Merged main:cc7b24a4d125e9a81480aaaa961a2b963bbb2ea2 into amd-gfx:d95b5e7b86c6

Local branch amd-gfx d95b5e7 Merged main:63b2595846b86b4e4eb9afba5e97dd64e8135c10 into amd-gfx:c176ed1b3b93
Remote branch main cc7b24a [NFC] Fix typos in comments (llvm#109765)

Author: SC llvm team

clang/lib/AST/ByteCode/Compiler.cpp

@@ -431,6 +431,7 @@ bool Compiler<Emitter>::VisitCastExpr(const CastExpr *CE) {
   case CK_NoOp:
   case CK_UserDefinedConversion:
   case CK_AddressSpaceConversion:
+  case CK_CPointerToObjCPointerCast:
     return this->delegate(SubExpr);
 
   case CK_BitCast: {
@@ -3116,21 +3117,22 @@ bool Compiler<Emitter>::VisitCXXNewExpr(const CXXNewExpr *E) {
         if (!this->discard(Arg1))
           return false;
         IsNoThrow = true;
-      } else if (Ctx.getLangOpts().CPlusPlus26 &&
-                 OperatorNew->isReservedGlobalPlacementOperator()) {
+      } else {
+        // Invalid unless we have C++26 or are in a std:: function.
+        if (!this->emitInvalidNewDeleteExpr(E, E))
+          return false;
+
         // If we have a placement-new destination, we'll later use that instead
         // of allocating.
-        PlacementDest = Arg1;
-      } else {
-        return this->emitInvalidNewDeleteExpr(E, E);
+        if (OperatorNew->isReservedGlobalPlacementOperator())
+          PlacementDest = Arg1;
       }
-
     } else {
+      // Always invalid.
       return this->emitInvalid(E);
     }
-  } else if (!OperatorNew->isReplaceableGlobalAllocationFunction()) {
+  } else if (!OperatorNew->isReplaceableGlobalAllocationFunction())
     return this->emitInvalidNewDeleteExpr(E, E);
-  }
 
   const Descriptor *Desc;
   if (!PlacementDest) {

clang/lib/AST/ByteCode/Interp.cpp

@@ -1293,6 +1293,13 @@ bool CheckNewTypeMismatch(InterpState &S, CodePtr OpPC, const Expr *E,
   if (!CheckStore(S, OpPC, Ptr))
     return false;
 
+  if (!InvalidNewDeleteExpr(S, OpPC, E))
+    return false;
+
+  // Assume proper types in std functions.
+  if (S.Current->isStdFunction())
+    return true;
+
   const auto *NewExpr = cast<CXXNewExpr>(E);
   QualType StorageType = Ptr.getType();
 
@@ -1334,10 +1341,16 @@ bool InvalidNewDeleteExpr(InterpState &S, CodePtr OpPC, const Expr *E) {
   assert(E);
   const auto &Loc = S.Current->getSource(OpPC);
 
+  if (S.getLangOpts().CPlusPlus26)
+    return true;
+
   if (const auto *NewExpr = dyn_cast<CXXNewExpr>(E)) {
     const FunctionDecl *OperatorNew = NewExpr->getOperatorNew();
 
     if (!S.getLangOpts().CPlusPlus26 && NewExpr->getNumPlacementArgs() > 0) {
+      // This is allowed pre-C++26, but only an std function.
+      if (S.Current->isStdFunction())
+        return true;
       S.FFDiag(Loc, diag::note_constexpr_new_placement)
           << /*C++26 feature*/ 1 << E->getSourceRange();
     } else if (NewExpr->getNumPlacementArgs() == 1 &&

clang/lib/AST/ByteCode/InterpBuiltin.cpp

@@ -1345,8 +1345,7 @@ static bool interp__builtin_operator_new(InterpState &S, CodePtr OpPC,
   assert(!ElemT);
   // Structs etc.
   const Descriptor *Desc = S.P.createDescriptor(
-      Call, ElemType.getTypePtr(),
-      NumElems.ule(1) ? std::nullopt : Descriptor::InlineDescMD,
+      Call, ElemType.getTypePtr(), Descriptor::InlineDescMD,
       /*IsConst=*/false, /*IsTemporary=*/false, /*IsMutable=*/false,
       /*Init=*/nullptr);
 

clang/lib/AST/ByteCode/InterpFrame.cpp

@@ -257,3 +257,13 @@ SourceRange InterpFrame::getRange(CodePtr PC) const {
 
   return S.getRange(Func, PC);
 }
+
+bool InterpFrame::isStdFunction() const {
+  if (!Func)
+    return false;
+  for (const DeclContext *DC = Func->getDecl(); DC; DC = DC->getParent())
+    if (DC->isStdNamespace())
+      return true;
+
+  return false;
+}

clang/lib/AST/ByteCode/InterpFrame.h

@@ -117,6 +117,8 @@ class InterpFrame final : public Frame {
 
   unsigned getDepth() const { return Depth; }
 
+  bool isStdFunction() const;
+
   void dump() const { dump(llvm::errs(), 0); }
   void dump(llvm::raw_ostream &OS, unsigned Indent = 0) const;
 

clang/lib/Basic/Targets/BPF.cpp

@@ -37,6 +37,7 @@ void BPFTargetInfo::getTargetDefines(const LangOptions &Opts,
   }
 
   Builder.defineMacro("__BPF_FEATURE_ADDR_SPACE_CAST");
+  Builder.defineMacro("__BPF_FEATURE_MAY_GOTO");
 
   if (CPU.empty())
     CPU = "v3";
@@ -48,7 +49,6 @@ void BPFTargetInfo::getTargetDefines(const LangOptions &Opts,
 
   std::string CpuVerNumStr = CPU.substr(1);
   Builder.defineMacro("__BPF_CPU_VERSION__", CpuVerNumStr);
-  Builder.defineMacro("__BPF_FEATURE_MAY_GOTO");
 
   int CpuVerNum = std::stoi(CpuVerNumStr);
   if (CpuVerNum >= 2)

clang/lib/Sema/SemaDecl.cpp

@@ -9762,26 +9762,26 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   if (getLangOpts().CPlusPlus) {
     // The rules for implicit inlines changed in C++20 for methods and friends
     // with an in-class definition (when such a definition is not attached to
-    // the global module).  User-specified 'inline' overrides this (set when
-    // the function decl is created above).
+    // the global module). This does not affect declarations that are already
+    // inline (whether explicitly or implicitly by being declared constexpr,
+    // consteval, etc).
     // FIXME: We need a better way to separate C++ standard and clang modules.
     bool ImplicitInlineCXX20 = !getLangOpts().CPlusPlusModules ||
-                               NewFD->isConstexpr() || NewFD->isConsteval() ||
                                !NewFD->getOwningModule() ||
                                NewFD->isFromGlobalModule() ||
                                NewFD->getOwningModule()->isHeaderLikeModule();
     bool isInline = D.getDeclSpec().isInlineSpecified();
     bool isVirtual = D.getDeclSpec().isVirtualSpecified();
     bool hasExplicit = D.getDeclSpec().hasExplicitSpecifier();
     isFriend = D.getDeclSpec().isFriendSpecified();
-    if (isFriend && !isInline && D.isFunctionDefinition()) {
+    if (ImplicitInlineCXX20 && isFriend && D.isFunctionDefinition()) {
       // Pre-C++20 [class.friend]p5
       //   A function can be defined in a friend declaration of a
       //   class . . . . Such a function is implicitly inline.
       // Post C++20 [class.friend]p7
       //   Such a function is implicitly an inline function if it is attached
       //   to the global module.
-      NewFD->setImplicitlyInline(ImplicitInlineCXX20);
+      NewFD->setImplicitlyInline();
     }
 
     // If this is a method defined in an __interface, and is not a constructor
@@ -10083,15 +10083,15 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
       break;
     }
 
-    if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
-        D.isFunctionDefinition() && !isInline) {
+    if (ImplicitInlineCXX20 && isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
+        D.isFunctionDefinition()) {
       // Pre C++20 [class.mfct]p2:
       //   A member function may be defined (8.4) in its class definition, in
       //   which case it is an inline member function (7.1.2)
       // Post C++20 [class.mfct]p1:
       //   If a member function is attached to the global module and is defined
       //   in its class definition, it is inline.
-      NewFD->setImplicitlyInline(ImplicitInlineCXX20);
+      NewFD->setImplicitlyInline();
     }
 
     if (!isFriend && SC != SC_None) {

clang/test/AST/ByteCode/codegen.m

@@ -10,3 +10,8 @@
 //
 // CHECK-NEXT: @.str = {{.*}}constant [13 x i8] c"Hello World!\00", section "__TEXT,__cstring,cstring_literals", align 1
 id a = @"Hello World!";
+
+extern void OBJC_CLASS_$_f;
+Class c = (Class)&OBJC_CLASS_$_f;
+// CHECK: @c ={{.*}} global ptr @"OBJC_CLASS_$_f"
+// CHECK: @"OBJC_CLASS_$_f" ={{.*}} global %struct._class_t

clang/test/AST/ByteCode/new-delete.cpp

@@ -594,6 +594,10 @@ namespace std {
                                     // both-note {{used to delete a null pointer}}
     }
   };
+  template<typename T, typename ...Args>
+  constexpr void construct_at(void *p, Args &&...args) { // #construct
+    new (p) T((Args&&)args...);
+  }
 }
 
 /// Specialization for float, using operator new/delete.
@@ -762,6 +766,16 @@ namespace Placement {
   }
   static_assert(ok1()); // both-error {{not an integral constant expression}} \
                         // both-note {{in call to}}
+
+  /// placement-new should be supported before C++26 in std functions.
+  constexpr int ok2() {
+    int *I = new int;
+    std::construct_at<int>(I);
+    int r = *I;
+    delete I;
+    return r;
+  }
+  static_assert(ok2()== 0);
 }
 
 #else

clang/test/AST/ByteCode/placement-new.cpp

@@ -3,6 +3,18 @@
 
 namespace std {
   using size_t = decltype(sizeof(0));
+  template<typename T> struct allocator {
+    constexpr T *allocate(size_t N) {
+      return (T*)operator new(sizeof(T) * N);
+    }
+    constexpr void deallocate(void *p) {
+      operator delete(p);
+    }
+  };
+  template<typename T, typename ...Args>
+  constexpr void construct_at(void *p, Args &&...args) {
+    new (p) T((Args&&)args...); // both-note {{in call to}}
+  }
 }
 
 void *operator new(std::size_t, void *p) { return p; }
@@ -217,3 +229,35 @@ namespace records {
   }
   static_assert(foo() == 0);
 }
+
+namespace ConstructAt {
+  struct S {
+    int a = 10;
+    float b = 1.0;
+  };
+
+  constexpr bool ok1() {
+    S s;
+
+    std::construct_at<S>(&s);
+    return s.a == 10 && s.b == 1.0;
+  }
+  static_assert(ok1());
+
+  struct S2 {
+    constexpr S2() {
+      (void)(1/0); // both-note {{division by zero}} \
+                   // both-warning {{division by zero is undefined}}
+    }
+  };
+
+  constexpr bool ctorFail() { //
+    S2 *s = std::allocator<S2>().allocate(1);
+    std::construct_at<S2>(s); // both-note {{in call to}}
+
+    return true;
+  }
+  static_assert(ctorFail()); // both-error {{not an integral constant expression}} \
+                             // both-note {{in call to 'ctorFail()'}}
+
+}