Merge branch 'master' into cmark-checkout

Author: palfrey

README.md

@@ -66,15 +66,15 @@ compiler for C++14 support and create a symlink:
 
 ### Getting Sources for Swift and Related Projects
 
-     git clone [email protected]:/apple/swift.git swift
-     git clone [email protected]:/apple/swift-llvm.git llvm
-     git clone [email protected]:/apple/swift-clang.git clang
-     git clone [email protected]:/apple/swift-lldb.git lldb
-     git clone [email protected]:/apple/swift-cmark.git cmark
-     git clone [email protected]:/apple/swift-llbuild.git llbuild
-     git clone [email protected]:/apple/swift-package-manager.git swiftpm
-     git clone [email protected]:/apple/swift-corelibs-xctest.git 
-     git clone [email protected]:/apple/swift-corelibs-foundation.git 
+     git clone [email protected]:apple/swift.git swift
+     git clone [email protected]:apple/swift-llvm.git llvm
+     git clone [email protected]:apple/swift-clang.git clang
+     git clone [email protected]:apple/swift-lldb.git lldb
+     git clone [email protected]:apple/swift-cmark.git cmark
+     git clone [email protected]:apple/swift-llbuild.git llbuild
+     git clone [email protected]:apple/swift-package-manager.git swiftpm
+     git clone [email protected]:apple/swift-corelibs-xctest.git
+     git clone [email protected]:apple/swift-corelibs-foundation.git
 
 
 [CMake](http://cmake.org) is the core infrastructure used to configure builds of
@@ -137,8 +137,8 @@ picking up new targets, file removals, or file additions.
 
 ## Testing Swift
 
-See docs/Testing.rst.
+See [docs/Testing.rst](docs/Testing.rst).
 
 ## Contributing to Swift
 
-Contributions to Swift are welcomed and encouraged! Please see the [Contributing to Swift guide](https://swift.org/contributing/).
+Contributions to Swift are welcomed and encouraged! Please see the [Contributing to Swift guide](https://swift.org/contributing/).

docs/ARCOptimization.rst

@@ -194,7 +194,7 @@ is_unique performs depends on the argument type:
       dynamic object type uses native swift reference counting:
       (Builtin.UnknownObject, unknown class reference, class existential)
 
-    - Bridged object types allow the dymanic object type check to be
+    - Bridged object types allow the dynamic object type check to be
       bypassed based on the pointer encoding:
       (Builtin.BridgeObject)
 

docs/Pattern Matching.rst

@@ -732,7 +732,7 @@ pattern-specific production.  I believe it should be true that, in
 general, match patterns for a production accept a strict superset of
 valid expressions, so that (e.g.) we do not need to disambiguate
 whether an open paren starts a tuple expression or a tuple pattern,
-but can instaed just aggressively parse as a pattern.  Note that
+but can instead just aggressively parse as a pattern.  Note that
 binary operators can mean that, using this strategy, we sometimes have
 to retroactively rewrite a pattern as an expression.
 

include/swift/AST/Builtins.def

@@ -306,7 +306,7 @@ BUILTIN_SIL_OPERATION(FixLifetime, "fixLifetime", Special)
 ///   dynamic object type uses native swift reference counting:
 ///   (Builtin.UnknownObject, unknown class reference, class existential)
 ///
-/// - Bridged object types allow the dymanic object type check to be
+/// - Bridged object types allow the dynamic object type check to be
 ///   passed based on their pointer encoding:
 ///   (Builtin.BridgeObject)
 ///

lib/SILPasses/Scalar/DeadStoreElimination.cpp

@@ -278,7 +278,7 @@ class DSEContext {
   llvm::BumpPtrAllocator BPA;
 
   /// Map every basic block to its location state.
-  llvm::SmallDenseMap<SILBasicBlock *, BBState, 4> BBToLocState;
+  llvm::DenseMap<SILBasicBlock *, BBState *> BBToLocState;
 
   /// Keeps the actual BBStates.
   std::vector<BBState> BBStates;
@@ -295,7 +295,7 @@ class DSEContext {
   MemLocationIndexMap LocToBitIndex;
 
   /// Return the BBState for the basic block this basic block belongs to.
-  BBState *getBBLocState(SILBasicBlock *B) { return &BBToLocState[B]; }
+  BBState *getBBLocState(SILBasicBlock *B) { return BBToLocState[B]; }
 
   /// Return the BBState for the basic block this instruction belongs to.
   BBState *getBBLocState(SILInstruction *I) {
@@ -854,8 +854,13 @@ void DSEContext::run() {
   // than 64 basic blocks. Therefore, allocate the BBState in a vector and use
   // pointer in BBToLocState to access them.
   for (auto &B : *F) {
-    BBToLocState[&B] = BBState(&B);
-    BBToLocState[&B].init(MemLocationVault.size());
+    BBStates.push_back(BBState(&B));
+    BBStates.back().init(MemLocationVault.size());
+  }
+
+  // Initialize the BBToLocState mapping.
+  for (auto &S : BBStates) {
+    BBToLocState[S.getBB()] = &S;
   }
 
   // Generate the genset and killset for each basic block.

lib/SILPasses/Scalar/RedundantLoadElimination.cpp

@@ -38,7 +38,7 @@
 /// 4. An optimistic iterative intersection-based dataflow is performed on the
 /// gen sets until convergence.
 ///
-/// At the core of RLE, there is the MemLocation class. a MemLocation is an
+/// At the core of RLE, there is the MemLocation class. A MemLocation is an
 /// abstraction of an object field in program. It consists of a base and a
 /// projection path to the field accessed.
 ///
@@ -48,12 +48,12 @@
 /// keeps their available LoadStoreValues. We call it *indivisible* because it
 /// can not be broken down to more MemLocations.
 ///
-/// LoadStoreValues consists of a base - a SILValue from the load or store inst,
+/// LoadStoreValue consists of a base - a SILValue from the load or store inst,
 /// as well as a projection path to which the field it represents. So, a
 /// store to an 2-field struct as mentioned above will generate 2 MemLocations
 /// and 2 LoadStoreValues.
 ///
-/// Every basic block keeps a map between MemLocation <-> LoadStoreValue. By
+/// Every basic block keeps a map between MemLocation and LoadStoreValue. By
 /// keeping the MemLocation and LoadStoreValue in their indivisible form, one
 /// can easily find which part of the load is redundant and how to compute its
 /// forwarding value.
@@ -74,7 +74,6 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "sil-redundant-load-elim"
-#include "swift/SILPasses/Passes.h"
 #include "swift/SIL/MemLocation.h"
 #include "swift/SIL/Projection.h"
 #include "swift/SIL/SILArgument.h"
@@ -83,17 +82,18 @@
 #include "swift/SILAnalysis/DominanceAnalysis.h"
 #include "swift/SILAnalysis/PostOrderAnalysis.h"
 #include "swift/SILAnalysis/ValueTracking.h"
+#include "swift/SILPasses/Passes.h"
+#include "swift/SILPasses/Transforms.h"
 #include "swift/SILPasses/Utils/CFG.h"
 #include "swift/SILPasses/Utils/Local.h"
 #include "swift/SILPasses/Utils/SILSSAUpdater.h"
-#include "swift/SILPasses/Transforms.h"
 #include "llvm/ADT/BitVector.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Debug.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/TinyPtrVector.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
 
 using namespace swift;
 
@@ -169,19 +169,14 @@ class BBState {
   /// A bit vector for which the ith bit represents the ith MemLocation in
   /// MemLocationVault. If the bit is set, then the location currently has an
   /// downward visible value.
-  llvm::BitVector ForwardSetOut;
-
-  /// If ForwardSetIn changes while processing a basicblock, then all its
-  /// predecessors needs to be rerun.
   llvm::BitVector ForwardSetIn;
 
-  /// This is a list of MemLocations and their LoadStoreValues.
-  ///
-  /// TODO: can we create a LoadStoreValue vault so that we do not need to keep
-  /// them per basic block. This would also give ForwardValIn more symmetry.
-  /// i.e. MemLocation and LoadStoreValue both represented as bit vector
-  /// indices.
-  ///
+  /// If ForwardSetOut changes while processing a basicblock, then all its
+  /// successors need to be rerun.
+  llvm::BitVector ForwardSetOut;
+
+  /// This is map between MemLocations and their available values at the
+  /// beginning of this basic block.
   ValueTableMap ForwardValIn;
 
   /// This is map between MemLocations and their available values at the end of
@@ -255,15 +250,17 @@ class BBState {
     ForwardSetOut.resize(bitcnt, reachable);
   }
 
+  /// Returns the current basic block we are processing.
+  SILBasicBlock *getBB() const { return BB; }
+
   /// Returns the ForwardValIn for the current basic block.
   ValueTableMap &getForwardValIn() { return ForwardValIn; }
 
   /// Returns the ForwardValOut for the current basic block.
   ValueTableMap &getForwardValOut() { return ForwardValOut; }
 
-  /// Returns the current basic block we are processing.
-  SILBasicBlock *getBB() const { return BB; }
-
+  /// Returns the redundant loads and their replacement in the currently basic
+  /// block.
   llvm::DenseMap<SILInstruction *, SILValue> &getRL() { return RedundantLoads; }
 
   bool optimize(RLEContext &Ctx, bool PF);
@@ -299,9 +296,8 @@ class BBState {
 
 namespace {
 
-/// This class stores global state that we use when processing and also drives
-/// the computation. We put its interface at the top for use in other parts of
-/// the pass which may want to use this global information.
+/// This class stores global state that we use when computing redudant load and
+/// their replacement in each basic block.
 class RLEContext {
   /// The alias analysis that we will use during all computations.
   AliasAnalysis *AA;
@@ -373,13 +369,6 @@ class RLEContext {
   /// collect forwarding values from their ForwardValOuts.
   bool gatherValues(SILBasicBlock *B, MemLocation &L, MemLocationValueMap &Vs,
                     bool UseForwardValOut);
-
-  /// Dump all the MemLocations in the MemLocationVault.
-  void printMemLocationVault() const {
-    for (auto &X : MemLocationVault) {
-      X.print();
-    }
-  }
 };
 
 } // end anonymous namespace