Merge pull request #29744 from apple/master-rebranch

Merge master-rebranch into master to support new llvm branch apple/stable/20200108

Author: shahmishal

CMakeLists.txt

@@ -32,6 +32,11 @@ endif()
 
 ENABLE_LANGUAGE(C)
 
+# Use C++14.
+set(CMAKE_CXX_STANDARD 14 CACHE STRING "C++ standard to conform to")
+set(CMAKE_CXX_STANDARD_REQUIRED YES)
+set(CMAKE_CXX_EXTENSIONS NO)
+
 # First include general CMake utilities.
 include(SwiftUtils)
 include(CheckSymbolExists)

cmake/modules/SwiftXcodeSupport.cmake

@@ -100,8 +100,8 @@ macro(swift_common_xcode_cxx_config)
   # Force usage of Clang.
   set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvm.clang.1_0"
       CACHE STRING "Xcode Compiler")
-  # Use C++'11.
-  set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++11"
+  # Use C++'14.
+  set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++14"
       CACHE STRING "Xcode C++ Language Standard")
   # Use libc++.
   set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++"

include/swift/ABI/TrailingObjects.h

@@ -55,6 +55,7 @@
 #ifndef SWIFT_ABI_TRAILINGOBJECTS_H
 #define SWIFT_ABI_TRAILINGOBJECTS_H
 
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
@@ -175,7 +176,7 @@ class TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, PrevTy, NextTy,
 
     if (requiresRealignment())
       return reinterpret_cast<const NextTy *>(
-          llvm::alignAddr(Ptr, alignof(NextTy)));
+          llvm::alignAddr(Ptr, llvm::Align(alignof(NextTy))));
     else
       return reinterpret_cast<const NextTy *>(Ptr);
   }
@@ -189,7 +190,8 @@ class TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, PrevTy, NextTy,
                     Obj, TrailingObjectsBase::OverloadToken<PrevTy>());
 
     if (requiresRealignment())
-      return reinterpret_cast<NextTy *>(llvm::alignAddr(Ptr, alignof(NextTy)));
+      return reinterpret_cast<NextTy *>(
+          llvm::alignAddr(Ptr, llvm::Align(alignof(NextTy))));
     else
       return reinterpret_cast<NextTy *>(Ptr);
   }

include/swift/ABI/TypeIdentity.h

@@ -19,6 +19,7 @@
 #define SWIFT_ABI_TYPEIDENTITY_H
 
 #include "swift/Basic/LLVM.h"
+#include <llvm/ADT/StringRef.h>
 
 namespace swift {
 template <class> class TargetTypeContextDescriptor;

include/swift/AST/Evaluator.h

@@ -345,7 +345,7 @@ class Evaluator {
     // Check for a cycle.
     if (checkDependency(activeReq)) {
       return llvm::Error(
-        llvm::make_unique<CyclicalRequestError<Request>>(request, *this));
+          std::make_unique<CyclicalRequestError<Request>>(request, *this));
     }
 
     // Make sure we remove this from the set of active requests once we're

include/swift/AST/SimpleRequest.h

@@ -195,7 +195,7 @@ class SimpleRequest<Derived, Output(Inputs...), Caching> {
 
   template<size_t ...Indices>
   llvm::Expected<Output>
-  callDerived(Evaluator &evaluator, llvm::index_sequence<Indices...>) const {
+  callDerived(Evaluator &evaluator, std::index_sequence<Indices...>) const {
     static_assert(sizeof...(Indices) > 0, "Subclass must define evaluate()");
     return asDerived().evaluate(evaluator, std::get<Indices>(storage)...);
   }
@@ -217,7 +217,7 @@ class SimpleRequest<Derived, Output(Inputs...), Caching> {
   static llvm::Expected<OutputType>
   evaluateRequest(const Derived &request, Evaluator &evaluator) {
     return request.callDerived(evaluator,
-                               llvm::index_sequence_for<Inputs...>());
+                               std::index_sequence_for<Inputs...>());
   }
 
   /// Retrieve the nearest source location to which this request applies.

include/swift/Basic/Statistic.h

@@ -25,8 +25,7 @@
 
 #define SWIFT_FUNC_STAT_NAMED(DEBUG_TYPE)                               \
   do {                                                                  \
-    static llvm::Statistic FStat =                                      \
-      {DEBUG_TYPE, __func__, __func__, {0}, {false}};                   \
+    static llvm::Statistic FStat = {DEBUG_TYPE, __func__, __func__};    \
     ++FStat;                                                            \
   } while (0)
 

include/swift/Frontend/Frontend.h

@@ -482,7 +482,7 @@ class CompilerInstance {
 
   void createDependencyTracker(bool TrackSystemDeps) {
     assert(!Context && "must be called before setup()");
-    DepTracker = llvm::make_unique<DependencyTracker>(TrackSystemDeps);
+    DepTracker = std::make_unique<DependencyTracker>(TrackSystemDeps);
   }
   DependencyTracker *getDependencyTracker() { return DepTracker.get(); }
   const DependencyTracker *getDependencyTracker() const { return DepTracker.get(); }

include/swift/LLVMPasses/Passes.h

@@ -15,6 +15,8 @@
 
 #include "swift/LLVMPasses/PassesFwd.h"
 #include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/Passes.h"
+#include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 
 namespace swift {

include/swift/Reflection/TypeRef.h

@@ -150,6 +150,9 @@ class alignas(void *) TypeRef {
   void dump() const;
   void dump(FILE *file, unsigned Indent = 0) const;
 
+  /// Build a demangle tree from this TypeRef.
+  Demangle::NodePointer getDemangling(Demangle::Demangler &Dem) const;
+
   bool isConcrete() const;
   bool isConcreteAfterSubstitutions(const GenericArgumentMap &Subs) const;
 

include/swift/SIL/PatternMatch.h

@@ -310,7 +310,7 @@ namespace detail {
 struct GetOperandsFunctor {
   template <size_t... Idx>
   std::array<SILValue, sizeof...(Idx)>
-  operator()(SILInstruction *i, llvm::index_sequence<Idx...> seq) const {
+  operator()(SILInstruction *i, std::index_sequence<Idx...> seq) const {
     return {i->getOperand(Idx)...};
   }
 };
@@ -327,15 +327,15 @@ template <typename... MatcherTys> struct MatcherFunctor {
   template <size_t... Idx>
   std::array<bool, sizeof...(MatcherTys)>
   matchHelper(const std::array<SILValue, sizeof...(MatcherTys)> &operands,
-              llvm::index_sequence<Idx...> seq) {
+              std::index_sequence<Idx...> seq) {
     return {individual(std::get<Idx>(matchers), std::get<Idx>(operands))...};
   }
 
   bool match(SILInstruction *i) {
     std::array<SILValue, sizeof...(MatcherTys)> operands =
-        GetOperandsFunctor{}(i, llvm::index_sequence_for<MatcherTys...>{});
+        GetOperandsFunctor{}(i, std::index_sequence_for<MatcherTys...>{});
     auto tmpResult =
-        matchHelper(operands, llvm::index_sequence_for<MatcherTys...>{});
+        matchHelper(operands, std::index_sequence_for<MatcherTys...>{});
     for (unsigned i : indices(tmpResult)) {
       if (!tmpResult[i])
         return false;

include/swift/SIL/SILInstruction.h

@@ -999,7 +999,7 @@ class MultipleValueInstructionTrailingObjects<Derived, DerivedResult,
                                       MultipleValueInstruction *,
                                       DerivedResult,
                                       FinalOtherTrailingTypes...> {
-  static_assert(LLVM_IS_FINAL(DerivedResult),
+  static_assert(std::is_final<DerivedResult>(),
                 "Expected DerivedResult to be final");
   static_assert(
       std::is_base_of<MultipleValueInstructionResult, DerivedResult>::value,

include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h

@@ -172,7 +172,7 @@ class BasicCalleeAnalysis : public SILAnalysis {
 
   void updateCache() {
     if (!Cache)
-      Cache = llvm::make_unique<CalleeCache>(M);
+      Cache = std::make_unique<CalleeCache>(M);
   }
 
   CalleeList getCalleeList(FullApplySite FAS) {

include/swift/SILOptimizer/Analysis/DominanceAnalysis.h

@@ -42,7 +42,7 @@ class DominanceAnalysis : public FunctionAnalysisBase<DominanceInfo> {
   }
 
   std::unique_ptr<DominanceInfo> newFunctionAnalysis(SILFunction *F) override {
-    return llvm::make_unique<DominanceInfo>(F);
+    return std::make_unique<DominanceInfo>(F);
   }
 
   virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override {
@@ -72,7 +72,7 @@ class PostDominanceAnalysis : public FunctionAnalysisBase<PostDominanceInfo> {
 
   std::unique_ptr<PostDominanceInfo>
   newFunctionAnalysis(SILFunction *F) override {
-    return llvm::make_unique<PostDominanceInfo>(F);
+    return std::make_unique<PostDominanceInfo>(F);
   }
 
   virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override {

include/swift/SILOptimizer/Analysis/EpilogueARCAnalysis.h

@@ -302,7 +302,7 @@ class EpilogueARCAnalysis : public FunctionAnalysisBase<EpilogueARCFunctionInfo>
 
   virtual std::unique_ptr<EpilogueARCFunctionInfo>
   newFunctionAnalysis(SILFunction *F) override {
-    return llvm::make_unique<EpilogueARCFunctionInfo>(F, PO, AA, RC);
+    return std::make_unique<EpilogueARCFunctionInfo>(F, PO, AA, RC);
   }
 
   virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override {

include/swift/SILOptimizer/Analysis/IVAnalysis.h

@@ -91,7 +91,7 @@ class IVAnalysis final : public FunctionAnalysisBase<IVInfo> {
   }
 
   std::unique_ptr<IVInfo> newFunctionAnalysis(SILFunction *F) override {
-    return llvm::make_unique<IVInfo>(*F);
+    return std::make_unique<IVInfo>(*F);
   }
 
   /// For now we always invalidate.

include/swift/SILOptimizer/Analysis/LoopRegionAnalysis.h

@@ -1082,7 +1082,7 @@ class LoopRegionAnalysis : public FunctionAnalysisBase<LoopRegionFunctionInfo> {
 
   virtual std::unique_ptr<LoopRegionFunctionInfo>
   newFunctionAnalysis(SILFunction *F) override {
-    return llvm::make_unique<LoopRegionFunctionInfo>(F, POA->get(F),
+    return std::make_unique<LoopRegionFunctionInfo>(F, POA->get(F),
                                                      SLA->get(F));
   }
 

include/swift/SILOptimizer/Analysis/PostOrderAnalysis.h

@@ -36,7 +36,7 @@ class PostOrderAnalysis : public FunctionAnalysisBase<PostOrderFunctionInfo> {
 protected:
   virtual std::unique_ptr<PostOrderFunctionInfo>
   newFunctionAnalysis(SILFunction *F) override {
-    return llvm::make_unique<PostOrderFunctionInfo>(F);
+    return std::make_unique<PostOrderFunctionInfo>(F);
   }
 
   virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override {

include/swift/SILOptimizer/Analysis/RCIdentityAnalysis.h

@@ -120,7 +120,7 @@ class RCIdentityAnalysis : public FunctionAnalysisBase<RCIdentityFunctionInfo> {
 
   virtual std::unique_ptr<RCIdentityFunctionInfo>
   newFunctionAnalysis(SILFunction *F) override {
-    return llvm::make_unique<RCIdentityFunctionInfo>(DA);
+    return std::make_unique<RCIdentityFunctionInfo>(DA);
   }
 
   virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override {

include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h

@@ -20,6 +20,7 @@
 #include "swift/SILOptimizer/Utils/ConstantFolding.h"
 #include "swift/SILOptimizer/Utils/SILInliner.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/CommandLine.h"
 
 
 using namespace swift;

lib/AST/ASTContext.cpp

@@ -504,7 +504,8 @@ static ModuleDecl *createBuiltinModule(ASTContext &ctx) {
 
 inline ASTContext::Implementation &ASTContext::getImpl() const {
   auto pointer = reinterpret_cast<char*>(const_cast<ASTContext*>(this));
-  auto offset = llvm::alignAddr((void*)sizeof(*this), alignof(Implementation));
+  auto offset = llvm::alignAddr((void *)sizeof(*this),
+                                llvm::Align(alignof(Implementation)));
   return *reinterpret_cast<Implementation*>(pointer + offset);
 }
 
@@ -524,7 +525,8 @@ ASTContext *ASTContext::get(LangOptions &langOpts,
   auto size = llvm::alignTo(sizeof(ASTContext) + sizeof(Implementation), align);
   auto mem = AlignedAlloc(size, align);
   auto impl = reinterpret_cast<void*>((char*)mem + sizeof(ASTContext));
-  impl = reinterpret_cast<void*>(llvm::alignAddr(impl,alignof(Implementation)));
+  impl = reinterpret_cast<void *>(
+      llvm::alignAddr(impl, llvm::Align(alignof(Implementation))));
   new (impl) Implementation();
   return new (mem)
       ASTContext(langOpts, typeckOpts, SearchPathOpts, SourceMgr, Diags);
@@ -1547,7 +1549,7 @@ void ASTContext::registerGenericSignatureBuilder(
 
   ++NumRegisteredGenericSignatureBuilders;
   genericSignatureBuilders[canSig] =
-    llvm::make_unique<GenericSignatureBuilder>(std::move(builder));
+    std::make_unique<GenericSignatureBuilder>(std::move(builder));
 }
 
 GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(

lib/AST/Builtins.cpp

@@ -1381,10 +1381,14 @@ Type IntrinsicTypeDecoder::decodeImmediate() {
   case IITDescriptor::ExtendArgument:
   case IITDescriptor::TruncArgument:
   case IITDescriptor::HalfVecArgument:
+  case IITDescriptor::ScalableVecArgument:
   case IITDescriptor::VarArg:
   case IITDescriptor::Token:
   case IITDescriptor::VecElementArgument:
   case IITDescriptor::VecOfAnyPtrsToElt:
+  case IITDescriptor::VecOfBitcastsToInt:
+  case IITDescriptor::Subdivide2Argument:
+  case IITDescriptor::Subdivide4Argument:
     // These types cannot be expressed in swift yet.
     return Type();
 

lib/AST/ClangTypeConverter.cpp

@@ -369,7 +369,7 @@ clang::QualType ClangTypeConverter::visitTupleType(TupleType *type) {
     return clang::QualType();
 
   APInt size(32, tupleNumElements);
-  return ClangASTContext.getConstantArrayType(clangEltTy, size,
+  return ClangASTContext.getConstantArrayType(clangEltTy, size, nullptr,
            clang::ArrayType::Normal, 0);
 }
 

lib/AST/DiagnosticConsumer.cpp

@@ -71,7 +71,7 @@ FileSpecificDiagnosticConsumer::consolidateSubconsumers(
   if (subconsumers.size() == 1)
     return std::move(subconsumers.front()).consumer;
   // Cannot use return
-  // llvm::make_unique<FileSpecificDiagnosticConsumer>(subconsumers); because
+  // std::make_unique<FileSpecificDiagnosticConsumer>(subconsumers); because
   // the constructor is private.
   return std::unique_ptr<DiagnosticConsumer>(
       new FileSpecificDiagnosticConsumer(subconsumers));

lib/AST/Expr.cpp

@@ -813,13 +813,14 @@ APInt BuiltinIntegerWidth::parse(StringRef text, unsigned radix, bool negate,
 static APFloat getFloatLiteralValue(bool IsNegative, StringRef Text,
                                     const llvm::fltSemantics &Semantics) {
   APFloat Val(Semantics);
-  APFloat::opStatus Res =
-    Val.convertFromString(Text, llvm::APFloat::rmNearestTiesToEven);
-  assert(Res != APFloat::opInvalidOp && "Sema didn't reject invalid number");
-  (void)Res;
+  llvm::Expected<APFloat::opStatus> MaybeRes =
+      Val.convertFromString(Text, llvm::APFloat::rmNearestTiesToEven);
+  assert(MaybeRes && *MaybeRes != APFloat::opInvalidOp &&
+         "Sema didn't reject invalid number");
+  (void)MaybeRes;
   if (IsNegative) {
     auto NegVal = APFloat::getZero(Semantics, /*negative*/ true);
-    Res = NegVal.subtract(Val, llvm::APFloat::rmNearestTiesToEven);
+    auto Res = NegVal.subtract(Val, llvm::APFloat::rmNearestTiesToEven);
     assert(Res != APFloat::opInvalidOp && "Sema didn't reject invalid number");
     (void)Res;
     return NegVal;

lib/AST/GenericSignatureBuilder.cpp

@@ -3208,7 +3208,7 @@ GenericSignatureBuilder::Implementation::getOrCreateRewriteTreeRoot(
     return root;
 
   auto &root = RewriteTreeRoots[anchor];
-  root = llvm::make_unique<RewriteTreeNode>(nullptr);
+  root = std::make_unique<RewriteTreeNode>(nullptr);
   return root.get();
 }
 

lib/AST/Module.cpp

@@ -83,7 +83,7 @@ BuiltinUnit::LookupCache &BuiltinUnit::getCache() const {
   // FIXME: This leaks. Sticking this into ASTContext isn't enough because then
   // the DenseMap will leak.
   if (!Cache)
-    const_cast<BuiltinUnit *>(this)->Cache = llvm::make_unique<LookupCache>();
+    const_cast<BuiltinUnit *>(this)->Cache = std::make_unique<LookupCache>();
   return *Cache;
 }
 
@@ -192,7 +192,7 @@ class swift::SourceLookupCache {
 SourceLookupCache &SourceFile::getCache() const {
   if (!Cache) {
     const_cast<SourceFile *>(this)->Cache =
-        llvm::make_unique<SourceLookupCache>(*this);
+        std::make_unique<SourceLookupCache>(*this);
   }
   return *Cache;
 }
@@ -435,7 +435,7 @@ void ModuleDecl::removeFile(FileUnit &existingFile) {
 SourceLookupCache &ModuleDecl::getSourceLookupCache() const {
   if (!Cache) {
     const_cast<ModuleDecl *>(this)->Cache =
-        llvm::make_unique<SourceLookupCache>(*this);
+        std::make_unique<SourceLookupCache>(*this);
   }
   return *Cache;
 }

lib/Basic/FileSystem.cpp

@@ -214,14 +214,14 @@ swift::areFilesDifferent(const llvm::Twine &source,
   // The two files match in size, so we have to compare the bytes to determine
   // if they're the same.
   std::error_code sourceRegionErr;
-  fs::mapped_file_region sourceRegion(sourceFile.fd,
+  fs::mapped_file_region sourceRegion(fs::convertFDToNativeFile(sourceFile.fd),
                                       fs::mapped_file_region::readonly,
                                       size, 0, sourceRegionErr);
   if (sourceRegionErr)
     return sourceRegionErr;
 
   std::error_code destRegionErr;
-  fs::mapped_file_region destRegion(destFile.fd,
+  fs::mapped_file_region destRegion(fs::convertFDToNativeFile(destFile.fd),
                                     fs::mapped_file_region::readonly,
                                     size, 0, destRegionErr);