Annotate V8 for MemorySanitizer.

src/deoptimizer.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 16 matching lines @@
 
 #include "v8.h"
 
 #include "accessors.h"
 #include "codegen.h"
 #include "deoptimizer.h"
 #include "disasm.h"
 #include "full-codegen.h"
 #include "global-handles.h"
 #include "macro-assembler.h"
+#include "msan.h"
 #include "prettyprinter.h"
 
 
 namespace v8 {
 namespace internal {
 
 static MemoryChunk* AllocateCodeChunk(MemoryAllocator* allocator) {
   return allocator->AllocateChunk(Deoptimizer::GetMaxDeoptTableSize(),
                                   OS::CommitPageSize(),
 #if defined(__native_client__)
@@ skipping 54 matching lines @@
 
 
 // We rely on this function not causing a GC.  It is called from generated code
 // without having a real stack frame in place.
 Deoptimizer* Deoptimizer::New(JSFunction* function,
                               BailoutType type,
                               unsigned bailout_id,
                               Address from,
                               int fp_to_sp_delta,
                               Isolate* isolate) {
+  MSAN_RUNTIME_FUNCTION6(function, type, bailout_id, from, fp_to_sp_delta,
+                         isolate);
   Deoptimizer* deoptimizer = new Deoptimizer(isolate,

[danno, 2013/10/10 14:18:07]

This big unpoison of the stack is total overkill. The deoptimizer copies a
specific number of frames from the stack to the input_ of buffer of the
Deoptimizer. This is done after returning from this routine in the hand-written
assembly code of the deoptimizer. After that, the
Deoptimizer::ComputeOutputFrames method inspect this buffer to build the output
frames. You should be able to precisely unpoison just the input buffer for which
you have the exact size at the beginning of Deoptimizer::ComputeOutputFrames.

[Evgeniy Stepanov, 2013/10/10 15:08:54]

Thanks, this is very helpful!

                                              function,
                                              type,
                                              bailout_id,
                                              from,
                                              fp_to_sp_delta,
                                              NULL);
   ASSERT(isolate->deoptimizer_data()->current_ == NULL);
   isolate->deoptimizer_data()->current_ = deoptimizer;
   return deoptimizer;
 }
@@ skipping 2816 matching lines @@
 
 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&function_));
   v->VisitPointers(parameters_, parameters_ + parameters_count_);
   v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal