Patch re2 to support MSan.

third_party/re2/util/sparse_array.h

 // Copyright 2006 The RE2 Authors.  All Rights Reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // DESCRIPTION
 // 
 // SparseArray<T>(m) is a map from integers in [0, m) to T values.
 // It requires (sizeof(T)+sizeof(int))*m memory, but it provides
 // fast iteration through the elements in the array and fast clearing
 // of the array.  The array has a concept of certain elements being
@@ skipping 213 matching lines @@
   int max_size_;
   int* sparse_to_dense_;
   vector<IndexValue> dense_;
   bool valgrind_;
 
   DISALLOW_EVIL_CONSTRUCTORS(SparseArray);
 };
 
 template<typename Value>
 SparseArray<Value>::SparseArray()
-    : size_(0), max_size_(0), sparse_to_dense_(NULL), dense_(), valgrind_(RunningOnValgrind()) {}
+    : size_(0), max_size_(0), sparse_to_dense_(NULL), dense_(),
+#if defined(MEMORY_SANITIZER)

[eugenis, 2014/01/30 09:02:55]

I think it would be cleaner to implement RunningOnValgringOrMemorySanitizer() in
util/util.h and replace all calls to RunningOnValgrind with it.

+    valgrind_(true)
+#else
+    valgrind_(RunningOnValgrind())
+#endif
+{
+}
 
 // IndexValue pairs: exposed in SparseArray::iterator.
 template<typename Value>
 class SparseArray<Value>::IndexValue {
   friend class SparseArray;
  public:
   typedef int first_type;
   typedef Value second_type;
 
   IndexValue() {}
@@ skipping 166 matching lines @@
   DCHECK(!has_index(i));
   DCHECK_LT(size_, max_size_);
   sparse_to_dense_[i] = size_;
   dense_[size_].index_ = i;
   size_++;
 }
 
 template<typename Value> SparseArray<Value>::SparseArray(int max_size) {
   max_size_ = max_size;
   sparse_to_dense_ = new int[max_size];
+#if defined(MEMORY_SANITIZER)
+  valgrind_ = true;
+#else
   valgrind_ = RunningOnValgrind();
+#endif
   dense_.resize(max_size);
   // Don't need to zero the new memory, but appease Valgrind.
   if (valgrind_) {
     for (int i = 0; i < max_size; i++) {
       sparse_to_dense_[i] = 0xababababU;
       dense_[i].index_ = 0xababababU;
     }
   }
   size_ = 0;
   DebugCheckInvariants();
@@ skipping 12 matching lines @@
 
 // Comparison function for sorting.
 template<typename Value> bool SparseArray<Value>::less(const IndexValue& a,
                                                        const IndexValue& b) {
   return a.index_ < b.index_;
 }
 
 }  // namespace re2
 
 #endif  // RE2_UTIL_SPARSE_ARRAY_H__