merge main into amd-stg-open

Change-Id: Id69edef44c1f1fb3eefe9a71413a00c831ba10ee

Author: Jenkins

CONTRIBUTING.md

@@ -5,8 +5,7 @@ contribute, and we appreciate all contributions.
 
 To get started with contributing, please take a look at the
 [Contributing to LLVM](https://llvm.org/docs/Contributing.html) guide. It
-describes how to get involved, raise issues and submit patches. Please note
-that at the moment the LLVM project does not use GitHub pull requests.
+describes how to get involved, raise issues and submit patches.
 
 ## Getting in touch
 

clang-tools-extra/clang-tidy/bugprone/NonZeroEnumToBoolConversionCheck.cpp

@@ -49,6 +49,11 @@ bool NonZeroEnumToBoolConversionCheck::isLanguageVersionSupported(
 }
 
 void NonZeroEnumToBoolConversionCheck::registerMatchers(MatchFinder *Finder) {
+  // Excluding bitwise operators (binary and overload) to avoid false-positives
+  // in code like this 'if (e & SUCCESS) {'.
+  auto ExcludedOperators = binaryOperation(hasAnyOperatorName(
+      "|", "&", "^", "<<", ">>", "~", "|=", "&=", "^=", "<<=", ">>="));
+
   Finder->addMatcher(
       castExpr(hasCastKind(CK_IntegralToBoolean),
                unless(isExpansionInSystemHeader()), hasType(booleanType()),
@@ -58,7 +63,8 @@ void NonZeroEnumToBoolConversionCheck::registerMatchers(MatchFinder *Finder) {
                                      unless(matchers::matchesAnyListedName(
                                          EnumIgnoreList)))
                                 .bind("enum"))))),
-                        unless(declRefExpr(to(enumConstantDecl()))))),
+                        unless(declRefExpr(to(enumConstantDecl()))),
+                        unless(ignoringImplicit(ExcludedOperators)))),
                unless(hasAncestor(staticAssertDecl())))
           .bind("cast"),
       this);

clang-tools-extra/docs/ReleaseNotes.rst

