Merge branch 'main' into constexpr-string-erase

Author: frederick-vs-ja

clang/lib/AST/ByteCode/Compiler.cpp

@@ -2843,6 +2843,8 @@ bool Compiler<Emitter>::VisitLambdaExpr(const LambdaExpr *E) {
 
   assert(Initializing);
   const Record *R = P.getOrCreateRecord(E->getLambdaClass());
+  if (!R)
+    return false;
 
   auto *CaptureInitIt = E->capture_init_begin();
   // Initialize all fields (which represent lambda captures) of the
@@ -4087,9 +4089,8 @@ bool Compiler<Emitter>::visitZeroRecordInitializer(const Record *R,
     } else if (D->isRecord()) {
       if (!this->visitZeroRecordInitializer(D->ElemRecord, E))
         return false;
-    } else {
-      assert(false);
-    }
+    } else
+      return false;
 
     if (!this->emitFinishInitPop(E))
       return false;

clang/lib/AST/ByteCode/Descriptor.cpp

@@ -404,10 +404,10 @@ Descriptor::Descriptor(const DeclTy &D, const Record *R, MetadataSize MD,
 }
 
 /// Dummy.
-Descriptor::Descriptor(const DeclTy &D)
-    : Source(D), ElemSize(1), Size(1), MDSize(0), AllocSize(MDSize),
-      ElemRecord(nullptr), IsConst(true), IsMutable(false), IsTemporary(false),
-      IsDummy(true) {
+Descriptor::Descriptor(const DeclTy &D, MetadataSize MD)
+    : Source(D), ElemSize(1), Size(1), MDSize(MD.value_or(0)),
+      AllocSize(MDSize), ElemRecord(nullptr), IsConst(true), IsMutable(false),
+      IsTemporary(false), IsDummy(true) {
   assert(Source && "Missing source");
 }
 

clang/lib/AST/ByteCode/Descriptor.h

@@ -200,7 +200,7 @@ struct Descriptor final {
              bool IsTemporary, bool IsMutable);
 
   /// Allocates a dummy descriptor.
-  Descriptor(const DeclTy &D);
+  Descriptor(const DeclTy &D, MetadataSize MD = std::nullopt);
 
   /// Make this descriptor a dummy descriptor.
   void makeDummy() { IsDummy = true; }
@@ -263,7 +263,7 @@ struct Descriptor final {
   bool isUnknownSizeArray() const { return Size == UnknownSizeMark; }
 
   /// Checks if the descriptor is of a primitive.
-  bool isPrimitive() const { return !IsArray && !ElemRecord; }
+  bool isPrimitive() const { return !IsArray && !ElemRecord && !IsDummy; }
 
   /// Checks if the descriptor is of an array.
   bool isArray() const { return IsArray; }

clang/lib/AST/ByteCode/Interp.h

@@ -1065,7 +1065,8 @@ inline bool CmpHelperEQ<Pointer>(InterpState &S, CodePtr OpPC, CompareFn Fn) {
   for (const auto &P : {LHS, RHS}) {
     if (P.isZero())
       continue;
-    if (BothNonNull && P.pointsToLiteral()) {
+    if (BothNonNull && P.pointsToLiteral() &&
+        isa<StringLiteral>(P.getDeclDesc()->asExpr())) {
       const SourceInfo &Loc = S.Current->getSource(OpPC);
       S.FFDiag(Loc, diag::note_constexpr_literal_comparison);
       return false;

clang/lib/AST/ByteCode/Pointer.cpp

@@ -248,7 +248,12 @@ APValue Pointer::toAPValue(const ASTContext &ASTCtx) const {
         Index = Ptr.getIndex();
 
       QualType ElemType = Desc->getElemQualType();
-      Offset += (Index * ASTCtx.getTypeSizeInChars(ElemType));
+      if (const auto *RD = ElemType->getAsRecordDecl();
+          RD && !RD->getDefinition()) {
+        // Ignore this for the offset.
+      } else {
+        Offset += (Index * ASTCtx.getTypeSizeInChars(ElemType));
+      }
       if (Ptr.getArray().getType()->isArrayType())
         Path.push_back(APValue::LValuePathEntry::ArrayIndex(Index));
       Ptr = Ptr.getArray();

clang/lib/AST/ByteCode/Program.cpp

@@ -393,6 +393,7 @@ Descriptor *Program::createDescriptor(const DeclTy &D, const Type *Ty,
     if (const auto *Record = getOrCreateRecord(RT->getDecl()))
       return allocateDescriptor(D, Record, MDSize, IsConst, IsTemporary,
                                 IsMutable);
+    return allocateDescriptor(D, MDSize);
   }
 
   // Arrays.

clang/lib/Analysis/FlowSensitive/Transfer.cpp

@@ -60,7 +60,9 @@ static BoolValue &evaluateBooleanEquality(const Expr &LHS, const Expr &RHS,
   Value *LHSValue = Env.getValue(LHS);
   Value *RHSValue = Env.getValue(RHS);
 
-  if (LHSValue == RHSValue)
+  // When two unsupported values are compared, both are nullptr. Only supported
+  // values should evaluate to equal.
+  if (LHSValue == RHSValue && LHSValue)
     return Env.getBoolLiteralValue(true);
 
   if (auto *LHSBool = dyn_cast_or_null<BoolValue>(LHSValue))
@@ -798,6 +800,14 @@ class TransferVisitor : public ConstStmtVisitor<TransferVisitor> {
     Env.setValue(*S, Env.getIntLiteralValue(S->getValue()));
   }
 
+  // Untyped nullptr's aren't handled by NullToPointer casts, so they need to be
+  // handled separately.
+  void VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) {
+    auto &NullPointerVal =
+        Env.getOrCreateNullPointerValue(S->getType()->getPointeeType());
+    Env.setValue(*S, NullPointerVal);
+  }
+
   void VisitParenExpr(const ParenExpr *S) {
     // The CFG does not contain `ParenExpr` as top-level statements in basic
     // blocks, however manual traversal to sub-expressions may encounter them.

clang/test/AST/ByteCode/builtin-functions.cpp

@@ -1008,9 +1008,9 @@ namespace shufflevector {
 
 namespace FunctionStart {
   void a(void) {}
-  static_assert(__builtin_function_start(a) == a, ""); // both-error {{not an integral constant expression}} \
+  static_assert(__builtin_function_start(a) == a, ""); // ref-error {{not an integral constant expression}} \
                                                        // ref-note {{comparison against opaque constant address '&__builtin_function_start(a)'}} \
-                                                       // expected-note {{comparison of addresses of potentially overlapping literals has unspecified value}}
+                                                       // expected-error {{static assertion failed}}
 }
 
 namespace BuiltinInImplicitCtor {

clang/test/AST/ByteCode/functions.cpp

@@ -484,6 +484,18 @@ namespace AddressOf {
   void testAddressof(int x) {
     static_assert(&x == __builtin_addressof(x), "");
   }
+
+  struct TS {
+    constexpr bool f(TS s) const {
+      /// The addressof call has a CXXConstructExpr as a parameter.
+      return this != __builtin_addressof(s);
+    }
+  };
+  constexpr bool exprAddressOf() {
+    TS s;
+    return s.f(s);
+  }
+  static_assert(exprAddressOf(), "");
 }
 
 namespace std {

clang/test/AST/ByteCode/records.cpp

@@ -1747,3 +1747,15 @@ namespace CtorOfInvalidClass {
   template<ReferenceOf<InvalidCtor> auto R, typename Rep> int F; // both-error {{non-type template argument is not a constant expression}}
 #endif
 }
+
+namespace IncompleteTypes {
+  struct Incomplete;
+
+  constexpr bool foo() {
+    extern Incomplete bounded[10];
+    extern Incomplete unbounded[];
+    extern Incomplete IT;
+    return true;
+  }
+  static_assert(foo(), "");
+}