Index: lib/Analysis/BasicAliasAnalysis.cpp
===================================================================
--- lib/Analysis/BasicAliasAnalysis.cpp
+++ lib/Analysis/BasicAliasAnalysis.cpp
@@ -42,6 +42,8 @@
 #include <algorithm>
 using namespace llvm;
 
+static cl::opt<bool> BasicAAStructGEPs("basicaa-struct-geps", cl::ReallyHidden);
+
 /// Cutoff after which to stop analysing a set of phi nodes potentially involved
 /// in a cycle. Because we are analysing 'through' phi nodes we need to be
 /// careful with value equivalence. We use reachability to make sure a value
@@ -997,6 +999,65 @@
              "DecomposeGEPExpression and GetUnderlyingObject disagree!");
       return MayAlias;
     }
+
+    // If both GEPs are based on the same pointer, and said pointer is a
+    // (possibly multidimensional) array of structs, we can try to determine
+    // whether struct field accesses don't alias.
+    // Note that the same pointer the GEPs are based on has to be the same
+    // pointer operand, not just the same underlying object.
+    if (BasicAAStructGEPs &&
+        GEP1->getPointerOperand() == GEP2->getPointerOperand() &&
+        GEP1->getNumIndices() == GEP2->getNumIndices()) {
+      // Find the last-indexed type of the GEP, i.e., the type you'd get if
+      // you stripped the last index.
+      // On the way, look at each indexed type.  If there's something other
+      // than an array, different indices can lead to different final types.
+      SmallVector<Value *, 8> IntermediateIndices;
+      bool IntermediateIndexedTypesAreArrays = true;
+      for (unsigned i = 0, e = GEP1->getNumIndices() - 1; i != e; ++i) {
+        if (i &&
+            !isa<ArrayType>(GetElementPtrInst::getIndexedType(
+                GEP1->getPointerOperandType(), IntermediateIndices)))
+          IntermediateIndexedTypesAreArrays = false;
+        IntermediateIndices.push_back(GEP1->getOperand(i + 1));
+      }
+
+      Type *LastIndexedType = GetElementPtrInst::getIndexedType(
+          GEP1->getPointerOperandType(), IntermediateIndices);
+
+      ConstantInt *C1 =
+          dyn_cast<ConstantInt>(GEP1->getOperand(GEP1->getNumOperands() - 1));
+      ConstantInt *C2 =
+          dyn_cast<ConstantInt>(GEP2->getOperand(GEP2->getNumOperands() - 1));
+
+      // If the last indices in both GEPs are constant, and they index into
+      // a struct, we can try to figure out if they access different fields.
+      if (C1 && C2 && C1 != C2 && isa<StructType>(LastIndexedType) &&
+          IntermediateIndexedTypesAreArrays) {
+        const StructLayout *SL =
+            DL->getStructLayout(cast<StructType>(LastIndexedType));
+        const uint64_t StructSize = SL->getSizeInBytes();
+        const uint64_t Elt1Idx = C1->getZExtValue();
+        const uint64_t Elt2Idx = C2->getZExtValue();
+        const uint64_t Elt1Off = SL->getElementOffset(Elt1Idx);
+        const uint64_t Elt2Off = SL->getElementOffset(Elt2Idx);
+
+        auto EltsDontOverlap = [StructSize](uint64_t Elt1Off, uint64_t Elt2Off,
+                                            uint64_t V1Size, uint64_t V2Size) {
+          return Elt1Off + V1Size <= Elt2Off &&
+                 ((Elt2Off + V2Size <= StructSize) ||
+                  (Elt2Off + V2Size - StructSize <= Elt1Off));
+        };
+
+        if (Elt1Off < Elt2Off &&
+            EltsDontOverlap(Elt1Off, Elt2Off, V1Size, V2Size)) {
+          return NoAlias;
+        } else if (EltsDontOverlap(Elt2Off, Elt1Off, V2Size, V1Size)) {
+          return NoAlias;
+        }
+      }
+    }
+
     // If the max search depth is reached the result is undefined
     if (GEP2MaxLookupReached || GEP1MaxLookupReached)
       return MayAlias;
