Blacklisted instrumenting _Balloc.

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
 /// \brief Implements the AddressSanitizer instrumentation class.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceASanInstrumentation.h"
 
 #include "IceBuildDefs.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceTargetLowering.h"
 #include "IceTypes.h"
 
 #include <sstream>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 namespace Ice {
 
 namespace {
 
 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');
 
-// TODO(tlively): Handle all allocation functions
 // 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>;
+// TODO(tlively): Handle all allocation functions
 const string_map FuncSubstitutions = {{"malloc", "__asan_malloc"},
                                       {"free", "__asan_free"}};
+const string_set 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(std::vector<InstCall *> *, ASanInstrumentation,
                      LocalDtors);
 
+bool ASanInstrumentation::isInstrumentable(Cfg *Func) {
+  std::string FuncName = Func->getFunctionName().toStringOrEmpty();
+  return FuncName == "" || FuncBlackList.find(FuncName) == FuncBlackList.end();

[Karl, 2016/07/07 21:20:49]

Actually, a simpler test is:

    || FuncBlackList.count(FuncName) == 0;

[tlively, 2016/07/08 16:56:21]

Done.

+}
+
 // 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.
 void ASanInstrumentation::instrumentGlobals(VariableDeclarationList &Globals) {
   if (DidProcessGlobals)
     return;
   VariableDeclarationList NewGlobals;
   // Global holding pointers to all redzones
   auto *RzArray = VariableDeclaration::create(&NewGlobals);
   // Global holding sizes of all redzones
@@ skipping 255 matching lines @@
     while (!DidProcessGlobals)
       GlobalsDoneCV.wait(GlobalsLock);
     GlobalsLock.release();
   }
   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 *Func) {
-  (void)Func;
+void ASanInstrumentation::finishFunc(Cfg *) {
   ICE_TLS_GET_FIELD(LocalDtors)->clear();
 }
 
 } // end of namespace Ice