Subzero: Replace pointers to allocation functions in stores

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 371 matching lines @@
     }
   }
   Constant *Func =
       Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_check_load"));
   instrumentAccess(Context, Instr->getSourceAddress(),
                    typeWidthInBytes(Instr->getDest()->getType()), Func);
 }
 
 void ASanInstrumentation::instrumentStore(LoweringContext &Context,
                                           InstStore *Instr) {
+  Operand *Data = Instr->getData();
+  if (auto *Reloc = llvm::dyn_cast<ConstantRelocatable>(Data)) {
+    std::string DataName = Reloc->getName().toStringOrEmpty();
+    assert(!DataName.empty());

[Jim Stichnoth, 2016/08/18 13:17:19]

I just realized that if you use this pattern:
  S = N.toStringOrEmpty();
  assert(!S.empty());
You can probably simplify it to:
  S = N.toString();

The main difference is that the former does an assertion failure while the
latter does a report_fatal_error.  There's another minor difference between
these two, in that this will give an assertion failure:
  N = StringID::createWithString(Ctx, "");
  S = N.toStringOrEmpty();
  assert(!S.empty());
while this will succeed:
  N = StringID::createWithString(Ctx, "");
  S = N.toString();
but I doubt this is really an issue for your case.

[tlively, 2016/08/18 15:17:48]

Done.

+    StringMap::const_iterator DataSub = FuncSubstitutions.find(DataName);
+    if (DataSub != FuncSubstitutions.end()) {
+      auto *NewData = ConstantRelocatable::create(
+          Ctx, Reloc->getType(),
+          RelocatableTuple(Reloc->getOffset(), RelocOffsetArray(0),
+                           Ctx->getGlobalString(DataSub->second),
+                           Reloc->getEmitString()));
+      auto *NewStore = InstStore::create(Context.getNode()->getCfg(), NewData,
+                                         Instr->getAddr());
+      Instr->setDeleted();
+      Context.insert(NewStore);
+      Instr = NewStore;
+    }
+  }

[Karl, 2016/08/18 14:17:01]

Minor nit. It appears that instrument load/store look nearly identical. Should
they use a common method?

[tlively, 2016/08/18 15:17:48]

Done.

   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
@@ skipping 70 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