merge main into amd-staging

Change-Id: I5a27c62a1c06b2dd867b52e19aca27c249173aa0

Author: Jenkins

bolt/lib/Rewrite/LinuxKernelRewriter.cpp

@@ -484,11 +484,11 @@ void LinuxKernelRewriter::updateLKMarkers() {
         LKPatcher->addLE64Patch(LKMarkerInfo.SectionOffset, NewAddress);
     }
   }
-  outs() << "BOLT-INFO: patching linux kernel sections. Total patches per "
-            "section are as follows:\n";
+  BC.outs() << "BOLT-INFO: patching linux kernel sections. Total patches per "
+               "section are as follows:\n";
   for (const std::pair<const std::string, uint64_t> &KV : PatchCounts)
-    outs() << "  Section: " << KV.first << ", patch-counts: " << KV.second
-           << '\n';
+    BC.outs() << "  Section: " << KV.first << ", patch-counts: " << KV.second
+              << '\n';
 }
 
 Error LinuxKernelRewriter::readORCTables() {
@@ -530,8 +530,8 @@ Error LinuxKernelRewriter::readORCTables() {
                                "out of bounds while reading ORC IP table");
 
     if (IP < PrevIP && opts::Verbosity)
-      errs() << "BOLT-WARNING: out of order IP 0x" << Twine::utohexstr(IP)
-             << " detected while reading ORC\n";
+      BC.errs() << "BOLT-WARNING: out of order IP 0x" << Twine::utohexstr(IP)
+                << " detected while reading ORC\n";
 
     PrevIP = IP;
 
@@ -564,8 +564,8 @@ Error LinuxKernelRewriter::readORCTables() {
 
     if (!BF) {
       if (opts::Verbosity)
-        errs() << "BOLT-WARNING: no binary function found matching ORC 0x"
-               << Twine::utohexstr(IP) << ": " << Entry.ORC << '\n';
+        BC.errs() << "BOLT-WARNING: no binary function found matching ORC 0x"
+                  << Twine::utohexstr(IP) << ": " << Entry.ORC << '\n';
       continue;
     }
 
@@ -591,15 +591,15 @@ Error LinuxKernelRewriter::readORCTables() {
     BC.MIB->addAnnotation(*Inst, "ORC", Entry.ORC);
   }
 
-  outs() << "BOLT-INFO: parsed " << NumORCEntries << " ORC entries\n";
+  BC.outs() << "BOLT-INFO: parsed " << NumORCEntries << " ORC entries\n";
 
   if (opts::DumpORC) {
-    outs() << "BOLT-INFO: ORC unwind information:\n";
+    BC.outs() << "BOLT-INFO: ORC unwind information:\n";
     for (const ORCListEntry &E : ORCEntries) {
-      outs() << "0x" << Twine::utohexstr(E.IP) << ": " << E.ORC;
+      BC.outs() << "0x" << Twine::utohexstr(E.IP) << ": " << E.ORC;
       if (E.BF)
-        outs() << ": " << *E.BF;
-      outs() << '\n';
+        BC.outs() << ": " << *E.BF;
+      BC.outs() << '\n';
     }
   }
 
@@ -632,12 +632,12 @@ Error LinuxKernelRewriter::readORCTables() {
   llvm::sort(ORCEntries);
 
   if (opts::DumpORC) {
-    outs() << "BOLT-INFO: amended ORC unwind information:\n";
+    BC.outs() << "BOLT-INFO: amended ORC unwind information:\n";
     for (const ORCListEntry &E : ORCEntries) {
-      outs() << "0x" << Twine::utohexstr(E.IP) << ": " << E.ORC;
+      BC.outs() << "0x" << Twine::utohexstr(E.IP) << ": " << E.ORC;
       if (E.BF)
-        outs() << ": " << *E.BF;
-      outs() << '\n';
+        BC.outs() << ": " << *E.BF;
+      BC.outs() << '\n';
     }
   }
 
@@ -684,8 +684,8 @@ Error LinuxKernelRewriter::processORCPostCFG() {
                  "ORC info at function entry expected.");
 
           if (It->ORC == NullORC && BF.hasORC()) {
-            errs() << "BOLT-WARNING: ORC unwind info excludes prologue for "
-                   << BF << '\n';
+            BC.errs() << "BOLT-WARNING: ORC unwind info excludes prologue for "
+                      << BF << '\n';
           }
 
           It->BF = &BF;
@@ -878,9 +878,10 @@ Error LinuxKernelRewriter::readStaticCalls() {
     ++EntryID;
 
     if (opts::DumpStaticCalls) {
-      outs() << "Static Call Site: " << EntryID << '\n';
-      outs() << "\tCallAddress:   0x" << Twine::utohexstr(CallAddress) << '\n'
-             << "\tKeyAddress:    0x" << Twine::utohexstr(KeyAddress) << '\n';
+      BC.outs() << "Static Call Site: " << EntryID << '\n';
+      BC.outs() << "\tCallAddress:   0x" << Twine::utohexstr(CallAddress)
+                << "\n\tKeyAddress:    0x" << Twine::utohexstr(KeyAddress)
+                << '\n';
     }
 
     BinaryFunction *BF = BC.getBinaryFunctionContainingAddress(CallAddress);
@@ -916,8 +917,8 @@ Error LinuxKernelRewriter::readStaticCalls() {
     StaticCallEntries.push_back({EntryID, BF, Label});
   }
 
-  outs() << "BOLT-INFO: parsed " << StaticCallEntries.size()
-         << " static call entries\n";
+  BC.outs() << "BOLT-INFO: parsed " << StaticCallEntries.size()
+            << " static call entries\n";
 
   return Error::success();
 }

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

@@ -1408,13 +1408,16 @@ const IdentifierNamingCheck::FileStyle &
 IdentifierNamingCheck::getStyleForFile(StringRef FileName) const {
   if (!GetConfigPerFile)
     return *MainFileStyle;
-  StringRef Parent = llvm::sys::path::parent_path(FileName);
+
+  SmallString<128> RealFileName;
+  llvm::sys::fs::real_path(FileName, RealFileName);
+  StringRef Parent = llvm::sys::path::parent_path(RealFileName);
   auto Iter = NamingStylesCache.find(Parent);
   if (Iter != NamingStylesCache.end())
     return Iter->getValue();
 
   llvm::StringRef CheckName = getID();
-  ClangTidyOptions Options = Context->getOptionsForFile(FileName);
+  ClangTidyOptions Options = Context->getOptionsForFile(RealFileName);
   if (Options.Checks && GlobList(*Options.Checks).contains(CheckName)) {
     auto It = NamingStylesCache.try_emplace(
         Parent,

clang-tools-extra/docs/ReleaseNotes.rst

@@ -188,6 +188,10 @@ Changes in existing checks
   <clang-tidy/checks/readability/redundant-inline-specifier>` check to properly
   emit warnings for static data member with an in-class initializer.
 
+- Improved :doc:`readability-identifier-naming
+  <clang-tidy/checks/readability/identifier-naming>` check in `GetConfigPerFile`
+  mode by resolving symbolic links to header files.
+
 Removed checks
 ^^^^^^^^^^^^^^
 

clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/symlink/include/.clang-tidy

@@ -0,0 +1,4 @@
+Checks: readability-identifier-naming
+CheckOptions:
+  readability-identifier-naming.GlobalConstantCase: CamelCase
+  readability-identifier-naming.GlobalConstantPrefix: k

clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/symlink/include/test.h

@@ -0,0 +1 @@
+const int global_const = 5;

clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-symlink.cpp

@@ -0,0 +1,18 @@
+// Specify `-std=c++20` to run test only once becuase test expects changes
+// in the header file so it fails if runs multiple times with different
+// `-std` flags as check_clang_tidy doesn by default.
+//
+// RUN: rm -rf %T/symlink
+// RUN: cp -r %S/Inputs/identifier-naming/symlink %T/symlink
+// RUN: mkdir -p %T/symlink/build
+// RUN: ln -s %T/symlink/include/test.h %T/symlink/build/test.h
+// RUN: %check_clang_tidy -std=c++20 %s readability-identifier-naming %t -- --header-filter="test.h" --config-file=%S/Inputs/identifier-naming/symlink/include/.clang-tidy -- -I %T/symlink/build
+// UNSUPPORTED: system-windows
+
+#include "test.h"
+
+int foo() {
+    return global_const;
+    // CHECK-MESSAGES: warning: invalid case style for global constant 'global_const' [readability-identifier-naming]
+    // CHECK-FIXES: return kGlobalConst;
+}

clang/docs/ReleaseNotes.rst

@@ -270,6 +270,8 @@ Bug Fixes to C++ Support
 - No longer reject valid use of the ``_Alignas`` specifier when declaring a
   local variable, which is supported as a C11 extension in C++. Previously, it
   was only accepted at namespace scope but not at local function scope.
+- Clang no longer tries to call consteval constructors at runtime when they appear in a member initializer.
+  (`#782154 <https://github.com/llvm/llvm-project/issues/82154>`_`)
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^

clang/lib/AST/Interp/ByteCodeExprGen.cpp

@@ -1157,8 +1157,13 @@ bool ByteCodeExprGen<Emitter>::VisitMemberExpr(const MemberExpr *E) {
   if (DiscardResult)
     return this->discard(Base);
 
-  if (!this->delegate(Base))
-    return false;
+  if (Initializing) {
+    if (!this->delegate(Base))
+      return false;
+  } else {
+    if (!this->visit(Base))
+      return false;
+  }
 
   // Base above gives us a pointer on the stack.
   // TODO: Implement non-FieldDecl members.
@@ -1716,6 +1721,9 @@ bool ByteCodeExprGen<Emitter>::VisitTypeTraitExpr(const TypeTraitExpr *E) {
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitLambdaExpr(const LambdaExpr *E) {
+  if (DiscardResult)
+    return true;
+
   assert(Initializing);
   const Record *R = P.getOrCreateRecord(E->getLambdaClass());
 
@@ -1848,6 +1856,8 @@ bool ByteCodeExprGen<Emitter>::VisitCXXConstructExpr(
 
     // Immediately call the destructor if we have to.
     if (DiscardResult) {
+      if (!this->emitRecordDestruction(getRecord(E->getType())))
+        return false;
       if (!this->emitPopPtr(E))
         return false;
     }
@@ -2463,17 +2473,6 @@ bool ByteCodeExprGen<Emitter>::dereferenceVar(
     }
   }
 
-  // If the declaration is a constant value, emit it here even
-  // though the declaration was not evaluated in the current scope.
-  // The access mode can only be read in this case.
-  if (!DiscardResult && AK == DerefKind::Read) {
-    if (VD->hasLocalStorage() && VD->hasInit() && !VD->isConstexpr()) {
-      QualType VT = VD->getType();
-      if (VT.isConstQualified() && VT->isFundamentalType())
-        return this->visit(VD->getInit());
-    }
-  }
-
   // Value cannot be produced - try to emit pointer.
   return visit(LV) && Indirect(T);
 }
@@ -2744,10 +2743,9 @@ bool ByteCodeExprGen<Emitter>::visitVarDecl(const VarDecl *VD) {
         return this->emitSetLocal(*VarT, Offset, VD);
       }
     } else {
-      if (std::optional<unsigned> Offset = this->allocateLocal(VD)) {
-        if (Init)
-          return this->visitLocalInitializer(Init, *Offset);
-      }
+      if (std::optional<unsigned> Offset = this->allocateLocal(VD))
+        return !Init || this->visitLocalInitializer(Init, *Offset);
+      return false;
     }
     return true;
   }
@@ -2822,14 +2820,28 @@ bool ByteCodeExprGen<Emitter>::VisitCallExpr(const CallExpr *E) {
     }
   }
 
+  auto Args = E->arguments();
+  // Calling a static operator will still
+  // pass the instance, but we don't need it.
+  // Discard it here.
+  if (isa<CXXOperatorCallExpr>(E)) {
+    if (const auto *MD =
+            dyn_cast_if_present<CXXMethodDecl>(E->getDirectCallee());
+        MD && MD->isStatic()) {
+      if (!this->discard(E->getArg(0)))
+        return false;
+      Args = drop_begin(Args, 1);
+    }
+  }
+
   // Add the (optional, implicit) This pointer.
   if (const auto *MC = dyn_cast<CXXMemberCallExpr>(E)) {
     if (!this->visit(MC->getImplicitObjectArgument()))
       return false;
   }
 
   // Put arguments on the stack.
-  for (const auto *Arg : E->arguments()) {
+  for (const auto *Arg : Args) {
     if (!this->visit(Arg))
       return false;
   }
@@ -3365,45 +3377,8 @@ bool ByteCodeExprGen<Emitter>::emitComplexReal(const Expr *SubExpr) {
   return true;
 }
 
-/// When calling this, we have a pointer of the local-to-destroy
-/// on the stack.
-/// Emit destruction of record types (or arrays of record types).
 template <class Emitter>
-bool ByteCodeExprGen<Emitter>::emitRecordDestruction(const Descriptor *Desc) {
-  assert(Desc);
-  assert(!Desc->isPrimitive());
-  assert(!Desc->isPrimitiveArray());
-
-  // Arrays.
-  if (Desc->isArray()) {
-    const Descriptor *ElemDesc = Desc->ElemDesc;
-    assert(ElemDesc);
-
-    // Don't need to do anything for these.
-    if (ElemDesc->isPrimitiveArray())
-      return this->emitPopPtr(SourceInfo{});
-
-    // If this is an array of record types, check if we need
-    // to call the element destructors at all. If not, try
-    // to save the work.
-    if (const Record *ElemRecord = ElemDesc->ElemRecord) {
-      if (const CXXDestructorDecl *Dtor = ElemRecord->getDestructor();
-          !Dtor || Dtor->isTrivial())
-        return this->emitPopPtr(SourceInfo{});
-    }
-
-    for (ssize_t I = Desc->getNumElems() - 1; I >= 0; --I) {
-      if (!this->emitConstUint64(I, SourceInfo{}))
-        return false;
-      if (!this->emitArrayElemPtrUint64(SourceInfo{}))
-        return false;
-      if (!this->emitRecordDestruction(ElemDesc))
-        return false;
-    }
-    return this->emitPopPtr(SourceInfo{});
-  }
-
-  const Record *R = Desc->ElemRecord;
+bool ByteCodeExprGen<Emitter>::emitRecordDestruction(const Record *R) {
   assert(R);
   // First, destroy all fields.
   for (const Record::Field &Field : llvm::reverse(R->fields())) {
@@ -3413,7 +3388,9 @@ bool ByteCodeExprGen<Emitter>::emitRecordDestruction(const Descriptor *Desc) {
         return false;
       if (!this->emitGetPtrField(Field.Offset, SourceInfo{}))
         return false;
-      if (!this->emitRecordDestruction(D))
+      if (!this->emitDestruction(D))
+        return false;
+      if (!this->emitPopPtr(SourceInfo{}))
         return false;
     }
   }
@@ -3437,13 +3414,57 @@ bool ByteCodeExprGen<Emitter>::emitRecordDestruction(const Descriptor *Desc) {
   for (const Record::Base &Base : llvm::reverse(R->bases())) {
     if (!this->emitGetPtrBase(Base.Offset, SourceInfo{}))
       return false;
-    if (!this->emitRecordDestruction(Base.Desc))
+    if (!this->emitRecordDestruction(Base.R))
+      return false;
+    if (!this->emitPopPtr(SourceInfo{}))
       return false;
   }
+
   // FIXME: Virtual bases.
+  return true;
+}
+/// When calling this, we have a pointer of the local-to-destroy
+/// on the stack.
+/// Emit destruction of record types (or arrays of record types).
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::emitDestruction(const Descriptor *Desc) {
+  assert(Desc);
+  assert(!Desc->isPrimitive());
+  assert(!Desc->isPrimitiveArray());
+
+  // Arrays.
+  if (Desc->isArray()) {
+    const Descriptor *ElemDesc = Desc->ElemDesc;
+    assert(ElemDesc);
+
+    // Don't need to do anything for these.
+    if (ElemDesc->isPrimitiveArray())
+      return true;
+
+    // If this is an array of record types, check if we need
+    // to call the element destructors at all. If not, try
+    // to save the work.
+    if (const Record *ElemRecord = ElemDesc->ElemRecord) {
+      if (const CXXDestructorDecl *Dtor = ElemRecord->getDestructor();
+          !Dtor || Dtor->isTrivial())
+        return true;
+    }
+
+    for (ssize_t I = Desc->getNumElems() - 1; I >= 0; --I) {
+      if (!this->emitConstUint64(I, SourceInfo{}))
+        return false;
+      if (!this->emitArrayElemPtrUint64(SourceInfo{}))
+        return false;
+      if (!this->emitDestruction(ElemDesc))
+        return false;
+      if (!this->emitPopPtr(SourceInfo{}))
+        return false;
+    }
+    return true;
+  }
 
-  // Remove the instance pointer.
-  return this->emitPopPtr(SourceInfo{});
+  assert(Desc->ElemRecord);
+  return this->emitRecordDestruction(Desc->ElemRecord);
 }
 
 namespace clang {