<div style="font-family: arial, helvetica, sans-serif; font-size: 10pt">Do we really want changes like this? <div><br></div><div><pre style="word-wrap:break-word;white-space:pre-wrap">         DEBUG(dbgs() << "No shadow: " << *V << "\n" << *(I->getParent()));
+       (void)I;
         assert(Shadow && "No shadow for a value");</pre></div><div>--kcc <br><br><div class="gmail_quote">On Thu, Nov 29, 2012 at 4:44 PM, NAKAMURA Takumi <span dir="ltr"><<a href="mailto:geek4civic@gmail.com" target="_blank">geek4civic@gmail.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Evgeniy, could you apply patches to suppress warnings?<br>
<br>
...Takumi<br>
<br>
2012/11/29 Evgeniy Stepanov <<a href="mailto:eugeni.stepanov@gmail.com">eugeni.stepanov@gmail.com</a>>:<br>
<div class="HOEnZb"><div class="h5">> Author: eugenis<br>
> Date: Thu Nov 29 03:57:20 2012<br>
> New Revision: 168866<br>
><br>
> URL: <a href="http://llvm.org/viewvc/llvm-project?rev=168866&view=rev" target="_blank">http://llvm.org/viewvc/llvm-project?rev=168866&view=rev</a><br>
> Log:<br>
> Initial commit of MemorySanitizer.<br>
><br>
> Compiler pass only.<br>
><br>
> Added:<br>
>     llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp   (with props)<br>
>     llvm/trunk/test/Instrumentation/MemorySanitizer/<br>
>     llvm/trunk/test/Instrumentation/MemorySanitizer/lit.local.cfg<br>
>     llvm/trunk/test/Instrumentation/MemorySanitizer/msan_basic.ll<br>
> Modified:<br>
>     llvm/trunk/include/llvm/InitializePasses.h<br>
>     llvm/trunk/include/llvm/Transforms/Instrumentation.h<br>
>     llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt<br>
>     llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp<br>
><br>
> Modified: llvm/trunk/include/llvm/InitializePasses.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/InitializePasses.h?rev=168866&r1=168865&r2=168866&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/InitializePasses.h?rev=168866&r1=168865&r2=168866&view=diff</a><br>

> ==============================================================================<br>
> --- llvm/trunk/include/llvm/InitializePasses.h (original)<br>
> +++ llvm/trunk/include/llvm/InitializePasses.h Thu Nov 29 03:57:20 2012<br>
> @@ -111,6 +111,7 @@<br>
>  void initializeGCOVProfilerPass(PassRegistry&);<br>
>  void initializeAddressSanitizerPass(PassRegistry&);<br>
>  void initializeAddressSanitizerModulePass(PassRegistry&);<br>
> +void initializeMemorySanitizerPass(PassRegistry&);<br>
>  void initializeThreadSanitizerPass(PassRegistry&);<br>
>  void initializeEarlyCSEPass(PassRegistry&);<br>
>  void initializeExpandISelPseudosPass(PassRegistry&);<br>
><br>
> Modified: llvm/trunk/include/llvm/Transforms/Instrumentation.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Instrumentation.h?rev=168866&r1=168865&r2=168866&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Instrumentation.h?rev=168866&r1=168865&r2=168866&view=diff</a><br>

> ==============================================================================<br>
> --- llvm/trunk/include/llvm/Transforms/Instrumentation.h (original)<br>
> +++ llvm/trunk/include/llvm/Transforms/Instrumentation.h Thu Nov 29 03:57:20 2012<br>
> @@ -36,6 +36,8 @@<br>
>  // Insert AddressSanitizer (address sanity checking) instrumentation<br>
>  FunctionPass *createAddressSanitizerFunctionPass();<br>
>  ModulePass *createAddressSanitizerModulePass();<br>
> +// Insert MemorySanitizer instrumentation (detection of uninitialized reads)<br>
> +FunctionPass *createMemorySanitizerPass();<br>
>  // Insert ThreadSanitizer (race detection) instrumentation<br>
>  FunctionPass *createThreadSanitizerPass();<br>
><br>
><br>
> Modified: llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt?rev=168866&r1=168865&r2=168866&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt?rev=168866&r1=168865&r2=168866&view=diff</a><br>

> ==============================================================================<br>
> --- llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt (original)<br>
> +++ llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt Thu Nov 29 03:57:20 2012<br>
> @@ -4,6 +4,7 @@<br>
>    BoundsChecking.cpp<br>
>    EdgeProfiling.cpp<br>
>    GCOVProfiling.cpp<br>
> +  MemorySanitizer.cpp<br>
>    Instrumentation.cpp<br>
>    OptimalEdgeProfiling.cpp<br>
>    PathProfiling.cpp<br>
><br>
> Modified: llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp?rev=168866&r1=168865&r2=168866&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp?rev=168866&r1=168865&r2=168866&view=diff</a><br>

> ==============================================================================<br>
> --- llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp (original)<br>
> +++ llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp Thu Nov 29 03:57:20 2012<br>
> @@ -27,6 +27,7 @@<br>
>    initializeGCOVProfilerPass(Registry);<br>
>    initializeOptimalEdgeProfilerPass(Registry);<br>
>    initializePathProfilerPass(Registry);<br>
> +  initializeMemorySanitizerPass(Registry);<br>
>    initializeThreadSanitizerPass(Registry);<br>
>  }<br>
><br>
><br>
> Added: llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp?rev=168866&view=auto" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp?rev=168866&view=auto</a><br>

