Implement __attribute__((require_constant_initialization)) for safe static initialization.

[EricWF]

Summary

This attribute specifies expectations about the initialization of static and
thread local variables. Specifically that the variable has a
constant initializer
according to the rules of [basic.start.static]. Failure to meet this expectation
will result in an error.

Static objects with constant initializers avoid hard-to-find bugs caused by
the indeterminate order of dynamic initialization. They can also be safely
used by other static constructors across translation units.

This attribute acts as a compile time assertion that the requirements
for constant initialization have been met. Since these requirements change
between dialects and have subtle pitfalls it's important to fail fast instead
of silently falling back on dynamic initialization.

c++
  // -std=c++14
  #define SAFE_STATIC __attribute__((require_constant_initialization)) static
  struct T {
    constexpr T(int) {}
    ~T();
  };
  SAFE_STATIC T x = {42}; // OK.
  SAFE_STATIC T y = 42; // error: variable does not have a constant initializer
  // copy initialization is not a constant expression on a non-literal type.

This attribute can only be applied to objects with static or thread-local storage
duration.

[EricWF]

Open questions:

• What should __has_constant_initializer do for non-static inputs? Currently it returns false.
• Do I need to do more to handle value dependent inputs?
• Should expression traits SFINAE?

[EricWF]

Check the initializers of TLS_Dynamic variables since they may actually be non-dynamic.

[EricWF]

Re-flow comments because I suck at English.

[jroelofs]

lib/AST/Expr.cpp

2656

no need for this if.

Also, I think the for should be written:

for (auto *Arg : CE->arguments())
  if (Arg->isConstantInitializer(Ctx, false, Culprit))
    return false;

lib/Sema/SemaExprCXX.cpp

4775

no else after return.

Also, what do you want this to do for ParmVarDecls that happen to have an initializer? i.e:

void foo(int i = 45) {}

[jroelofs]

One more thing: need to add docs to clang/docs/LanguageExtensions.rst.

[EricWF]

include/clang/Basic/DiagnosticSemaKinds.td

6807

Help improving this wording would be appreciated.

lib/Sema/SemaExprCXX.cpp

4775

I believe that case should return false. i isn't static or thread local so it doesn't have a "constant initializer" according to [basic.start.static].

[EricWF]

lib/Sema/SemaExprCXX.cpp

4775

Perhaps using __has_constant_initializer should emit a diagnostic when used on non-static, non-thread-local objects?

[jroelofs]

include/clang/Basic/DiagnosticSemaKinds.td

6807

"expression must be a named variable", maybe?

A "counterexample" to the original wording is __has_constant_initializer(x+1).

lib/Sema/SemaExprCXX.cpp

4775

Maybe a warning... And you might want it to behave differently when it comes from a macro expansion. I'm not sure what the norm is for that sort of thing though.

I think the more important thing at this point is to precisely document what you want the behavior to be in the docs. Then any difference from that spec is "just a compiler bug", rather than potentially being a breaking change in behavior for someone who used your API in a way that you didn't expect.

[EricWF]

• Apply @jroelof's suggestions
• Add tests for static class members

[EricWF]

• Add documentation for __has_constant_initializer and expression traits in general.
• Make expression traits detectable using __has_extension.

[EricWF]

lib/Sema/SemaExprCXX.cpp

4775

I've added docs to LanguageExtensions.rst specifying the semantics I intend for the trait.

[jroelofs]

I don't think I have any more comments, but I'll let one of the other reviewers give the final go/no-go.

docs/LanguageExtensions.rst

1047

s/a object/an object/

(english sucks)

[rsmith]

