Revert today's changes to SIL AliasAnalysis.

This series of commits is reverted because it introduces risk. This type
of change requires design discussion and thorough unit testing.

Revert "Refactor in alias analysis. NFC"

This reverts commit 3390a58.

Revert "Update SILArgument alias analysis to make use of the new alias() interface"

This reverts commit 5940fcc.

Revert "Clean up uneeded SIL in a LIT test"

This reverts commit 81ebb56.

Revert "Fix LIT test in basic-aa."

This reverts commit a553403.

Revert "Improve comments in alias analysis"

This reverts commit 44ddc5b.

Revert "Implement SILArgument and select_enum handling for alias analysis"

This reverts commit 23c2579.

Author: atrick

include/swift/SILAnalysis/AliasAnalysis.h

@@ -70,11 +70,6 @@ class AliasAnalysis : public SILAnalysis {
 
   SideEffectAnalysis *getSideEffectAnalysis() const { return SEA; }
 
-  /// Perform alias queries to see if \p V1, \p V2 can refer to the same value.
-  /// \p V1 and \p V2 may be SILValues with multiple underlying objects. e.g.
-  /// SILArgument. \returns MayAlias or NoAlias.
-  AliasResult handleMultiUnderlyingObjectAlias(SILValue V1, SILValue V2);
-
   /// Perform an alias query to see if V1, V2 refer to the same values.
   AliasResult alias(SILValue V1, SILValue V2, SILType TBAAType1 = SILType(),
                     SILType TBAAType2 = SILType());

lib/SILAnalysis/AliasAnalysis.cpp

@@ -28,9 +28,6 @@
 
 using namespace swift;
 
-using SILValueSet = llvm::DenseSet<SILValue>;
-using SILValueList = llvm::SmallVector<SILValue, 8>;
-
 //===----------------------------------------------------------------------===//
 //                                AA Debugging
 //===----------------------------------------------------------------------===//
@@ -102,80 +99,6 @@ llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &OS,
   }
 }
 
-/// Return true if the SILValue is the result of multiple SILValues, e.g.
-/// select_enum, silargument.
-static bool isMultiUnderlyingObjectValue(SILValue V) {
-  if (isa<SelectEnumInst>(V))
-    return true;
-  // We are only interested in basic block SILArguments as those are the
-  // ones we can collect all the possible incoming values.
-  if (auto *SA = dyn_cast<SILArgument>(V))
-    if (!SA->isFunctionArg())
-      return true;
-  return false;
-}
-
-/// Get the first level underlying objects, e.g. in case of select_enum,
-/// look to the possible underlying objects from all the cases.
-static bool getFirstLevelUnderlyingObjects(SILValue V, SILValueSet &Cache,
-                                           SILValueList &WorkList) {
-  // Look through SILArgument.
-  if (auto *SA = dyn_cast<SILArgument>(V)) {
-    SILValueList Args;
-    bool Succ = SA->getIncomingValues(Args);
-    // Unable to get SILValue for every predecessor.
-    if (!Succ)
-      return false;
-    for (auto &X : Args) {
-      if (Cache.count(X))
-        continue;
-      // We have not seen this SILValue before.
-      Cache.insert(X);
-      WorkList.push_back(X);
-    }
-  }
-
-  // Look through SelectEnumInst.
-  if (auto *SE = dyn_cast<SelectEnumInst>(V)) {
-    unsigned CaseNum = SE->getNumCases();
-    for (unsigned i = 0; i < CaseNum; ++i) {
-      SILValue C = SE->getCase(i).second;
-      if (Cache.count(C))
-        continue;
-      // We have not seen this SILValue before.
-      Cache.insert(C);
-      WorkList.push_back(C);
-    }
-  }
-  return true;
-}
-
-/// Collect all the underlying objects for the given SILValue. Return false
-/// if fail to collect all possible underlying objects.
-static bool getTransistiveUnderlyingObjects(SILValue V, SILValueList &Objs) {
-  // Cache keeps track of what has been processed, so that we do not collected
-  // it again.
-  SILValueSet Cache;
-  SILValueList WorkList;
-
-  // Start with the given SILValue.
-  WorkList.push_back(V);
-  while(!WorkList.empty()) {
-    SILValue V = WorkList.pop_back_val();
-    if (isMultiUnderlyingObjectValue(V)) {
-      if (getFirstLevelUnderlyingObjects(V, Cache, WorkList))
-        continue;
-      // Failed to get all possible underlying value, bail out.
-      return false; 
-    }
-  
-    // This is single base SILValue.
-    Objs.push_back(V);
-    Cache.insert(V);
-  }
-  return true;
-}
-
 //===----------------------------------------------------------------------===//
 //                           Unequal Base Object AA
 //===----------------------------------------------------------------------===//
