Subzero: Elide checks of known valid accesses of locals

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 23 matching lines @@
 constexpr const char *ASanPrefix = "__asan";
 constexpr SizeT RzSize = 32;
 constexpr const char *RzPrefix = "__$rz";
 constexpr const char *RzArrayName = "__$rz_array";
 constexpr const char *RzSizesName = "__$rz_sizes";
 const llvm::NaClBitcodeRecord::RecordVector RzContents =
     llvm::NaClBitcodeRecord::RecordVector(RzSize, 'R');
 
 // In order to instrument the code correctly, the .pexe must not have had its
 // symbols stripped.
-using string_map = std::unordered_map<std::string, std::string>;
-using string_set = std::unordered_set<std::string>;
+using StringMap = std::unordered_map<std::string, std::string>;
+using StringSet = std::unordered_set<std::string>;
 // TODO(tlively): Handle all allocation functions
-const string_map FuncSubstitutions = {{"malloc", "__asan_malloc"},
-                                      {"free", "__asan_free"},
-                                      {"calloc", "__asan_calloc"},
-                                      {"__asan_dummy_calloc", "__asan_calloc"},
-                                      {"realloc", "__asan_realloc"}};
-const string_set FuncBlackList = {"_Balloc"};
+const StringMap FuncSubstitutions = {{"malloc", "__asan_malloc"},
+                                     {"free", "__asan_free"},
+                                     {"calloc", "__asan_calloc"},
+                                     {"__asan_dummy_calloc", "__asan_calloc"},
+                                     {"realloc", "__asan_realloc"}};
+const StringSet FuncBlackList = {"_Balloc"};
 
 llvm::NaClBitcodeRecord::RecordVector sizeToByteVec(SizeT Size) {
   llvm::NaClBitcodeRecord::RecordVector SizeContents;
   for (unsigned i = 0; i < sizeof(Size); ++i) {
     SizeContents.emplace_back(Size % (1 << CHAR_BIT));
     Size >>= CHAR_BIT;
   }
   return SizeContents;
 }
 
 } // end of anonymous namespace
 
+ICE_TLS_DEFINE_FIELD(VarSizeMap *, ASanInstrumentation, LocalVars);
 ICE_TLS_DEFINE_FIELD(std::vector<InstCall *> *, ASanInstrumentation,
                      LocalDtors);
 
 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
@@ skipping 75 matching lines @@
 
 std::string ASanInstrumentation::nextRzName() {
   std::stringstream Name;
   Name << RzPrefix << RzNum++;
   return Name.str();
 }
 
 // Check for an alloca signaling the presence of local variables and add a
 // redzone if it is found
 void ASanInstrumentation::instrumentFuncStart(LoweringContext &Context) {
-  if (ICE_TLS_GET_FIELD(LocalDtors) == nullptr)
+  if (ICE_TLS_GET_FIELD(LocalDtors) == nullptr) {
     ICE_TLS_SET_FIELD(LocalDtors, new std::vector<InstCall *>());
+    ICE_TLS_SET_FIELD(LocalVars, new VarSizeMap());
+  }
   Cfg *Func = Context.getNode()->getCfg();
   bool HasLocals = false;
   LoweringContext C;
   C.init(Context.getNode());
   std::vector<Inst *> Initializations;
   Constant *InitFunc =
       Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_poison"));
   Constant *DestroyFunc =
       Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_unpoison"));
 
   InstAlloca *Cur;
   ConstantInteger32 *VarSizeOp;
   while (
       (Cur = llvm::dyn_cast<InstAlloca>(iteratorToInst(C.getCur()))) &&
       (VarSizeOp = llvm::dyn_cast<ConstantInteger32>(Cur->getSizeInBytes()))) {
     HasLocals = true;
 
     // create the new alloca that includes a redzone
     SizeT VarSize = VarSizeOp->getValue();
     Variable *Dest = Cur->getDest();
+    ICE_TLS_GET_FIELD(LocalVars)->insert({Dest, VarSize});
     SizeT RzPadding = RzSize + Utils::OffsetToAlignment(VarSize, RzSize);
     auto *ByteCount =
         ConstantInteger32::create(Ctx, IceType_i32, VarSize + RzPadding);
     constexpr SizeT Alignment = 8;
     auto *NewVar = InstAlloca::create(Func, Dest, ByteCount, Alignment);
 
     // calculate the redzone offset
     Variable *RzLocVar = Func->makeVariable(IceType_i32);
     RzLocVar->setName(Func, nextRzName());
     auto *Offset = ConstantInteger32::create(Ctx, IceType_i32, VarSize);
@@ skipping 87 matching lines @@
 }
 
 void ASanInstrumentation::instrumentStore(LoweringContext &Context,
                                           InstStore *Instr) {
   Constant *Func =
       Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_check_store"));
   instrumentAccess(Context, Instr->getAddr(),
                    typeWidthInBytes(Instr->getData()->getType()), Func);
 }
 
-// TODO(tlively): Take size of access into account as well
 void ASanInstrumentation::instrumentAccess(LoweringContext &Context,
                                            Operand *Op, SizeT Size,
                                            Constant *CheckFunc) {
+  VarSizeMap::iterator LocalSize = ICE_TLS_GET_FIELD(LocalVars)->find(Op);
+  if (LocalSize != ICE_TLS_GET_FIELD(LocalVars)->end() &&
+      LocalSize->second >= Size)
+    return;
   constexpr SizeT NumArgs = 2;
   constexpr Variable *Void = nullptr;
   constexpr bool NoTailCall = false;
   auto *Call = InstCall::create(Context.getNode()->getCfg(), NumArgs, Void,
                                 CheckFunc, NoTailCall);
   Call->addArg(Op);
   Call->addArg(ConstantInteger32::create(Ctx, IceType_i32, Size));
   // play games to insert the call before the access instruction
   InstList::iterator Next = Context.getNext();
   Context.setInsertPoint(Context.getCur());
@@ skipping 32 matching lines @@
 
   instrumentGlobals(*getGlobals());
 
   Call->addArg(ConstantInteger32::create(Ctx, IceType_i32, RzGlobalsNum));
   Call->addArg(Ctx->getConstantSym(0, Ctx->getGlobalString(RzArrayName)));
   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