Instrumented malloc and free with dummy functions.

src/IceInstrumentation.cpp

 //===- subzero/src/IceInstrumentation.cpp - ICE instrumentation framework -===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 11 matching lines @@
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
 // Iterate through the instructions in the given CFG and instrument each one.
 // Also instrument the beginning of the function.
 void Instrumentation::instrumentFunc(Cfg *Func) {
   assert(Func);
   assert(!Func->getNodes().empty());
 
+  // TODO(tlively): Create a more precise blacklist than this
+  std::string FuncName = Func->getFunctionName().toStringOrEmpty();
+  if (FuncName.substr(0, 1) == "_" && FuncName != "_start")
+    return;
+
   LoweringContext Context;
   Context.init(Func->getNodes().front());
   instrumentFuncStart(Context);
   for (CfgNode *Node : Func->getNodes()) {
     Context.init(Node);
     while (!Context.atEnd()) {
       instrumentInst(Context);
       // go to next undeleted instruction
       Context.advanceCur();
       Context.advanceNext();
     }
   }
 
-  if (Func->getFunctionName().toStringOrEmpty() == "_start")
+  if (FuncName == "_start")
     instrumentStart(Func);
 }
 
 void Instrumentation::instrumentInst(LoweringContext &Context) {
   assert(!Context.atEnd());
   Inst *Instr = iteratorToInst(Context.getCur());
   switch (Instr->getKind()) {
   case Inst::Alloca:
     instrumentAlloca(Context, llvm::cast<InstAlloca>(Instr));
     break;
@@ skipping 46 matching lines @@
     instrumentUnreachable(Context, llvm::cast<InstUnreachable>(Instr));
     break;
   default:
     // Only instrument high-level ICE instructions
     assert(false && "Instrumentation encountered an unexpected instruction");
     break;
   }
 }
 
 } // end of namespace Ice