Update from https://crrev.com/327068

base/security_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 51 matching lines @@
     buf = new_buf;
   }
 }
 #endif
 
 // This function acts as a compiler optimization barrier. We use it to
 // prevent the compiler from making an expression a compile-time constant.
 // We also use it so that the compiler doesn't discard certain return values
 // as something we don't need (see the comment with calloc below).
 template <typename Type>
-Type HideValueFromCompiler(volatile Type value) {
+NOINLINE Type HideValueFromCompiler(volatile Type value) {
 #if defined(__GNUC__)
   // In a GCC compatible compiler (GCC or Clang), make this compiler barrier
   // more robust than merely using "volatile".
   __asm__ volatile ("" : "+r" (value));
 #endif  // __GNUC__
   return value;
 }
 
 // Tcmalloc and Windows allocator shim support setting malloc limits.
 // - NO_TCMALLOC (should be defined if compiled with use_allocator!="tcmalloc")
@@ skipping 203 matching lines @@
   }
 #endif  // !defined(OS_WIN) || !defined(ARCH_CPU_64_BITS)
 }
 
 // Call calloc(), eventually free the memory and return whether or not
 // calloc() did succeed.
 bool CallocReturnsNull(size_t nmemb, size_t size) {
   scoped_ptr<char, base::FreeDeleter> array_pointer(
       static_cast<char*>(calloc(nmemb, size)));
   // We need the call to HideValueFromCompiler(): we have seen LLVM
-  // optimize away the call to calloc() entirely and assume
-  // the pointer to not be NULL.
+  // optimize away the call to calloc() entirely and assume the pointer to not
+  // be NULL.
   return HideValueFromCompiler(array_pointer.get()) == NULL;
 }
 
 // Test if calloc() can overflow.
 TEST(SecurityTest, CallocOverflow) {
   const size_t kArraySize = 4096;
   const size_t kMaxSizeT = numeric_limits<size_t>::max();
   const size_t kArraySize2 = kMaxSizeT / kArraySize + 10;
   if (!CallocDiesOnOOM()) {
     EXPECT_TRUE(CallocReturnsNull(kArraySize, kArraySize2));
@@ skipping 59 matching lines @@
   // kRandomMask, so we use it as an additional detection mechanism.
   const uintptr_t kRandomMask = 0x3fffffffffffULL;
   bool impossible_random_address =
       reinterpret_cast<uintptr_t>(ptr.get()) & ~kRandomMask;
   EXPECT_FALSE(impossible_random_address);
 }
 
 #endif  // defined(OS_LINUX) && defined(__x86_64__)
 
 }  // namespace