<div dir="ltr"><div class="gmail_extra"><div class="gmail_quote">On 2 May 2017 at 12:21, Daniel Jasper via cfe-commits <span dir="ltr"><<a href="mailto:cfe-commits@lists.llvm.org" target="_blank">cfe-commits@lists.llvm.org</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Author: djasper<br>
Date: Tue May  2 14:21:42 2017<br>
New Revision: 301963<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=301963&view=rev" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-<wbr>project?rev=301963&view=rev</a><br>
Log:<br>
Revert r301822 (and dependent r301825), which tried to improve the<br>
handling of constexprs with unknown bounds.<br>
<br>
This triggers a corner case of the language where it's not yet clear<br>
whether this should be an error:<br>
<br>
  struct A {<br>
  Â  static void *const a[];<br>
  Â  static void *const b[];<br>
  };<br>
  constexpr void *A::a[] = {&b[0]};<br>
  constexpr void *A::b[] = {&a[0]};<br>
<br>
When discovering the initializer for A::a, the bounds of A::b aren't known yet.<br>
It is unclear whether warning about errors should be deferred until the end of<br>
the translation unit, possibly resolving errors that can be resolved. In<br>
practice, the compiler can know the bounds of all arrays in this example.<br></blockquote><div><br></div><div>I've started a discussion on the C++ core reflector about this.</div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
Credits for reproducers and explanation go to Richard Smith. Richard, please<br>
add more info in case my explanation is wrong.<br>
<br>
Removed:<br>
  Â  cfe/trunk/test/SemaCXX/<wbr>constexpr-array-unknown-bound.<wbr>cpp<br>
Modified:<br>
  Â  cfe/trunk/include/clang/Basic/<wbr>DiagnosticASTKinds.td<br>
  Â  cfe/trunk/lib/AST/<wbr>ExprConstant.cpp<br>
<br>
Modified: cfe/trunk/include/clang/Basic/<wbr>DiagnosticASTKinds.td<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticASTKinds.td?rev=301963&r1=301962&r2=301963&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-<wbr>project/cfe/trunk/include/<wbr>clang/Basic/<wbr>DiagnosticASTKinds.td?rev=<wbr>301963&r1=301962&r2=301963&<wbr>view=diff</a><br>
==============================<wbr>==============================<wbr>==================<br>
--- cfe/trunk/include/clang/Basic/<wbr>DiagnosticASTKinds.td (original)<br>
+++ cfe/trunk/include/clang/Basic/<wbr>DiagnosticASTKinds.td Tue May  2 14:21:42 2017<br>
@@ -154,14 +154,12 @@ def note_constexpr_baa_<wbr>insufficient_alig<br>
 def note_constexpr_baa_value_<wbr>insufficient_alignment : Note<<br>
  Â "value of the aligned pointer (%0) is not a multiple of the asserted %1 "<br>
  Â "%plural{1:byte|:bytes}1">;<br>
-def note_constexpr_array_unknown_<wbr>bound_arithmetic : Note<<br>
-  "cannot perform pointer arithmetic on pointer to array without constant bound">;<br>
<br>
 def warn_integer_constant_overflow : Warning<<br>
  Â "overflow in expression; result is %0 with type %1">,<br>
  Â InGroup<DiagGroup<"integer-<wbr>overflow">>;<br>
<br>
-// This is a temporary diagnostic, and shall be removed once our<br>
+// This is a temporary diagnostic, and shall be removed once our<br>
 // implementation is complete, and like the preceding constexpr notes belongs<br>
 // in Sema.<br>
 def note_unimplemented_constexpr_<wbr>lambda_feature_ast : Note<<br>
