diff --git a/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp b/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
--- a/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
+++ b/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
@@ -1017,6 +1017,21 @@
       }
     }
 
+    // Try to get the Index as Nonloc, then cast to ArrayIndexTy.
+    // Otherwise return None.
+    const auto MaybeNonLocIndexOfElementRegion =
+        [this](const ElementRegion *ElemReg) -> Optional<NonLoc> {
+      SVal IndexVal = ElemReg->getIndex();
+      Optional<NonLoc> Index = IndexVal.getAs<NonLoc>();
+      if (!Index)
+        return llvm::None;
+      IndexVal = evalCastFromNonLoc(*Index, ArrayIndexTy);
+      Index = IndexVal.getAs<NonLoc>();
+      if (!Index)
+        return llvm::None;
+      return Index.getValue();
+    };
+
     // Handle special cases for when both regions are element regions.
     const ElementRegion *RightER = dyn_cast<ElementRegion>(RightMR);
     const ElementRegion *LeftER = dyn_cast<ElementRegion>(LeftMR);
@@ -1027,31 +1042,32 @@
       // give the correct answer.
       if (LeftER->getSuperRegion() == RightER->getSuperRegion() &&
           LeftER->getElementType() == RightER->getElementType()) {
-        // Get the left index and cast it to the correct type.
-        // If the index is unknown or undefined, bail out here.
-        SVal LeftIndexVal = LeftER->getIndex();
-        Optional<NonLoc> LeftIndex = LeftIndexVal.getAs<NonLoc>();
-        if (!LeftIndex)
-          return UnknownVal();
-        LeftIndexVal = evalCastFromNonLoc(*LeftIndex, ArrayIndexTy);
-        LeftIndex = LeftIndexVal.getAs<NonLoc>();
-        if (!LeftIndex)
-          return UnknownVal();
 
-        // Do the same for the right index.
-        SVal RightIndexVal = RightER->getIndex();
-        Optional<NonLoc> RightIndex = RightIndexVal.getAs<NonLoc>();
-        if (!RightIndex)
-          return UnknownVal();
-        RightIndexVal = evalCastFromNonLoc(*RightIndex, ArrayIndexTy);
-        RightIndex = RightIndexVal.getAs<NonLoc>();
-        if (!RightIndex)
+        Optional<NonLoc> LeftIndex = MaybeNonLocIndexOfElementRegion(LeftER);
+        Optional<NonLoc> RightIndex = MaybeNonLocIndexOfElementRegion(RightER);
+
+        if (!LeftIndex || !RightIndex)
           return UnknownVal();
 
         // Actually perform the operation.
         // evalBinOpNN expects the two indexes to already be the right type.
         return evalBinOpNN(state, op, *LeftIndex, *RightIndex, resultTy);
       }
+    } else if (LeftER && isa<SymbolicRegion>(RightMR)) {
+      if (LeftER->getSuperRegion() != RightMR)
+        return UnknownVal();
+      if (Optional<NonLoc> LeftIndex = MaybeNonLocIndexOfElementRegion(LeftER))
+        return LeftIndex.getValue();
+      return UnknownVal();
+    } else if (RightER && isa<SymbolicRegion>(LeftMR)) {
+      if (RightER->getSuperRegion() != LeftMR)
+        return UnknownVal();
+      if (Optional<NonLoc> RightIndex =
+              MaybeNonLocIndexOfElementRegion(RightER))
+        llvm_unreachable(
+            "TODO: return the negated value of RightIndex - figure out how :D\n"
+            "Maybe a unary minus operator would do the job.");
+      return UnknownVal();
     }
 
     // Special handling of the FieldRegions, even with symbolic offsets.