Inserted local redzones.

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>
 
 namespace Ice {
@@ skipping 60 matching lines @@
 
   // Log the new set of globals
   if (BuildDefs::dump() && (getFlags().getVerbose() & IceV_GlobalInit)) {
     OstreamLocker _(Ctx);
     Ctx->getStrDump() << "========= Instrumented Globals =========\n";
     for (VariableDeclaration *Global : Globals) {
       Global->dump(Ctx->getStrDump());
     }
   }
 }
-
+// TODO(tlively): Make this thread safe
 std::string ASanInstrumentation::nextRzName() {
   std::stringstream Name;
   Name << RzPrefix << RzNum++;
   return Name.str();
 }
 
 VariableDeclaration *
 ASanInstrumentation::createRz(VariableDeclarationList *List,
                               VariableDeclaration *RzArray, SizeT &RzArraySize,
                               VariableDeclaration *Global) {
   auto *Rz = VariableDeclaration::create(List);
   Rz->setName(Ctx, nextRzName());
   if (Global->hasNonzeroInitializer()) {
     Rz->addInitializer(
         VariableDeclaration::DataInitializer::create(List, RzContents));
   } else {
     Rz->addInitializer(
         VariableDeclaration::ZeroInitializer::create(List, RzSize));
   }
   Rz->setIsConstant(Global->getIsConstant());
   RzArray->addInitializer(VariableDeclaration::RelocInitializer::create(
       List, Rz, RelocOffsetArray(0)));
   ++RzArraySize;
   return Rz;
 }
 
+// Check for an alloca signaling the presence of local variables and add a
+// redzone if it is found
+void ASanInstrumentation::instrumentFuncStart(LoweringContext &Context) {
+  auto *FirstAlloca = llvm::dyn_cast<InstAlloca>(Context.getCur());
+  if (FirstAlloca == nullptr)
+    return;
+
+  constexpr SizeT Alignment = 4;
+  InstAlloca *RzAlloca = createLocalRz(Context, RzSize, Alignment);
+
+  // insert before the current instruction
+  InstList::iterator Next = Context.getNext();
+  Context.setInsertPoint(Context.getCur());
+  Context.insert(RzAlloca);
+  Context.setNext(Next);
+}
+
+void ASanInstrumentation::instrumentAlloca(LoweringContext &Context,
+                                           InstAlloca *Instr) {
+  auto *VarSizeOp = llvm::dyn_cast<ConstantInteger32>(Instr->getSizeInBytes());
+  SizeT VarSize = (VarSizeOp == nullptr) ? RzSize : VarSizeOp->getValue();
+  SizeT Padding = (VarSize % RzSize) ? RzSize - VarSize % RzSize : 0;

[Jim Stichnoth, 2016/06/20 19:44:41]

Can you use Utils::OffsetToAlignment() here?

[tlively, 2016/06/20 22:19:33]

Done.

+  constexpr SizeT Alignment = 1;
+  InstAlloca *Rz = createLocalRz(Context, RzSize + Padding, Alignment);
+  Context.insert(Rz);
+}
+
+InstAlloca *ASanInstrumentation::createLocalRz(LoweringContext &Context,
+                                               SizeT Size, SizeT Alignment) {
+  Cfg *Func = Context.getNode()->getCfg();
+  Variable *Rz = Func->makeVariable(IceType_i32);
+  Rz->setName(Func, nextRzName());
+  // TODO(tlively): Make this unnecessary

[Jim Stichnoth, 2016/06/20 19:44:41]

I'm not sure what the exact problem is here.  Is it that the new alloca
instruction gets dead-code eliminated because of no uses of Rz?

If so, you might be able to create a FakeUse instruction after the alloca
instruction.

[tlively, 2016/06/20 22:19:33]

I'll just get rid of this now. It will be unnecessary once the redzones are
used.

+  Rz->setIgnoreLiveness();
+
+  auto *ByteCount = ConstantInteger32::create(Ctx, IceType_i32, Size);
+  auto *RzAlloca = InstAlloca::create(Func, Rz, ByteCount, Alignment);
+
+  return RzAlloca;
+}
+
 void ASanInstrumentation::instrumentCall(LoweringContext &Context,
                                          InstCall *Instr) {
   auto *CallTarget =
       llvm::dyn_cast<ConstantRelocatable>(Instr->getCallTarget());
   if (CallTarget == nullptr)
     return;
 
   std::string TargetName = CallTarget->getName().toStringOrEmpty();
   auto Subst = FuncSubstitutions.find(TargetName);
   if (Subst == FuncSubstitutions.end())
@@ skipping 45 matching lines @@
   Constant *ShadowMemInit =
       Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_init"));
   constexpr SizeT NumArgs = 0;
   constexpr Variable *Void = nullptr;
   constexpr bool NoTailCall = false;
   auto *Call = InstCall::create(Func, NumArgs, Void, ShadowMemInit, NoTailCall);
   Func->getEntryNode()->getInsts().push_front(Call);
 }
 
 } // end of namespace Ice