Subzero: Elide redundant access checks within basic blocks

src/IceASanInstrumentation.cpp

 //===- subzero/src/IceASanInstrumentation.cpp - ASan ------------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 52 matching lines @@
     Size >>= CHAR_BIT;
   }
   return SizeContents;
 }
 
 } // end of anonymous namespace
 
 ICE_TLS_DEFINE_FIELD(VarSizeMap *, ASanInstrumentation, LocalVars);
 ICE_TLS_DEFINE_FIELD(std::vector<InstStore *> *, ASanInstrumentation,
                      LocalDtors);
+ICE_TLS_DEFINE_FIELD(CfgNode *, ASanInstrumentation, CurNode);
+ICE_TLS_DEFINE_FIELD(VarSizeMap *, ASanInstrumentation, CheckedVars);
 
 bool ASanInstrumentation::isInstrumentable(Cfg *Func) {
   std::string FuncName = Func->getFunctionName().toStringOrEmpty();
   return FuncName == "" ||
          (FuncBlackList.count(FuncName) == 0 && FuncName.find(ASanPrefix) != 0);
 }
 
 // Create redzones around all global variables, ensuring that the initializer
 // types of the redzones and their associated globals match so that they are
 // laid out together in memory.
@@ skipping 239 matching lines @@
                                           InstStore *Instr) {
   Constant *Func =
       Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_check_store"));
   instrumentAccess(Context, Instr->getAddr(),
                    typeWidthInBytes(Instr->getData()->getType()), Func);
 }
 
 void ASanInstrumentation::instrumentAccess(LoweringContext &Context,
                                            Operand *Op, SizeT Size,
                                            Constant *CheckFunc) {
+  // Skip redundant checks within basic blocks
+  VarSizeMap *Checked = ICE_TLS_GET_FIELD(CheckedVars);
+  if (ICE_TLS_GET_FIELD(CurNode) != Context.getNode()) {
+    ICE_TLS_SET_FIELD(CurNode, Context.getNode());
+    if (Checked == NULL) {
+      Checked = new VarSizeMap();
+      ICE_TLS_SET_FIELD(CheckedVars, Checked);
+    }
+    Checked->clear();
+  }
+  VarSizeMap::iterator PrevCheck = Checked->find(Op);
+  if (PrevCheck != Checked->end() && PrevCheck->second >= Size)
+    return;
+  else
+    Checked->insert({Op, Size});
+
+  // check for known good local access
   VarSizeMap::iterator LocalSize = ICE_TLS_GET_FIELD(LocalVars)->find(Op);
   if (LocalSize != ICE_TLS_GET_FIELD(LocalVars)->end() &&
       LocalSize->second >= Size)
     return;
   if (isOkGlobalAccess(Op, Size))
     return;
   constexpr SizeT NumArgs = 2;
   constexpr Variable *Void = nullptr;
   constexpr bool NoTailCall = false;
   auto *Call = InstCall::create(Context.getNode()->getCfg(), NumArgs, Void,
@@ skipping 44 matching lines @@
   Call->addArg(Ctx->getConstantSym(0, Ctx->getGlobalString(RzSizesName)));
 }
 
 // TODO(tlively): make this more efficient with swap idiom
 void ASanInstrumentation::finishFunc(Cfg *) {
   ICE_TLS_GET_FIELD(LocalVars)->clear();
   ICE_TLS_GET_FIELD(LocalDtors)->clear();
 }
 
 } // end of namespace Ice