Index: test/Analysis/BasicAA/struct-geps.ll
===================================================================
--- /dev/null
+++ test/Analysis/BasicAA/struct-geps.ll
@@ -0,0 +1,133 @@
+; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output -basicaa-struct-geps=true 2>&1 | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-darwin"
+
+%struct = type { i32, i32, i32 }
+
+; CHECK-LABEL: test_simple
+
+; CHECK-DAG: PartialAlias: %struct* %st, i32* %x
+; CHECK-DAG: PartialAlias: %struct* %st, i32* %y
+; CHECK-DAG: PartialAlias: %struct* %st, i32* %z
+
+; CHECK-DAG: NoAlias: i32* %x, i32* %y
+; CHECK-DAG: NoAlias: i32* %x, i32* %z
+; CHECK-DAG: NoAlias: i32* %y, i32* %z
+
+; CHECK-DAG: PartialAlias: %struct* %st, %struct* %y_12
+; CHECK-DAG: PartialAlias: %struct* %y_12, i32* %x
+; CHECK-DAG: PartialAlias: i32* %x, i80* %y_10
+
+; CHECK-DAG: PartialAlias: %struct* %st, i64* %y_8
+; CHECK-DAG: PartialAlias: i32* %z, i64* %y_8
+; CHECK-DAG: NoAlias: i32* %x, i64* %y_8
+
+; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y
+; CHECK-DAG: MustAlias: i32* %y, i64* %y_8
+; CHECK-DAG: MustAlias: i32* %y, i80* %y_10
+
+define void @test_simple(%struct* %st, i64 %i, i64 %j, i64 %k) {
+  %x = getelementptr %struct* %st, i64 %i, i32 0
+  %y = getelementptr %struct* %st, i64 %j, i32 1
+  %z = getelementptr %struct* %st, i64 %k, i32 2
+  %y_12 = bitcast i32* %y to %struct*
+  %y_10 = bitcast i32* %y to i80*
+  %y_8 = bitcast i32* %y to i64*
+  ret void
+}
+
+; CHECK-LABEL: test_in_array
+
+; CHECK-DAG: PartialAlias: [1 x %struct]* %st, i32* %x
+; CHECK-DAG: PartialAlias: [1 x %struct]* %st, i32* %y
+; CHECK-DAG: PartialAlias: [1 x %struct]* %st, i32* %z
+
+; CHECK-DAG: NoAlias: i32* %x, i32* %y
+; CHECK-DAG: NoAlias: i32* %x, i32* %z
+; CHECK-DAG: NoAlias: i32* %y, i32* %z
+
+; CHECK-DAG: PartialAlias: %struct* %y_12, [1 x %struct]* %st
+; CHECK-DAG: PartialAlias: %struct* %y_12, i32* %x
+; CHECK-DAG: PartialAlias: i32* %x, i80* %y_10
+
+; CHECK-DAG: PartialAlias: [1 x %struct]* %st, i64* %y_8
+; CHECK-DAG: PartialAlias: i32* %z, i64* %y_8
+; CHECK-DAG: NoAlias: i32* %x, i64* %y_8
+
+; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y
+; CHECK-DAG: MustAlias: i32* %y, i64* %y_8
+; CHECK-DAG: MustAlias: i32* %y, i80* %y_10
+
+define void @test_in_array([1 x %struct]* %st, i64 %i, i64 %j, i64 %k, i64 %i1, i64 %j1, i64 %k1) {
+  %x = getelementptr [1 x %struct]* %st, i64 %i, i64 %i1, i32 0
+  %y = getelementptr [1 x %struct]* %st, i64 %j, i64 %j1, i32 1
+  %z = getelementptr [1 x %struct]* %st, i64 %k, i64 %k1, i32 2
+  %y_12 = bitcast i32* %y to %struct*
+  %y_10 = bitcast i32* %y to i80*
+  %y_8 = bitcast i32* %y to i64*
+  ret void
+}
+
+; CHECK-LABEL: test_same_underlying_object_same_indices
+
+; CHECK-DAG: NoAlias: i32* %x, i32* %x2
+; CHECK-DAG: NoAlias: i32* %y, i32* %y2
+; CHECK-DAG: NoAlias: i32* %z, i32* %z2
+
+; CHECK-DAG: PartialAlias: i32* %x, i32* %y2
+; CHECK-DAG: PartialAlias: i32* %x, i32* %z2
+
+; CHECK-DAG: PartialAlias: i32* %x2, i32* %y
+; CHECK-DAG: PartialAlias: i32* %y, i32* %z2
+
+; CHECK-DAG: PartialAlias: i32* %x2, i32* %z
+; CHECK-DAG: PartialAlias: i32* %y2, i32* %z
+
+define void @test_same_underlying_object_same_indices(%struct* %st, i64 %i, i64 %j, i64 %k) {
+  %st2 = getelementptr %struct* %st, i32 10
+  %x2 = getelementptr %struct* %st2, i64 %i, i32 0
+  %y2 = getelementptr %struct* %st2, i64 %j, i32 1
+  %z2 = getelementptr %struct* %st2, i64 %k, i32 2
+  %x = getelementptr %struct* %st, i64 %i, i32 0
+  %y = getelementptr %struct* %st, i64 %j, i32 1
+  %z = getelementptr %struct* %st, i64 %k, i32 2
+  ret void
+}
+
+; CHECK-LABEL: test_same_underlying_object_different_indices
+
+; CHECK-DAG: PartialAlias: i32* %x, i32* %x2
+; CHECK-DAG: PartialAlias: i32* %y, i32* %y2
+; CHECK-DAG: PartialAlias: i32* %z, i32* %z2
+
+; CHECK-DAG: PartialAlias: i32* %x, i32* %y2
+; CHECK-DAG: PartialAlias: i32* %x, i32* %z2
+
+; CHECK-DAG: PartialAlias: i32* %x2, i32* %y
+; CHECK-DAG: PartialAlias: i32* %y, i32* %z2
+
+; CHECK-DAG: PartialAlias: i32* %x2, i32* %z
+; CHECK-DAG: PartialAlias: i32* %y2, i32* %z
+
+define void @test_same_underlying_object_different_indices(%struct* %st, i64 %i1, i64 %j1, i64 %k1, i64 %i2, i64 %k2, i64 %j2) {
+  %st2 = getelementptr %struct* %st, i32 10
+  %x2 = getelementptr %struct* %st2, i64 %i2, i32 0
+  %y2 = getelementptr %struct* %st2, i64 %j2, i32 1
+  %z2 = getelementptr %struct* %st2, i64 %k2, i32 2
+  %x = getelementptr %struct* %st, i64 %i1, i32 0
+  %y = getelementptr %struct* %st, i64 %j1, i32 1
+  %z = getelementptr %struct* %st, i64 %k1, i32 2
+  ret void
+}
+
+
+%struct2 = type { [1 x { i32, i32 }], [2 x { i32 }] }
+
+; CHECK-LABEL: test_struct_in_array
+; CHECK-DAG: MustAlias: i32* %x, i32* %y
+define void @test_struct_in_array(%struct2* %st, i64 %i, i64 %j, i64 %k) {
+  %x = getelementptr %struct2* %st, i32 0, i32 1, i32 1, i32 0
+  %y = getelementptr %struct2* %st, i32 0, i32 0, i32 1, i32 1
+  ret void
+}