@@ -604,37 +527,6 @@ static bool typesMayAlias(SILType T1, SILType T2, SILType TBAA1Ty,
 //                                Entry Points
 //===----------------------------------------------------------------------===//
 
-AliasAnalysis::AliasResult
-AliasAnalysis::handleMultiUnderlyingObjectAlias(SILValue V1, SILValue V2) {
-  const unsigned AliasQueryLimit = 16;
-  SmallVector<SILValue, 8> V1Base, V2Base;
-  // Collect the transistive closure of all the SILValue V1 and V2 can
-  // point to. If for some reason we can not collect all the possible
-  // underlying objects, return MayAlias to be conservative.
-  if (!getTransistiveUnderlyingObjects(V1, V1Base) ||
-      !getTransistiveUnderlyingObjects(V2, V2Base))
-    return AliasResult::MayAlias;
-
-  // An mxn alias analysis query, bail out if this results in too many
-  // alias queries.
-  if (V1Base.size() * V2Base.size() > AliasQueryLimit)
-    return AliasResult::MayAlias;
-
-  // Return MayAlias if any pair does not have a NoAlias relation.
-  for (auto &M : V1Base) {
-    for (auto &N : V2Base) {
-      AliasAnalysis::AliasResult R = aliasInner(M, N, findTypedAccessType(M),
-                                                findTypedAccessType(N));
-      // Return MayAlias whenever we have 1 non-NoAlias pair. This is a
-      // tradeoff between compilation time and being conservative. 
-      if (R != AliasResult::NoAlias)
-        return AliasResult::MayAlias;
-    }
-  }
-
-  return AliasResult::NoAlias;
-}
-
 /// The main AA entry point. Performs various analyses on V1, V2 in an attempt
 /// to disambiguate the two values.
 AliasAnalysis::AliasResult AliasAnalysis::alias(SILValue V1, SILValue V2,
@@ -697,13 +589,8 @@ AliasAnalysis::AliasResult AliasAnalysis::aliasInner(SILValue V1, SILValue V2,
     }
   }
 
-  // Ok, we need to actually compute an Alias Analysis result for V1, V2. First
-  // find whether V1, V2 potentially have multiple underlying objects.
-  if (isMultiUnderlyingObjectValue(V1) || isMultiUnderlyingObjectValue(V2))
-    return handleMultiUnderlyingObjectAlias(V1, V2);
-    
-  // At this point, V1 and V2 are both single base SIlValues, begin by
-  // finding the "base" of V1, V2 by stripping off all casts and GEPs.
+  // Ok, we need to actually compute an Alias Analysis result for V1, V2. Begin
+  // by finding the "base" of V1, V2 by stripping off all casts and GEPs.
   SILValue O1 = getUnderlyingObject(V1);
   SILValue O2 = getUnderlyingObject(V2);
   DEBUG(llvm::dbgs() << "        Underlying V1:" << *O1.getDef());
@@ -739,7 +626,6 @@ AliasAnalysis::AliasResult AliasAnalysis::aliasInner(SILValue V1, SILValue V2,
   return AliasResult::MayAlias;
 }
 
-
 /// Check if this is the address of a "let" member.
 /// Nobody can write into let members.
 bool swift::isLetPointer(SILValue V) {

test/SILAnalysis/basic-aa.sil

@@ -5,102 +5,6 @@
 import Builtin
 import Swift
 
-///////////////////////
-// Type Declarations //
-///////////////////////
-
-struct Int {
-  var value : Builtin.Int64
-}
-
-enum E { 
-  case A
-  case B
-  case C
-}
-
-class Base { } 
-
-class Derived1 : Base {}
-
-class foo {
-  @sil_stored var a: Int { get set }
-   deinit 
-  init()
-}
-
-sil @foo_init : $@convention(thin) (@thick foo.Type) -> @owned foo 
-
-// CHECK-LABEL: silargument_alias_check
-
-// CHECK: PAIR #23.
-// CHECK: (0):   %1 = alloc_ref $foo
-// CHECK: (0):   %12 = argument of bb3 : $foo
-// CHECK: NoAlias
-sil hidden @silargument_alias_check : $@convention(thin) (Bool) -> () {
-bb0(%0 : $Bool):
-  %1 = alloc_ref $foo
-  %2 = struct_extract %0 : $Bool, #Bool._value    // user: %3
-  cond_br %2, bb1, bb2                            // id: %3
-
-bb1:                                              // Preds: bb0
-  %4 = function_ref @foo_init : $@convention(thin) (@thick foo.Type) -> @owned foo // user: %6
-  %5 = metatype $@thick foo.Type                  // user: %6
-  %6 = apply %4(%5) : $@convention(thin) (@thick foo.Type) -> @owned foo // user: %7
-  br bb3(%6 : $foo)                               // id: %7
-
-bb2:                                              // Preds: bb0
-  %8 = function_ref @foo_init : $@convention(thin) (@thick foo.Type) -> @owned foo // user: %10
-  %9 = metatype $@thick foo.Type                  // user: %10
-  %10 = apply %8(%9) : $@convention(thin) (@thick foo.Type) -> @owned foo // user: %11
-  br bb3(%10 : $foo)                              // id: %11
-
-bb3(%12 : $foo):                                  // Preds: bb1 bb2
-  strong_retain %12 : $foo                        // id: %13
-  %14 = integer_literal $Builtin.Int64, 12        // user: %15
-  %15 = struct $Int (%14 : $Builtin.Int64)        // user: %17
-  %16 = ref_element_addr %12 : $foo, #foo.a       // user: %17
-  store %15 to %16 : $*Int                        // id: %17
-  %18 = tuple ()
-  strong_release %12 : $foo                       // id: %19
-  strong_release %12 : $foo                       // id: %20
-  %21 = tuple ()                                  // user: %22
-  return %21 : $()                                // id: %22
-}
-
-
-// CHECK-LABEL: select_enum_and_local_object
-
-// CHECK: PAIR #61.
-// CHECK: (0):   %5 = alloc_ref $Base
-// CHECK: (0):   %6 = select_enum %0 : $E, case #E.A!enumelt: %1, default %2 : $Base
-// CHECK: NoAlias
-sil @select_enum_and_local_object : $@convention(thin) (E, @owned Base, @owned Base, @owned Base, @owned Base) -> Builtin.Int64 {
-bb0(%0 : $E, %1 : $Base, %2 : $Base, %3 : $Base, %4 : $Base):
-  %5 = alloc_ref $Base
-  %6 = select_enum %0 : $E, case #E.A!enumelt: %1, default %2 : $Base // user: %7
-  checked_cast_br %6 : $Base to $Derived1, bb1, bb2 // id: %7
-
-bb1(%8 : $Derived1):                              // Preds: bb0 
-  %9 = integer_literal $Builtin.Int64, 1          // user: %10 
-  br bb5(%9 : $Builtin.Int64)                     // id: %10 
-
-bb2:                                              // Preds: bb0 
-  %11 = select_enum %0 : $E, case #E.B!enumelt: %3, default %4 : $Base // user: %12 
-  checked_cast_br %11 : $Base to $Derived1, bb3, bb4 // id: %12 
-
-bb3(%13 : $Derived1):                             // Preds: bb2 
-  %14 = integer_literal $Builtin.Int64, 2         // user: %15 
-  br bb5(%14 : $Builtin.Int64)                    // id: %15 
-
-bb4:                                              // Preds: bb2 
-  %16 = integer_literal $Builtin.Int64, 3         // user: %17 
-  br bb5(%16 : $Builtin.Int64)                    // id: %17 
-
-bb5(%18 : $Builtin.Int64):                        // Preds: bb1 bb3 bb4 
-  return %18 : $Builtin.Int64                     // id: %19 
-}
-
 // Address Arguments don't alias if they are arguments to the first BB.
 //
 // CHECK-LABEL: @address_args_dont_alias_in_first_bb