Update swift:main to support llvm-project:stable/20211026 changes (Rebranch merge)

include/swift/Basic/APIntMap.h

@@ -38,11 +38,11 @@ struct WidthPreservingAPIntDenseMapInfo {
   }
 
   static unsigned getHashValue(const APInt &Key) {
-    return static_cast<unsigned>(hash_value(Key));
+    return llvm::DenseMapInfo<APInt>::getHashValue(Key);
   }
 
   static bool isEqual(const APInt &LHS, const APInt &RHS) {
-    return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
+    return llvm::DenseMapInfo<APInt>::isEqual(LHS, RHS);
   }
 };
 

include/swift/Basic/ExponentialGrowthAppendingBinaryByteStream.h

@@ -42,29 +42,29 @@ class ExponentialGrowthAppendingBinaryByteStream
 
   llvm::support::endianness getEndian() const override { return Endian; }
 
-  llvm::Error readBytes(uint32_t Offset, uint32_t Size,
+  llvm::Error readBytes(uint64_t Offset, uint64_t Size,
                         ArrayRef<uint8_t> &Buffer) override;
 
-  llvm::Error readLongestContiguousChunk(uint32_t Offset,
+  llvm::Error readLongestContiguousChunk(uint64_t Offset,
                                          ArrayRef<uint8_t> &Buffer) override;
 
   MutableArrayRef<uint8_t> data() { return Data; }
 
-  uint32_t getLength() override { return Data.size(); }
+  uint64_t getLength() override { return Data.size(); }
 
-  llvm::Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Buffer) override;
+  llvm::Error writeBytes(uint64_t Offset, ArrayRef<uint8_t> Buffer) override;
 
   /// This is an optimized version of \c writeBytes specifically for integers.
   /// Integers are written in little-endian byte order.
   template<typename T>
-  llvm::Error writeInteger(uint32_t Offset, T Value) {
+  llvm::Error writeInteger(uint64_t Offset, T Value) {
     static_assert(std::is_integral<T>::value, "Integer required.");
     if (auto Error = checkOffsetForWrite(Offset, sizeof(T))) {
       return Error;
     }
 
     // Resize the internal buffer if needed.
-    uint32_t RequiredSize = Offset + sizeof(T);
+    uint64_t RequiredSize = Offset + sizeof(T);
     if (RequiredSize > Data.size()) {
       Data.resize(RequiredSize);
     }

include/swift/Basic/ExternalUnion.h

@@ -24,8 +24,9 @@
 
 #include "llvm/Support/ErrorHandling.h"
 #include "swift/Basic/type_traits.h"
+#include <cassert>
+#include <cstdint>
 #include <utility>
-#include <assert.h>
 
 namespace swift {
 

include/swift/Demangling/TypeLookupError.h

@@ -20,7 +20,8 @@
 
 #include "swift/Basic/TaggedUnion.h"
 #include "swift/Runtime/Portability.h"
-#include <string.h>
+#include <cstring>
+#include <string>
 
 namespace swift {
 

lib/AST/Availability.cpp

@@ -506,6 +506,7 @@ ASTContext::getSwift5PlusAvailability(llvm::VersionTuple swiftVersion) {
     default: break;
     }
   }
-  llvm::report_fatal_error("Missing call to getSwiftXYAvailability for Swift " +
-                           swiftVersion.getAsString());
+  llvm::report_fatal_error(
+      Twine("Missing call to getSwiftXYAvailability for Swift ") +
+      swiftVersion.getAsString());
 }

lib/AST/Builtins.cpp

@@ -2208,18 +2208,17 @@ getSwiftFunctionTypeForIntrinsic(llvm::Intrinsic::ID ID,
       return false;
     ArgElts.push_back(ArgTy);
   }
-  
+
   // Translate LLVM function attributes to Swift function attributes.
   IntrinsicInfo II;
   II.ID = ID;
   auto attrs = II.getOrCreateAttributes(Context);
-  if (attrs.hasAttribute(llvm::AttributeList::FunctionIndex,
-                         llvm::Attribute::NoReturn)) {
+  if (attrs.hasFnAttr(llvm::Attribute::NoReturn)) {
     ResultTy = Context.getNeverType();
     if (!ResultTy)
       return false;
   }
-  
+
   return true;
 }
 

lib/Basic/ExponentialGrowthAppendingBinaryByteStream.cpp

@@ -16,7 +16,7 @@ using namespace llvm;
 using namespace swift;
 
 Error ExponentialGrowthAppendingBinaryByteStream::readBytes(
-    uint32_t Offset, uint32_t Size, ArrayRef<uint8_t> &Buffer) {
+    uint64_t Offset, uint64_t Size, ArrayRef<uint8_t> &Buffer) {
   if (auto Error = checkOffsetForRead(Offset, Size)) {
     return Error;
   }
@@ -26,7 +26,7 @@ Error ExponentialGrowthAppendingBinaryByteStream::readBytes(
 }
 
 Error ExponentialGrowthAppendingBinaryByteStream::readLongestContiguousChunk(
-    uint32_t Offset, ArrayRef<uint8_t> &Buffer) {
+    uint64_t Offset, ArrayRef<uint8_t> &Buffer) {
   if (auto Error = checkOffsetForRead(Offset, 0)) {
     return Error;
   }
@@ -40,7 +40,7 @@ void ExponentialGrowthAppendingBinaryByteStream::reserve(size_t Size) {
 }
 
 Error ExponentialGrowthAppendingBinaryByteStream::writeBytes(
-    uint32_t Offset, ArrayRef<uint8_t> Buffer) {
+    uint64_t Offset, ArrayRef<uint8_t> Buffer) {
   if (Buffer.empty())
     return Error::success();
 
@@ -49,7 +49,7 @@ Error ExponentialGrowthAppendingBinaryByteStream::writeBytes(
   }
 
   // Resize the internal buffer if needed.
-  uint32_t RequiredSize = Offset + Buffer.size();
+  uint64_t RequiredSize = Offset + Buffer.size();
   if (RequiredSize > Data.size()) {
     Data.resize(RequiredSize);
   }

lib/ClangImporter/CFTypeInfo.h

@@ -14,9 +14,10 @@
 //
 //===----------------------------------------------------------------------===//
 #ifndef SWIFT_IMPORTER_CFTYPEINFO_H
-#define SWIFT_IMPORTER_CFTYPEINFO_H 
+#define SWIFT_IMPORTER_CFTYPEINFO_H
 
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace clang {
   class RecordDecl;

lib/ClangImporter/ClangAdapter.cpp

@@ -396,6 +396,7 @@ OmissionTypeName importer::getClangTypeNameForOmission(clang::ASTContext &ctx,
     case clang::BuiltinType::Float16:
     case clang::BuiltinType::Float128:
     case clang::BuiltinType::NullPtr:
+    case clang::BuiltinType::Ibm128:
       return OmissionTypeName();
 
     // Objective-C types that aren't mapped directly; rather, pointers to

lib/ClangImporter/ClangImporter.cpp

@@ -1130,6 +1130,10 @@ ClangImporter::create(ASTContext &ctx,
 
   // Create a compiler instance.
   {
+    // The Clang modules produced by ClangImporter are always embedded in an
+    // ObjectFilePCHContainer and contain -gmodules debug info.
+    importer->Impl.Invocation->getCodeGenOpts().DebugTypeExtRefs = true;
+
     auto PCHContainerOperations =
       std::make_shared<clang::PCHContainerOperations>();
     PCHContainerOperations->registerWriter(

lib/ClangImporter/ImportType.cpp

@@ -289,6 +289,7 @@ namespace {
       case clang::BuiltinType::Float128:
       case clang::BuiltinType::NullPtr:
       case clang::BuiltinType::Char8:
+      case clang::BuiltinType::Ibm128:
         return Type();
 
       // Objective-C types that aren't mapped directly; rather, pointers to

lib/ClangImporter/ImporterImpl.h

@@ -1738,7 +1738,7 @@ class SwiftNameLookupExtension : public clang::ModuleFileExtension {
         buffersForDiagnostics(buffersForDiagnostics), availability(avail) {}
 
   clang::ModuleFileExtensionMetadata getExtensionMetadata() const override;
-  llvm::hash_code hashExtension(llvm::hash_code code) const override;
+  void hashExtension(ExtensionHashBuilder &HBuilder) const override;
 
   std::unique_ptr<clang::ModuleFileExtensionWriter>
   createExtensionWriter(clang::ASTWriter &writer) override;

lib/ClangImporter/SwiftLookupTable.cpp

@@ -1849,12 +1849,12 @@ SwiftNameLookupExtension::getExtensionMetadata() const {
   return metadata;
 }
 
-llvm::hash_code
-SwiftNameLookupExtension::hashExtension(llvm::hash_code code) const {
-  return llvm::hash_combine(code, StringRef("swift.lookup"),
-                            SWIFT_LOOKUP_TABLE_VERSION_MAJOR,
-                            SWIFT_LOOKUP_TABLE_VERSION_MINOR,
-                            version::getSwiftFullVersion());
+void
+SwiftNameLookupExtension::hashExtension(ExtensionHashBuilder &HBuilder) const {
+  HBuilder.add(StringRef("swift.lookup"));
+  HBuilder.add(SWIFT_LOOKUP_TABLE_VERSION_MAJOR);
+  HBuilder.add(SWIFT_LOOKUP_TABLE_VERSION_MINOR);
+  HBuilder.add(version::getSwiftFullVersion());
 }
 
 void importer::addEntryToLookupTable(SwiftLookupTable &table,

lib/Demangling/Demangler.cpp

@@ -91,10 +91,8 @@ static bool isRequirement(Node::Kind kind) {
 // Public utility functions    //
 //////////////////////////////////
 
-LLVM_ATTRIBUTE_NORETURN void swift::Demangle::failAssert(const char *file,
-                                                         unsigned line,
-                                                         NodePointer node,
-                                                         const char *expr) {
+void swift::Demangle::failAssert(const char *file, unsigned line,
+                                 NodePointer node, const char *expr) {
   fprintf(stderr, "%s:%u: assertion failed for Node %p: %s", file, line, node,
           expr);
   abort();

lib/Demangling/DemanglerAssert.h

@@ -46,8 +46,8 @@ namespace swift {
 namespace Demangle {
 SWIFT_BEGIN_INLINE_NAMESPACE
 
-LLVM_ATTRIBUTE_NORETURN void failAssert(const char *file, unsigned line,
-                                        NodePointer node, const char *expr);
+[[noreturn]] void failAssert(const char *file, unsigned line, NodePointer node,
+                             const char *expr);
 
 SWIFT_END_INLINE_NAMESPACE
 } // end namespace Demangle

lib/DependencyScan/ScanDependencies.cpp

@@ -808,8 +808,8 @@ generateFullDependencyGraph(CompilerInstance &instance,
                                         module.first,
                                         {module.second, currentImportPathSet});
     if (!moduleDepsQuery) {
-      std::string err = "Module Dependency Cache missing module" + module.first;
-      llvm::report_fatal_error(err);
+      llvm::report_fatal_error(Twine("Module Dependency Cache missing module") +
+                               module.first);
     }
 
     auto moduleDeps = *moduleDepsQuery;

lib/Driver/Driver.cpp

@@ -1157,7 +1157,8 @@ parseArgsUntil(const llvm::opt::OptTable& Opts,
     }
 
     unsigned Prev = Index;
-    Arg *A = Opts.ParseOneArg(*Args, Index, FlagsToInclude, FlagsToExclude);
+    Arg *A = Opts.ParseOneArg(*Args, Index, FlagsToInclude, FlagsToExclude)
+                 .release();
     assert(Index > Prev && "Parser failed to consume argument.");
 
     // Check for missing argument error.

lib/Driver/UnixToolChains.cpp

@@ -310,11 +310,11 @@ toolchains::GenericUnix::constructInvocation(const DynamicLinkJobAction &job,
   }
 
   if (!linkFilePath.empty()) {
-    auto linkFile = linkFilePath.str();
-    if (llvm::sys::fs::is_regular_file(linkFile)) {
-      Arguments.push_back(context.Args.MakeArgString(Twine("@") + linkFile));
+    if (llvm::sys::fs::is_regular_file(linkFilePath)) {
+      Arguments.push_back(
+          context.Args.MakeArgString(Twine("@") + linkFilePath));
     } else {
-      llvm::report_fatal_error(linkFile + " not found");
+      llvm::report_fatal_error(Twine(linkFilePath) + " not found");
     }
   }
 

lib/DriverTool/swift_symbolgraph_extract_main.cpp

@@ -23,6 +23,7 @@
 #include "swift/Option/Options.h"
 #include "swift/SymbolGraphGen/SymbolGraphGen.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;

lib/FrontendTool/FrontendTool.cpp

@@ -1880,15 +1880,15 @@ int swift::performFrontend(ArrayRef<const char *> Args,
   //
   // Unfortunately it's not really safe to do anything else, since very
   // low-level operations in LLVM can trigger fatal errors.
-  auto diagnoseFatalError = [&PDC](const std::string &reason, bool shouldCrash){
-    static const std::string *recursiveFatalError = nullptr;
+  auto diagnoseFatalError = [&PDC](const char *reason, bool shouldCrash) {
+    static const char *recursiveFatalError = nullptr;
     if (recursiveFatalError) {
       // Report the /original/ error through LLVM's default handler, not
       // whatever we encountered.
       llvm::remove_fatal_error_handler();
-      llvm::report_fatal_error(*recursiveFatalError, shouldCrash);
+      llvm::report_fatal_error(recursiveFatalError, shouldCrash);
     }
-    recursiveFatalError = &reason;
+    recursiveFatalError = reason;
 
     SourceManager dummyMgr;
 
@@ -1904,12 +1904,13 @@ int swift::performFrontend(ArrayRef<const char *> Args,
     if (shouldCrash)
       abort();
   };
-  llvm::ScopedFatalErrorHandler handler([](void *rawCallback,
-                                           const std::string &reason,
-                                           bool shouldCrash) {
-    auto *callback = static_cast<decltype(&diagnoseFatalError)>(rawCallback);
-    (*callback)(reason, shouldCrash);
-  }, &diagnoseFatalError);
+  llvm::ScopedFatalErrorHandler handler(
+      [](void *rawCallback, const char *reason, bool shouldCrash) {
+        auto *callback =
+            static_cast<decltype(&diagnoseFatalError)>(rawCallback);
+        (*callback)(reason, shouldCrash);
+      },
+      &diagnoseFatalError);
 
   std::unique_ptr<CompilerInstance> Instance =
     std::make_unique<CompilerInstance>();