[sanitizer_common] Don't provide sanitizer_procmaps API functions where not defined

[fjricci]

Summary

Platforms that don't implement procmaps (primarily fuchsia and windows) still expose
the procmaps API when including sanitizer_procmaps.h, despite not implementing the functions
provided by that header. Ensure that the API is only exposed on platforms that implement it.

[fjricci]

I tested that this builds on mac, linux, android, and windows, but I don't have a fuschia cross-compilation toolchain set up to test there. Should be more or less the same as windows though.

compiler-rt/trunk/lib/sanitizer_common/sanitizer_common.h

 uptr GetRSS();
 void NoHugePagesInRegion(uptr addr, uptr length);
 void DontDumpShadowMemory(uptr addr, uptr length);
 // Check if the built VMA size matches the runtime one.
 void CheckVMASize();
 void RunMallocHooks(const void *ptr, uptr size);
 void RunFreeHooks(const void *ptr);
 
+typedef void (*fill_profile_f)(uptr start, uptr rss, bool file,
+                               /*out*/uptr *stats, uptr stats_size);
+
+// Parse the contents of /proc/self/smaps and generate a memory profile.
+// |cb| is a tool-specific callback that fills the |stats| array containing
+// |stats_size| elements.
+void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size);
+
 // InternalScopedBuffer can be used instead of large stack arrays to
 // keep frame size low.
 // FIXME: use InternalAlloc instead of MmapOrDie once
 // InternalAlloc is made libc-free.
 template <typename T>
 class InternalScopedBuffer {
  public:
   explicit InternalScopedBuffer(uptr cnt) {

compiler-rt/trunk/lib/sanitizer_common/sanitizer_fuchsia.h

 
 #include <zircon/sanitizer.h>
 
 namespace __sanitizer {
 
 extern uptr MainThreadStackBase, MainThreadStackSize;
 extern sanitizer_shadow_bounds_t ShadowBounds;
 
-// TODO(fjricci) Remove this struct by refactoring common functions
-// out of sanitizer_procmaps.h
-struct MemoryMappingLayoutData {};
-
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FUCHSIA
 #endif  // SANITIZER_FUCHSIA_H

compiler-rt/trunk/lib/sanitizer_common/sanitizer_fuchsia.cc

 //===---------------------------------------------------------------------===//
 
 #include "sanitizer_fuchsia.h"
 #if SANITIZER_FUCHSIA
 
 #include "sanitizer_common.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_mutex.h"
-#include "sanitizer_procmaps.h"
 #include "sanitizer_stacktrace.h"
 
 #include <limits.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <unwind.h>
 #include <zircon/errors.h>

compiler-rt/trunk/lib/sanitizer_common/sanitizer_procmaps.h

 //===-- sanitizer_procmaps.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer.
 //
 // Information about the process mappings.
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_PROCMAPS_H
 #define SANITIZER_PROCMAPS_H
 
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_MAC
+
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
-#include "sanitizer_fuchsia.h"
 #include "sanitizer_linux.h"
 #include "sanitizer_mac.h"
 #include "sanitizer_mutex.h"
-#include "sanitizer_win.h"
 
 namespace __sanitizer {
 
 
 // Memory protection masks.
 static const uptr kProtectionRead = 1;
 static const uptr kProtectionWrite = 2;
 static const uptr kProtectionExecute = 4;
public:
   static void CacheMemoryMappings();
 
   // Adds all mapped objects into a vector.
   void DumpListOfModules(InternalMmapVector<LoadedModule> *modules);
 
  private:
   void LoadFromCache();
 
-  // FIXME: Hide implementation details for different platforms in
-  // platform-specific files.
   MemoryMappingLayoutData data_;
 };
 
-typedef void (*fill_profile_f)(uptr start, uptr rss, bool file,
-                               /*out*/uptr *stats, uptr stats_size);
-
-// Parse the contents of /proc/self/smaps and generate a memory profile.
-// |cb| is a tool-specific callback that fills the |stats| array containing
-// |stats_size| elements.
-void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size);
-
 // Returns code range for the specified module.
 bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end);
 
 bool IsDecimal(char c);
 uptr ParseDecimal(const char **p);
 bool IsHex(char c);
 uptr ParseHex(const char **p);
 
 }  // namespace __sanitizer
 
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_MAC
 #endif  // SANITIZER_PROCMAPS_H

compiler-rt/trunk/lib/sanitizer_common/sanitizer_win.h

 
 #include "sanitizer_platform.h"
 #if SANITIZER_WINDOWS
 #include "sanitizer_internal_defs.h"
 
 namespace __sanitizer {
 // Check based on flags if we should handle the exception.
 bool IsHandledDeadlyException(DWORD exceptionCode);
-struct MemoryMappingLayoutData {};
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_WINDOWS
 #endif  // SANITIZER_WIN_H

compiler-rt/trunk/lib/sanitizer_common/sanitizer_win.cc

 #include <stdlib.h>
 
 #include "sanitizer_common.h"
 #include "sanitizer_dbghelp.h"
 #include "sanitizer_file.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_placement_new.h"
-#include "sanitizer_procmaps.h"
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_symbolizer.h"
 #include "sanitizer_win_defs.h"
 
 // A macro to tell the compiler that this part of the code cannot be reached,
 // if the compiler supports this feature. Since we're using this in
 // code that is called when terminating the process, the expansion of the
 // macro should not terminate the process to avoid infinite recursion.