> ==============================================================================<br>
> --- llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp (added)<br>
> +++ llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp Thu Nov 29 03:57:20 2012<br>
> @@ -0,0 +1,1419 @@<br>
> +//===-- MemorySanitizer.cpp - detector of uninitialized reads -------------===//<br>
> +//<br>
> +//                     The LLVM Compiler Infrastructure<br>
> +//<br>
> +// This file is distributed under the University of Illinois Open Source<br>
> +// License. See LICENSE.TXT for details.<br>
> +//<br>
> +//===----------------------------------------------------------------------===//<br>
> +/// \file<br>
> +/// This file is a part of MemorySanitizer, a detector of uninitialized<br>
> +/// reads.<br>
> +///<br>
> +/// Status: early prototype.<br>
> +///<br>
> +/// The algorithm of the tool is similar to Memcheck<br>
> +/// (<a href="http://goo.gl/QKbem" target="_blank">http://goo.gl/QKbem</a>). We associate a few shadow bits with every<br>
> +/// byte of the application memory, poison the shadow of the malloc-ed<br>
> +/// or alloca-ed memory, load the shadow bits on every memory read,<br>
> +/// propagate the shadow bits through some of the arithmetic<br>
> +/// instruction (including MOV), store the shadow bits on every memory<br>
> +/// write, report a bug on some other instructions (e.g. JMP) if the<br>
> +/// associated shadow is poisoned.<br>
> +///<br>
> +/// But there are differences too. The first and the major one:<br>
> +/// compiler instrumentation instead of binary instrumentation. This<br>
> +/// gives us much better register allocation, possible compiler<br>
> +/// optimizations and a fast start-up. But this brings the major issue<br>
> +/// as well: msan needs to see all program events, including system<br>
> +/// calls and reads/writes in system libraries, so we either need to<br>
> +/// compile *everything* with msan or use a binary translation<br>
> +/// component (e.g. DynamoRIO) to instrument pre-built libraries.<br>
> +/// Another difference from Memcheck is that we use 8 shadow bits per<br>
> +/// byte of application memory and use a direct shadow mapping. This<br>
> +/// greatly simplifies the instrumentation code and avoids races on<br>
> +/// shadow updates (Memcheck is single-threaded so races are not a<br>
> +/// concern there. Memcheck uses 2 shadow bits per byte with a slow<br>
> +/// path storage that uses 8 bits per byte).<br>
> +///<br>
> +/// The default value of shadow is 0, which means "clean" (not poisoned).<br>
> +///<br>
> +/// Every module initializer should call __msan_init to ensure that the<br>
> +/// shadow memory is ready. On error, __msan_warning is called. Since<br>
> +/// parameters and return values may be passed via registers, we have a<br>
> +/// specialized thread-local shadow for return values<br>
> +/// (__msan_retval_tls) and parameters (__msan_param_tls).<br>
> +//===----------------------------------------------------------------------===//<br>
> +<br>
> +#define DEBUG_TYPE "msan"<br>
> +<br>
> +#include "BlackList.h"<br>
> +#include "llvm/DataLayout.h"<br>
> +#include "llvm/Function.h"<br>
> +#include "llvm/InlineAsm.h"<br>
> +#include "llvm/IntrinsicInst.h"<br>
> +#include "llvm/IRBuilder.h"<br>
> +#include "llvm/LLVMContext.h"<br>
> +#include "llvm/MDBuilder.h"<br>
> +#include "llvm/Module.h"<br>
> +#include "llvm/Type.h"<br>
> +#include "llvm/ADT/DepthFirstIterator.h"<br>
> +#include "llvm/ADT/SmallString.h"<br>
> +#include "llvm/ADT/SmallVector.h"<br>
> +#include "llvm/ADT/ValueMap.h"<br>
> +#include "llvm/Transforms/Instrumentation.h"<br>
> +#include "llvm/Transforms/Utils/BasicBlockUtils.h"<br>
> +#include "llvm/Transforms/Utils/ModuleUtils.h"<br>
> +#include "llvm/Support/CommandLine.h"<br>
> +#include "llvm/Support/Compiler.h"<br>
> +#include "llvm/Support/Debug.h"<br>
> +#include "llvm/Support/InstVisitor.h"<br>
> +#include "llvm/Support/raw_ostream.h"<br>
> +#include "llvm/Transforms/Instrumentation.h"<br>
> +#include "llvm/Transforms/Utils/BasicBlockUtils.h"<br>
> +#include "llvm/Transforms/Utils/ModuleUtils.h"<br>
> +<br>
> +using namespace llvm;<br>
> +<br>
> +static const uint64_t kShadowMask32 = 1ULL << 31;<br>
> +static const uint64_t kShadowMask64 = 1ULL << 46;<br>
> +static const uint64_t kOriginOffset32 = 1ULL << 30;<br>
> +static const uint64_t kOriginOffset64 = 1ULL << 45;<br>
> +<br>
> +// This is an important flag that makes the reports much more<br>
> +// informative at the cost of greater slowdown. Not fully implemented<br>
> +// yet.<br>
> +// FIXME: this should be a top-level clang flag, e.g.<br>
> +// -fmemory-sanitizer-full.<br>
> +static cl::opt<bool> ClTrackOrigins("msan-track-origins",<br>
> +       cl::desc("Track origins (allocation sites) of poisoned memory"),<br>
> +       cl::Hidden, cl::init(false));<br>
> +static cl::opt<bool> ClKeepGoing("msan-keep-going",<br>
> +       cl::desc("keep going after reporting a UMR"),<br>
> +       cl::Hidden, cl::init(false));<br>
> +static cl::opt<bool> ClPoisonStack("msan-poison-stack",<br>
> +       cl::desc("poison uninitialized stack variables"),<br>
> +       cl::Hidden, cl::init(true));<br>
> +static cl::opt<bool> ClPoisonStackWithCall("msan-poison-stack-with-call",<br>
> +       cl::desc("poison uninitialized stack variables with a call"),<br>
> +       cl::Hidden, cl::init(false));<br>
> +static cl::opt<int> ClPoisonStackPattern("msan-poison-stack-pattern",<br>
> +       cl::desc("poison uninitialized stack variables with the given patter"),<br>
> +       cl::Hidden, cl::init(0xff));<br>
> +<br>
> +static cl::opt<bool> ClHandleICmp("msan-handle-icmp",<br>
> +       cl::desc("propagate shadow through ICmpEQ and ICmpNE"),<br>
> +       cl::Hidden, cl::init(true));<br>
> +<br>
> +// This flag controls whether we check the shadow of the address<br>
> +// operand of load or store. Such bugs are very rare, since load from<br>
> +// a garbage address typically results in SEGV, but still happen<br>
> +// (e.g. only lower bits of address are garbage, or the access happens<br>
> +// early at program startup where malloc-ed memory is more likely to<br>
> +// be zeroed. As of 2012-08-28 this flag adds 20% slowdown.<br>
> +static cl::opt<bool> ClCheckAccessAddress("msan-check-access-address",<br>
> +       cl::desc("report accesses through a pointer which has poisoned shadow"),<br>
> +       cl::Hidden, cl::init(true));<br>
> +<br>
> +static cl::opt<bool> ClDumpStrictInstructions("msan-dump-strict-instructions",<br>
> +       cl::desc("print out instructions with default strict semantics"),<br>
> +       cl::Hidden, cl::init(false));<br>
> +<br>
> +static cl::opt<std::string>  ClBlackListFile("msan-blacklist",<br>
> +       cl::desc("File containing the list of functions where MemorySanitizer "<br>
> +                "should not report bugs"), cl::Hidden);<br>
> +<br>
> +namespace {<br>
> +<br>
> +/// \brief An instrumentation pass implementing detection of uninitialized<br>
> +/// reads.<br>
> +///<br>
> +/// MemorySanitizer: instrument the code in module to find<br>
> +/// uninitialized reads.<br>
> +class MemorySanitizer : public FunctionPass {<br>
> +public:<br>
> +  MemorySanitizer() : FunctionPass(ID), TD(0) { }<br>
> +  const char *getPassName() const { return "MemorySanitizer"; }<br>
> +  bool runOnFunction(Function &F);<br>
> +  bool doInitialization(Module &M);<br>
> +  static char ID;  // Pass identification, replacement for typeid.<br>
> +<br>
> +private:<br>
> +  DataLayout *TD;<br>
> +  LLVMContext *C;<br>
> +  Type *IntptrTy;<br>
> +  Type *OriginTy;<br>
> +  /// \brief Thread-local shadow storage for function parameters.<br>
> +  GlobalVariable *ParamTLS;<br>
> +  /// \brief Thread-local origin storage for function parameters.<br>
> +  GlobalVariable *ParamOriginTLS;<br>
> +  /// \brief Thread-local shadow storage for function return value.<br>
> +  GlobalVariable *RetvalTLS;<br>
> +  /// \brief Thread-local origin storage for function return value.<br>
> +  GlobalVariable *RetvalOriginTLS;<br>
> +  /// \brief Thread-local shadow storage for in-register va_arg function<br>
> +  /// parameters (x86_64-specific).<br>
> +  GlobalVariable *VAArgTLS;<br>
> +  /// \brief Thread-local shadow storage for va_arg overflow area<br>
> +  /// (x86_64-specific).<br>
> +  GlobalVariable *VAArgOverflowSizeTLS;<br>
> +  /// \brief Thread-local space used to pass origin value to the UMR reporting<br>
> +  /// function.<br>
> +  GlobalVariable *OriginTLS;<br>
> +<br>
> +  /// \brief The run-time callback to print a warning.<br>
> +  Value *WarningFn;<br>
> +  /// \brief Run-time helper that copies origin info for a memory range.<br>
> +  Value *MsanCopyOriginFn;<br>
> +  /// \brief Run-time helper that generates a new origin value for a stack<br>
> +  /// allocation.<br>
> +  Value *MsanSetAllocaOriginFn;<br>
> +  /// \brief Run-time helper that poisons stack on function entry.<br>
> +  Value *MsanPoisonStackFn;<br>
> +  /// \brief The actual "memmove" function.<br>
> +  Value *MemmoveFn;<br>
> +<br>
> +  /// \brief Address mask used in application-to-shadow address calculation.<br>
> +  /// ShadowAddr is computed as ApplicationAddr & ~ShadowMask.<br>
> +  uint64_t ShadowMask;<br>
> +  /// \brief Offset of the origin shadow from the "normal" shadow.<br>
> +  /// OriginAddr is computed as (ShadowAddr + OriginOffset) & ~3ULL<br>
> +  uint64_t OriginOffset;<br>
> +  /// \brief Branch weights for error reporting.<br>
> +  MDNode *ColdCallWeights;<br>
> +  /// \brief The blacklist.<br>
> +  OwningPtr<BlackList> BL;<br>
> +<br>
> +  friend class MemorySanitizerVisitor;<br>
> +  friend class VarArgAMD64Helper;<br>
> +};<br>
> +}  // namespace<br>
> +<br>
> +char MemorySanitizer::ID = 0;<br>
> +INITIALIZE_PASS(MemorySanitizer, "msan",<br>
> +                "MemorySanitizer: detects uninitialized reads.",<br>
> +                false, false)<br>
> +<br>
> +FunctionPass *llvm::createMemorySanitizerPass() {<br>
> +  return new MemorySanitizer();<br>
> +}<br>
> +<br>
> +/// \brief Create a non-const global initialized with the given string.<br>
> +///<br>
> +/// Creates a writable global for Str so that we can pass it to the<br>
> +/// run-time lib. Runtime uses first 4 bytes of the string to store the<br>
> +/// frame ID, so the string needs to be mutable.<br>
> +static GlobalVariable *createPrivateNonConstGlobalForString(Module &M,<br>
> +                                                            StringRef Str) {<br>
> +  Constant *StrConst = ConstantDataArray::getString(M.getContext(), Str);<br>
> +  return new GlobalVariable(M, StrConst->getType(), /*isConstant=*/false,<br>
> +                            GlobalValue::PrivateLinkage, StrConst, "");<br>
> +}<br>
> +<br>
> +/// \brief Module-level initialization.<br>
> +///<br>
> +/// Obtains pointers to the required runtime library functions, and<br>
> +/// inserts a call to __msan_init to the module's constructor list.<br>
> +bool MemorySanitizer::doInitialization(Module &M) {<br>
> +  TD = getAnalysisIfAvailable<DataLayout>();<br>
> +  if (!TD)<br>
> +    return false;<br>
> +  BL.reset(new BlackList(ClBlackListFile));<br>
> +  C = &(M.getContext());<br>
> +  unsigned PtrSize = TD->getPointerSizeInBits(/* AddressSpace */0);<br>
> +  switch (PtrSize) {<br>
> +    case 64:<br>
> +      ShadowMask = kShadowMask64;<br>
> +      OriginOffset = kOriginOffset64;<br>
> +      break;<br>
> +    case 32:<br>
> +      ShadowMask = kShadowMask32;<br>
> +      OriginOffset = kOriginOffset32;<br>
> +      break;<br>
> +    default:<br>
> +      report_fatal_error("unsupported pointer size");<br>
> +      break;<br>
> +  }<br>
> +<br>
> +  IRBuilder<> IRB(*C);<br>
> +  IntptrTy = IRB.getIntPtrTy(TD);<br>
> +  OriginTy = IRB.getInt32Ty();<br>
> +<br>
> +  ColdCallWeights = MDBuilder(*C).createBranchWeights(1, 1000);<br>
> +<br>
> +  // Insert a call to __msan_init/__msan_track_origins into the module's CTORs.<br>
> +  appendToGlobalCtors(M, cast<Function>(M.getOrInsertFunction(<br>
> +                      "__msan_init", IRB.getVoidTy(), NULL)), 0);<br>
> +<br>
> +  new GlobalVariable(M, IRB.getInt32Ty(), true, GlobalValue::LinkOnceODRLinkage,<br>
> +                     IRB.getInt32(ClTrackOrigins), "__msan_track_origins");<br>
> +<br>
> +  // Create the callback.<br>
> +  // FIXME: this function should have "Cold" calling conv,<br>
> +  // which is not yet implemented.<br>
> +  StringRef WarningFnName = ClKeepGoing ? "__msan_warning"<br>
> +                                        : "__msan_warning_noreturn";<br>
> +  WarningFn = M.getOrInsertFunction(WarningFnName, IRB.getVoidTy(), NULL);<br>
> +<br>
> +  MsanCopyOriginFn = M.getOrInsertFunction(<br>
> +    "__msan_copy_origin", IRB.getVoidTy(), IRB.getInt8PtrTy(),<br>
> +    IRB.getInt8PtrTy(), IntptrTy, NULL);<br>
> +  MsanSetAllocaOriginFn = M.getOrInsertFunction(<br>
> +    "__msan_set_alloca_origin", IRB.getVoidTy(), IRB.getInt8PtrTy(), IntptrTy,<br>
> +    IRB.getInt8PtrTy(), NULL);<br>
> +  MsanPoisonStackFn = M.getOrInsertFunction(<br>
> +    "__msan_poison_stack", IRB.getVoidTy(), IRB.getInt8PtrTy(), IntptrTy, NULL);<br>
> +  MemmoveFn = M.getOrInsertFunction(<br>
> +    "memmove", IRB.getInt8PtrTy(), IRB.getInt8PtrTy(), IRB.getInt8PtrTy(),<br>
> +    IntptrTy, NULL);<br>
> +<br>
> +  // Create globals.<br>
> +  RetvalTLS = new GlobalVariable(<br>
> +    M, ArrayType::get(IRB.getInt64Ty(), 8), false,<br>
> +    GlobalVariable::ExternalLinkage, 0, "__msan_retval_tls", 0,<br>
> +    GlobalVariable::GeneralDynamicTLSModel);<br>
> +  RetvalOriginTLS = new GlobalVariable(<br>
> +    M, OriginTy, false, GlobalVariable::ExternalLinkage, 0,<br>
> +    "__msan_retval_origin_tls", 0, GlobalVariable::GeneralDynamicTLSModel);<br>
> +<br>
> +  ParamTLS = new GlobalVariable(<br>
> +    M, ArrayType::get(IRB.getInt64Ty(), 1000), false,<br>
> +    GlobalVariable::ExternalLinkage, 0, "__msan_param_tls", 0,<br>
> +    GlobalVariable::GeneralDynamicTLSModel);<br>
> +  ParamOriginTLS = new GlobalVariable(<br>
> +    M, ArrayType::get(OriginTy, 1000), false, GlobalVariable::ExternalLinkage,<br>
> +    0, "__msan_param_origin_tls", 0, GlobalVariable::GeneralDynamicTLSModel);<br>
> +<br>
> +  VAArgTLS = new GlobalVariable(<br>
> +    M, ArrayType::get(IRB.getInt64Ty(), 1000), false,<br>
> +    GlobalVariable::ExternalLinkage, 0, "__msan_va_arg_tls", 0,<br>
> +    GlobalVariable::GeneralDynamicTLSModel);<br>
> +  VAArgOverflowSizeTLS = new GlobalVariable(<br>
> +    M, IRB.getInt64Ty(), false, GlobalVariable::ExternalLinkage, 0,<br>
> +    "__msan_va_arg_overflow_size_tls", 0,<br>
> +    GlobalVariable::GeneralDynamicTLSModel);<br>
> +  OriginTLS = new GlobalVariable(<br>
> +    M, IRB.getInt32Ty(), false, GlobalVariable::ExternalLinkage, 0,<br>
> +    "__msan_origin_tls", 0, GlobalVariable::GeneralDynamicTLSModel);<br>
> +  return true;<br>
> +}<br>
> +<br>
> +namespace {<br>
> +<br>
> +/// \brief A helper class that handles instrumentation of VarArg<br>
> +/// functions on a particular platform.<br>
> +///<br>
> +/// Implementations are expected to insert the instrumentation<br>
> +/// necessary to propagate argument shadow through VarArg function<br>
> +/// calls. Visit* methods are called during an InstVisitor pass over<br>
> +/// the function, and should avoid creating new basic blocks. A new<br>
> +/// instance of this class is created for each instrumented function.<br>
> +struct VarArgHelper {<br>
> +  /// \brief Visit a CallSite.<br>
> +  virtual void visitCallSite(CallSite &CS, IRBuilder<> &IRB) = 0;<br>
> +<br>
> +  /// \brief Visit a va_start call.<br>
> +  virtual void visitVAStartInst(VAStartInst &I) = 0;<br>
> +<br>
> +  /// \brief Visit a va_copy call.<br>
> +  virtual void visitVACopyInst(VACopyInst &I) = 0;<br>
> +<br>
> +  /// \brief Finalize function instrumentation.<br>
> +  ///<br>
> +  /// This method is called after visiting all interesting (see above)<br>
> +  /// instructions in a function.<br>
> +  virtual void finalizeInstrumentation() = 0;<br>
> +};<br>
> +<br>
> +struct MemorySanitizerVisitor;<br>
> +<br>
> +VarArgHelper*<br>
> +CreateVarArgHelper(Function &Func, MemorySanitizer &Msan,<br>
> +                   MemorySanitizerVisitor &Visitor);<br>
> +<br>
> +/// This class does all the work for a given function. Store and Load<br>
> +/// instructions store and load corresponding shadow and origin<br>
> +/// values. Most instructions propagate shadow from arguments to their<br>
> +/// return values. Certain instructions (most importantly, BranchInst)<br>
> +/// test their argument shadow and print reports (with a runtime call) if it's<br>
> +/// non-zero.<br>
> +struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> {<br>
> +  Function &F;<br>
> +  MemorySanitizer &MS;<br>
> +  SmallVector<PHINode *, 16> ShadowPHINodes, OriginPHINodes;<br>
> +  ValueMap<Value*, Value*> ShadowMap, OriginMap;<br>
> +  bool InsertChecks;<br>
> +  OwningPtr<VarArgHelper> VAHelper;<br>
> +<br>
> +  // An unfortunate workaround for asymmetric lowering of va_arg stuff.<br>
> +  // See a comment in visitCallSite for more details.<br>
> +  static const unsigned AMD64GpEndOffset = 48; // AMD64 ABI Draft 0.99.6 p3.5.7<br>
> +  static const unsigned AMD64FpEndOffset = 176;<br>
> +<br>
> +  struct ShadowOriginAndInsertPoint {<br>
> +    Instruction *Shadow;<br>
> +    Instruction *Origin;<br>
> +    Instruction *OrigIns;<br>
> +    ShadowOriginAndInsertPoint(Instruction *S, Instruction *O, Instruction *I)<br>
> +      : Shadow(S), Origin(O), OrigIns(I) { }<br>
> +    ShadowOriginAndInsertPoint() : Shadow(0), Origin(0), OrigIns(0) { }<br>
> +  };<br>
> +  SmallVector<ShadowOriginAndInsertPoint, 16> InstrumentationList;<br>
> +<br>
> +  MemorySanitizerVisitor(Function &F, MemorySanitizer &MS)<br>
> +    : F(F), MS(MS), VAHelper(CreateVarArgHelper(F, MS, *this)) {<br>
> +    InsertChecks = !MS.BL->isIn(F);<br>
> +    DEBUG(if (!InsertChecks)<br>
> +            dbgs() << "MemorySanitizer is not inserting checks into '"<br>
> +                   << F.getName() << "'\n");<br>
> +  }<br>
> +<br>
> +  void materializeChecks() {<br>
> +    for (size_t i = 0, n = InstrumentationList.size(); i < n; i++) {<br>
> +      Instruction *Shadow = InstrumentationList[i].Shadow;<br>
> +      Instruction *OrigIns = InstrumentationList[i].OrigIns;<br>
> +      IRBuilder<> IRB(OrigIns);<br>
> +      DEBUG(dbgs() << "  SHAD0 : " << *Shadow << "\n");<br>
> +      Value *ConvertedShadow = convertToShadowTyNoVec(Shadow, IRB);<br>
> +      DEBUG(dbgs() << "  SHAD1 : " << *ConvertedShadow << "\n");<br>
> +      Value *Cmp = IRB.CreateICmpNE(ConvertedShadow,<br>
> +                                    getCleanShadow(ConvertedShadow), "_mscmp");<br>
> +      Instruction *CheckTerm =<br>
> +        SplitBlockAndInsertIfThen(cast<Instruction>(Cmp),<br>
> +                                  /* Unreachable */ !ClKeepGoing,<br>
> +                                  MS.ColdCallWeights);<br>
> +<br>
> +      IRB.SetInsertPoint(CheckTerm);<br>
> +      if (ClTrackOrigins) {<br>
> +        Instruction *Origin = InstrumentationList[i].Origin;<br>
> +        IRB.CreateStore(Origin ? (Value*)Origin : (Value*)IRB.getInt32(0),<br>
> +                        MS.OriginTLS);<br>
> +      }<br>
> +      CallInst *Call = IRB.CreateCall(MS.WarningFn);<br>
> +      Call->setDebugLoc(OrigIns->getDebugLoc());<br>
> +      DEBUG(dbgs() << "  CHECK: " << *Cmp << "\n");<br>
> +    }<br>
> +    DEBUG(dbgs() << "DONE:\n" << F);<br>
> +  }<br>
> +<br>
> +  /// \brief Add MemorySanitizer instrumentation to a function.<br>
> +  bool runOnFunction() {<br>
> +    if (!<a href="http://MS.TD" target="_blank">MS.TD</a>) return false;<br>
> +    // Iterate all BBs in depth-first order and create shadow instructions<br>
> +    // for all instructions (where applicable).<br>
> +    // For PHI nodes we create dummy shadow PHIs which will be finalized later.<br>
> +    for (df_iterator<BasicBlock*> DI = df_begin(&F.getEntryBlock()),<br>
> +         DE = df_end(&F.getEntryBlock()); DI != DE; ++DI) {<br>
> +      BasicBlock *BB = *DI;<br>
> +      visit(*BB);<br>
> +    }<br>
> +<br>
> +    // Finalize PHI nodes.<br>
> +    for (size_t i = 0, n = ShadowPHINodes.size(); i < n; i++) {<br>
> +      PHINode *PN = ShadowPHINodes[i];<br>
> +      PHINode *PNS = cast<PHINode>(getShadow(PN));<br>
> +      PHINode *PNO = ClTrackOrigins ? cast<PHINode>(getOrigin(PN)) : 0;<br>
> +      size_t NumValues = PN->getNumIncomingValues();<br>
> +      for (size_t v = 0; v < NumValues; v++) {<br>
> +        PNS->addIncoming(getShadow(PN, v), PN->getIncomingBlock(v));<br>
> +        if (PNO)<br>
> +          PNO->addIncoming(getOrigin(PN, v), PN->getIncomingBlock(v));<br>
> +      }<br>
> +    }<br>
> +<br>
> +    VAHelper->finalizeInstrumentation();<br>
> +<br>
> +    materializeChecks();<br>
> +<br>
> +    return true;<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the shadow type that corresponds to a given Value.<br>
> +  Type *getShadowTy(Value *V) {<br>
> +    return getShadowTy(V->getType());<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the shadow type that corresponds to a given Type.<br>
> +  Type *getShadowTy(Type *OrigTy) {<br>
> +    if (!OrigTy->isSized()) {<br>
> +      return 0;<br>
> +    }<br>
> +    // For integer type, shadow is the same as the original type.<br>
> +    // This may return weird-sized types like i1.<br>
> +    if (IntegerType *IT = dyn_cast<IntegerType>(OrigTy))<br>
> +      return IT;<br>
> +    if (VectorType *VT = dyn_cast<VectorType>(OrigTy))<br>
> +      return VectorType::getInteger(VT);<br>
> +    if (StructType *ST = dyn_cast<StructType>(OrigTy)) {<br>
> +      SmallVector<Type*, 4> Elements;<br>
> +      for (unsigned i = 0, n = ST->getNumElements(); i < n; i++)<br>
> +        Elements.push_back(getShadowTy(ST->getElementType(i)));<br>
> +      StructType *Res = StructType::get(*MS.C, Elements, ST->isPacked());<br>
> +      DEBUG(dbgs() << "getShadowTy: " << *ST << " ===> " << *Res << "\n");<br>
> +      return Res;<br>
> +    }<br>
> +    uint32_t TypeSize = MS.TD->getTypeStoreSizeInBits(OrigTy);<br>
> +    return IntegerType::get(*MS.C, TypeSize);<br>
> +  }<br>
> +<br>
> +  /// \brief Flatten a vector type.<br>
> +  Type *getShadowTyNoVec(Type *ty) {<br>
> +    if (VectorType *vt = dyn_cast<VectorType>(ty))<br>
> +      return IntegerType::get(*MS.C, vt->getBitWidth());<br>
> +    return ty;<br>
> +  }<br>
> +<br>
> +  /// \brief Convert a shadow value to it's flattened variant.<br>
> +  Value *convertToShadowTyNoVec(Value *V, IRBuilder<> &IRB) {<br>
> +    Type *Ty = V->getType();<br>
> +    Type *NoVecTy = getShadowTyNoVec(Ty);<br>
> +    if (Ty == NoVecTy) return V;<br>
> +    return IRB.CreateBitCast(V, NoVecTy);<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the shadow address that corresponds to a given application<br>
> +  /// address.<br>
> +  ///<br>
> +  /// Shadow = Addr & ~ShadowMask.<br>
> +  Value *getShadowPtr(Value *Addr, Type *ShadowTy,<br>
> +                      IRBuilder<> &IRB) {<br>
> +    Value *ShadowLong =<br>
> +      IRB.CreateAnd(IRB.CreatePointerCast(Addr, MS.IntptrTy),<br>
> +                    ConstantInt::get(MS.IntptrTy, ~MS.ShadowMask));<br>
> +    return IRB.CreateIntToPtr(ShadowLong, PointerType::get(ShadowTy, 0));<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the origin address that corresponds to a given application<br>
> +  /// address.<br>
> +  ///<br>
> +  /// OriginAddr = (ShadowAddr + OriginOffset) & ~3ULL<br>
> +  ///            = Addr & (~ShadowMask & ~3ULL) + OriginOffset<br>
> +  Value *getOriginPtr(Value *Addr, IRBuilder<> &IRB) {<br>
> +    Value *ShadowLong =<br>
> +      IRB.CreateAnd(IRB.CreatePointerCast(Addr, MS.IntptrTy),<br>
> +                    ConstantInt::get(MS.IntptrTy, ~MS.ShadowMask & ~3ULL));<br>
> +    Value *Add =<br>
> +      IRB.CreateAdd(ShadowLong,<br>
> +                    ConstantInt::get(MS.IntptrTy, MS.OriginOffset));<br>
> +    return IRB.CreateIntToPtr(Add, PointerType::get(IRB.getInt32Ty(), 0));<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the shadow address for a given function argument.<br>
> +  ///<br>
> +  /// Shadow = ParamTLS+ArgOffset.<br>
> +  Value *getShadowPtrForArgument(Value *A, IRBuilder<> &IRB,<br>
> +                                 int ArgOffset) {<br>
> +    Value *Base = IRB.CreatePointerCast(MS.ParamTLS, MS.IntptrTy);<br>
> +    Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));<br>
> +    return IRB.CreateIntToPtr(Base, PointerType::get(getShadowTy(A), 0),<br>
> +                              "_msarg");<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the origin address for a given function argument.<br>
> +  Value *getOriginPtrForArgument(Value *A, IRBuilder<> &IRB,<br>
> +                                 int ArgOffset) {<br>
> +    if (!ClTrackOrigins) return 0;<br>
> +    Value *Base = IRB.CreatePointerCast(MS.ParamOriginTLS, MS.IntptrTy);<br>
> +    Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));<br>
> +    return IRB.CreateIntToPtr(Base, PointerType::get(MS.OriginTy, 0),<br>
> +                              "_msarg_o");<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the shadow address for a retval.<br>
> +  Value *getShadowPtrForRetval(Value *A, IRBuilder<> &IRB) {<br>
> +    Value *Base = IRB.CreatePointerCast(MS.RetvalTLS, MS.IntptrTy);<br>
> +    return IRB.CreateIntToPtr(Base, PointerType::get(getShadowTy(A), 0),<br>
> +                              "_msret");<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the origin address for a retval.<br>
> +  Value *getOriginPtrForRetval(IRBuilder<> &IRB) {<br>
> +    // We keep a single origin for the entire retval. Might be too optimistic.<br>
> +    return MS.RetvalOriginTLS;<br>
> +  }<br>
> +<br>
> +  /// \brief Set SV to be the shadow value for V.<br>
> +  void setShadow(Value *V, Value *SV) {<br>
> +    assert(!ShadowMap.count(V) && "Values may only have one shadow");<br>
> +    ShadowMap[V] = SV;<br>
> +  }<br>
> +<br>
> +  /// \brief Set Origin to be the origin value for V.<br>
> +  void setOrigin(Value *V, Value *Origin) {<br>
> +    if (!ClTrackOrigins) return;<br>
> +    assert(!OriginMap.count(V) && "Values may only have one origin");<br>
> +    DEBUG(dbgs() << "ORIGIN: " << *V << "  ==> " << *Origin << "\n");<br>
> +    OriginMap[V] = Origin;<br>
> +  }<br>
> +<br>
> +  /// \brief Create a clean shadow value for a given value.<br>
> +  ///<br>
> +  /// Clean shadow (all zeroes) means all bits of the value are defined<br>
> +  /// (initialized).<br>
> +  Value *getCleanShadow(Value *V) {<br>
> +    Type *ShadowTy = getShadowTy(V);<br>
> +    if (!ShadowTy)<br>
> +      return 0;<br>
> +    return Constant::getNullValue(ShadowTy);<br>
> +  }<br>
> +<br>
> +  /// \brief Create a dirty shadow of a given shadow type.<br>
> +  Constant *getPoisonedShadow(Type *ShadowTy) {<br>
> +    assert(ShadowTy);<br>
> +    if (isa<IntegerType>(ShadowTy) || isa<VectorType>(ShadowTy))<br>
> +      return Constant::getAllOnesValue(ShadowTy);<br>
> +    StructType *ST = cast<StructType>(ShadowTy);<br>
> +    SmallVector<Constant *, 4> Vals;<br>
> +    for (unsigned i = 0, n = ST->getNumElements(); i < n; i++)<br>
> +      Vals.push_back(getPoisonedShadow(ST->getElementType(i)));<br>
> +    return ConstantStruct::get(ST, Vals);<br>
> +  }<br>
> +<br>
> +  /// \brief Create a clean (zero) origin.<br>
> +  Value *getCleanOrigin() {<br>
> +    return Constant::getNullValue(MS.OriginTy);<br>
> +  }<br>
> +<br>
> +  /// \brief Get the shadow value for a given Value.<br>
> +  ///<br>
> +  /// This function either returns the value set earlier with setShadow,<br>
> +  /// or extracts if from ParamTLS (for function arguments).<br>
> +  Value *getShadow(Value *V) {<br>
> +    if (Instruction *I = dyn_cast<Instruction>(V)) {<br>
> +      // For instructions the shadow is already stored in the map.<br>
> +      Value *Shadow = ShadowMap[V];<br>
> +      if (!Shadow) {<br>
> +        DEBUG(dbgs() << "No shadow: " << *V << "\n" << *(I->getParent()));<br>
> +        assert(Shadow && "No shadow for a value");<br>
> +      }<br>
> +      return Shadow;<br>
> +    }<br>
> +    if (UndefValue *U = dyn_cast<UndefValue>(V)) {<br>
> +      Value *AllOnes = getPoisonedShadow(getShadowTy(V));<br>
> +      DEBUG(dbgs() << "Undef: " << *U << " ==> " << *AllOnes << "\n");<br>
> +      return AllOnes;<br>
> +    }<br>
> +    if (Argument *A = dyn_cast<Argument>(V)) {<br>
> +      // For arguments we compute the shadow on demand and store it in the map.<br>
> +      Value **ShadowPtr = &ShadowMap[V];<br>
> +      if (*ShadowPtr)<br>
> +        return *ShadowPtr;<br>
> +      Function *F = A->getParent();<br>
> +      IRBuilder<> EntryIRB(F->getEntryBlock().getFirstNonPHI());<br>
> +      unsigned ArgOffset = 0;<br>
> +      for (Function::arg_iterator AI = F->arg_begin(), AE = F->arg_end();<br>
> +           AI != AE; ++AI) {<br>
> +        if (!AI->getType()->isSized()) {<br>
> +          DEBUG(dbgs() << "Arg is not sized\n");<br>
> +          continue;<br>
> +        }<br>
> +        unsigned Size = AI->hasByValAttr()<br>
> +          ? MS.TD->getTypeAllocSize(AI->getType()->getPointerElementType())<br>
> +          : MS.TD->getTypeAllocSize(AI->getType());<br>
> +        if (A == AI) {<br>
> +          Value *Base = getShadowPtrForArgument(AI, EntryIRB, ArgOffset);<br>
> +          if (AI->hasByValAttr()) {<br>
> +            // ByVal pointer itself has clean shadow. We copy the actual<br>
> +            // argument shadow to the underlying memory.<br>
> +            Value *Cpy = EntryIRB.CreateMemCpy(<br>
> +              getShadowPtr(V, EntryIRB.getInt8Ty(), EntryIRB),<br>
> +              Base, Size, AI->getParamAlignment());<br>
> +            DEBUG(dbgs() << "  ByValCpy: " << *Cpy << "\n");<br>
> +            *ShadowPtr = getCleanShadow(V);<br>
> +          } else {<br>
> +            *ShadowPtr = EntryIRB.CreateLoad(Base);<br>
> +          }<br>
> +          DEBUG(dbgs() << "  ARG:    "  << *AI << " ==> " <<<br>
> +                **ShadowPtr << "\n");<br>
> +          if (ClTrackOrigins) {<br>
> +            Value* OriginPtr = getOriginPtrForArgument(AI, EntryIRB, ArgOffset);<br>
> +            setOrigin(A, EntryIRB.CreateLoad(OriginPtr));<br>
> +          }<br>
> +        }<br>
> +        ArgOffset += DataLayout::RoundUpAlignment(Size, 8);<br>
> +      }<br>
> +      assert(*ShadowPtr && "Could not find shadow for an argument");<br>
> +      return *ShadowPtr;<br>
> +    }<br>
> +    // For everything else the shadow is zero.<br>
> +    return getCleanShadow(V);<br>
> +  }<br>
> +<br>
> +  /// \brief Get the shadow for i-th argument of the instruction I.<br>
> +  Value *getShadow(Instruction *I, int i) {<br>
> +    return getShadow(I->getOperand(i));<br>
> +  }<br>
> +<br>
> +  /// \brief Get the origin for a value.<br>
> +  Value *getOrigin(Value *V) {<br>
> +    if (!ClTrackOrigins) return 0;<br>
> +    if (isa<Instruction>(V) || isa<Argument>(V)) {<br>
> +      Value *Origin = OriginMap[V];<br>
> +      if (!Origin) {<br>
> +        DEBUG(dbgs() << "NO ORIGIN: " << *V << "\n");<br>
> +        Origin = getCleanOrigin();<br>
> +      }<br>
> +      return Origin;<br>
> +    }<br>
> +    return getCleanOrigin();<br>
> +  }<br>
> +<br>
> +  /// \brief Get the origin for i-th argument of the instruction I.<br>
> +  Value *getOrigin(Instruction *I, int i) {<br>
> +    return getOrigin(I->getOperand(i));<br>
> +  }<br>
> +<br>
> +  /// \brief Remember the place where a shadow check should be inserted.<br>
> +  ///<br>
> +  /// This location will be later instrumented with a check that will print a<br>
> +  /// UMR warning in runtime if the value is not fully defined.<br>
> +  void insertCheck(Value *Val, Instruction *OrigIns) {<br>
> +    assert(Val);<br>
> +    if (!InsertChecks) return;<br>
> +    Instruction *Shadow = dyn_cast_or_null<Instruction>(getShadow(Val));<br>
> +    if (!Shadow) return;<br>
> +    Type *ShadowTy = Shadow->getType();<br>
> +    assert((isa<IntegerType>(ShadowTy) || isa<VectorType>(ShadowTy)) &&<br>
> +           "Can only insert checks for integer and vector shadow types");<br>
> +    Instruction *Origin = dyn_cast_or_null<Instruction>(getOrigin(Val));<br>
> +    InstrumentationList.push_back(<br>
> +      ShadowOriginAndInsertPoint(Shadow, Origin, OrigIns));<br>
> +  }<br>
> +<br>
> +  //------------------- Visitors.<br>
> +<br>
> +  /// \brief Instrument LoadInst<br>
> +  ///<br>
> +  /// Loads the corresponding shadow and (optionally) origin.<br>
> +  /// Optionally, checks that the load address is fully defined.<br>
> +  void visitLoadInst(LoadInst &I) {<br>
> +    Type *LoadTy = I.getType();<br>
> +    assert(LoadTy->isSized() && "Load type must have size");<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Type *ShadowTy = getShadowTy(&I);<br>
> +    Value *Addr = I.getPointerOperand();<br>
> +    Value *ShadowPtr = getShadowPtr(Addr, ShadowTy, IRB);<br>
> +    setShadow(&I, IRB.CreateLoad(ShadowPtr, "_msld"));<br>
> +<br>
> +    if (ClCheckAccessAddress)<br>
> +      insertCheck(I.getPointerOperand(), &I);<br>
> +<br>
> +    if (ClTrackOrigins)<br>
> +      setOrigin(&I, IRB.CreateLoad(getOriginPtr(Addr, IRB)));<br>
> +  }<br>
> +<br>
> +  /// \brief Instrument StoreInst<br>
> +  ///<br>
> +  /// Stores the corresponding shadow and (optionally) origin.<br>
> +  /// Optionally, checks that the store address is fully defined.<br>
> +  /// Volatile stores check that the value being stored is fully defined.<br>
> +  void visitStoreInst(StoreInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *Val = I.getValueOperand();<br>
> +    Value *Addr = I.getPointerOperand();<br>
> +    Value *Shadow = getShadow(Val);<br>
> +    Value *ShadowPtr = getShadowPtr(Addr, Shadow->getType(), IRB);<br>
> +<br>
> +    StoreInst *NewSI = IRB.CreateStore(Shadow, ShadowPtr);<br>
> +    DEBUG(dbgs() << "  STORE: " << *NewSI << "\n");<br>
> +    // If the store is volatile, add a check.<br>
> +    if (I.isVolatile())<br>
> +      insertCheck(Val, &I);<br>
> +    if (ClCheckAccessAddress)<br>
> +      insertCheck(Addr, &I);<br>
> +<br>
> +    if (ClTrackOrigins)<br>
> +      IRB.CreateStore(getOrigin(Val), getOriginPtr(Addr, IRB));<br>
> +  }<br>
> +<br>
> +  // Casts.<br>
> +  void visitSExtInst(SExtInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    setShadow(&I, IRB.CreateSExt(getShadow(&I, 0), I.getType(), "_msprop"));<br>
> +    setOrigin(&I, getOrigin(&I, 0));<br>
> +  }<br>
> +<br>
> +  void visitZExtInst(ZExtInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    setShadow(&I, IRB.CreateZExt(getShadow(&I, 0), I.getType(), "_msprop"));<br>
> +    setOrigin(&I, getOrigin(&I, 0));<br>
> +  }<br>
> +<br>
> +  void visitTruncInst(TruncInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    setShadow(&I, IRB.CreateTrunc(getShadow(&I, 0), I.getType(), "_msprop"));<br>
> +    setOrigin(&I, getOrigin(&I, 0));<br>
> +  }<br>
> +<br>
> +  void visitBitCastInst(BitCastInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    setShadow(&I, IRB.CreateBitCast(getShadow(&I, 0), getShadowTy(&I)));<br>
> +    setOrigin(&I, getOrigin(&I, 0));<br>
> +  }<br>
> +<br>
> +  void visitPtrToIntInst(PtrToIntInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    setShadow(&I, IRB.CreateIntCast(getShadow(&I, 0), getShadowTy(&I), false,<br>
> +             "_msprop_ptrtoint"));<br>
> +    setOrigin(&I, getOrigin(&I, 0));<br>
> +  }<br>
> +<br>
> +  void visitIntToPtrInst(IntToPtrInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    setShadow(&I, IRB.CreateIntCast(getShadow(&I, 0), getShadowTy(&I), false,<br>
> +             "_msprop_inttoptr"));<br>
> +    setOrigin(&I, getOrigin(&I, 0));<br>
> +  }<br>
> +<br>
> +  void visitFPToSIInst(CastInst& I) { handleShadowOr(I); }<br>
> +  void visitFPToUIInst(CastInst& I) { handleShadowOr(I); }<br>
> +  void visitSIToFPInst(CastInst& I) { handleShadowOr(I); }<br>
> +  void visitUIToFPInst(CastInst& I) { handleShadowOr(I); }<br>
> +  void visitFPExtInst(CastInst& I) { handleShadowOr(I); }<br>
> +  void visitFPTruncInst(CastInst& I) { handleShadowOr(I); }<br>
> +<br>
> +  /// \brief Propagate shadow for bitwise AND.<br>
> +  ///<br>
> +  /// This code is exact, i.e. if, for example, a bit in the left argument<br>
> +  /// is defined and 0, then neither the value not definedness of the<br>
> +  /// corresponding bit in B don't affect the resulting shadow.<br>
> +  void visitAnd(BinaryOperator &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    //  "And" of 0 and a poisoned value results in unpoisoned value.<br>
> +    //  1&1 => 1;     0&1 => 0;     p&1 => p;<br>
> +    //  1&0 => 0;     0&0 => 0;     p&0 => 0;<br>
> +    //  1&p => p;     0&p => 0;     p&p => p;<br>
> +    //  S = (S1 & S2) | (V1 & S2) | (S1 & V2)<br>
> +    Value *S1 = getShadow(&I, 0);<br>
> +    Value *S2 = getShadow(&I, 1);<br>
> +    Value *V1 = I.getOperand(0);<br>
> +    Value *V2 = I.getOperand(1);<br>
> +    if (V1->getType() != S1->getType()) {<br>
> +      V1 = IRB.CreateIntCast(V1, S1->getType(), false);<br>
> +      V2 = IRB.CreateIntCast(V2, S2->getType(), false);<br>
> +    }<br>
> +    Value *S1S2 = IRB.CreateAnd(S1, S2);<br>
> +    Value *V1S2 = IRB.CreateAnd(V1, S2);<br>
> +    Value *S1V2 = IRB.CreateAnd(S1, V2);<br>
> +    setShadow(&I, IRB.CreateOr(S1S2, IRB.CreateOr(V1S2, S1V2)));<br>
> +    setOriginForNaryOp(I);<br>
> +  }<br>
> +<br>
> +  void visitOr(BinaryOperator &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    //  "Or" of 1 and a poisoned value results in unpoisoned value.<br>
> +    //  1|1 => 1;     0|1 => 1;     p|1 => 1;<br>
> +    //  1|0 => 1;     0|0 => 0;     p|0 => p;<br>
> +    //  1|p => 1;     0|p => p;     p|p => p;<br>
> +    //  S = (S1 & S2) | (~V1 & S2) | (S1 & ~V2)<br>
> +    Value *S1 = getShadow(&I, 0);<br>
> +    Value *S2 = getShadow(&I, 1);<br>
> +    Value *V1 = IRB.CreateNot(I.getOperand(0));<br>
> +    Value *V2 = IRB.CreateNot(I.getOperand(1));<br>
> +    if (V1->getType() != S1->getType()) {<br>
> +      V1 = IRB.CreateIntCast(V1, S1->getType(), false);<br>
> +      V2 = IRB.CreateIntCast(V2, S2->getType(), false);<br>
> +    }<br>
> +    Value *S1S2 = IRB.CreateAnd(S1, S2);<br>
> +    Value *V1S2 = IRB.CreateAnd(V1, S2);<br>
> +    Value *S1V2 = IRB.CreateAnd(S1, V2);<br>
> +    setShadow(&I, IRB.CreateOr(S1S2, IRB.CreateOr(V1S2, S1V2)));<br>
> +    setOriginForNaryOp(I);<br>
> +  }<br>
> +<br>
> +  /// \brief Propagate origin for an instruction.<br>
> +  ///<br>
> +  /// This is a general case of origin propagation. For an Nary operation,<br>
> +  /// is set to the origin of an argument that is not entirely initialized.<br>
> +  /// It does not matter which one is picked if all arguments are initialized.<br>
> +  void setOriginForNaryOp(Instruction &I) {<br>
> +    if (!ClTrackOrigins) return;<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *Origin = getOrigin(&I, 0);<br>
> +    for (unsigned Op = 1, n = I.getNumOperands(); Op < n; ++Op) {<br>
> +      Value *S = convertToShadowTyNoVec(getShadow(&I, Op - 1), IRB);<br>
> +      Origin = IRB.CreateSelect(IRB.CreateICmpNE(S, getCleanShadow(S)),<br>
> +                                Origin, getOrigin(&I, Op));<br>
> +    }<br>
> +    setOrigin(&I, Origin);<br>
> +  }<br>
> +<br>
> +  /// \brief Propagate shadow for a binary operation.<br>
> +  ///<br>
> +  /// Shadow = Shadow0 | Shadow1, all 3 must have the same type.<br>
> +  /// Bitwise OR is selected as an operation that will never lose even a bit of<br>
> +  /// poison.<br>
> +  void handleShadowOrBinary(Instruction &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *Shadow0 = getShadow(&I, 0);<br>
> +    Value *Shadow1 = getShadow(&I, 1);<br>
> +    setShadow(&I, IRB.CreateOr(Shadow0, Shadow1, "_msprop"));<br>
> +    setOriginForNaryOp(I);<br>
> +  }<br>
> +<br>
> +  /// \brief Propagate shadow for arbitrary operation.<br>
> +  ///<br>
> +  /// This is a general case of shadow propagation, used in all cases where we<br>
> +  /// don't know and/or care about what the operation actually does.<br>
> +  /// It converts all input shadow values to a common type (extending or<br>
> +  /// truncating as necessary), and bitwise OR's them.<br>
> +  ///<br>
> +  /// This is much cheaper than inserting checks (i.e. requiring inputs to be<br>
> +  /// fully initialized), and less prone to false positives.<br>
> +  // FIXME: is the casting actually correct?<br>
> +  // FIXME: merge this with handleShadowOrBinary.<br>
> +  void handleShadowOr(Instruction &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *Shadow = getShadow(&I, 0);<br>
> +    for (unsigned Op = 1, n = I.getNumOperands(); Op < n; ++Op)<br>
> +      Shadow = IRB.CreateOr(<br>
> +        Shadow, IRB.CreateIntCast(getShadow(&I, Op), Shadow->getType(), false),<br>
> +        "_msprop");<br>
> +    Shadow = IRB.CreateIntCast(Shadow, getShadowTy(&I), false);<br>
> +    setShadow(&I, Shadow);<br>
> +    setOriginForNaryOp(I);<br>
> +  }<br>
> +<br>
> +  void visitFAdd(BinaryOperator &I) { handleShadowOrBinary(I); }<br>
> +  void visitFSub(BinaryOperator &I) { handleShadowOrBinary(I); }<br>
> +  void visitFMul(BinaryOperator &I) { handleShadowOrBinary(I); }<br>
> +  void visitAdd(BinaryOperator &I) { handleShadowOrBinary(I); }<br>
> +  void visitSub(BinaryOperator &I) { handleShadowOrBinary(I); }<br>
> +  void visitXor(BinaryOperator &I) { handleShadowOrBinary(I); }<br>
> +  void visitMul(BinaryOperator &I) { handleShadowOrBinary(I); }<br>
> +<br>
> +  void handleDiv(Instruction &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    // Strict on the second argument.<br>
> +    insertCheck(I.getOperand(1), &I);<br>
> +    setShadow(&I, getShadow(&I, 0));<br>
> +    setOrigin(&I, getOrigin(&I, 0));<br>
> +  }<br>
> +<br>
> +  void visitUDiv(BinaryOperator &I) { handleDiv(I); }<br>
> +  void visitSDiv(BinaryOperator &I) { handleDiv(I); }<br>
> +  void visitFDiv(BinaryOperator &I) { handleDiv(I); }<br>
> +  void visitURem(BinaryOperator &I) { handleDiv(I); }<br>
> +  void visitSRem(BinaryOperator &I) { handleDiv(I); }<br>
> +  void visitFRem(BinaryOperator &I) { handleDiv(I); }<br>
> +<br>
> +  /// \brief Instrument == and != comparisons.<br>
> +  ///<br>
> +  /// Sometimes the comparison result is known even if some of the bits of the<br>
> +  /// arguments are not.<br>
> +  void handleEqualityComparison(ICmpInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *A = I.getOperand(0);<br>
> +    Value *B = I.getOperand(1);<br>
> +    Value *Sa = getShadow(A);<br>
> +    Value *Sb = getShadow(B);<br>
> +    if (A->getType()->isPointerTy())<br>
> +      A = IRB.CreatePointerCast(A, MS.IntptrTy);<br>
> +    if (B->getType()->isPointerTy())<br>
> +      B = IRB.CreatePointerCast(B, MS.IntptrTy);<br>
> +    // A == B  <==>  (C = A^B) == 0<br>
> +    // A != B  <==>  (C = A^B) != 0<br>
> +    // Sc = Sa | Sb<br>
> +    Value *C = IRB.CreateXor(A, B);<br>
> +    Value *Sc = IRB.CreateOr(Sa, Sb);<br>
> +    // Now dealing with i = (C == 0) comparison (or C != 0, does not matter now)<br>
> +    // Result is defined if one of the following is true<br>
> +    // * there is a defined 1 bit in C<br>
> +    // * C is fully defined<br>
> +    // Si = !(C & ~Sc) && Sc<br>
> +    Value *Zero = Constant::getNullValue(Sc->getType());<br>
> +    Value *MinusOne = Constant::getAllOnesValue(Sc->getType());<br>
> +    Value *Si =<br>
> +      IRB.CreateAnd(IRB.CreateICmpNE(Sc, Zero),<br>
> +                    IRB.CreateICmpEQ(<br>
> +                      IRB.CreateAnd(IRB.CreateXor(Sc, MinusOne), C), Zero));<br>
> +    Si->setName("_msprop_icmp");<br>
> +    setShadow(&I, Si);<br>
> +    setOriginForNaryOp(I);<br>
> +  }<br>
> +<br>
> +  void visitICmpInst(ICmpInst &I) {<br>
> +    if (ClHandleICmp && I.isEquality())<br>
> +      handleEqualityComparison(I);<br>
> +    else<br>
> +      handleShadowOr(I);<br>
> +  }<br>
> +<br>
> +  void visitFCmpInst(FCmpInst &I) {<br>
> +    handleShadowOr(I);<br>
> +  }<br>
> +<br>
> +  void handleShift(BinaryOperator &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    // If any of the S2 bits are poisoned, the whole thing is poisoned.<br>
> +    // Otherwise perform the same shift on S1.<br>
> +    Value *S1 = getShadow(&I, 0);<br>
> +    Value *S2 = getShadow(&I, 1);<br>
> +    Value *S2Conv = IRB.CreateSExt(IRB.CreateICmpNE(S2, getCleanShadow(S2)),<br>
> +                                   S2->getType());<br>
> +    Value *V2 = I.getOperand(1);<br>
> +    Value *Shift = IRB.CreateBinOp(I.getOpcode(), S1, V2);<br>
> +    setShadow(&I, IRB.CreateOr(Shift, S2Conv));<br>
> +    setOriginForNaryOp(I);<br>
> +  }<br>
> +<br>
> +  void visitShl(BinaryOperator &I) { handleShift(I); }<br>
> +  void visitAShr(BinaryOperator &I) { handleShift(I); }<br>
> +  void visitLShr(BinaryOperator &I) { handleShift(I); }<br>
> +<br>
> +  void visitMemSetInst(MemSetInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *Ptr = I.getArgOperand(0);<br>
> +    Value *Val = I.getArgOperand(1);<br>
> +    Value *ShadowPtr = getShadowPtr(Ptr, Val->getType(), IRB);<br>
> +    Value *ShadowVal = getCleanShadow(Val);<br>
> +    Value *Size = I.getArgOperand(2);<br>
> +    unsigned Align = I.getAlignment();<br>
> +    bool isVolatile = I.isVolatile();<br>
> +<br>
> +    IRB.CreateMemSet(ShadowPtr, ShadowVal, Size, Align, isVolatile);<br>
> +  }<br>
> +<br>
> +  void visitMemCpyInst(MemCpyInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *Dst = I.getArgOperand(0);<br>
> +    Value *Src = I.getArgOperand(1);<br>
> +    Type *ElementType = dyn_cast<PointerType>(Dst->getType())->getElementType();<br>
> +    Value *ShadowDst = getShadowPtr(Dst, ElementType, IRB);<br>
> +    Value *ShadowSrc = getShadowPtr(Src, ElementType, IRB);<br>
> +    Value *Size = I.getArgOperand(2);<br>
> +    unsigned Align = I.getAlignment();<br>
> +    bool isVolatile = I.isVolatile();<br>
> +<br>
> +    IRB.CreateMemCpy(ShadowDst, ShadowSrc, Size, Align, isVolatile);<br>
> +    if (ClTrackOrigins)<br>
> +      IRB.CreateCall3(MS.MsanCopyOriginFn, Dst, Src, Size);<br>
> +  }<br>
> +<br>
> +  /// \brief Instrument llvm.memmove<br>
> +  ///<br>
> +  /// At this point we don't know if llvm.memmove will be inlined or not.<br>
> +  /// If we don't instrument it and it gets inlined,<br>
> +  /// our interceptor will not kick in and we will lose the memmove.<br>
> +  /// If we instrument the call here, but it does not get inlined,<br>
> +  /// we will memove the shadow twice: which is bad in case<br>
> +  /// of overlapping regions. So, we simply lower the intrinsic to a call.<br>
> +  ///<br>
> +  /// Similar situation exists for memcpy and memset, but for those functions<br>
> +  /// calling instrumentation twice does not lead to incorrect results.<br>
> +  void visitMemMoveInst(MemMoveInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    IRB.CreateCall3(<br>
> +      MS.MemmoveFn,<br>
> +      IRB.CreatePointerCast(I.getArgOperand(0), IRB.getInt8PtrTy()),<br>
> +      IRB.CreatePointerCast(I.getArgOperand(1), IRB.getInt8PtrTy()),<br>
> +      IRB.CreateIntCast(I.getArgOperand(2), MS.IntptrTy, false));<br>
> +    I.eraseFromParent();<br>
> +  }<br>
> +<br>
> +  void visitVAStartInst(VAStartInst &I) {<br>
> +    VAHelper->visitVAStartInst(I);<br>
> +  }<br>
> +<br>
> +  void visitVACopyInst(VACopyInst &I) {<br>
> +    VAHelper->visitVACopyInst(I);<br>
> +  }<br>
> +<br>
> +  void visitCallSite(CallSite CS) {<br>
> +    Instruction &I = *CS.getInstruction();<br>
> +    assert((CS.isCall() || CS.isInvoke()) && "Unknown type of CallSite");<br>
> +    if (CS.isCall()) {<br>
> +      // Allow only tail calls with the same types, otherwise<br>
> +      // we may have a false positive: shadow for a non-void RetVal<br>
> +      // will get propagated to a void RetVal.<br>
> +      CallInst *Call = cast<CallInst>(&I);<br>
> +      if (Call->isTailCall() && Call->getType() != Call->getParent()->getType())<br>
> +        Call->setTailCall(false);<br>
> +      if (isa<IntrinsicInst>(&I)) {<br>
> +        // All intrinsics we care about are handled in corresponding visit*<br>
> +        // methods. Add checks for the arguments, mark retval as clean.<br>
> +        visitInstruction(I);<br>
> +        return;<br>
> +      }<br>
> +    }<br>
> +    IRBuilder<> IRB(&I);<br>
> +    unsigned ArgOffset = 0;<br>
> +    DEBUG(dbgs() << "  CallSite: " << I << "\n");<br>
> +    for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();<br>
> +         ArgIt != End; ++ArgIt) {<br>
> +      Value *A = *ArgIt;<br>
> +      unsigned i = ArgIt - CS.arg_begin();<br>
> +      if (!A->getType()->isSized()) {<br>
> +        DEBUG(dbgs() << "Arg " << i << " is not sized: " << I << "\n");<br>
> +        continue;<br>
> +      }<br>
> +      unsigned Size = 0;<br>
> +      Value *Store = 0;<br>
> +      // Compute the Shadow for arg even if it is ByVal, because<br>
> +      // in that case getShadow() will copy the actual arg shadow to<br>
> +      // __msan_param_tls.<br>
> +      Value *ArgShadow = getShadow(A);<br>
> +      Value *ArgShadowBase = getShadowPtrForArgument(A, IRB, ArgOffset);<br>
> +      DEBUG(dbgs() << "  Arg#" << i << ": " << *A <<<br>
> +            " Shadow: " << *ArgShadow << "\n");<br>
> +      if (CS.paramHasAttr(i + 1, Attributes::ByVal)) {<br>
> +        assert(A->getType()->isPointerTy() &&<br>
> +               "ByVal argument is not a pointer!");<br>
> +        Size = MS.TD->getTypeAllocSize(A->getType()->getPointerElementType());<br>
> +        unsigned Alignment = CS.getParamAlignment(i + 1);<br>
> +        Store = IRB.CreateMemCpy(ArgShadowBase,<br>
> +                                 getShadowPtr(A, Type::getInt8Ty(*MS.C), IRB),<br>
> +                                 Size, Alignment);<br>
> +      } else {<br>
> +        Size = MS.TD->getTypeAllocSize(A->getType());<br>
> +        Store = IRB.CreateStore(ArgShadow, ArgShadowBase);<br>
> +      }<br>
> +      if (ClTrackOrigins)<br>
> +        IRB.CreateStore(getOrigin(A),<br>
> +                        getOriginPtrForArgument(A, IRB, ArgOffset));<br>
> +      assert(Size != 0 && Store != 0);<br>
> +      DEBUG(dbgs() << "  Param:" << *Store << "\n");<br>
> +      ArgOffset += DataLayout::RoundUpAlignment(Size, 8);<br>
> +    }<br>
> +    DEBUG(dbgs() << "  done with call args\n");<br>
> +<br>
> +    FunctionType *FT =<br>
> +      cast<FunctionType>(CS.getCalledValue()->getType()-> getContainedType(0));<br>
> +    if (FT->isVarArg()) {<br>
> +      VAHelper->visitCallSite(CS, IRB);<br>
> +    }<br>
> +<br>
> +    // Now, get the shadow for the RetVal.<br>
> +    if (!I.getType()->isSized()) return;<br>
> +    IRBuilder<> IRBBefore(&I);<br>
> +    // Untill we have full dynamic coverage, make sure the retval shadow is 0.<br>
> +    Value *Base = getShadowPtrForRetval(&I, IRBBefore);<br>
> +    IRBBefore.CreateStore(getCleanShadow(&I), Base);<br>
> +    Instruction *NextInsn = 0;<br>
> +    if (CS.isCall()) {<br>
> +      NextInsn = I.getNextNode();<br>
> +    } else {<br>
> +      BasicBlock *NormalDest = cast<InvokeInst>(&I)->getNormalDest();<br>
> +      if (!NormalDest->getSinglePredecessor()) {<br>
> +        // FIXME: this case is tricky, so we are just conservative here.<br>
> +        // Perhaps we need to split the edge between this BB and NormalDest,<br>
> +        // but a naive attempt to use SplitEdge leads to a crash.<br>
> +        setShadow(&I, getCleanShadow(&I));<br>
> +        setOrigin(&I, getCleanOrigin());<br>
> +        return;<br>
> +      }<br>
> +      NextInsn = NormalDest->getFirstInsertionPt();<br>
> +      assert(NextInsn &&<br>
> +             "Could not find insertion point for retval shadow load");<br>
> +    }<br>
> +    IRBuilder<> IRBAfter(NextInsn);<br>
> +    setShadow(&I, IRBAfter.CreateLoad(getShadowPtrForRetval(&I, IRBAfter),<br>
> +                                      "_msret"));<br>
> +    if (ClTrackOrigins)<br>
> +      setOrigin(&I, IRBAfter.CreateLoad(getOriginPtrForRetval(IRBAfter)));<br>
> +  }<br>
> +<br>
> +  void visitReturnInst(ReturnInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    if (Value *RetVal = I.getReturnValue()) {<br>
> +      // Set the shadow for the RetVal.<br>
> +      Value *Shadow = getShadow(RetVal);<br>
> +      Value *ShadowPtr = getShadowPtrForRetval(RetVal, IRB);<br>
> +      DEBUG(dbgs() << "Return: " << *Shadow << "\n" << *ShadowPtr << "\n");<br>
> +      IRB.CreateStore(Shadow, ShadowPtr);<br>
> +      if (ClTrackOrigins)<br>
> +        IRB.CreateStore(getOrigin(RetVal), getOriginPtrForRetval(IRB));<br>
> +    }<br>
> +  }<br>
> +<br>
> +  void visitPHINode(PHINode &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    ShadowPHINodes.push_back(&I);<br>
> +    setShadow(&I, IRB.CreatePHI(getShadowTy(&I), I.getNumIncomingValues(),<br>
> +                                "_msphi_s"));<br>
> +    if (ClTrackOrigins)<br>
> +      setOrigin(&I, IRB.CreatePHI(MS.OriginTy, I.getNumIncomingValues(),<br>
> +                                  "_msphi_o"));<br>
> +  }<br>
> +<br>
> +  void visitAllocaInst(AllocaInst &I) {<br>
> +    setShadow(&I, getCleanShadow(&I));<br>
> +    if (!ClPoisonStack) return;<br>
> +    IRBuilder<> IRB(I.getNextNode());<br>
> +    uint64_t Size = MS.TD->getTypeAllocSize(I.getAllocatedType());<br>
> +    if (ClPoisonStackWithCall) {<br>
> +      IRB.CreateCall2(MS.MsanPoisonStackFn,<br>
> +                      IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()),<br>
> +                      ConstantInt::get(MS.IntptrTy, Size));<br>
> +    } else {<br>
> +      Value *ShadowBase = getShadowPtr(&I, Type::getInt8PtrTy(*MS.C), IRB);<br>
> +      IRB.CreateMemSet(ShadowBase, IRB.getInt8(ClPoisonStackPattern),<br>
> +                       Size, I.getAlignment());<br>
> +    }<br>
> +<br>
> +    if (ClTrackOrigins) {<br>
> +      setOrigin(&I, getCleanOrigin());<br>
> +      SmallString<2048> StackDescriptionStorage;<br>
> +      raw_svector_ostream StackDescription(StackDescriptionStorage);<br>
> +      // We create a string with a description of the stack allocation and<br>
> +      // pass it into __msan_set_alloca_origin.<br>
> +      // It will be printed by the run-time if stack-originated UMR is found.<br>
> +      // The first 4 bytes of the string are set to '----' and will be replaced<br>
> +      // by __msan_va_arg_overflow_size_tls at the first call.<br>
> +      StackDescription << "----" << I.getName() << "@" << F.getName();<br>
> +      Value *Descr =<br>
> +          createPrivateNonConstGlobalForString(*F.getParent(),<br>
> +                                               StackDescription.str());<br>
> +      IRB.CreateCall3(MS.MsanSetAllocaOriginFn,<br>
> +                      IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()),<br>
> +                      ConstantInt::get(MS.IntptrTy, Size),<br>
> +                      IRB.CreatePointerCast(Descr, IRB.getInt8PtrTy()));<br>
> +    }<br>
> +  }<br>
> +<br>
> +  void visitSelectInst(SelectInst& I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    setShadow(&I,  IRB.CreateSelect(I.getCondition(),<br>
> +              getShadow(I.getTrueValue()), getShadow(I.getFalseValue()),<br>
> +              "_msprop"));<br>
> +    if (ClTrackOrigins)<br>
> +      setOrigin(&I, IRB.CreateSelect(I.getCondition(),<br>
> +                getOrigin(I.getTrueValue()), getOrigin(I.getFalseValue())));<br>
> +  }<br>
> +<br>
> +  void visitLandingPadInst(LandingPadInst &I) {<br>
> +    // Do nothing.<br>
> +    // See <a href="http://code.google.com/p/memory-sanitizer/issues/detail?id=1" target="_blank">http://code.google.com/p/memory-sanitizer/issues/detail?id=1</a><br>
> +    setShadow(&I, getCleanShadow(&I));<br>
> +    setOrigin(&I, getCleanOrigin());<br>
> +  }<br>
> +<br>
> +  void visitGetElementPtrInst(GetElementPtrInst &I) {<br>
> +    handleShadowOr(I);<br>
> +  }<br>
> +<br>
> +  void visitExtractValueInst(ExtractValueInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *Agg = I.getAggregateOperand();<br>
> +    DEBUG(dbgs() << "ExtractValue:  " << I << "\n");<br>
> +    Value *AggShadow = getShadow(Agg);<br>
> +    DEBUG(dbgs() << "   AggShadow:  " << *AggShadow << "\n");<br>
> +    Value *ResShadow = IRB.CreateExtractValue(AggShadow, I.getIndices());<br>
> +    DEBUG(dbgs() << "   ResShadow:  " << *ResShadow << "\n");<br>
> +    setShadow(&I, ResShadow);<br>
> +    setOrigin(&I, getCleanOrigin());<br>
> +  }<br>
> +<br>
> +  void visitInsertValueInst(InsertValueInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    DEBUG(dbgs() << "InsertValue:  " << I << "\n");<br>
> +    Value *AggShadow = getShadow(I.getAggregateOperand());<br>
> +    Value *InsShadow = getShadow(I.getInsertedValueOperand());<br>
> +    DEBUG(dbgs() << "   AggShadow:  " << *AggShadow << "\n");<br>
> +    DEBUG(dbgs() << "   InsShadow:  " << *InsShadow << "\n");<br>
> +    Value *Res = IRB.CreateInsertValue(AggShadow, InsShadow, I.getIndices());<br>
> +    DEBUG(dbgs() << "   Res:        " << *Res << "\n");<br>
> +    setShadow(&I, Res);<br>
> +    setOrigin(&I, getCleanOrigin());<br>
> +  }<br>
> +<br>
> +  void dumpInst(Instruction &I) {<br>
> +    if (CallInst *CI = dyn_cast<CallInst>(&I)) {<br>
> +      errs() << "ZZZ call " << CI->getCalledFunction()->getName() << "\n";<br>
> +    } else {<br>
> +      errs() << "ZZZ " << I.getOpcodeName() << "\n";<br>
> +    }<br>
> +    errs() << "QQQ " << I << "\n";<br>
> +  }<br>
> +<br>
> +  void visitResumeInst(ResumeInst &I) {<br>
> +    DEBUG(dbgs() << "Resume: " << I << "\n");<br>
> +    // Nothing to do here.<br>
> +  }<br>
> +<br>
> +  void visitInstruction(Instruction &I) {<br>
> +    // Everything else: stop propagating and check for poisoned shadow.<br>
> +    if (ClDumpStrictInstructions)<br>
> +      dumpInst(I);<br>
> +    DEBUG(dbgs() << "DEFAULT: " << I << "\n");<br>
> +    for (size_t i = 0, n = I.getNumOperands(); i < n; i++)<br>
> +      insertCheck(I.getOperand(i), &I);<br>
> +    setShadow(&I, getCleanShadow(&I));<br>
> +    setOrigin(&I, getCleanOrigin());<br>
> +  }<br>
> +};<br>
> +<br>
> +/// \brief AMD64-specific implementation of VarArgHelper.<br>
> +struct VarArgAMD64Helper : public VarArgHelper {<br>
> +  // An unfortunate workaround for asymmetric lowering of va_arg stuff.<br>
> +  // See a comment in visitCallSite for more details.<br>
> +  static const unsigned AMD64GpEndOffset = 48; // AMD64 ABI Draft 0.99.6 p3.5.7<br>
> +  static const unsigned AMD64FpEndOffset = 176;<br>
> +<br>
> +  Function &F;<br>
> +  MemorySanitizer &MS;<br>
> +  MemorySanitizerVisitor &MSV;<br>
> +  Value *VAArgTLSCopy;<br>
> +  Value *VAArgOverflowSize;<br>
> +<br>
> +  SmallVector<CallInst*, 16> VAStartInstrumentationList;<br>
> +<br>
> +  VarArgAMD64Helper(Function &F, MemorySanitizer &MS,<br>
> +                    MemorySanitizerVisitor &MSV)<br>
> +    : F(F), MS(MS), MSV(MSV), VAArgTLSCopy(0), VAArgOverflowSize(0) { }<br>
> +<br>
> +  enum ArgKind { AK_GeneralPurpose, AK_FloatingPoint, AK_Memory };<br>
> +<br>
> +  ArgKind classifyArgument(Value* arg) {<br>
> +    // A very rough approximation of X86_64 argument classification rules.<br>
> +    Type *T = arg->getType();<br>
> +    if (T->isFPOrFPVectorTy() || T->isX86_MMXTy())<br>
> +      return AK_FloatingPoint;<br>
> +    if (T->isIntegerTy() && T->getPrimitiveSizeInBits() <= 64)<br>
> +      return AK_GeneralPurpose;<br>
> +    if (T->isPointerTy())<br>
> +      return AK_GeneralPurpose;<br>
> +    return AK_Memory;<br>
> +  }<br>
> +<br>
> +  // For VarArg functions, store the argument shadow in an ABI-specific format<br>
> +  // that corresponds to va_list layout.<br>
> +  // We do this because Clang lowers va_arg in the frontend, and this pass<br>
> +  // only sees the low level code that deals with va_list internals.<br>
> +  // A much easier alternative (provided that Clang emits va_arg instructions)<br>
> +  // would have been to associate each live instance of va_list with a copy of<br>
> +  // MSanParamTLS, and extract shadow on va_arg() call in the argument list<br>
> +  // order.<br>
> +  void visitCallSite(CallSite &CS, IRBuilder<> &IRB) {<br>
> +    unsigned GpOffset = 0;<br>
> +    unsigned FpOffset = AMD64GpEndOffset;<br>
> +    unsigned OverflowOffset = AMD64FpEndOffset;<br>
> +    for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();<br>
> +         ArgIt != End; ++ArgIt) {<br>
> +      Value *A = *ArgIt;<br>
> +      ArgKind AK = classifyArgument(A);<br>
> +      if (AK == AK_GeneralPurpose && GpOffset >= AMD64GpEndOffset)<br>
> +        AK = AK_Memory;<br>
> +      if (AK == AK_FloatingPoint && FpOffset >= AMD64FpEndOffset)<br>
> +        AK = AK_Memory;<br>
> +      Value *Base;<br>
> +      switch (AK) {<br>
> +      case AK_GeneralPurpose:<br>
> +        Base = getShadowPtrForVAArgument(A, IRB, GpOffset);<br>
> +        GpOffset += 8;<br>
> +        break;<br>
> +      case AK_FloatingPoint:<br>
> +        Base = getShadowPtrForVAArgument(A, IRB, FpOffset);<br>
> +        FpOffset += 16;<br>
> +        break;<br>
> +      case AK_Memory:<br>
> +        uint64_t ArgSize = MS.TD->getTypeAllocSize(A->getType());<br>
> +        Base = getShadowPtrForVAArgument(A, IRB, OverflowOffset);<br>
> +        OverflowOffset += DataLayout::RoundUpAlignment(ArgSize, 8);<br>
> +      }<br>
> +      IRB.CreateStore(MSV.getShadow(A), Base);<br>
> +    }<br>
> +    Constant *OverflowSize =<br>
> +      ConstantInt::get(IRB.getInt64Ty(), OverflowOffset - AMD64FpEndOffset);<br>
> +    IRB.CreateStore(OverflowSize, MS.VAArgOverflowSizeTLS);<br>
> +  }<br>
> +<br>
> +  /// \brief Compute the shadow address for a given va_arg.<br>
> +  Value *getShadowPtrForVAArgument(Value *A, IRBuilder<> &IRB,<br>
> +                                   int ArgOffset) {<br>
> +    Value *Base = IRB.CreatePointerCast(MS.VAArgTLS, MS.IntptrTy);<br>
> +    Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));<br>
> +    return IRB.CreateIntToPtr(Base, PointerType::get(MSV.getShadowTy(A), 0),<br>
> +                              "_msarg");<br>
> +  }<br>
> +<br>
> +  void visitVAStartInst(VAStartInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    VAStartInstrumentationList.push_back(&I);<br>
> +    Value *VAListTag = I.getArgOperand(0);<br>
> +    Value *ShadowPtr = MSV.getShadowPtr(VAListTag, IRB.getInt8Ty(), IRB);<br>
> +<br>
> +    // Unpoison the whole __va_list_tag.<br>
> +    // FIXME: magic ABI constants.<br>
> +    IRB.CreateMemSet(ShadowPtr, Constant::getNullValue(IRB.getInt8Ty()),<br>
> +                     /* size */24, /* alignment */16, false);<br>
> +  }<br>
> +<br>
> +  void visitVACopyInst(VACopyInst &I) {<br>
> +    IRBuilder<> IRB(&I);<br>
> +    Value *VAListTag = I.getArgOperand(0);<br>
> +    Value *ShadowPtr = MSV.getShadowPtr(VAListTag, IRB.getInt8Ty(), IRB);<br>
> +<br>
> +    // Unpoison the whole __va_list_tag.<br>
> +    // FIXME: magic ABI constants.<br>
> +    IRB.CreateMemSet(ShadowPtr, Constant::getNullValue(IRB.getInt8Ty()),<br>
> +                     /* size */ 24, /* alignment */ 16, false);<br>
> +  }<br>
> +<br>
> +  void finalizeInstrumentation() {<br>
> +    assert(!VAArgOverflowSize && !VAArgTLSCopy &&<br>
> +           "finalizeInstrumentation called twice");<br>
> +    if (!VAStartInstrumentationList.empty()) {<br>
> +      // If there is a va_start in this function, make a backup copy of<br>
> +      // va_arg_tls somewhere in the function entry block.<br>
> +      IRBuilder<> IRB(F.getEntryBlock().getFirstNonPHI());<br>
> +      VAArgOverflowSize = IRB.CreateLoad(MS.VAArgOverflowSizeTLS);<br>
> +      Value *CopySize =<br>
> +        IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, AMD64FpEndOffset),<br>
> +                      VAArgOverflowSize);<br>
> +      VAArgTLSCopy = IRB.CreateAlloca(Type::getInt8Ty(*MS.C), CopySize);<br>
> +      IRB.CreateMemCpy(VAArgTLSCopy, MS.VAArgTLS, CopySize, 8);<br>
> +    }<br>
> +<br>
> +    // Instrument va_start.<br>
> +    // Copy va_list shadow from the backup copy of the TLS contents.<br>
> +    for (size_t i = 0, n = VAStartInstrumentationList.size(); i < n; i++) {<br>
> +      CallInst *OrigInst = VAStartInstrumentationList[i];<br>
> +      IRBuilder<> IRB(OrigInst->getNextNode());<br>
> +      Value *VAListTag = OrigInst->getArgOperand(0);<br>
> +<br>
> +      Value *RegSaveAreaPtrPtr =<br>
> +        IRB.CreateIntToPtr(<br>
> +          IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy),<br>
> +                        ConstantInt::get(MS.IntptrTy, 16)),<br>
> +          Type::getInt64PtrTy(*MS.C));<br>
> +      Value *RegSaveAreaPtr = IRB.CreateLoad(RegSaveAreaPtrPtr);<br>
> +      Value *RegSaveAreaShadowPtr =<br>
> +        MSV.getShadowPtr(RegSaveAreaPtr, IRB.getInt8Ty(), IRB);<br>
> +      IRB.CreateMemCpy(RegSaveAreaShadowPtr, VAArgTLSCopy,<br>
> +                       AMD64FpEndOffset, 16);<br>
> +<br>
> +      Value *OverflowArgAreaPtrPtr =<br>
> +        IRB.CreateIntToPtr(<br>
> +          IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy),<br>
> +                        ConstantInt::get(MS.IntptrTy, 8)),<br>
> +          Type::getInt64PtrTy(*MS.C));<br>
> +      Value *OverflowArgAreaPtr = IRB.CreateLoad(OverflowArgAreaPtrPtr);<br>
> +      Value *OverflowArgAreaShadowPtr =<br>
> +        MSV.getShadowPtr(OverflowArgAreaPtr, IRB.getInt8Ty(), IRB);<br>
> +      Value *SrcPtr =<br>
> +        getShadowPtrForVAArgument(VAArgTLSCopy, IRB, AMD64FpEndOffset);<br>
> +      IRB.CreateMemCpy(OverflowArgAreaShadowPtr, SrcPtr, VAArgOverflowSize, 16);<br>
> +    }<br>
> +  }<br>
> +};<br>
> +<br>
> +VarArgHelper* CreateVarArgHelper(Function &Func, MemorySanitizer &Msan,<br>
> +                                 MemorySanitizerVisitor &Visitor) {<br>
> +  return new VarArgAMD64Helper(Func, Msan, Visitor);<br>
> +}<br>
> +<br>
> +}  // namespace<br>
> +<br>
> +bool MemorySanitizer::runOnFunction(Function &F) {<br>
> +  MemorySanitizerVisitor Visitor(F, *this);<br>
> +<br>
> +  // Clear out readonly/readnone attributes.<br>
> +  AttrBuilder B;<br>
> +  B.addAttribute(Attributes::ReadOnly)<br>
> +    .addAttribute(Attributes::ReadNone);<br>
> +  F.removeAttribute(AttrListPtr::FunctionIndex,<br>
> +                    Attributes::get(F.getContext(), B));<br>
> +<br>
> +  return Visitor.runOnFunction();<br>
> +}<br>
><br>
> Propchange: llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp<br>
> ------------------------------------------------------------------------------<br>
>     svn:eol-style = LF<br>
><br>
> Added: llvm/trunk/test/Instrumentation/MemorySanitizer/lit.local.cfg<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Instrumentation/MemorySanitizer/lit.local.cfg?rev=168866&view=auto" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Instrumentation/MemorySanitizer/lit.local.cfg?rev=168866&view=auto</a><br>