@@ -183,6 +183,10 @@ Changes in existing checks
   <clang-tidy/checks/bugprone/lambda-function-name>` check by adding option
   `IgnoreMacros` to ignore warnings in macros.
 
+- Improved :doc:`bugprone-non-zero-enum-to-bool-conversion
+  <clang-tidy/checks/bugprone/non-zero-enum-to-bool-conversion>` check by
+  eliminating false positives resulting from direct usage of bitwise operators.
+
 - Improved :doc:`bugprone-reserved-identifier
   <clang-tidy/checks/bugprone/reserved-identifier>` check, so that it does not
   warn on macros starting with underscore and lowercase letter.

clang-tools-extra/test/clang-tidy/checkers/bugprone/non-zero-enum-to-bool-conversion.cpp

@@ -82,6 +82,14 @@ bool explicitCompare(EStatus value) {
   return value == SUCCESS;
 }
 
+bool explicitBitUsage1(EStatus value) {
+  return (value & SUCCESS);
+}
+
+bool explicitBitUsage2(EStatus value) {
+  return (value | SUCCESS);
+}
+
 bool testEnumeratorCompare() {
   return SUCCESS;
 }
@@ -104,4 +112,16 @@ bool testIgnored(IgnoredSecondEnum value) {
   return value;
 }
 
+enum CustomOperatorEnum {
+    E0 = 0x1,
+    E1 = 0x2,
+    E2 = 0x4
+};
+
+CustomOperatorEnum operator&(CustomOperatorEnum a, CustomOperatorEnum b) { return static_cast<CustomOperatorEnum>(a & b); }
+
+void testCustomOperator(CustomOperatorEnum e) {
+    if (e & E1) {}
+}
+
 }

clang/docs/ClangFormatStyleOptions.rst

@@ -5514,7 +5514,7 @@ the configuration (without a prefix: ``Auto``).
 .. _SpacesInParentheses:
 
 **SpacesInParentheses** (``Boolean``) :versionbadge:`clang-format 3.7` :ref:`¶ <SpacesInParentheses>`
-  If ``true'', spaces will be inserted after ``(`` and before ``)``.
+  If ``true``, spaces will be inserted after ``(`` and before ``)``.
   This option is **deprecated**. The previous behavior is preserved by using
   ``SpacesInParens`` with ``Custom`` and by setting all
   ``SpacesInParensOptions`` to ``true`` except for ``InCStyleCasts`` and

clang/include/clang/ARCMigrate/FileRemapper.h

@@ -9,6 +9,7 @@
 #ifndef LLVM_CLANG_ARCMIGRATE_FILEREMAPPER_H
 #define LLVM_CLANG_ARCMIGRATE_FILEREMAPPER_H
 
+#include "clang/Basic/FileEntry.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerUnion.h"
@@ -23,7 +24,6 @@ namespace llvm {
 
 namespace clang {
   class FileManager;
-  class FileEntry;
   class DiagnosticsEngine;
   class PreprocessorOptions;
 
@@ -33,11 +33,11 @@ class FileRemapper {
   // FIXME: Reuse the same FileManager for multiple ASTContexts.
   std::unique_ptr<FileManager> FileMgr;
 
-  typedef llvm::PointerUnion<const FileEntry *, llvm::MemoryBuffer *> Target;
-  typedef llvm::DenseMap<const FileEntry *, Target> MappingsTy;
+  typedef llvm::PointerUnion<FileEntryRef, llvm::MemoryBuffer *> Target;
+  using MappingsTy = llvm::DenseMap<FileEntryRef, Target>;
   MappingsTy FromToMappings;
 
-  llvm::DenseMap<const FileEntry *, const FileEntry *> ToFromMappings;
+  llvm::DenseMap<const FileEntry *, FileEntryRef> ToFromMappings;
 
 public:
   FileRemapper();
@@ -66,10 +66,10 @@ class FileRemapper {
   void clear(StringRef outputDir = StringRef());
 
 private:
-  void remap(const FileEntry *file, std::unique_ptr<llvm::MemoryBuffer> memBuf);
-  void remap(const FileEntry *file, const FileEntry *newfile);
+  void remap(FileEntryRef file, std::unique_ptr<llvm::MemoryBuffer> memBuf);
+  void remap(FileEntryRef file, FileEntryRef newfile);
 
-  const FileEntry *getOriginalFile(StringRef filePath);
+  OptionalFileEntryRef getOriginalFile(StringRef filePath);
   void resetTarget(Target &targ);
 
   bool report(const Twine &err, DiagnosticsEngine &Diag);

clang/include/clang/AST/Expr.h

@@ -566,7 +566,7 @@ class Expr : public ValueStmt {
                                       SmallVectorImpl<
                                         PartialDiagnosticAt> &Diags);
 
-  /// isPotentialConstantExprUnevaluted - Return true if this expression might
+  /// isPotentialConstantExprUnevaluated - Return true if this expression might
   /// be usable in a constant expression in C++11 in an unevaluated context, if
   /// it were in function FD marked constexpr. Return false if the function can
   /// never produce a constant expression, along with diagnostics describing

clang/include/clang/Format/Format.h

@@ -4351,7 +4351,7 @@ struct FormatStyle {
     SIPO_Custom,
   };
 
-  /// If ``true'', spaces will be inserted after ``(`` and before ``)``.
+  /// If ``true``, spaces will be inserted after ``(`` and before ``)``.
   /// This option is **deprecated**. The previous behavior is preserved by using
   /// ``SpacesInParens`` with ``Custom`` and by setting all
   /// ``SpacesInParensOptions`` to ``true`` except for ``InCStyleCasts`` and

clang/lib/ARCMigrate/FileRemapper.cpp

@@ -60,7 +60,7 @@ bool FileRemapper::initFromFile(StringRef filePath, DiagnosticsEngine &Diag,
   if (!llvm::sys::fs::exists(infoFile))
     return false;
 
-  std::vector<std::pair<const FileEntry *, const FileEntry *> > pairs;
+  std::vector<std::pair<FileEntryRef, FileEntryRef>> pairs;
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileBuf =
       llvm::MemoryBuffer::getFile(infoFile, /*IsText=*/true);
@@ -78,20 +78,20 @@ bool FileRemapper::initFromFile(StringRef filePath, DiagnosticsEngine &Diag,
                     Diag);
     StringRef toFilename = lines[idx+2];
 
-    llvm::ErrorOr<const FileEntry *> origFE = FileMgr->getFile(fromFilename);
+    auto origFE = FileMgr->getOptionalFileRef(fromFilename);
     if (!origFE) {
       if (ignoreIfFilesChanged)
         continue;
       return report("File does not exist: " + fromFilename, Diag);
     }
-    llvm::ErrorOr<const FileEntry *> newFE = FileMgr->getFile(toFilename);
+    auto newFE = FileMgr->getOptionalFileRef(toFilename);
     if (!newFE) {
       if (ignoreIfFilesChanged)
         continue;
       return report("File does not exist: " + toFilename, Diag);
     }
 
-    if ((uint64_t)(*origFE)->getModificationTime() != timeModified) {
+    if ((uint64_t)origFE->getModificationTime() != timeModified) {
       if (ignoreIfFilesChanged)
         continue;
       return report("File was modified: " + fromFilename, Diag);
@@ -128,23 +128,24 @@ bool FileRemapper::flushToFile(StringRef outputPath, DiagnosticsEngine &Diag) {
   for (MappingsTy::iterator
          I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
 
-    const FileEntry *origFE = I->first;
-    SmallString<200> origPath = StringRef(origFE->getName());
+    FileEntryRef origFE = I->first;
+    SmallString<200> origPath = StringRef(origFE.getName());
     fs::make_absolute(origPath);
     infoOut << origPath << '\n';
-    infoOut << (uint64_t)origFE->getModificationTime() << '\n';
+    infoOut << (uint64_t)origFE.getModificationTime() << '\n';
 
-    if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
-      SmallString<200> newPath = StringRef(FE->getName());
+    if (I->second.is<FileEntryRef>()) {
+      auto FE = I->second.get<FileEntryRef>();
+      SmallString<200> newPath = StringRef(FE.getName());
       fs::make_absolute(newPath);
       infoOut << newPath << '\n';
     } else {
 
       SmallString<64> tempPath;
       int fd;
       if (fs::createTemporaryFile(
-              path::filename(origFE->getName()),
-              path::extension(origFE->getName()).drop_front(), fd, tempPath,
+              path::filename(origFE.getName()),
+              path::extension(origFE.getName()).drop_front(), fd, tempPath,
               llvm::sys::fs::OF_Text))
         return report("Could not create file: " + tempPath.str(), Diag);
 
@@ -153,10 +154,10 @@ bool FileRemapper::flushToFile(StringRef outputPath, DiagnosticsEngine &Diag) {
       newOut.write(mem->getBufferStart(), mem->getBufferSize());
       newOut.close();
 
-      auto newE = FileMgr->getFile(tempPath);
+      auto newE = FileMgr->getOptionalFileRef(tempPath);
       if (newE) {
         remap(origFE, *newE);
-        infoOut << (*newE)->getName() << '\n';
+        infoOut << newE->getName() << '\n';
       }
     }
   }
@@ -171,14 +172,14 @@ bool FileRemapper::overwriteOriginal(DiagnosticsEngine &Diag,
 
   for (MappingsTy::iterator
          I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
-    const FileEntry *origFE = I->first;
+    FileEntryRef origFE = I->first;
     assert(I->second.is<llvm::MemoryBuffer *>());
-    if (!fs::exists(origFE->getName()))
-      return report(StringRef("File does not exist: ") + origFE->getName(),
+    if (!fs::exists(origFE.getName()))
+      return report(StringRef("File does not exist: ") + origFE.getName(),
                     Diag);
 
     std::error_code EC;
-    llvm::raw_fd_ostream Out(origFE->getName(), EC, llvm::sys::fs::OF_None);
+    llvm::raw_fd_ostream Out(origFE.getName(), EC, llvm::sys::fs::OF_None);
     if (EC)
       return report(EC.message(), Diag);
 
@@ -196,24 +197,26 @@ void FileRemapper::forEachMapping(
     llvm::function_ref<void(StringRef, const llvm::MemoryBufferRef &)>
         CaptureBuffer) const {
   for (auto &Mapping : FromToMappings) {
-    if (const FileEntry *FE = Mapping.second.dyn_cast<const FileEntry *>()) {
-      CaptureFile(Mapping.first->getName(), FE->getName());
+    if (Mapping.second.is<FileEntryRef>()) {
+      auto FE = Mapping.second.get<FileEntryRef>();
+      CaptureFile(Mapping.first.getName(), FE.getName());
       continue;
     }
     CaptureBuffer(
-        Mapping.first->getName(),
+        Mapping.first.getName(),
         Mapping.second.get<llvm::MemoryBuffer *>()->getMemBufferRef());
   }
 }
 
 void FileRemapper::applyMappings(PreprocessorOptions &PPOpts) const {
   for (MappingsTy::const_iterator
          I = FromToMappings.begin(), E = FromToMappings.end(); I != E; ++I) {
-    if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
-      PPOpts.addRemappedFile(I->first->getName(), FE->getName());
+    if (I->second.is<FileEntryRef>()) {
+      auto FE = I->second.get<FileEntryRef>();
+      PPOpts.addRemappedFile(I->first.getName(), FE.getName());
     } else {
       llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
-      PPOpts.addRemappedFile(I->first->getName(), mem);
+      PPOpts.addRemappedFile(I->first.getName(), mem);
     }
   }
 
@@ -222,38 +225,37 @@ void FileRemapper::applyMappings(PreprocessorOptions &PPOpts) const {
 
 void FileRemapper::remap(StringRef filePath,
                          std::unique_ptr<llvm::MemoryBuffer> memBuf) {
-  remap(getOriginalFile(filePath), std::move(memBuf));
+  OptionalFileEntryRef File = getOriginalFile(filePath);
+  assert(File);
+  remap(*File, std::move(memBuf));
 }
 
-void FileRemapper::remap(const FileEntry *file,
+void FileRemapper::remap(FileEntryRef file,
                          std::unique_ptr<llvm::MemoryBuffer> memBuf) {
-  assert(file);
   Target &targ = FromToMappings[file];
   resetTarget(targ);
   targ = memBuf.release();
 }
 
-void FileRemapper::remap(const FileEntry *file, const FileEntry *newfile) {
-  assert(file && newfile);
+void FileRemapper::remap(FileEntryRef file, FileEntryRef newfile) {
   Target &targ = FromToMappings[file];
   resetTarget(targ);
   targ = newfile;
-  ToFromMappings[newfile] = file;
+  ToFromMappings.insert({newfile, file});
 }
 
-const FileEntry *FileRemapper::getOriginalFile(StringRef filePath) {
-  const FileEntry *file = nullptr;
-  if (auto fileOrErr = FileMgr->getFile(filePath))
-    file = *fileOrErr;
+OptionalFileEntryRef FileRemapper::getOriginalFile(StringRef filePath) {
+  OptionalFileEntryRef File = FileMgr->getOptionalFileRef(filePath);
+  if (!File)
+    return std::nullopt;
   // If we are updating a file that overridden an original file,
   // actually update the original file.
-  llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
-    I = ToFromMappings.find(file);
+  auto I = ToFromMappings.find(*File);
   if (I != ToFromMappings.end()) {
-    file = I->second;
-    assert(FromToMappings.contains(file) && "Original file not in mappings!");
+    *File = I->second;
+    assert(FromToMappings.contains(*File) && "Original file not in mappings!");
   }
-  return file;
+  return File;
 }
 
 void FileRemapper::resetTarget(Target &targ) {
@@ -263,7 +265,7 @@ void FileRemapper::resetTarget(Target &targ) {
   if (llvm::MemoryBuffer *oldmem = targ.dyn_cast<llvm::MemoryBuffer *>()) {
     delete oldmem;
   } else {
-    const FileEntry *toFE = targ.get<const FileEntry *>();
+    FileEntryRef toFE = targ.get<FileEntryRef>();
     ToFromMappings.erase(toFE);
   }
 }

clang/lib/Basic/Targets/AArch64.cpp

@@ -335,7 +335,18 @@ void AArch64TargetInfo::getTargetDefinesARMV94A(const LangOptions &Opts,
 void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
                                          MacroBuilder &Builder) const {
   // Target identification.
-  Builder.defineMacro("__aarch64__");
+  if (getTriple().isWindowsArm64EC()) {
+    // Define the same set of macros as would be defined on x86_64 to ensure that
+    // ARM64EC datatype layouts match those of x86_64 compiled code
+    Builder.defineMacro("__amd64__");
+    Builder.defineMacro("__amd64");
+    Builder.defineMacro("__x86_64");
+    Builder.defineMacro("__x86_64__");
+    Builder.defineMacro("__arm64ec__");
+  } else {
+    Builder.defineMacro("__aarch64__");
+  }
+
   // Inline assembly supports AArch64 flag outputs.
   Builder.defineMacro("__GCC_ASM_FLAG_OUTPUTS__");
 
@@ -1465,7 +1476,13 @@ MicrosoftARM64TargetInfo::MicrosoftARM64TargetInfo(const llvm::Triple &Triple,
 void MicrosoftARM64TargetInfo::getTargetDefines(const LangOptions &Opts,
                                                 MacroBuilder &Builder) const {
   WindowsARM64TargetInfo::getTargetDefines(Opts, Builder);
-  Builder.defineMacro("_M_ARM64", "1");
+  if (getTriple().isWindowsArm64EC()) {
+    Builder.defineMacro("_M_X64", "100");
+    Builder.defineMacro("_M_AMD64", "100");
+    Builder.defineMacro("_M_ARM64EC", "1");
+  } else {
+    Builder.defineMacro("_M_ARM64", "1");
+  }
 }
 
 TargetInfo::CallingConvKind

clang/lib/Driver/ToolChains/Darwin.cpp

@@ -53,9 +53,6 @@ llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
   // translation.
 
   return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
-      .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
-      .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
-      .Case("ppc64", llvm::Triple::ppc64)
       .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
       .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
              llvm::Triple::x86)

clang/lib/Serialization/ASTReader.cpp

@@ -5689,7 +5689,7 @@ llvm::Error ASTReader::ReadSubmoduleBlock(ModuleFile &F,
                                        "too many submodules");
 
       if (!ParentModule) {
-        if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
+        if (OptionalFileEntryRef CurFile = CurrentModule->getASTFile()) {
           // Don't emit module relocation error if we have -fno-validate-pch
           if (!bool(PP.getPreprocessorOpts().DisablePCHOrModuleValidation &
                     DisableValidationForModuleKind::Module) &&