Turn on stack use-after-return detection in non-official ASan builds.

base/debug/proc_maps_linux_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 "base/debug/proc_maps_linux.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
@@ skipping 163 matching lines @@
 
     std::vector<MappedMemoryRegion> regions;
     EXPECT_TRUE(ParseProcMaps(kTestCases[i].input, &regions));
     EXPECT_EQ(1u, regions.size());
     if (regions.empty())
       continue;
     EXPECT_EQ(kTestCases[i].permissions, regions[0].permissions);
   }
 }
 
-TEST(ProcMapsTest, ReadProcMaps) {
-  std::string proc_maps;
-  ASSERT_TRUE(ReadProcMaps(&proc_maps));
-
-  std::vector<MappedMemoryRegion> regions;
-  ASSERT_TRUE(ParseProcMaps(proc_maps, &regions));
-  ASSERT_FALSE(regions.empty());
-
+#if defined(ADDRESS_SANITIZER)
+// AddressSanitizer may move local variables to a dedicated "fake stack" which
+// is outside the stack region listed in /proc/self/maps. We disable ASan
+// instrumentation for this function to force the variable to be local.
+__attribute__((no_sanitize_address))
+#endif
+void CheckProcMapsRegions(const std::vector<MappedMemoryRegion> &regions) {
   // We should be able to find both the current executable as well as the stack
-  // mapped into memory. Use the address of |proc_maps| as a way of finding the
+  // mapped into memory. Use the address of |exe_path| as a way of finding the
   // stack.
   FilePath exe_path;
   EXPECT_TRUE(PathService::Get(FILE_EXE, &exe_path));
-  uintptr_t address = reinterpret_cast<uintptr_t>(&proc_maps);
+  uintptr_t address = reinterpret_cast<uintptr_t>(&exe_path);
   bool found_exe = false;
   bool found_stack = false;
   bool found_address = false;
 
   for (size_t i = 0; i < regions.size(); ++i) {
     if (regions[i].path == exe_path.value()) {
       // It's OK to find the executable mapped multiple times as there'll be
       // multiple sections (e.g., text, data).
       found_exe = true;
     }
@@ skipping 31 matching lines @@
     }
   }
 
   EXPECT_TRUE(found_exe);
   if (!RunningOnValgrind()) {
     EXPECT_TRUE(found_stack);
     EXPECT_TRUE(found_address);
   }
 }
 
+TEST(ProcMapsTest, ReadProcMaps) {
+  std::string proc_maps;
+  ASSERT_TRUE(ReadProcMaps(&proc_maps));
+
+  std::vector<MappedMemoryRegion> regions;
+  ASSERT_TRUE(ParseProcMaps(proc_maps, &regions));
+  ASSERT_FALSE(regions.empty());
+
+  CheckProcMapsRegions(regions);
+}
+
 TEST(ProcMapsTest, ReadProcMapsNonEmptyString) {
   std::string old_string("I forgot to clear the string");
   std::string proc_maps(old_string);
   ASSERT_TRUE(ReadProcMaps(&proc_maps));
   EXPECT_EQ(std::string::npos, proc_maps.find(old_string));
 }
 
 TEST(ProcMapsTest, MissingFields) {
   static const char* const kTestCases[] = {
     "00400000\n",                               // Missing end + beyond.
@@ skipping 60 matching lines @@
   EXPECT_EQ(5ULL, regions.size());
   EXPECT_EQ("/bin/cat", regions[0].path);
   EXPECT_EQ("/lib/x86_64-linux-gnu/libc-2.15.so", regions[1].path);
   EXPECT_EQ("/lib/x86_64-linux-gnu/ld-2.15.so", regions[2].path);
   EXPECT_EQ("\"vd so\"", regions[3].path);
   EXPECT_EQ("[vsys call]", regions[4].path);
 }
 
 }  // namespace debug
 }  // namespace base