Merge pull request swiftlang#35663 from apple/pr-rebranch

Support new changes from swift/rebranch on llvm-project repo

Author: shahmishal

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -97,6 +97,10 @@ macro(swift_common_standalone_build_config_llvm product)
     endif()
   endif()
 
+  if(LLVM_ENABLE_ZLIB)
+   find_package(ZLIB REQUIRED)
+  endif()
+
   include(AddLLVM)
   include(AddSwiftTableGen) # This imports TableGen from LLVM.
   include(HandleLLVMOptions)

include/swift/ABI/TrailingObjects.h

@@ -56,7 +56,6 @@
 #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"
 #include "llvm/Support/type_traits.h"

include/swift/AST/FineGrainedDependencyFormat.h

@@ -13,7 +13,7 @@
 #ifndef SWIFT_AST_FINEGRAINEDDEPENDENCYFORMAT_H
 #define SWIFT_AST_FINEGRAINEDDEPENDENCYFORMAT_H
 
-#include "llvm/Bitcode/RecordLayout.h"
+#include "llvm/Bitcode/BitcodeConvenience.h"
 #include "llvm/Bitstream/BitCodes.h"
 
 namespace llvm {

include/swift/Basic/AnyValue.h

@@ -30,14 +30,6 @@ namespace llvm {
     return hash_value(ptr.getOpaqueValue());
   }
 
-  // FIXME: Belongs in LLVM itself
-  template<typename T>
-  hash_code hash_value(const llvm::Optional<T> &opt) {
-    if (!opt)
-      return 1;
-    return hash_value(*opt);
-  }
-
   template<typename T>
   bool operator==(const TinyPtrVector<T> &lhs, const TinyPtrVector<T> &rhs) {
     if (lhs.size() != rhs.size())

include/swift/Basic/DiagnosticOptions.h

@@ -41,6 +41,10 @@ class DiagnosticOptions {
   /// Indicates whether diagnostic passes should be skipped.
   bool SkipDiagnosticPasses = false;
 
+  /// Additional non-source files which will have diagnostics emitted in them,
+  /// and which should be scanned for expectations by the diagnostic verifier.
+  std::vector<std::string> AdditionalVerifierFiles;
+
   /// Keep emitting subsequent diagnostics after a fatal error.
   bool ShowDiagnosticsAfterFatalError = false;
 
@@ -54,22 +58,23 @@ class DiagnosticOptions {
   /// Treat all warnings as errors
   bool WarningsAsErrors = false;
 
-  // When printing diagnostics, include the diagnostic name at the end
+  /// When printing diagnostics, include the diagnostic name (diag::whatever) at
+  /// the end.
   bool PrintDiagnosticNames = false;
 
   /// If set to true, include educational notes in printed output if available.
   /// Educational notes are documentation which supplement diagnostics.
   bool PrintEducationalNotes = false;
 
-  // If set to true, use the more descriptive experimental formatting style for
-  // diagnostics.
+  /// Whether to emit diagnostics in the terse LLVM style or in a more
+  /// descriptive style that's specific to Swift (currently experimental).
   FormattingStyle PrintedFormattingStyle = FormattingStyle::LLVM;
 
   std::string DiagnosticDocumentationPath = "";
 
   std::string LocalizationCode = "";
 
-  // Diagnostic messages directory path.
+  /// Path to a directory of diagnostic localization tables.
   std::string LocalizationPath = "";
 
   /// Return a hash code of any components from these options that should

include/swift/ClangImporter/SwiftAbstractBasicWriter.h

@@ -44,6 +44,8 @@ class DataStreamBasicWriter
 public:
   using super::asImpl;
 
+  DataStreamBasicWriter(clang::ASTContext &ctx) : super(ctx) {}
+
   /// Perform all the calls necessary to write out the given type.
   void writeTypeRef(const clang::Type *type) {
     asImpl().writeUInt64(uint64_t(type->getTypeClass()));

include/swift/Frontend/DiagnosticVerifier.h

@@ -65,6 +65,7 @@ class DiagnosticVerifier : public DiagnosticConsumer {
   SourceManager &SM;
   std::vector<CapturedDiagnosticInfo> CapturedDiagnostics;
   ArrayRef<unsigned> BufferIDs;
+  SmallVector<unsigned, 4> AdditionalBufferIDs;
   bool AutoApplyFixes;
   bool IgnoreUnknown;
 
@@ -74,6 +75,10 @@ class DiagnosticVerifier : public DiagnosticConsumer {
       : SM(SM), BufferIDs(BufferIDs), AutoApplyFixes(AutoApplyFixes),
         IgnoreUnknown(IgnoreUnknown) {}
 
+  void appendAdditionalBufferID(unsigned bufferID) {
+    AdditionalBufferIDs.push_back(bufferID);
+  }
+
   virtual void handleDiagnostic(SourceManager &SM,
                                 const DiagnosticInfo &Info) override;
 

include/swift/Frontend/Frontend.h

@@ -558,8 +558,11 @@ class CompilerInstance {
   bool setUpInputs();
   bool setUpASTContextIfNeeded();
   void setupStatsReporter();
-  void setupDiagnosticVerifierIfNeeded();
   void setupDependencyTrackerIfNeeded();
+
+  /// \return false if successsful, true on error.
+  bool setupDiagnosticVerifierIfNeeded();
+
   Optional<unsigned> setUpCodeCompletionBuffer();
 
   /// Find a buffer for a given input file and ensure it is recorded in

include/swift/Option/FrontendOptions.td

@@ -101,6 +101,8 @@ def tbd_is_installapi: Flag<["-"], "tbd-is-installapi">,
 def verify : Flag<["-"], "verify">,
   HelpText<"Verify diagnostics against expected-{error|warning|note} "
            "annotations">;
+def verify_additional_file : Separate<["-"], "verify-additional-file">,
+  HelpText<"Verify diagnostics in this file in addition to source files">;
 def verify_apply_fixes : Flag<["-"], "verify-apply-fixes">,
   HelpText<"Like -verify, but updates the original source file">;
 def verify_ignore_unknown: Flag<["-"], "verify-ignore-unknown">,

include/swift/SIL/CFG.h

@@ -19,8 +19,16 @@
 #define SWIFT_SIL_CFG_H
 
 #include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILValue.h"
 #include "llvm/ADT/GraphTraits.h"
 
+#if defined(__has_include)
+#if __has_include("llvm/Support/CfgTraits.h")
+#include "llvm/Support/CfgTraits.h"
+#define SWIFT_LLVM_HAS_CFGTRAITS_H
+#endif
+#endif
+
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
@@ -119,6 +127,99 @@ template <> struct GraphTraits<Inverse<swift::SILFunction*> >
   static unsigned size(GraphType F) { return F.Graph->size(); }
 };
 
+#ifdef SWIFT_LLVM_HAS_CFGTRAITS_H
+
+class SILCfgTraitsBase : public CfgTraitsBase {
+public:
+  using ParentType = swift::SILFunction;
+  using BlockRef = swift::SILBasicBlock *;
+  using ValueRef = swift::SILInstruction *;
+
+  static CfgBlockRef wrapRef(BlockRef block) {
+    return makeOpaque<CfgBlockRefTag>(block);
+  }
+  static CfgValueRef wrapRef(ValueRef block) {
+    return makeOpaque<CfgValueRefTag>(block);
+  }
+  static BlockRef unwrapRef(CfgBlockRef block) {
+    return static_cast<BlockRef>(getOpaque(block));
+  }
+  static ValueRef unwrapRef(CfgValueRef block) {
+    return static_cast<ValueRef>(getOpaque(block));
+  }
+};
+/// \brief CFG traits for SIL IR.
+class SILCfgTraits : public CfgTraits<SILCfgTraitsBase, SILCfgTraits> {
+public:
+  explicit SILCfgTraits(swift::SILFunction * /*parent*/) {}
+
+  static swift::SILFunction *getBlockParent(swift::SILBasicBlock *block) {
+    return block->getParent();
+  }
+
+  static auto predecessors(swift::SILBasicBlock *block) {
+    return block->getPredecessorBlocks();
+  }
+  static auto successors(swift::SILBasicBlock *block) {
+    return block->getSuccessors();
+  }
+
+  /// Get the defining block of a value if it is an instruction, or null
+  /// otherwise.
+  static BlockRef getValueDefBlock(ValueRef value) {
+    if (auto *instruction = dyn_cast<swift::SILInstruction>(value))
+      return instruction->getParent();
+    return nullptr;
+  }
+
+  struct block_iterator
+      : iterator_adaptor_base<block_iterator, swift::SILFunction::iterator> {
+    using Base = iterator_adaptor_base<block_iterator, swift::SILFunction::iterator>;
+
+    block_iterator() = default;
+
+    explicit block_iterator(swift::SILFunction::iterator i) : Base(i) {}
+
+    swift::SILBasicBlock *operator*() const { return &Base::operator*(); }
+  };
+
+  static iterator_range<block_iterator> blocks(swift::SILFunction *function) {
+    return {block_iterator(function->begin()), block_iterator(function->end())};
+  }
+
+  struct value_iterator
+      : iterator_adaptor_base<value_iterator, swift::SILBasicBlock::iterator> {
+    using Base = iterator_adaptor_base<value_iterator, swift::SILBasicBlock::iterator>;
+
+    value_iterator() = default;
+
+    explicit value_iterator(swift::SILBasicBlock::iterator i) : Base(i) {}
+
+    ValueRef operator*() const { return &Base::operator*(); }
+  };
+
+  static iterator_range<value_iterator> blockdefs(BlockRef block) {
+    return {value_iterator(block->begin()), value_iterator(block->end())};
+  }
+  struct Printer {
+    explicit Printer(const SILCfgTraits &) {}
+    ~Printer(){}
+
+    void printBlockName(raw_ostream &out, BlockRef block) const {
+      block->printAsOperand(out);
+    }
+    void printValue(raw_ostream &out, ValueRef value) const {
+      value->print(out);
+    }
+  };
+};
+
+template <> struct CfgTraitsFor<swift::SILBasicBlock> {
+  using CfgTraits = SILCfgTraits;
+};
+
+#endif
+
 } // end llvm namespace
 
 #endif