> ==============================================================================<br>
> --- llvm/trunk/test/Instrumentation/MemorySanitizer/lit.local.cfg (added)<br>
> +++ llvm/trunk/test/Instrumentation/MemorySanitizer/lit.local.cfg Thu Nov 29 03:57:20 2012<br>
> @@ -0,0 +1 @@<br>
> +config.suffixes = ['.ll', '.c', '.cpp']<br>
><br>
> Added: llvm/trunk/test/Instrumentation/MemorySanitizer/msan_basic.ll<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Instrumentation/MemorySanitizer/msan_basic.ll?rev=168866&view=auto" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Instrumentation/MemorySanitizer/msan_basic.ll?rev=168866&view=auto</a><br>

> ==============================================================================<br>
> --- llvm/trunk/test/Instrumentation/MemorySanitizer/msan_basic.ll (added)<br>
> +++ llvm/trunk/test/Instrumentation/MemorySanitizer/msan_basic.ll Thu Nov 29 03:57:20 2012<br>
> @@ -0,0 +1,235 @@<br>
> +; RUN: opt < %s -msan -S | FileCheck %s<br>
> +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"<br>
> +<br>
> +; Check the presence of __msan_init<br>
> +; CHECK: @llvm.global_ctors {{.*}} @__msan_init<br>
> +<br>
> +; load followed by cmp: check that we load the shadow and call __msan_warning.<br>
> +define void @LoadAndCmp(i32* nocapture %a) nounwind uwtable {<br>
> +entry:<br>
> +  %0 = load i32* %a, align 4<br>
> +  %tobool = icmp eq i32 %0, 0<br>
> +  br i1 %tobool, label %if.end, label %if.then<br>
> +<br>
> +if.then:                                          ; preds = %entry<br>
> +  tail call void (...)* @foo() nounwind<br>
> +  br label %if.end<br>
> +<br>
> +if.end:                                           ; preds = %entry, %if.then<br>
> +  ret void<br>
> +}<br>
> +<br>
> +declare void @foo(...)<br>
> +<br>
> +; CHECK: define void @LoadAndCmp<br>
> +; CHECK: = load<br>
> +; CHECK: = load<br>
> +; CHECK: call void @__msan_warning_noreturn()<br>
> +; CHECK: }<br>
> +<br>
> +; Check that we store the shadow for the retval.<br>
> +define i32 @ReturnInt() nounwind uwtable readnone {<br>
> +entry:<br>
> +  ret i32 123<br>
> +}<br>
> +<br>
> +; CHECK: define i32 @ReturnInt()<br>
> +; CHECK: store i32 0,{{.*}}__msan_retval_tls<br>
> +; CHECK: }<br>
> +<br>
> +; Check that we get the shadow for the retval.<br>
> +define void @CopyRetVal(i32* nocapture %a) nounwind uwtable {<br>
> +entry:<br>
> +  %call = tail call i32 @ReturnInt() nounwind<br>
> +  store i32 %call, i32* %a, align 4<br>
> +  ret void<br>
> +}<br>
> +<br>
> +; CHECK: define void @CopyRetVal<br>
> +; CHECK: load{{.*}}__msan_retval_tls<br>
> +; CHECK: store<br>
> +; CHECK: store<br>
> +; CHECK: }<br>
> +<br>
> +<br>
> +; Check that we generate PHIs for shadow.<br>
> +define void @FuncWithPhi(i32* nocapture %a, i32* %b, i32* nocapture %c) nounwind uwtable {<br>
> +entry:<br>
> +  %tobool = icmp eq i32* %b, null<br>
> +  br i1 %tobool, label %if.else, label %if.then<br>
> +<br>
> +  if.then:                                          ; preds = %entry<br>
> +  %0 = load i32* %b, align 4<br>
> +  br label %if.end<br>
> +<br>
> +  if.else:                                          ; preds = %entry<br>
> +  %1 = load i32* %c, align 4<br>
> +  br label %if.end<br>
> +<br>
> +  if.end:                                           ; preds = %if.else, %if.then<br>
> +  %t.0 = phi i32 [ %0, %if.then ], [ %1, %if.else ]<br>
> +  store i32 %t.0, i32* %a, align 4<br>
> +  ret void<br>
> +}<br>
> +<br>
> +; CHECK: define void @FuncWithPhi<br>
> +; CHECK: = phi<br>
> +; CHECK-NEXT: = phi<br>
> +; CHECK: store<br>
> +; CHECK: store<br>
> +; CHECK: }<br>
> +<br>
> +; Compute shadow for "x << 10"<br>
> +define void @ShlConst(i32* nocapture %x) nounwind uwtable {<br>
> +entry:<br>
> +  %0 = load i32* %x, align 4<br>
> +  %1 = shl i32 %0, 10<br>
> +  store i32 %1, i32* %x, align 4<br>
> +  ret void<br>
> +}<br>
> +<br>
> +; CHECK: define void @ShlConst<br>
> +; CHECK: = load<br>
> +; CHECK: = load<br>
> +; CHECK: shl<br>
> +; CHECK: shl<br>
> +; CHECK: store<br>
> +; CHECK: store<br>
> +; CHECK: }<br>
> +<br>
> +; Compute shadow for "10 << x": it should have 'sext i1'.<br>
> +define void @ShlNonConst(i32* nocapture %x) nounwind uwtable {<br>
> +entry:<br>
> +  %0 = load i32* %x, align 4<br>
> +  %1 = shl i32 10, %0<br>
> +  store i32 %1, i32* %x, align 4<br>
> +  ret void<br>
> +}<br>
> +<br>
> +; CHECK: define void @ShlNonConst<br>
> +; CHECK: = load<br>
> +; CHECK: = load<br>
> +; CHECK: = sext i1<br>
> +; CHECK: store<br>
> +; CHECK: store<br>
> +; CHECK: }<br>
> +<br>
> +; SExt<br>
> +define void @SExt(i32* nocapture %a, i16* nocapture %b) nounwind uwtable {<br>
> +entry:<br>
> +  %0 = load i16* %b, align 2<br>
> +  %1 = sext i16 %0 to i32<br>
> +  store i32 %1, i32* %a, align 4<br>
> +  ret void<br>
> +}<br>
> +<br>
> +; CHECK: define void @SExt<br>
> +; CHECK: = load<br>
> +; CHECK: = load<br>
> +; CHECK: = sext<br>
> +; CHECK: = sext<br>
> +; CHECK: store<br>
> +; CHECK: store<br>
> +; CHECK: }<br>
> +<br>
> +<br>
> +; memset<br>
> +define void @MemSet(i8* nocapture %x) nounwind uwtable {<br>
> +entry:<br>
> +  call void @llvm.memset.p0i8.i64(i8* %x, i8 42, i64 10, i32 1, i1 false)<br>
> +  ret void<br>
> +}<br>
> +<br>
> +declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind<br>
> +<br>
> +; CHECK: define void @MemSet<br>
> +; CHECK: call void @llvm.memset.p0i8.i64<br>
> +; CHECK: call void @llvm.memset.p0i8.i64<br>
> +; CHECK: }<br>
> +<br>
> +<br>
> +; memcpy<br>
> +define void @MemCpy(i8* nocapture %x, i8* nocapture %y) nounwind uwtable {<br>
> +entry:<br>
> +  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %x, i8* %y, i64 10, i32 1, i1 false)<br>
> +  ret void<br>
> +}<br>
> +<br>
> +declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind<br>
> +<br>
> +; CHECK: define void @MemCpy<br>
> +; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64<br>
> +; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64<br>
> +; CHECK: }<br>
> +<br>
> +<br>
> +; memmove is lowered to a call<br>
> +define void @MemMove(i8* nocapture %x, i8* nocapture %y) nounwind uwtable {<br>
> +entry:<br>
> +  call void @llvm.memmove.p0i8.p0i8.i64(i8* %x, i8* %y, i64 10, i32 1, i1 false)<br>
> +  ret void<br>
> +}<br>
> +<br>
> +declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind<br>
> +<br>
> +; CHECK: define void @MemMove<br>
> +; CHECK: call i8* @memmove<br>
> +; CHECK: }<br>
> +<br>
> +<br>
> +; Check that we propagate shadow for "select"<br>
> +<br>
> +define i32 @Select(i32 %a, i32 %b, i32 %c) nounwind uwtable readnone {<br>
> +entry:<br>
> +  %tobool = icmp ne i32 %c, 0<br>
> +  %cond = select i1 %tobool, i32 %a, i32 %b<br>
> +  ret i32 %cond<br>
> +}<br>
> +<br>
> +; CHECK: define i32 @Select<br>
> +; CHECK: select<br>
> +; CHECK-NEXT: select<br>
> +; CHECK: }<br>
> +<br>
> +<br>
> +define i8* @IntToPtr(i64 %x) nounwind uwtable readnone {<br>
> +entry:<br>
> +  %0 = inttoptr i64 %x to i8*<br>
> +  ret i8* %0<br>
> +}<br>
> +<br>
> +; CHECK: define i8* @IntToPtr<br>
> +; CHECK: load i64*{{.*}}__msan_param_tls<br>
> +; CHECK-NEXT: inttoptr<br>
> +; CHECK-NEXT: store i64{{.*}}__msan_retval_tls<br>
> +; CHECK: }<br>
> +<br>
> +<br>
> +define i8* @IntToPtr_ZExt(i16 %x) nounwind uwtable readnone {<br>
> +entry:<br>
> +  %0 = inttoptr i16 %x to i8*<br>
> +  ret i8* %0<br>
> +}<br>
> +<br>
> +; CHECK: define i8* @IntToPtr_ZExt<br>
> +; CHECK: zext<br>
> +; CHECK-NEXT: inttoptr<br>
> +; CHECK: }<br>
> +<br>
> +<br>
> +; Check that we insert exactly one check on udiv<br>
> +; (2nd arg shadow is checked, 1st arg shadow is propagated)<br>
> +<br>
> +define i32 @Div(i32 %a, i32 %b) nounwind uwtable readnone {<br>
> +entry:<br>
> +  %div = udiv i32 %a, %b<br>
> +  ret i32 %div<br>
> +}<br>
> +<br>
> +; CHECK: define i32 @Div<br>
> +; CHECK: icmp<br>
> +; CHECK: br<br>
> +; CHECK-NOT: icmp<br>
> +; CHECK: udiv<br>
> +; CHECK-NOT: icmp<br>
> +; CHECK: }<br>
><br>
><br>
> _______________________________________________<br>
> llvm-commits mailing list<br>
> <a href="mailto:llvm-commits@cs.uiuc.edu">llvm-commits@cs.uiuc.edu</a><br>
> <a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits" target="_blank">http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits</a><br>
</div></div><br>_______________________________________________<br>
llvm-commits mailing list<br>
<a href="mailto:llvm-commits@cs.uiuc.edu">llvm-commits@cs.uiuc.edu</a><br>
<a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits" target="_blank">http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits</a><br>
<br></blockquote></div><br></div></div>