Subzero: Fix x86-64 memory sandboxing.

src/IceTargetLoweringX8664.cpp

 //===- subzero/src/IceTargetLoweringX8664.cpp - x86-64 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 390 matching lines @@
         ZeroReg = Index;
       } else {
         T = Index;
         Shift = Mem->getShift();
       }
     }
   }
 
   // NeedsLea is a flag indicating whether Mem needs to be materialized to a GPR
   // prior to being used. A LEA is needed if Mem.Offset is a constant
-  // relocatable, or if Mem.Offset is negative. In both these cases, the LEA is
-  // needed to ensure the sandboxed memory operand will only use the lower
-  // 32-bits of T+Offset.
+  // relocatable with a nonzero offset, or if Mem.Offset is a nonzero immediate;
+  // but only when the address mode contains a "user" register other than the
+  // rsp/rbp/r15 base. In both these cases, the LEA is needed to ensure the
+  // sandboxed memory operand will only use the lower 32-bits of T+Offset.
   bool NeedsLea = false;
-  if (Offset != nullptr) {
-    if (llvm::isa<ConstantRelocatable>(Offset)) {
-      NeedsLea = true;
+  if (!Mem->getIsRebased()) {
+    bool IsOffsetZero = false;
+    if (Offset == nullptr) {
+      IsOffsetZero = true;
+    } else if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(Offset)) {
+      IsOffsetZero = (CR->getOffset() == 0);
     } else if (const auto *Imm = llvm::dyn_cast<ConstantInteger32>(Offset)) {
-      NeedsLea = Imm->getValue() < 0;
+      IsOffsetZero = (Imm->getValue() == 0);
     } else {
       llvm::report_fatal_error("Unexpected Offset type.");
     }
+    if (!IsOffsetZero) {
+      if (Base != nullptr && Base != ZeroReg)
+        NeedsLea = true;
+      if (Index != nullptr && Index != ZeroReg)
+        NeedsLea = true;
+    }
   }
 
   RegNumT RegNum, RegNum32;
   if (T != nullptr) {
     if (T->hasReg()) {
       RegNum = Traits::getGprForType(IceType_i64, T->getRegNum());
       RegNum32 = Traits::getGprForType(IceType_i32, RegNum);
       // At this point, if T was assigned to rsp/rbp, then we would have already
       // made this the ZeroReg.
       assert(RegNum != Traits::RegisterSet::Reg_rsp);
@@ skipping 382 matching lines @@
 #define X(tag, sizeLog2, align, elts, elty, str, rcstr)                        \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8664_TABLE and ICETYPE_TABLE");
 ICETYPE_TABLE
 #undef X
 } // end of namespace dummy3
 } // end of anonymous namespace
 
 } // end of namespace X8664
 } // end of namespace Ice