<br>
Modified: cfe/trunk/lib/AST/<wbr>ExprConstant.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ExprConstant.cpp?rev=301963&r1=301962&r2=301963&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-<wbr>project/cfe/trunk/lib/AST/<wbr>ExprConstant.cpp?rev=301963&<wbr>r1=301962&r2=301963&view=diff</a><br>
==============================<wbr>==============================<wbr>==================<br>
--- cfe/trunk/lib/AST/<wbr>ExprConstant.cpp (original)<br>
+++ cfe/trunk/lib/AST/<wbr>ExprConstant.cpp Tue May  2 14:21:42 2017<br>
@@ -148,8 +148,7 @@ namespace {<br>
  Â static unsigned<br>
  Â findMostDerivedSubobject(<wbr>ASTContext &Ctx, APValue::LValueBase Base,<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  ArrayRef<APValue::<wbr>LValuePathEntry> Path,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â uint64_t &ArraySize, QualType &Type, bool &IsArray,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â bool &IsUnsizedArray) {<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â uint64_t &ArraySize, QualType &Type, bool &IsArray) {<br>
  Â  Â // This only accepts LValueBases from APValues, and APValues don't support<br>
  Â  Â // arrays that lack size info.<br>
  Â  Â assert(!isBaseAnAllocSizeCall(<wbr>Base) &&<br>
@@ -158,34 +157,28 @@ namespace {<br>
  Â  Â Type = getType(Base);<br>
<br>
  Â  Â for (unsigned I = 0, N = Path.size(); I != N; ++I) {<br>
-  Â  Â  if (auto AT = Ctx.getAsArrayType(Type)) {<br>
+  Â  Â  if (Type->isArrayType()) {<br>
+  Â  Â  Â  const ConstantArrayType *CAT =<br>
+  Â  Â  Â  Â  Â  cast<ConstantArrayType>(Ctx.<wbr>getAsArrayType(Type));<br>
+  Â  Â  Â  Type = CAT->getElementType();<br>
+  Â  Â  Â  ArraySize = CAT->getSize().getZExtValue();<br>
  Â  Â  Â  Â MostDerivedLength = I + 1;<br>
  Â  Â  Â  Â IsArray = true;<br>
-  Â  Â  Â  if (auto CAT = Ctx.getAsConstantArrayType(<wbr>Type))<br>
-  Â  Â  Â  Â  ArraySize = CAT->getSize().getZExtValue();<br>
-  Â  Â  Â  else {<br>
-  Â  Â  Â  Â  ArraySize = 0;<br>
-  Â  Â  Â  Â  IsUnsizedArray = true;<br>
-  Â  Â  Â  }<br>
-  Â  Â  Â  Type = AT->getElementType();<br>
  Â  Â  Â } else if (Type->isAnyComplexType()) {<br>
  Â  Â  Â  Â const ComplexType *CT = Type->castAs<ComplexType>();<br>
  Â  Â  Â  Â Type = CT->getElementType();<br>
  Â  Â  Â  Â ArraySize = 2;<br>
  Â  Â  Â  Â MostDerivedLength = I + 1;<br>
  Â  Â  Â  Â IsArray = true;<br>
-  Â  Â  Â  IsUnsizedArray = false;<br>
  Â  Â  Â } else if (const FieldDecl *FD = getAsField(Path[I])) {<br>
  Â  Â  Â  Â Type = FD->getType();<br>
  Â  Â  Â  Â ArraySize = 0;<br>
  Â  Â  Â  Â MostDerivedLength = I + 1;<br>
  Â  Â  Â  Â IsArray = false;<br>
-  Â  Â  Â  IsUnsizedArray = false;<br>
  Â  Â  Â } else {<br>
  Â  Â  Â  Â // Path[I] describes a base class.<br>
  Â  Â  Â  Â ArraySize = 0;<br>
  Â  Â  Â  Â IsArray = false;<br>
-  Â  Â  Â  IsUnsizedArray = false;<br>
  Â  Â  Â }<br>
  Â  Â }<br>
  Â  Â return MostDerivedLength;<br>
@@ -207,9 +200,8 @@ namespace {<br>
  Â  Â /// Is this a pointer one past the end of an object?<br>
  Â  Â unsigned IsOnePastTheEnd : 1;<br>
<br>
-  Â  /// Indicator of whether the most-derived object is an unsized array (e.g.<br>
-  Â  /// of unknown bound).<br>
-  Â  unsigned MostDerivedIsAnUnsizedArray : 1;<br>
+  Â  /// Indicator of whether the first entry is an unsized array.<br>
+  Â  unsigned FirstEntryIsAnUnsizedArray : 1;<br>
<br>
  Â  Â /// Indicator of whether the most-derived object is an array element.<br>
  Â  Â unsigned MostDerivedIsArrayElement : 1;<br>
@@ -239,28 +231,25 @@ namespace {<br>
<br>
  Â  Â explicit SubobjectDesignator(QualType T)<br>
  Â  Â  Â  Â : Invalid(false), IsOnePastTheEnd(false),<br>
-  Â  Â  Â  Â  MostDerivedIsAnUnsizedArray(<wbr>false), MostDerivedIsArrayElement(<wbr>false),<br>
+  Â  Â  Â  Â  FirstEntryIsAnUnsizedArray(<wbr>false), MostDerivedIsArrayElement(<wbr>false),<br>
  Â  Â  Â  Â  Â MostDerivedPathLength(0), MostDerivedArraySize(0),<br>
  Â  Â  Â  Â  Â MostDerivedType(T) {}<br>
<br>
  Â  Â SubobjectDesignator(ASTContext &Ctx, const APValue &V)<br>
  Â  Â  Â  Â : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false),<br>
-  Â  Â  Â  Â  MostDerivedIsAnUnsizedArray(<wbr>false), MostDerivedIsArrayElement(<wbr>false),<br>
+  Â  Â  Â  Â  FirstEntryIsAnUnsizedArray(<wbr>false), MostDerivedIsArrayElement(<wbr>false),<br>
  Â  Â  Â  Â  Â MostDerivedPathLength(0), MostDerivedArraySize(0) {<br>
  Â  Â  Â assert(V.isLValue() && "Non-LValue used to make an LValue designator?");<br>
  Â  Â  Â if (!Invalid) {<br>
  Â  Â  Â  Â IsOnePastTheEnd = V.isLValueOnePastTheEnd();<br>
  Â  Â  Â  Â ArrayRef<PathEntry> VEntries = V.getLValuePath();<br>
  Â  Â  Â  Â Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());<br>
-  Â  Â  Â  if (auto Base = V.getLValueBase()) {<br>
-  Â  Â  Â  Â  if (auto Decl = Base.dyn_cast<ValueDecl const*>())<br>
-  Â  Â  Â  Â  Â  Base = cast<ValueDecl>(Decl-><wbr>getMostRecentDecl());<br>
-  Â  Â  Â  Â  bool IsArray = false, IsUnsizedArray = false;<br>
+  Â  Â  Â  if (V.getLValueBase()) {<br>
+  Â  Â  Â  Â  bool IsArray = false;<br>
  Â  Â  Â  Â  Â MostDerivedPathLength = findMostDerivedSubobject(<br>
-  Â  Â  Â  Â  Â  Â  Ctx, Base, V.getLValuePath(), MostDerivedArraySize,<br>
-  Â  Â  Â  Â  Â  Â  MostDerivedType, IsArray, IsUnsizedArray);<br>
-  Â  Â  Â  Â  Â  Â  MostDerivedIsArrayElement = IsArray;<br>
-  Â  Â  Â  Â  Â  Â  MostDerivedIsAnUnsizedArray = IsUnsizedArray;<br>
+  Â  Â  Â  Â  Â  Â  Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize,<br>
+  Â  Â  Â  Â  Â  Â  MostDerivedType, IsArray);<br>
+  Â  Â  Â  Â  MostDerivedIsArrayElement = IsArray;<br>
  Â  Â  Â  Â }<br>
  Â  Â  Â }<br>
  Â  Â }<br>
@@ -274,7 +263,7 @@ namespace {<br>
  Â  Â /// known bound.<br>
  Â  Â bool isMostDerivedAnUnsizedArray() const {<br>
  Â  Â  Â assert(!Invalid && "Calling this makes no sense on invalid designators");<br>
-  Â  Â  return MostDerivedIsAnUnsizedArray;<br>
+  Â  Â  return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;<br>
  Â  Â }<br>
<br>
  Â  Â /// Determine what the most derived array's size is. Results in an assertion<br>
@@ -314,7 +303,6 @@ namespace {<br>
  Â  Â  Â // This is a most-derived object.<br>
  Â  Â  Â MostDerivedType = CAT->getElementType();<br>
  Â  Â  Â MostDerivedIsArrayElement = true;<br>
-  Â  Â  MostDerivedIsAnUnsizedArray = false;<br>
  Â  Â  Â MostDerivedArraySize = CAT->getSize().getZExtValue();<br>
  Â  Â  Â MostDerivedPathLength = Entries.size();<br>
  Â  Â }<br>
@@ -327,7 +315,6 @@ namespace {<br>
<br>
  Â  Â  Â MostDerivedType = ElemTy;<br>
  Â  Â  Â MostDerivedIsArrayElement = true;<br>
-  Â  Â  MostDerivedIsAnUnsizedArray = true;<br>
  Â  Â  Â // The value in MostDerivedArraySize is undefined in this case. So, set it<br>
  Â  Â  Â // to an arbitrary value that's likely to loudly break things if it's<br>
  Â  Â  Â // used.<br>
@@ -346,7 +333,6 @@ namespace {<br>
  Â  Â  Â if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {<br>
  Â  Â  Â  Â MostDerivedType = FD->getType();<br>
  Â  Â  Â  Â MostDerivedIsArrayElement = false;<br>
-  Â  Â  Â  MostDerivedIsAnUnsizedArray = false;<br>
  Â  Â  Â  Â MostDerivedArraySize = 0;<br>
  Â  Â  Â  Â MostDerivedPathLength = Entries.size();<br>
  Â  Â  Â }<br>
@@ -361,14 +347,53 @@ namespace {<br>
  Â  Â  Â // is unlikely to matter.<br>
  Â  Â  Â MostDerivedType = EltTy;<br>
  Â  Â  Â MostDerivedIsArrayElement = true;<br>
-  Â  Â  MostDerivedIsAnUnsizedArray = false;<br>
  Â  Â  Â MostDerivedArraySize = 2;<br>
  Â  Â  Â MostDerivedPathLength = Entries.size();<br>
  Â  Â }<br>
  Â  Â void diagnosePointerArithmetic(<wbr>EvalInfo &Info, const Expr *E,<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  const APSInt &N);<br>
  Â  Â /// Add N to the address of this subobject.<br>
-  Â  void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N);<br>
+  Â  void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {<br>
+  Â  Â  if (Invalid || !N) return;<br>
+  Â  Â  uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue(<wbr>);<br>
+  Â  Â  if (isMostDerivedAnUnsizedArray()<wbr>) {<br>
+  Â  Â  Â  // Can't verify -- trust that the user is doing the right thing (or if<br>
+  Â  Â  Â  // not, trust that the caller will catch the bad behavior).<br>
+  Â  Â  Â  // FIXME: Should we reject if this overflows, at least?<br>
+  Â  Â  Â  Entries.back().ArrayIndex += TruncatedN;<br>
+  Â  Â  Â  return;<br>
+  Â  Â  }<br>
+<br>
+  Â  Â  // [expr.add]p4: For the purposes of these operators, a pointer to a<br>
+  Â  Â  // nonarray object behaves the same as a pointer to the first element of<br>
+  Â  Â  // an array of length one with the type of the object as its element type.<br>
+  Â  Â  bool IsArray = MostDerivedPathLength == Entries.size() &&<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â MostDerivedIsArrayElement;<br>
+  Â  Â  uint64_t ArrayIndex =<br>
+  Â  Â  Â  Â  IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;<br>
+  Â  Â  uint64_t ArraySize =<br>
+  Â  Â  Â  Â  IsArray ? getMostDerivedArraySize() : (uint64_t)1;<br>
+<br>
+  Â  Â  if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {<br>
+  Â  Â  Â  // Calculate the actual index in a wide enough type, so we can include<br>
+  Â  Â  Â  // it in the note.<br>
+  Â  Â  Â  N = N.extend(std::max<unsigned>(N.<wbr>getBitWidth() + 1, 65));<br>
+  Â  Â  Â  (llvm::APInt&)N += ArrayIndex;<br>
+  Â  Â  Â  assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");<br>
+  Â  Â  Â  diagnosePointerArithmetic(<wbr>Info, E, N);<br>
+  Â  Â  Â  setInvalid();<br>
+  Â  Â  Â  return;<br>
+  Â  Â  }<br>
+<br>
+  Â  Â  ArrayIndex += TruncatedN;<br>
+  Â  Â  assert(ArrayIndex <= ArraySize &&<br>
+  Â  Â  Â  Â  Â  Â "bounds check succeeded for out-of-bounds index");<br>
+<br>
+  Â  Â  if (IsArray)<br>
+  Â  Â  Â  Entries.back().ArrayIndex = ArrayIndex;<br>
+  Â  Â  else<br>
+  Â  Â  Â  IsOnePastTheEnd = (ArrayIndex != 0);<br>
+  Â  }<br>
  Â };<br>
<br>
  Â /// A stack frame in the constexpr call stack.<br>
@@ -470,7 +495,7 @@ namespace {<br>
  Â  Â  Â  Â // FIXME: Force the precision of the source value down so we don't<br>
  Â  Â  Â  Â // print digits which are usually useless (we don't really care here if<br>
  Â  Â  Â  Â // we truncate a digit by accident in edge cases).  Ideally,<br>
-  Â  Â  Â  // APFloat::toString would automatically print the shortest<br>
+  Â  Â  Â  // APFloat::toString would automatically print the shortest<br>
  Â  Â  Â  Â // representation which rounds to the correct value, but it's a bit<br>
  Â  Â  Â  Â // tricky to implement.<br>
  Â  Â  Â  Â unsigned precision =<br>
@@ -695,7 +720,7 @@ namespace {<br>
  Â private:<br>
  Â  Â OptionalDiagnostic Diag(SourceLocation Loc, diag::kind DiagId,<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â unsigned ExtraNotes, bool IsCCEDiag) {<br>
-<br>
+<br>
  Â  Â  Â if (EvalStatus.Diag) {<br>
  Â  Â  Â  Â // If we have a prior diagnostic, it will be noting that the expression<br>
  Â  Â  Â  Â // isn't a constant expression. This diagnostic is more important,<br>
@@ -748,7 +773,7 @@ namespace {<br>
  Â  Â  Â  Â  Â unsigned ExtraNotes = 0) {<br>
  Â  Â  Â return Diag(Loc, DiagId, ExtraNotes, false);<br>
  Â  Â }<br>
-<br>
+<br>
  Â  Â OptionalDiagnostic FFDiag(const Expr *E, diag::kind DiagId<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â = diag::note_invalid_subexpr_in_<wbr>const_expr,<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â unsigned ExtraNotes = 0) {<br>
@@ -1061,53 +1086,6 @@ void SubobjectDesignator::<wbr>diagnosePointe<br>
  Â setInvalid();<br>
 }<br>
<br>
-void SubobjectDesignator::<wbr>adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {<br>
-  if (Invalid || !N) return;<br>
-<br>
-  uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue(<wbr>);<br>
-  if (isMostDerivedAnUnsizedArray()<wbr>) {<br>
-  Â  // If we're dealing with an array without constant bound, the expression is<br>
-  Â  // not a constant expression.<br>
-  Â  if (!Info.<wbr>checkingPotentialConstantExpre<wbr>ssion())<br>
-  Â  Â  Info.CCEDiag(E, diag::note_constexpr_array_<wbr>unknown_bound_arithmetic);<br>
-  Â  // Can't verify -- trust that the user is doing the right thing (or if<br>
-  Â  // not, trust that the caller will catch the bad behavior).<br>
-  Â  // FIXME: Should we reject if this overflows, at least?<br>
-  Â  Entries.back().ArrayIndex += TruncatedN;<br>
-  Â  return;<br>
-  }<br>
-<br>
-  // [expr.add]p4: For the purposes of these operators, a pointer to a<br>
-  // nonarray object behaves the same as a pointer to the first element of<br>
-  // an array of length one with the type of the object as its element type.<br>
-  bool IsArray = MostDerivedPathLength == Entries.size() &&<br>
-  Â  Â  Â  Â  Â  Â  Â  Â MostDerivedIsArrayElement;<br>
-  uint64_t ArrayIndex =<br>
-  Â  Â  IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;<br>
-  uint64_t ArraySize =<br>
-  Â  Â  IsArray ? getMostDerivedArraySize() : (uint64_t)1;<br>
-<br>
-  if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {<br>
-  Â  // Calculate the actual index in a wide enough type, so we can include<br>
-  Â  // it in the note.<br>
-  Â  N = N.extend(std::max<unsigned>(N.<wbr>getBitWidth() + 1, 65));<br>
-  Â  (llvm::APInt&)N += ArrayIndex;<br>
-  Â  assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");<br>
-  Â  diagnosePointerArithmetic(<wbr>Info, E, N);<br>
-  Â  setInvalid();<br>
-  Â  return;<br>
-  }<br>
-<br>
-  ArrayIndex += TruncatedN;<br>
-  assert(ArrayIndex <= ArraySize &&<br>
-  Â  Â  Â  Â "bounds check succeeded for out-of-bounds index");<br>
-<br>
-  if (IsArray)<br>
-  Â  Entries.back().ArrayIndex = ArrayIndex;<br>
-  else<br>
-  Â  IsOnePastTheEnd = (ArrayIndex != 0);<br>
-}<br>
-<br>
 CallStackFrame::<wbr>CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  const FunctionDecl *Callee, const LValue *This,<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  APValue *Arguments)<br>
@@ -1236,6 +1214,8 @@ namespace {<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â IsNullPtr);<br>
  Â  Â  Â else {<br>
  Â  Â  Â  Â assert(!InvalidBase && "APValues can't handle invalid LValue bases");<br>
+  Â  Â  Â  assert(!Designator.<wbr>FirstEntryIsAnUnsizedArray &&<br>
+  Â  Â  Â  Â  Â  Â  Â "Unsized array with a valid base?");<br>
  Â  Â  Â  Â V = APValue(Base, Offset, Designator.Entries,<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Designator.IsOnePastTheEnd, CallIndex, IsNullPtr);<br>
  Â  Â  Â }<br>
@@ -1300,9 +1280,12 @@ namespace {<br>
  Â  Â  Â if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))<br>
  Â  Â  Â  Â Designator.addDeclUnchecked(D, Virtual);<br>
  Â  Â }<br>
-  Â  void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {<br>
-  Â  Â  if (checkSubobject(Info, E, CSK_ArrayToPointer))<br>
-  Â  Â  Â  Designator.<wbr>addUnsizedArrayUnchecked(<wbr>ElemTy);<br>
+  Â  void addUnsizedArray(EvalInfo &Info, QualType ElemTy) {<br>
+  Â  Â  assert(Designator.Entries.<wbr>empty() && getType(Base)->isPointerType()<wbr>);<br>
+  Â  Â  assert(isBaseAnAllocSizeCall(<wbr>Base) &&<br>
+  Â  Â  Â  Â  Â  Â "Only alloc_size bases can have unsized arrays");<br>
+  Â  Â  Designator.<wbr>FirstEntryIsAnUnsizedArray = true;<br>
+  Â  Â  Designator.<wbr>addUnsizedArrayUnchecked(<wbr>ElemTy);<br>
  Â  Â }<br>
  Â  Â void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {<br>
  Â  Â  Â if (checkSubobject(Info, E, CSK_ArrayToPointer))<br>
@@ -3033,15 +3016,6 @@ static CompleteObject findCompleteObject<br>
<br>
  Â  Â if (!evaluateVarDeclInit(Info, E, VD, Frame, BaseVal))<br>
  Â  Â  Â return CompleteObject();<br>
-<br>
-  Â  // The complete object can be an array of unknown bound, in which case we<br>
-  Â  // have to find the most recent declaration and adjust the type accordingly.<br>
-  Â  if (Info.Ctx.<wbr>getAsIncompleteArrayType(<wbr>BaseType)) {<br>
-  Â  Â  QualType MostRecentType =<br>
-  Â  Â  Â  Â cast<ValueDecl const>(D->getMostRecentDecl())<wbr>->getType();<br>
-  Â  Â  if (Info.Ctx.<wbr>getAsConstantArrayType(<wbr>MostRecentType))<br>
-  Â  Â  Â  BaseType = MostRecentType;<br>
-  Â  }<br>
  Â } else {<br>
  Â  Â const Expr *Base = LVal.Base.dyn_cast<const Expr*>();<br>
<br>
@@ -4124,13 +4098,13 @@ static bool CheckConstexprFunction(EvalI<br>
<br>
  Â if (Info.getLangOpts().<wbr>CPlusPlus11) {<br>
  Â  Â const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;<br>
-<br>
+<br>
  Â  Â // If this function is not constexpr because it is an inherited<br>
  Â  Â // non-constexpr constructor, diagnose that directly.<br>
  Â  Â auto *CD = dyn_cast<CXXConstructorDecl>(<wbr>DiagDecl);<br>
  Â  Â if (CD && CD->isInheritingConstructor()) {<br>
  Â  Â  Â auto *Inherited = CD->getInheritedConstructor().<wbr>getConstructor();<br>
-  Â  Â  if (!Inherited->isConstexpr())<br>
+  Â  Â  if (!Inherited->isConstexpr())<br>
  Â  Â  Â  Â DiagDecl = CD = Inherited;<br>
  Â  Â }<br>
<br>
@@ -4667,7 +4641,7 @@ public:<br>
  Â  Â  Â  Â  Â return false;<br>
  Â  Â  Â  Â This = &ThisVal;<br>
  Â  Â  Â  Â Args = Args.slice(1);<br>
-  Â  Â  } else if (MD && MD->isLambdaStaticInvoker()) {<br>
+  Â  Â  } else if (MD && MD->isLambdaStaticInvoker()) {<br>
  Â  Â  Â  Â // Map the static invoker for the lambda back to the call operator.<br>
  Â  Â  Â  Â // Conveniently, we don't have to slice out the 'this' argument (as is<br>
  Â  Â  Â  Â // being done for the non-static case), since a static member function<br>
@@ -4702,7 +4676,7 @@ public:<br>
  Â  Â  Â  Â  Â FD = LambdaCallOp;<br>
  Â  Â  Â }<br>
<br>
-<br>
+<br>
  Â  Â } else<br>
  Â  Â  Â return Error(E);<br>
<br>
@@ -5462,7 +5436,7 @@ static bool evaluateLValueAsAllocSize(Ev<br>
  Â Result.setInvalid(E);<br>
<br>
  Â QualType Pointee = E->getType()->castAs<<wbr>PointerType>()-><wbr>getPointeeType();<br>
-  Result.addUnsizedArray(Info, E, Pointee);<br>
+  Result.addUnsizedArray(Info, Pointee);<br>
  Â return true;<br>
 }<br>
<br>
@@ -5541,7 +5515,7 @@ public:<br>
  Â  Â  Â // Update 'Result' to refer to the data member/field of the closure object<br>
  Â  Â  Â // that represents the '*this' capture.<br>
  Â  Â  Â if (!HandleLValueMember(Info, E, Result,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Info.CurrentCall-><wbr>LambdaThisCaptureField))<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Info.CurrentCall-><wbr>LambdaThisCaptureField))<br>
  Â  Â  Â  Â return false;<br>
  Â  Â  Â // If we captured '*this' by reference, replace the field with its referent.<br>
  Â  Â  Â if (Info.CurrentCall-><wbr>LambdaThisCaptureField-><wbr>getType()<br>
@@ -5682,18 +5656,12 @@ bool PointerExprEvaluator::<wbr>VisitCastExpr<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Info, Result, SubExpr))<br>
  Â  Â  Â  Â return false;<br>
  Â  Â }<br>
-<br>
  Â  Â // The result is a pointer to the first element of the array.<br>
  Â  Â if (const ConstantArrayType *CAT<br>
  Â  Â  Â  Â  Â = Info.Ctx.<wbr>getAsConstantArrayType(<wbr>SubExpr->getType()))<br>
  Â  Â  Â Result.addArray(Info, E, CAT);<br>
-  Â  // If the array hasn't been given a bound yet, add it as an unsized one.<br>
-  Â  else {<br>
-  Â  Â  auto AT = Info.Ctx.getAsArrayType(<wbr>SubExpr->getType());<br>
-  Â  Â  assert(AT && "Array to pointer decay on non-array object?");<br>
-  Â  Â  Result.addUnsizedArray(Info, E, AT->getElementType());<br>
-  Â  }<br>
-<br>
+  Â  else<br>
+  Â  Â  Result.Designator.setInvalid()<wbr>;<br>
  Â  Â return true;<br>
<br>
  Â case CK_FunctionToPointerDecay:<br>
@@ -5761,7 +5729,7 @@ bool PointerExprEvaluator::<wbr>visitNonBuilt<br>
<br>
  Â Result.setInvalid(E);<br>
  Â QualType PointeeTy = E->getType()->castAs<<wbr>PointerType>()-><wbr>getPointeeType();<br>
-  Result.addUnsizedArray(Info, E, PointeeTy);<br>
+  Result.addUnsizedArray(Info, PointeeTy);<br>
  Â return true;<br>
 }<br>
<br>
@@ -6395,7 +6363,7 @@ bool RecordExprEvaluator::<wbr>VisitLambdaExp<br>
  Â if (ClosureClass->isInvalidDecl()<wbr>) return false;<br>
<br>
  Â if (Info.<wbr>checkingPotentialConstantExpre<wbr>ssion()) return true;<br>
-<br>
+<br>
  Â const size_t NumFields =<br>
  Â  Â  Â std::distance(ClosureClass-><wbr>field_begin(), ClosureClass->field_end());<br>
<br>
@@ -6414,7 +6382,7 @@ bool RecordExprEvaluator::<wbr>VisitLambdaExp<br>
  Â  Â assert(CaptureInitIt != E->capture_init_end());<br>
  Â  Â // Get the initializer for this field<br>
  Â  Â Expr *const CurFieldInit = *CaptureInitIt++;<br>
-<br>
+<br>
  Â  Â // If there is no initializer, either this is a VLA or an error has<br>
  Â  Â // occurred.<br>
  Â  Â if (!CurFieldInit)<br>
@@ -6615,18 +6583,18 @@ VectorExprEvaluator::<wbr>VisitInitListExpr(c<br>
<br>
  Â // The number of initializers can be less than the number of<br>
  Â // vector elements. For OpenCL, this can be due to nested vector<br>
-  // initialization. For GCC compatibility, missing trailing elements<br>
+  // initialization. For GCC compatibility, missing trailing elements<br>
  Â // should be initialized with zeroes.<br>
  Â unsigned CountInits = 0, CountElts = 0;<br>
  Â while (CountElts < NumElements) {<br>
  Â  Â // Handle nested vector initialization.<br>
-  Â  if (CountInits < NumInits<br>
+  Â  if (CountInits < NumInits<br>
  Â  Â  Â  Â && E->getInit(CountInits)-><wbr>getType()->isVectorType()) {<br>
  Â  Â  Â APValue v;<br>
  Â  Â  Â if (!EvaluateVector(E->getInit(<wbr>CountInits), v, Info))<br>
  Â  Â  Â  Â return Error(E);<br>
  Â  Â  Â unsigned vlen = v.getVectorLength();<br>
-  Â  Â  for (unsigned j = 0; j < vlen; j++)<br>
+  Â  Â  for (unsigned j = 0; j < vlen; j++)<br>
  Â  Â  Â  Â Elements.push_back(v.<wbr>getVectorElt(j));<br>
  Â  Â  Â CountElts += vlen;<br>
  Â  Â } else if (EltTy->isIntegerType()) {<br>
@@ -6902,7 +6870,7 @@ public:<br>
  Â }<br>
<br>
  Â bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {<br>
-  Â  assert(E->getType()-><wbr>isIntegralOrEnumerationType() &&<br>
+  Â  assert(E->getType()-><wbr>isIntegralOrEnumerationType() &&<br>
  Â  Â  Â  Â  Â  "Invalid evaluation result.");<br>
  Â  Â assert(I.getBitWidth() == Info.Ctx.getIntWidth(E-><wbr>getType()) &&<br>
  Â  Â  Â  Â  Â  "Invalid evaluation result.");<br>
@@ -6916,7 +6884,7 @@ public:<br>
  Â }<br>
<br>
  Â bool Success(uint64_t Value, const Expr *E, APValue &Result) {<br>
-  Â  assert(E->getType()-><wbr>isIntegralOrEnumerationType() &&<br>
+  Â  assert(E->getType()-><wbr>isIntegralOrEnumerationType() &&<br>
  Â  Â  Â  Â  Â  "Invalid evaluation result.");<br>
  Â  Â Result = APValue(Info.Ctx.MakeIntValue(<wbr>Value, E->getType()));<br>
  Â  Â return true;<br>
@@ -6992,7 +6960,7 @@ public:<br>
  Â  Â }<br>
  Â  Â return Success(Info.ArrayInitIndex, E);<br>
  Â }<br>
-<br>
+<br>
  Â // Note, GNU defines __null as an integer, not a pointer.<br>
  Â bool VisitGNUNullExpr(const GNUNullExpr *E) {<br>
  Â  Â return ZeroInitialization(E);<br>
@@ -7356,8 +7324,10 @@ static bool isDesignatorAtObjectEnd(cons<br>
<br>
  Â unsigned I = 0;<br>
  Â QualType BaseType = getType(Base);<br>
-  // If this is an alloc_size base, we should ignore the initial array index<br>
-  if (isBaseAnAllocSizeCall(Base)) {<br>
+  if (LVal.Designator.<wbr>FirstEntryIsAnUnsizedArray) {<br>
+  Â  assert(isBaseAnAllocSizeCall(<wbr>Base) &&<br>
+  Â  Â  Â  Â  Â "Unsized array in non-alloc_size call?");<br>
+  Â  // If this is an alloc_size base, we should ignore the initial array index<br>
  Â  Â ++I;<br>
  Â  Â BaseType = BaseType->castAs<PointerType>(<wbr>)->getPointeeType();<br>
  Â }<br>
@@ -8144,12 +8114,12 @@ bool DataRecursiveIntBinOpEvaluator<wbr>::<br>
  Â  Â Result = RHSResult.Val;<br>
  Â  Â return true;<br>
  Â }<br>
-<br>
+<br>
  Â if (E->isLogicalOp()) {<br>
  Â  Â bool lhsResult, rhsResult;<br>
  Â  Â bool LHSIsOK = HandleConversionToBool(<wbr>LHSResult.Val, lhsResult);<br>
  Â  Â bool RHSIsOK = HandleConversionToBool(<wbr>RHSResult.Val, rhsResult);<br>
-<br>
+<br>
  Â  Â if (LHSIsOK) {<br>
  Â  Â  Â if (RHSIsOK) {<br>
  Â  Â  Â  Â if (E->getOpcode() == BO_LOr)<br>
@@ -8165,26 +8135,26 @@ bool DataRecursiveIntBinOpEvaluator<wbr>::<br>
  Â  Â  Â  Â  Â return Success(rhsResult, E, Result);<br>
  Â  Â  Â }<br>
  Â  Â }<br>
-<br>
+<br>
  Â  Â return false;<br>
  Â }<br>
-<br>
+<br>
  Â assert(E->getLHS()->getType()-<wbr>>isIntegralOrEnumerationType() &&<br>
  Â  Â  Â  Â  E->getRHS()->getType()-><wbr>isIntegralOrEnumerationType())<wbr>;<br>
-<br>
+<br>
  Â if (LHSResult.Failed || RHSResult.Failed)<br>
  Â  Â return false;<br>
-<br>
+<br>
  Â const APValue &LHSVal = LHSResult.Val;<br>
  Â const APValue &RHSVal = RHSResult.Val;<br>
-<br>
+<br>
  Â // Handle cases like (unsigned long)&a + 4.<br>
  Â if (E->isAdditiveOp() && LHSVal.isLValue() && RHSVal.isInt()) {<br>
  Â  Â Result = LHSVal;<br>
  Â  Â addOrSubLValueAsInteger(<wbr>Result, RHSVal.getInt(), E->getOpcode() == BO_Sub);<br>
  Â  Â return true;<br>
  Â }<br>
-<br>
+<br>
  Â // Handle cases like 4 + (unsigned long)&a<br>
  Â if (E->getOpcode() == BO_Add &&<br>
  Â  Â  Â RHSVal.isLValue() && LHSVal.isInt()) {<br>
@@ -8192,7 +8162,7 @@ bool DataRecursiveIntBinOpEvaluator<wbr>::<br>
  Â  Â addOrSubLValueAsInteger(<wbr>Result, LHSVal.getInt(), /*IsSub*/false);<br>
  Â  Â return true;<br>
  Â }<br>
-<br>
+<br>
  Â if (E->getOpcode() == BO_Sub && LHSVal.isLValue() && RHSVal.isLValue()) {<br>
  Â  Â // Handle (intptr_t)&&A - (intptr_t)&&B.<br>
  Â  Â if (!LHSVal.getLValueOffset().<wbr>isZero() ||<br>
@@ -8231,7 +8201,7 @@ bool DataRecursiveIntBinOpEvaluator<wbr>::<br>
<br>
 void DataRecursiveIntBinOpEvaluator<wbr>::process(EvalResult &Result) {<br>
  Â Job &job = Queue.back();<br>
-<br>
+<br>
  Â switch (job.Kind) {<br>
  Â  Â case Job::AnyExprKind: {<br>
  Â  Â  Â if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.<wbr>E)) {<br>
@@ -8241,12 +8211,12 @@ void DataRecursiveIntBinOpEvaluator<wbr>::pro<br>
  Â  Â  Â  Â  Â return;<br>
  Â  Â  Â  Â }<br>
  Â  Â  Â }<br>
-<br>
+<br>
  Â  Â  Â EvaluateExpr(job.E, Result);<br>
  Â  Â  Â Queue.pop_back();<br>
  Â  Â  Â return;<br>
  Â  Â }<br>
-<br>
+<br>
  Â  Â case Job::BinOpKind: {<br>
  Â  Â  Â const BinaryOperator *Bop = cast<BinaryOperator>(job.E);<br>
  Â  Â  Â bool SuppressRHSDiags = false;<br>
@@ -8261,7 +8231,7 @@ void DataRecursiveIntBinOpEvaluator<wbr>::pro<br>
  Â  Â  Â enqueue(Bop->getRHS());<br>
  Â  Â  Â return;<br>
  Â  Â }<br>
-<br>
+<br>
  Â  Â case Job::BinOpVisitedLHSKind: {<br>
  Â  Â  Â const BinaryOperator *Bop = cast<BinaryOperator>(job.E);<br>
  Â  Â  Â EvalResult RHS;<br>
@@ -8271,7 +8241,7 @@ void DataRecursiveIntBinOpEvaluator<wbr>::pro<br>
  Â  Â  Â return;<br>
  Â  Â }<br>
  Â }<br>
-<br>
+<br>
  Â llvm_unreachable("Invalid Job::Kind!");<br>
 }<br>
<br>
@@ -8783,7 +8753,7 @@ bool IntExprEvaluator::<wbr>VisitOffsetOfExpr<br>
  Â  Â  Â const RecordType *BaseRT = CurrentType->getAs<RecordType><wbr>();<br>
  Â  Â  Â if (!BaseRT)<br>
  Â  Â  Â  Â return Error(OOE);<br>
-<br>
+<br>
  Â  Â  Â // Add the offset to the base.<br>
  Â  Â  Â Result += RL.getBaseClassOffset(cast<<wbr>CXXRecordDecl>(BaseRT-><wbr>getDecl()));<br>
  Â  Â  Â break;<br>
@@ -9978,7 +9948,7 @@ static bool FastEvaluateAsRValue(const E<br>
  Â  Â IsConst = false;<br>
  Â  Â return true;<br>
  Â }<br>
-<br>
+<br>
  Â // FIXME: Evaluating values of large array and record types can cause<br>
  Â // performance problems. Only do so in C++11 for now.<br>
  Â if (Exp->isRValue() && (Exp->getType()->isArrayType() ||<br>
@@ -10000,7 +9970,7 @@ bool Expr::EvaluateAsRValue(<wbr>EvalResult &<br>
  Â bool IsConst;<br>
  Â if (FastEvaluateAsRValue(this, Result, Ctx, IsConst, false))<br>
  Â  Â return IsConst;<br>
-<br>
+<br>
  Â EvalInfo Info(Ctx, Result, EvalInfo::EM_<wbr>IgnoreSideEffects);<br>
  Â return ::EvaluateAsRValue(Info, this, Result.Val);<br>
 }<br>
<br>
Removed: cfe/trunk/test/SemaCXX/<wbr>constexpr-array-unknown-bound.<wbr>cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/constexpr-array-unknown-bound.cpp?rev=301962&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-<wbr>project/cfe/trunk/test/<wbr>SemaCXX/constexpr-array-<wbr>unknown-bound.cpp?rev=301962&<wbr>view=auto</a><br>
==============================<wbr>==============================<wbr>==================<br>
--- cfe/trunk/test/SemaCXX/<wbr>constexpr-array-unknown-bound.<wbr>cpp (original)<br>
+++ cfe/trunk/test/SemaCXX/<wbr>constexpr-array-unknown-bound.<wbr>cpp (removed)<br>
@@ -1,25 +0,0 @@<br>
-// RUN: %clang_cc1 %s -Wno-uninitialized -std=c++1z -fsyntax-only -verify<br>
-<br>
-const extern int arr[];<br>
-constexpr auto p = arr; // ok<br>
-constexpr int f(int i) {return p[i];} // expected-note {{read of dereferenced one-past-the-end pointer}}<br>
-<br>
-constexpr int arr[] {1, 2, 3};<br>
-constexpr auto p2 = arr + 2; // ok<br>
-constexpr int x = f(2); // ok<br>
-constexpr int y = f(3); // expected-error {{constant expression}}<br>
-// expected-note-re@-1 {{in call to 'f({{.*}})'}}<br>
-<br>
-struct A {int m[];} a;<br>
-constexpr auto p3 = a.m; // ok<br>
-constexpr auto p4 = a.m + 1; // expected-error {{constant expression}} expected-note {{constant bound}}<br>
-<br>
-void g(int i) {<br>
-  int arr[i];<br>
-  constexpr auto *p = arr + 2; // expected-error {{constant expression}} expected-note {{constant bound}}<br>
-<br>
-  // FIXME: Give a better diagnostic here. The issue is that computing<br>
-  // sizeof(*arr2) within the array indexing fails due to the VLA.<br>
-  int arr2[2][i];<br>
-  constexpr int m = ((void)arr2[2], 0); // expected-error {{constant expression}}<br>
-}<br>
<br>
<br>
______________________________<wbr>_________________<br>
cfe-commits mailing list<br>
<a href="mailto:cfe-commits@lists.llvm.org">cfe-commits@lists.llvm.org</a><br>
<a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits" rel="noreferrer" target="_blank">http://lists.llvm.org/cgi-bin/<wbr>mailman/listinfo/cfe-commits</a><br>
</blockquote></div><br></div></div>