Have you considered modelling this as an attribute on the declaration of the variable instead of as a separate check? If so, why do you prefer this approach? (If I were to suggest this for standardization, an attribute is the approach I'd probably take.)

lib/AST/Expr.cpp

2653–2662

This doesn't look right: just because we're calling a constexpr constructor with constant arguments doesn't imply that the initializer is constant.

[EricWF]

In D23385#513443, @rsmith wrote:

Have you considered modelling this as an attribute on the declaration of the variable instead of as a separate check? If so, why do you prefer this approach? (If I were to suggest this for standardization, an attribute is the approach I'd probably take.)

An attribute would be a much better approach! I only went this root because I figured out how to do it. If you could give me a starting point I'll change it over to an attribute.

[EricWF]

Switch to an attribute based implementation as suggested by @rsmith.

[EricWF]

• Remove test from previous implementation.

[EricWF]

lib/AST/Expr.cpp

2653–2662

I changed this to use VD->checkInitICE() when evaluating a constexpr constructor or if VD->isInitKnownICE(). Otherwise it falls back on isConstantInitializer()

[aaron.ballman]

include/clang/Basic/Attr.td

1384 ↗

(On Diff #67822)

This should not use the GCC spelling because GCC doesn't support the attribute. Do you expect this attribute to do anything useful in C? If not, this should just be a CXX11 spelling in the clang namespace.

1385 ↗

(On Diff #67822)

You might want to make a custom SubsetSubject for this. Check out NormalVar, SharedVar, and the likes in Attr.td. Then you can get rid of the custom handling in SemaDeclAttr.cpp.

include/clang/Basic/AttrDocs.td

835 ↗

(On Diff #67822)

Should be no need to specify the heading manually since there's only one spelling for the attribute.

847 ↗

(On Diff #67822)

s/acts an a/acts as a

include/clang/Basic/DiagnosticSemaKinds.td

6842

I would reword this to: "'require_constant_initialization' attribute only applies to variables with static or thread-local storage duration"

test/SemaCXX/attr-require-constant-initialization.cpp

1 ↗

(On Diff #67822)

This file should also get tests that ensure we properly diagnose the attribute when it doesn't apply to a declaration (such as a local variable, as well as nonsense like a function), test that it does not accept arguments, etc.

4–6 ↗

(On Diff #67822)

Does this comment actually apply?

[EricWF]

Address @aaron.ballman's review comments.

include/clang/Basic/Attr.td

1384 ↗

(On Diff #67822)

Are CXX11 attributes usable in C++03? If not perhaps we should provide both?

test/SemaCXX/attr-require-constant-initialization.cpp

4–6 ↗

(On Diff #67822)

No.

[majnemer]

lib/Sema/SemaDecl.cpp

10388–10390 ↗

(On Diff #67827)

You could use a lambda to abstract away the "check if it's cached, if not query" logic.

10485 ↗

(On Diff #67827)

Any reason not to use the already existing err_init_element_not_constant?

[rsmith]

Attributes are specified in include/clang/Basic/Attr.td with a (hopefully) fairly self-explanatory declarative syntax. You'll then need to add code to lib/Sema/SemaDeclAttr.cpp to create a corresponding attribute object and attach it to the declaration.

Two implementation approaches seem feasible: either check that the VarDecl has constant initialization at the point when the attribute is attached in SemaDeclAttr.cpp, or attach the attribute without checking and instead perform the check from Sema::CheckCompleteVariableDeclaration, around where we currently call isConstantInitializer to produce a warning on non-constant initialization -- the effect of the attribute would then be to promote that warning to an error.

[rsmith]

Sorry about the redundant previous comment, the thread got forked by the change of subject and I missed the updated patch.

lib/Sema/SemaDecl.cpp

10484–10485 ↗

(On Diff #67827)

I think this check is incorrect: we perform constant initialization (to zero) for globals with no initializer.

10500 ↗

(On Diff #67827)

Instead of diagnosing the condition separately (and getting both a warning and an error for the same situation), it would seem preferable to change this to produce either diag::warn_global_constructor or your new error depending on whether the attribute is present. This would also remove the duplicate error messages if the attribute is specified on an object that is also marked constexpr.

[EricWF]

Attempt to address Richards concerns about duplicate diagnostics and add tests for those cases.

Unfortunately the tests are failing, because there is a duplicate -Wglobal-constructors diagnostic, but I can't find where it's being emitted.

lib/Sema/SemaDecl.cpp

10484–10485 ↗

(On Diff #67827)

Agreed. Technically not "constant initialization" but every bit as safe.

10485 ↗

(On Diff #67827)

Any reason not to use the already existing err_init_element_not_constant?

I hadn't considered it, but the error text seems misleading, since it may select a constructor that's not a valid constant expression even when every element in the initializer is.

10500 ↗

(On Diff #67827)

Already I think I've dealt with the duplicate diagnostics.

10528 ↗

(On Diff #67983)

I can't figure out where the diagnostic is this comment is coming from. Hopefully I'm just missing something simple.

[EricWF]

lib/Sema/SemaDecl.cpp

10528 ↗

(On Diff #67983)

Nevermind, I kept reading "global destructor" as "global constructor" and was looking for the wrong thing.

[EricWF]

Get all tests passing regarding duplicate warnings between __attribute__((requires_constant_initialization)) and -Wglobal-constructors. The warning will not emit a duplicate warning about global constructors, but it will still warn if the variable has a global destructor, which make sense to me.

I believe this is ready to go and I have addressed all concerns.

[EricWF]

Fix missing semicolon.

[rsmith]

include/clang/Basic/Attr.td

1384 ↗

(On Diff #67987)

Providing both seems fine, but regardless this should be a GNU spelling not a GCC spelling, because GCC doesn't support the attribute.

include/clang/Basic/AttrDocs.td

836–840 ↗

(On Diff #67987)

This reads a bit awkwardly, since you don't actually say what the attribute does until the second sentence. Maybe fold the first two sentences together:

"This attribute specifies that the variable to which it is attached is intended to have a constant initializer according to the rules of [basic.start.static]. The variable is required to have static or thread storage duration. If the initialization of the variable is not a constant initializer, an error will be produced."

842 ↗

(On Diff #67987)

Static objects -> Static storage duration variables

844 ↗

(On Diff #67987)

static constructors -> dynamic initializers?

858 ↗

(On Diff #67987)

OK even though T has a non-trivial destructor? This makes the variable unsafe to use during program shutdown in the general case.

include/clang/Basic/DiagnosticSemaKinds.td

2575

thread-local -> thread, per standard terminology

6842

It may be useful for this diagnostic to say why we consider this to be an error (that is, mention that there is a require_constant_initialization attribute attached to the variable). The attribute will typically be hidden behind a (perhaps unfamiliar to the reader) macro, so it may not be obvious if we don't point it out.

lib/Sema/SemaDecl.cpp

10519–10520 ↗

(On Diff #67987)

Falling back to checkConstInit here will suppress the warning on some cases that are not technically constant initializers (but that Clang can emit as constants regardless). Is that what you want? If so, you should update the documentation to say that instead of saying that we only check for a constant initializer.

test/SemaCXX/attr-require-constant-initialization.cpp

7–15 ↗

(On Diff #67987)

Just use _Static_assert.

96–100 ↗

(On Diff #67987)

Did you mean for this to still be here?

[EricWF]

include/clang/Basic/AttrDocs.td

844 ↗

(On Diff #67987)

Changed "by other static constructors" -> "during dynamic initialization"

858 ↗

(On Diff #67987)

Right, but I want this attribute to be able to work with (A) the union trick for "trivial" destructors and (B) variables not used during shutdown.
I was planning on following this up with an additional feature to aid in the shutdown case as well, but I think there is value in separating the features.

Currently -Wglobal-destructors will still warn on that declaration, so at least the unsafe shutdown is not silently missed.

Does this behavior make sense to you?

include/clang/Basic/DiagnosticSemaKinds.td

6842

"variable does not have a constant initializer as required by 'require_constant_initializer' attribute"?

Or do we want the diagnostic to point to the attribute token in a "required from here"-like note?

lib/Sema/SemaDecl.cpp

10519–10520 ↗

(On Diff #67987)

Falling back to checkConstInit here will suppress the warning on some cases that are not technically constant initializers (but that Clang can emit as constants regardless). Is that what you want?

Not really. I would prefer this strictly conform to the standard so it can be used to portably detect possible dynamic initializers on other toolchains.

What would the correct fallback here be?

test/SemaCXX/attr-require-constant-initialization.cpp

96–100 ↗

(On Diff #67987)

No.

[EricWF]

Address most of @rsmiths review comments.

[rsmith]

include/clang/Basic/AttrDocs.td

858 ↗

(On Diff #68094)

Sure, if that's a conscious design decision for the attribute.

include/clang/Basic/DiagnosticSemaKinds.td

6842

A separate note pointed at the attribute would make it clearer how the attribute got involved (especially via the macro expansion backtrace).

lib/Sema/SemaDecl.cpp

10519–10520 ↗

(On Diff #68094)

In C++11 onwards, checkInitIsICE is the right thing to use in all cases. In C++98, checkInitIsICE is appropriate for globals of integral type; we do not have an implementation of strict constant expression checking for other types. Perhaps just documenting that (and maybe adding a FIXME here) is the best you can do for now, assuming you're not interested in implementing the C++98 rules.

[EricWF]

lib/Sema/SemaDecl.cpp

10519–10520 ↗

(On Diff #68094)

SGTM. I think I'll fall back to isConstantInitializer() in C++03. Do you have an example of what checkConstantInitializer() gets wrong in C++03?

[rsmith]

lib/Sema/SemaDecl.cpp

10519–10520 ↗

(On Diff #68094)

struct A {
  ~A();
  int n;
} a;
int *p = &a.n; // constant initializer, but not a C++98 address constant expression

[EricWF]

Do strict 'constant initializer' checking in C++11, but fall back to isConstantInitializer() in C++03. Add documentation about non-strict C++03 checking.

This has weird results for example:

struct PODType { int x; int y; };
__attribute__((require_constant_initialization)) PODType pod; // error in C++11, OK in C++03.

[aaron.ballman]

include/clang/Basic/AttrDocs.td

836 ↗

(On Diff #68121)

I don't think I ever heard whether this attribute was usable in C or not. I suspect it's not particularly needed in C. If that's true, we should state that in the documentation, and consider making the attribute a C++-only attribute?

test/SemaCXX/attr-require-constant-initialization.cpp

1 ↗

(On Diff #68121)

Can you run this file through clang-format?

7–9 ↗

(On Diff #68121)

This doesn't appear to be needed by the test.

11 ↗

(On Diff #68121)

Hah, I've not seen 0+ before in a verify comment, that's a neat trick!

[EricWF]

include/clang/Basic/AttrDocs.td

836 ↗

(On Diff #68121)

I think it would be somewhat useful in C. In particular if you have globals initialized from values you don't own. Example:

#include <y.h>
ATTR int x = y; // Will diagnose if  becomes 'y' is a non-constant expression.

However the current implementation only handles C++ and I'm satisfied with that. I'll mark the attribute as C++ only and document that change.

[EricWF]

Address all comments except making the attribute C++ only.

[EricWF]

Make the attribute C++ only.

[EricWF]

utils/TableGen/ClangAttrEmitter.cpp

2794 ↗

(On Diff #69775)

This is needed so that the COnly and CPlusPlus entries in Attr.td don't create the same function name.

[rsmith]

include/clang/Basic/AttrDocs.td

836 ↗

(On Diff #69775)

For the record, in C the program is ill-formed if the initializer for a global is non-constant, so it doesn't seem like this attribute would ever be useful.

[EricWF]

include/clang/Basic/AttrDocs.td

836 ↗

(On Diff #69775)

Ah I didn't know that!

[EricWF]

Are there any remaining issues with this patch?

[aaron.ballman]

LGTM!

[EricWF]

Updating against recent ToT.

docs/LanguageExtensions.rst

 Modules
 -------
 
 Use ``__has_feature(modules)`` to determine if Modules have been enabled.
 For example, compiling code with ``-fmodules`` enables the use of Modules.
 
 More information could be found `here <http://clang.llvm.org/docs/Modules.html>`_.
 
+
+.. _langext-traits_feature_detection:
+
 Checks for Type Trait Primitives
 ================================
 
 Type trait primitives are special builtin constant expressions that can be used
 by the standard C++ library to facilitate or simplify the implementation of
 user-facing type traits in the <type_traits> header.
 
 They are not intended to be used directly by user code because they are
* ``__is_trivially_constructible(type, argtypes...)``: Determines whether a
   library.
 * ``__is_destructible`` (MSVC 2013)
 * ``__is_nothrow_destructible`` (MSVC 2013)
 * ``__is_nothrow_assignable`` (MSVC 2013, clang)
 * ``__is_constructible`` (MSVC 2013, clang)
 * ``__is_nothrow_constructible`` (MSVC 2013, clang)
 * ``__is_assignable`` (MSVC 2015, clang)
 
+
+Expression Traits
+=================
+
+Expression traits are special builtin constant expressions much like type traits
+except that they act on expressions not types. They allow the determination of
+various characteristics of an expression. The supplied expression is treated
+as an unevaluated operand.
+
+Feature detection for expression traits is the same as for type traits.
+See :ref:`Checks for Type Trait Primatives <langext-traits_feature_detection>`
+for information.
+
+The following expression trait primitives are supported by Clang:
+
+* ``__has_constant_initializer(expr)``:
+  Determines whether `expr` names
+  a object that will be initialized during
+  `constant initialization <http://en.cppreference.com/w/cpp/language/constant_initialization>`_
+  according to the rules of [basic.start.static]. If ``expr`` does not name
+  an object, or if the object it names doesn't have static or thread-local
+  storage duration the result is false. This trait can be used determine if it's
+  safe to use a global variable during program startup. For example:
+
+  .. code-block:: c++
+
+    static MyType global_obj;
+    #if __has_extension(has_constant_initializer)
+    static_assert(__has_constant_initializer(global_obj),
+                  "global_obj may be unsafely used before it is initialized");
+    #endif
+
+* ``__is_lvalue_expr(expr)``
+* ``__is_rvalue_expr(expr)``
+
 Blocks
 ======
 
 The syntax and high level language feature description is in
 :doc:`BlockLanguageSpec<BlockLanguageSpec>`. Implementation and ABI details for
 the clang implementation are in :doc:`Block-ABI-Apple<Block-ABI-Apple>`.
 
 Query for this feature with ``__has_extension(blocks)``.

include/clang/AST/Expr.h

static bool isPotentialConstantExprUnevaluated(Expr *E,
                                                  SmallVectorImpl<
                                                    PartialDiagnosticAt> &Diags);
 
   /// isConstantInitializer - Returns true if this expression can be emitted to
   /// IR as a constant, and thus can be used as a constant initializer in C.
   /// If this expression is not constant and Culprit is non-null,
   /// it is used to store the address of first non constant expr.
   bool isConstantInitializer(ASTContext &Ctx, bool ForRef,
-                             const Expr **Culprit = nullptr) const;
+                             const Expr **Culprit = nullptr,
+                             bool AllowNonLiteral = false) const;
 
   /// EvalStatus is a struct with detailed info about an evaluation in progress.
   struct EvalStatus {
     /// \brief Whether the evaluated expression has side effects.
     /// For example, (f() && 0) can be folded, but it still has side effects.
     bool HasSideEffects;
 
     /// \brief Whether the evaluation hit undefined behavior.

include/clang/Basic/DiagnosticSemaKinds.td

   "'__builtin_choose_expr' requires a constant expression">;
 def warn_unused_expr : Warning<"expression result unused">,
   InGroup<UnusedValue>;
 def warn_unused_voidptr : Warning<
   "expression result unused; should this cast be to 'void'?">,
   InGroup<UnusedValue>;
 def warn_unused_property_expr : Warning<
  "property access result unused - getters should not be used for side effects">,
   InGroup<UnusedGetterReturnValue>;
 def warn_unused_container_subscript_expr : Warning<
  "container access result unused - container access should not be used for side effects">,
   InGroup<UnusedValue>;
 def warn_unused_call : Warning<
   "ignoring return value of function declared with %0 attribute">,
   InGroup<UnusedValue>;
 def warn_side_effects_unevaluated_context : Warning<
   "expression with side effects has no effect in an unevaluated context">,

 def warn_unused_comparison : Warning<
   "%select{%select{|in}1equality|relational}0 comparison result unused">,
   InGroup<UnusedComparison>;
 def note_inequality_comparison_to_or_assign : Note<
   "use '|=' to turn this inequality comparison into an or-assignment">;
 
 def err_incomplete_type_used_in_type_trait_expr : Error<
   "incomplete type %0 used in type trait expression">;
-  
+def err_has_constant_init_expression_not_named_var : Error<
+  "expression must be a named variable">;
+
 def err_dimension_expr_not_constant_integer : Error<
   "dimension expression does not evaluate to a constant unsigned int">;
 
 def err_typecheck_cond_incompatible_operands_null : Error<
   "non-pointer operand type %0 incompatible with %select{NULL|nullptr}1">;
 def ext_empty_struct_union : Extension<
   "empty %select{struct|union}0 is a GNU extension">, InGroup<GNUEmptyStruct>;
 def ext_no_named_members_in_struct_union : Extension<

include/clang/Basic/ExpressionTraits.h

 
 #ifndef LLVM_CLANG_BASIC_EXPRESSIONTRAITS_H
 #define LLVM_CLANG_BASIC_EXPRESSIONTRAITS_H
 
 namespace clang {
 
   enum ExpressionTrait {
     ET_IsLValueExpr,
-    ET_IsRValueExpr
+    ET_IsRValueExpr,
+    ET_HasConstantInitializer
   };
 }
 
 #endif

include/clang/Basic/TokenKinds.def

 TYPE_TRAIT_1(__is_union, IsUnion, KEYCXX)
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_N(__is_trivially_constructible, IsTriviallyConstructible, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_copyable, IsTriviallyCopyable, KEYCXX)
 TYPE_TRAIT_2(__is_trivially_assignable, IsTriviallyAssignable, KEYCXX)
 KEYWORD(__underlying_type           , KEYCXX)
 
+// Clang-only C++ Expression Traits
+KEYWORD(__has_constant_initializer  , KEYCXX)
+
 // Embarcadero Expression Traits
 KEYWORD(__is_lvalue_expr            , KEYCXX)
 KEYWORD(__is_rvalue_expr            , KEYCXX)
 
 // Embarcadero Unary Type Traits
 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)
 TYPE_TRAIT_1(__is_floating_point, IsFloatingPoint, KEYCXX)
 TYPE_TRAIT_1(__is_integral, IsIntegral, KEYCXX)

lib/AST/Expr.cpp

   for (unsigned I = 0; I < Exprs.size(); ++I)
     if (Exprs[I]->isTypeDependent())
       return true;
 
   return false;
 }
 
 bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef,
-                                 const Expr **Culprit) const {
+                                 const Expr **Culprit,
+                                 bool AllowNonLiteral) const {
   // This function is attempting whether an expression is an initializer
   // which can be evaluated at compile-time. It very closely parallels
   // ConstExprEmitter in CGExprConstant.cpp; if they don't match, it
   // will lead to unexpected results.  Like ConstExprEmitter, it falls back
   // to isEvaluatable most of the time.
   //
   // If we ever capture reference-binding directly in the AST, we can
   // kill the second parameter.

         CE->getConstructor()->getParent()->hasTrivialDestructor()) {
       // Trivial default constructor
       if (!CE->getNumArgs()) return true;
 
       // Trivial copy constructor
       assert(CE->getNumArgs() == 1 && "trivial ctor with > 1 argument");
       return CE->getArg(0)->isConstantInitializer(Ctx, false, Culprit);
     }
-
+    if (CE->getConstructor()->isConstexpr() &&
+        (CE->getConstructor()->getParent()->hasTrivialDestructor() ||
+            AllowNonLiteral)) {
+        for (auto *Arg : CE->arguments()) {
+          if (!Arg->isConstantInitializer(Ctx, false, Culprit))
+            return false;
+        }
+        return true;
+    }
     break;
   }
   case CompoundLiteralExprClass: {
     // This handles gcc's extension that allows global initializers like
     // "struct x {int x;} x = (struct x) {};".
     // FIXME: This accepts other cases it shouldn't!
     const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
     return Exp->isConstantInitializer(Ctx, false, Culprit);
   }

lib/AST/StmtPrinter.cpp

   case ATT_ArrayRank:        return "__array_rank";
   case ATT_ArrayExtent:      return "__array_extent";
   }
   llvm_unreachable("Array type trait not covered by switch");
 }
 
 static const char *getExpressionTraitName(ExpressionTrait ET) {
   switch (ET) {
-  case ET_IsLValueExpr:      return "__is_lvalue_expr";
-  case ET_IsRValueExpr:      return "__is_rvalue_expr";
+  case ET_IsLValueExpr:           return "__is_lvalue_expr";
+  case ET_IsRValueExpr:           return "__is_rvalue_expr";
+  case ET_HasConstantInitializer:  return "__has_constant_initializer";
   }
   llvm_unreachable("Expression type trait not covered by switch");
 }
 
 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
   OS << getTypeTraitName(E->getTrait()) << "(";
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
     if (I > 0)

lib/Lex/PPMacroExpansion.cpp

            .Case("cxx_range_for", LangOpts.CPlusPlus)
            .Case("cxx_reference_qualified_functions", LangOpts.CPlusPlus)
            .Case("cxx_rvalue_references", LangOpts.CPlusPlus)
            .Case("cxx_variadic_templates", LangOpts.CPlusPlus)
            // C++1y features supported by other languages as extensions.
            .Case("cxx_binary_literals", true)
            .Case("cxx_init_captures", LangOpts.CPlusPlus11)
            .Case("cxx_variable_templates", LangOpts.CPlusPlus)
+           // Expression traits
+           .Case("has_constant_initializer", LangOpts.CPlusPlus)
+           .Case("is_lvalue_expr", LangOpts.CPlusPlus)
+           .Case("is_rvalue_expr", LangOpts.CPlusPlus)
            .Default(false);
 }
 
 /// EvaluateHasIncludeCommon - Process a '__has_include("path")'
 /// or '__has_include_next("path")' expression.
 /// Returns true if successful.
 static bool EvaluateHasIncludeCommon(Token &Tok,
                                      IdentifierInfo *II, Preprocessor &PP,

lib/Parse/ParseDeclCXX.cpp

   // Source location used by FIXIT to insert misplaced
   // C++11 attributes
   SourceLocation AttrFixitLoc = Tok.getLocation();
 
   if (TagType == DeclSpec::TST_struct &&
       Tok.isNot(tok::identifier) &&
       !Tok.isAnnotation() &&
       Tok.getIdentifierInfo() &&
-      Tok.isOneOf(tok::kw___is_abstract,
+      Tok.isOneOf(tok::kw___has_constant_initializer,
+                  tok::kw___is_abstract,
                   tok::kw___is_arithmetic,
                   tok::kw___is_array,
                   tok::kw___is_assignable,
                   tok::kw___is_base_of,
                   tok::kw___is_class,
                   tok::kw___is_complete_type,
                   tok::kw___is_compound,
                   tok::kw___is_const,

                                  AttributeList::AS_CXX11)) {
   case AttributeList::AT_CarriesDependency:
   case AttributeList::AT_Deprecated:
   case AttributeList::AT_FallThrough:
   case AttributeList::AT_CXX11NoReturn:
     return true;
   case AttributeList::AT_WarnUnusedResult:
     return !ScopeName && AttrName->getName().equals("nodiscard");
-  case AttributeList::AT_Unused:
-    return !ScopeName && AttrName->getName().equals("maybe_unused");
+  case AttributeList::AT_Unused:
+    return !ScopeName && AttrName->getName().equals("maybe_unused");
   default:
     return false;
   }
 }
 
 /// ParseCXX11AttributeArgs -- Parse a C++11 attribute-argument-clause.
 ///
 /// [C++11] attribute-argument-clause:

lib/Parse/ParseExpr.cpp

 ///                   '__is_sealed'                           [MS]
 ///                   '__is_trivial'
 ///                   '__is_union'
 ///
 /// [Clang] unary-type-trait:
 ///                   '__trivially_copyable'
 ///
 ///       binary-type-trait:
-/// [GNU]             '__is_base_of'       
+/// [GNU]             '__is_base_of'
 /// [MS]              '__is_convertible_to'
 ///                   '__is_convertible'
 ///                   '__is_same'
 ///
+/// [Clang] expression-trait:
+///                   '__has_constant_initializer'
+///
 /// [Embarcadero] array-type-trait:
 ///                   '__array_rank'
 ///                   '__array_extent'
 ///
 /// [Embarcadero] expression-trait:
 ///                   '__is_lvalue_expr'
 ///                   '__is_rvalue_expr'
 /// \endverbatim
if (getLangOpts().CPlusPlus) {
         IdentifierInfo *II = Tok.getIdentifierInfo();
         // Build up the mapping of revertible type traits, for future use.
         if (RevertibleTypeTraits.empty()) {
 #define RTT_JOIN(X,Y) X##Y
 #define REVERTIBLE_TYPE_TRAIT(Name)                         \
           RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] \
             = RTT_JOIN(tok::kw_,Name)
 
+          REVERTIBLE_TYPE_TRAIT(__has_constant_initializer);
           REVERTIBLE_TYPE_TRAIT(__is_abstract);
           REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
           REVERTIBLE_TYPE_TRAIT(__is_array);
           REVERTIBLE_TYPE_TRAIT(__is_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_base_of);
           REVERTIBLE_TYPE_TRAIT(__is_class);
           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
           REVERTIBLE_TYPE_TRAIT(__is_compound);
#define TYPE_TRAIT(N,Spelling,K) \
   case tok::kw_##Spelling:
 #include "clang/Basic/TokenKinds.def"
     return ParseTypeTrait();
       
   case tok::kw___array_rank:
   case tok::kw___array_extent:
     return ParseArrayTypeTrait();
 
+  case tok::kw___has_constant_initializer:
   case tok::kw___is_lvalue_expr:
   case tok::kw___is_rvalue_expr:
     return ParseExpressionTrait();
-      
   case tok::at: {
     SourceLocation AtLoc = ConsumeToken();
     return ParseObjCAtExpression(AtLoc);
   }
   case tok::caret:
     Res = ParseBlockLiteralExpression();
     break;
   case tok::code_completion: {

lib/Parse/ParseExprCXX.cpp

   case tok::kw___array_rank:                 return ATT_ArrayRank;
   case tok::kw___array_extent:               return ATT_ArrayExtent;
   }
 }
 
 static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
   switch(kind) {
   default: llvm_unreachable("Not a known unary expression trait.");
+  case tok::kw___has_constant_initializer:   return ET_HasConstantInitializer;
   case tok::kw___is_lvalue_expr:             return ET_IsLValueExpr;
   case tok::kw___is_rvalue_expr:             return ET_IsRValueExpr;
   }
 }
 
 static unsigned TypeTraitArity(tok::TokenKind kind) {
   switch (kind) {
     default: llvm_unreachable("Not a known type trait");

 ExprResult Parser::ParseExpressionTrait() {
   ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
   SourceLocation Loc = ConsumeToken();
 
   BalancedDelimiterTracker T(*this, tok::l_paren);
   if (T.expectAndConsume())
     return ExprError();
 
+  EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
   ExprResult Expr = ParseExpression();
 
   T.consumeClose();
 
   return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
                                       T.getCloseLocation());
 }
 

lib/Sema/SemaExprCXX.cpp

   if (!Queried)
     return ExprError();
 
   ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen);
 
   return Result;
 }
 
-static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) {
+static bool EvaluateExpressionTrait(Sema &Self, ExpressionTrait ET,
+                                    SourceLocation KWLoc, Expr *E,
+                                    SourceLocation RParen) {
   switch (ET) {
   case ET_IsLValueExpr: return E->isLValue();
   case ET_IsRValueExpr: return E->isRValue();
+  case ET_HasConstantInitializer: {
+    // Check for 'constant initialization' according to [basic.start.static].
+    DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreImpCasts());
+    if (!DRE) {
+      // It is a usage error to specify an expression that does not reference
+      // a named variable.
+      Self.Diag(KWLoc, diag::err_has_constant_init_expression_not_named_var)
+        << E->getSourceRange();
+      return false;
+    }
+    if (VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
+      // Thread local objects specified as TSL_Static have a constant
+      // initializer. TLS_Dynamic objects still need to be checked below.
+      if (VD->getTLSKind() == VarDecl::TLS_Static)
+        return true;
+      // Check the initializer of objects with static or thread-local storage
+      // duration. AObjects with automatic or dynamic lifetime never have
+      // a 'constant initializer'.
+      if ((VD->hasGlobalStorage() ||
+          VD->getTLSKind() != VarDecl::TLS_None) && VD->hasInit()) {
+        QualType baseType = Self.Context.getBaseElementType(VD->getType());
+        return VD->getInit()->isConstantInitializer(Self.Context,
+            baseType->isReferenceType(), nullptr, /*AllowNonLiteral=*/true);
+      }
+    }
+    return false;
+  }
   }
   llvm_unreachable("Expression trait not covered by switch");
 }
 
 ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET,
                                       SourceLocation KWLoc,
                                       Expr *Queried,
                                       SourceLocation RParen) {
   if (Queried->isTypeDependent()) {
     // Delay type-checking for type-dependent expressions.
   } else if (Queried->getType()->isPlaceholderType()) {
     ExprResult PE = CheckPlaceholderExpr(Queried);
     if (PE.isInvalid()) return ExprError();
     return BuildExpressionTrait(ET, KWLoc, PE.get(), RParen);
   }
 
-  bool Value = EvaluateExpressionTrait(ET, Queried);
+  bool Value = EvaluateExpressionTrait(*this, ET, KWLoc, Queried, RParen);
 
   return new (Context)
       ExpressionTraitExpr(KWLoc, ET, Queried, Value, RParen, Context.BoolTy);
 }
 
 QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
                                             ExprValueKind &VK,
                                             SourceLocation Loc,

test/Lexer/has_extension_cxx.cpp

 int has_variable_templates();
 #endif
 
 // CHECK-NOT: has_init_captures
 // CHECK11: has_init_captures
 #if __has_extension(cxx_init_captures)
 int has_init_captures();
 #endif
+
+// CHECK: has_constant_initializer
+#if __has_extension(has_constant_initializer)
+int has_constant_initializer();
+#endif

test/SemaCXX/expression-traits.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -fcxx-exceptions %s
-
+// RUN: %clang_cc1 -fsyntax-only -verify -fcxx-exceptions -std=c++14 %s
 //
 // Tests for "expression traits" intrinsics such as __is_lvalue_expr.
 //
 // For the time being, these tests are written against the 2003 C++
 // standard (ISO/IEC 14882:2003 -- see draft at
 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2001/n1316/).
 //
 // C++0x has its own, more-refined, idea of lvalues and rvalues.

 }
 
 int AnInt = 0;
 
 void temp_param_6()
 {
     check_temp_param_6<3,AnInt>();
 }
+
+//===========================================================================//
+// __has_constant_initializer
+//===========================================================================//
+struct PODType {
+    int value;
+    int value2;
+};
+#if __cplusplus >= 201103L
+struct LitType {
+    constexpr LitType() : value(0) {}
+    constexpr LitType(int x) : value(x) {}
+    LitType(void*) : value(-1) {}
+    int value;
+};
+#endif
+
+struct NonLit {
+#if __cplusplus >= 201402L
+    constexpr NonLit() : value(0) {}
+    constexpr NonLit(int x ) : value(x) {}
+#else
+    NonLit() : value(0) {}
+    NonLit(int x) : value(x) {}
+#endif
+    NonLit(void*) : value(-1) {}
+    ~NonLit() {}
+    int value;
+};
+
+struct StoresNonLit {
+#if __cplusplus >= 201402L
+    constexpr StoresNonLit() : obj() {}
+    constexpr StoresNonLit(int x) : obj(x) {}
+#else
+    StoresNonLit() : obj() {}
+    StoresNonLit(int x) : obj(x) {}
+#endif
+    StoresNonLit(void* p) : obj(p) {}
+    NonLit obj;
+};
+
+const bool NonLitHasConstInit =
+#if __cplusplus >= 201402L
+    true;
+#else
+    false;
+#endif
+
+// Test diagnostics when the argument does not refer to a named identifier
+void check_is_constant_init_bogus()
+{
+    (void)__has_constant_initializer(42); // expected-error {{does not reference a named variable}}
+    (void)__has_constant_initializer(ReturnInt()); // expected-error {{does not reference a named variable}}
+    (void)__has_constant_initializer(42, 43); // expected-error {{does not reference a named variable}}
+}
+
+// [basic.start.static]p2.1
+// if each full-expression (including implicit conversions) that appears in
+// the initializer of a reference with static or thread storage duration is
+// a constant expression (5.20) and the reference is bound to a glvalue
+// designating an object with static storage duration, to a temporary object
+// (see 12.2) or subobject thereof, or to a function;
+
+// Test binding to a static glvalue
+const int glvalue_int = 42;
+const int glvalue_int2 = ReturnInt();
+const int& glvalue_ref = glvalue_int;
+const int& glvalue_ref2 = glvalue_int2;
+static_assert(__has_constant_initializer(glvalue_ref), "");
+static_assert(__has_constant_initializer(glvalue_ref2), "");
+
+__thread const int& glvalue_ref_tl = glvalue_int;
+static_assert(__has_constant_initializer(glvalue_ref_tl), "");
+
+void test_basic_start_static_2_1() {
+    const int non_global = 42;
+    const int& non_global_ref = non_global;
+    static_assert(!__has_constant_initializer(non_global), "automatic variables never have const init");
+    static_assert(!__has_constant_initializer(non_global_ref), "automatic variables never have const init");
+
+    static const int& local_init = non_global;
+    static_assert(!__has_constant_initializer(local_init), "init must be static glvalue");
+    static const int& global_init = glvalue_int;
+    static_assert(__has_constant_initializer(global_init), "");
+    static const int& temp_init = 42;
+    static_assert(__has_constant_initializer(temp_init), "");
+#if 0
+    /// FIXME: Why is this failing?
+    __thread const int& tl_init = 42;
+    static_assert(__has_constant_initializer(tl_init), "");
+#endif
+}
+
+const int& temp_ref = 42;
+const int& temp_ref2 = ReturnInt();
+static_assert(__has_constant_initializer(temp_ref), "");
+static_assert(!__has_constant_initializer(temp_ref2), "");
+
+const NonLit& nl_temp_ref = 42;
+static_assert(!__has_constant_initializer(nl_temp_ref), "");
+
+#if __cplusplus >= 201103L
+const LitType& lit_temp_ref = 42;
+static_assert(__has_constant_initializer(lit_temp_ref), "");
+
+const int& subobj_ref = LitType{}.value;
+static_assert(__has_constant_initializer(subobj_ref), "");
+#endif
+
+const int& nl_subobj_ref = NonLit().value;
+static_assert(!__has_constant_initializer(nl_subobj_ref), "");
+
+struct TT1 {
+  static const int& no_init;
+  static const int& glvalue_init;
+  static const int& temp_init;
+  static const int& subobj_init;
+#if __cplusplus >= 201103L
+  static thread_local const int& tl_glvalue_init;
+  static thread_local const int& tl_temp_init;
+#endif
+};
+const int& TT1::glvalue_init = glvalue_int;
+const int& TT1::temp_init = 42;
+const int& TT1::subobj_init = PODType().value;
+
+static_assert(!__has_constant_initializer(TT1::no_init), "");
+static_assert(__has_constant_initializer(TT1::glvalue_init), "");
+static_assert(__has_constant_initializer(TT1::temp_init), "");
+static_assert(__has_constant_initializer(TT1::subobj_init), "");
+#if __cplusplus >= 201103L
+thread_local const int& TT1::tl_glvalue_init = glvalue_int;
+thread_local const int& TT1::tl_temp_init = 42;
+static_assert(__has_constant_initializer(TT1::tl_glvalue_init), "");
+static_assert(!__has_constant_initializer(TT1::tl_temp_init), "");
+#endif
+
+// [basic.start.static]p2.2
+// if an object with static or thread storage duration is initialized by a
+// constructor call, and if the initialization full-expression is a constant
+// initializer for the object;
+
+void test_basic_start_static_2_2()
+{
+    static PODType pod;
+    static_assert(__has_constant_initializer(pod), "");
+
+#if __cplusplus >= 201103L
+    constexpr LitType l;
+    static_assert(!__has_constant_initializer(l), "non-static objects don't have const init");
+
+    static LitType static_lit = l;
+    static_assert(__has_constant_initializer(static_lit), "");
+
+    static LitType static_lit2 = (void*)0;
+    static_assert(!__has_constant_initializer(static_lit2), "constructor not constexpr");
+
+    static LitType static_lit3 = ReturnInt();
+    static_assert(!__has_constant_initializer(static_lit3), "initializer not constexpr");
+
+    thread_local LitType tls = 42;
+    static_assert(__has_constant_initializer(tls), "");
+#endif
+}
+
+struct TT2 {
+  static PODType pod_noinit;
+  static PODType pod_copy_init;
+#if __cplusplus >= 201103L
+  static constexpr LitType lit = {};
+  static const NonLit non_lit;
+  static const NonLit non_lit_copy_init;
+#endif
+};
+PODType TT2::pod_noinit;
+PODType TT2::pod_copy_init(TT2::pod_noinit);
+static_assert(__has_constant_initializer(TT2::pod_noinit), "");
+static_assert(!__has_constant_initializer(TT2::pod_copy_init), "");
+#if __cplusplus >= 201103L
+const NonLit TT2::non_lit(42);
+const NonLit TT2::non_lit_copy_init = 42;
+static_assert(__has_constant_initializer(TT2::lit), "");
+static_assert(__has_constant_initializer(TT2::non_lit) == NonLitHasConstInit, "");
+static_assert(!__has_constant_initializer(TT2::non_lit_copy_init), "");
+#endif
+
+#if __cplusplus >= 201103L
+LitType lit_ctor;
+LitType lit_ctor2{};
+LitType lit_ctor3 = {};
+__thread LitType lit_ctor_tl = {};
+static_assert(__has_constant_initializer(lit_ctor), "");
+static_assert(__has_constant_initializer(lit_ctor2), "");
+static_assert(__has_constant_initializer(lit_ctor3), "");
+static_assert(__has_constant_initializer(lit_ctor_tl), "");
+
+NonLit nl_ctor;
+NonLit nl_ctor2{};
+NonLit nl_ctor3 = {};
+thread_local NonLit nl_ctor_tl = {};
+static_assert(NonLitHasConstInit == __has_constant_initializer(nl_ctor), "");
+static_assert(NonLitHasConstInit == __has_constant_initializer(nl_ctor2), "");
+static_assert(NonLitHasConstInit == __has_constant_initializer(nl_ctor3), "");
+static_assert(NonLitHasConstInit == __has_constant_initializer(nl_ctor_tl), "");
+
+StoresNonLit snl;
+static_assert(NonLitHasConstInit == __has_constant_initializer(snl), "");
+
+// Non-literal types cannot appear in the initializer of a non-literal type.
+int nl_in_init = NonLit{42}.value;
+static_assert(!__has_constant_initializer(nl_in_init), "");
+
+int lit_in_init = LitType{42}.value;
+static_assert(__has_constant_initializer(lit_in_init), "");
+#endif
+
+// [basic.start.static]p2.3
+// if an object with static or thread storage duration is not initialized by a
+// constructor call and if either the object is value-initialized or every
+// full-expression that appears in its initializer is a constant expression.
+void test_basic_start_static_2_3()
+{
+    const int local = 42;
+    static_assert(!__has_constant_initializer(local), "automatic variable does not have const init");
+
+    static int static_local = 42;
+    static_assert(__has_constant_initializer(static_local), "");
+
+    static int static_local2;
+    static_assert(!__has_constant_initializer(static_local2), "no init");
+
+#if __cplusplus >= 201103L
+    thread_local int tl_local = 42;
+    static_assert(__has_constant_initializer(tl_local), "");
+#endif
+}
+
+int no_init;
+static_assert(!__has_constant_initializer(no_init), "");
+
+int arg_init = 42;
+static_assert(__has_constant_initializer(arg_init), "");
+
+PODType pod_init = {};
+static_assert(__has_constant_initializer(pod_init), "");
+
+PODType pod_missing_init = {42 /* should have second arg */};
+static_assert(__has_constant_initializer(pod_missing_init), "");
+
+PODType pod_full_init = {1, 2};
+static_assert(__has_constant_initializer(pod_full_init), "");
+
+PODType pod_non_constexpr_init = {1, ReturnInt()};
+static_assert(!__has_constant_initializer(pod_non_constexpr_init), "");
+
+#if __cplusplus >= 201103L
+int val_init{};
+static_assert(__has_constant_initializer(val_init), "");
+
+int brace_init = {};
+static_assert(__has_constant_initializer(brace_init), "");
+#endif
+
+__thread int tl_init = 0;
+static_assert(__has_constant_initializer(tl_init), "");
+
+void foo1(int p = 42) {
+  // ParmVarDecl's with an initializer do not have static or thread local
+  // storage duration.
+  static_assert(!__has_constant_initializer(p), "");
+}