Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/src/windows/port.h

 /* Copyright (c) 2007, Google Inc.
  * 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
@@ skipping 47 matching lines @@
 #include <process.h>         /* for _getpid */
 #include <limits.h>          /* for PATH_MAX */
 #include <stdarg.h>          /* for va_list */
 #include <stdio.h>           /* need this to override stdio's (v)snprintf */
 #include <sys/types.h>       /* for _off_t */
 #include <assert.h>
 #include <stdlib.h>          /* for rand, srand, _strtoxxx */
 
 /*
  * 4018: signed/unsigned mismatch is common (and ok for signed_i < unsigned_i)
- * 4244: otherwise we get problems when substracting two size_t's to an int
+ * 4244: otherwise we get problems when subtracting two size_t's to an int
  * 4288: VC++7 gets confused when a var is defined in a loop and then after it
  * 4267: too many false positives for "conversion gives possible data loss"
  * 4290: it's ok windows ignores the "throw" directive
  * 4996: Yes, we're ok using "unsafe" functions like vsnprintf and getenv()
+ * 4146: internal_logging.cc intentionally negates an unsigned value
  */
 #ifdef _MSC_VER
-#pragma warning(disable:4018 4244 4288 4267 4290 4996)
+#pragma warning(disable:4018 4244 4288 4267 4290 4996 4146)
 #endif
 
 #ifndef __cplusplus
 /* MSVC does not support C99 */
 # if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L
 #  ifdef _MSC_VER
 #    define inline __inline
 #  else
 #    define inline static
 #  endif
@@ skipping 72 matching lines @@
   else
     return GetLastError();
 }
 
 EXTERN_C int perftools_pthread_once(pthread_once_t *once_control,
                                     void (*init_routine)(void));
 
 #endif  /* __cplusplus */
 #endif  /* HAVE_PTHREAD */
 
+inline void sched_yield(void) {
+  Sleep(0);
+}
+
 /*
  * __declspec(thread) isn't usable in a dll opened via LoadLibrary().
  * But it doesn't work to LoadLibrary() us anyway, because of all the
  * things we need to do before main()!  So this kind of TLS is safe for us.
  */
 #define __thread __declspec(thread)
 
 /*
  * This code is obsolete, but I keep it around in case we are ever in
  * an environment where we can't or don't want to use google spinlocks
@@ skipping 75 matching lines @@
 #ifndef HAVE_MMAP   /* not true for MSVC, but may be true for msys */
 #define MAP_FAILED  0
 #define MREMAP_FIXED  2  /* the value in linux, though it doesn't really matter */
 /* These, when combined with the mmap invariants below, yield the proper action */
 #define PROT_READ      PAGE_READWRITE
 #define PROT_WRITE     PAGE_READWRITE
 #define MAP_ANONYMOUS  MEM_RESERVE
 #define MAP_PRIVATE    MEM_COMMIT
 #define MAP_SHARED     MEM_RESERVE   /* value of this #define is 100% arbitrary */
 
-#if __STDC__
+#if __STDC__ && !defined(__MINGW32__)
 typedef _off_t off_t;
 #endif
 
 /* VirtualAlloc only replaces for mmap when certain invariants are kept. */
 inline void *mmap(void *addr, size_t length, int prot, int flags,
                   int fd, off_t offset) {
   if (addr == NULL && fd == -1 && offset == 0 &&
       prot == (PROT_READ|PROT_WRITE) && flags == (MAP_PRIVATE|MAP_ANONYMOUS)) {
     return VirtualAlloc(0, length, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
   } else {
@@ skipping 91 matching lines @@
 }
 inline off_t lseek(int fd, off_t offset, int whence) {
   return _lseek(fd, offset, whence);
 }
 inline char *getcwd(char *buf, size_t size) {
   return _getcwd(buf, size);
 }
 inline int mkdir(const char *pathname, int) {
   return _mkdir(pathname);
 }
-#endif
 
 inline FILE *popen(const char *command, const char *type) {
   return _popen(command, type);
 }
 inline int pclose(FILE *stream) {
   return _pclose(stream);
 }
+#endif
 
 EXTERN_C PERFTOOLS_DLL_DECL void WriteToStderr(const char* buf, int len);
 
 /* ----------------------------------- SYSTEM/PROCESS */
 
 typedef int pid_t;
-#if __STDC__
+#if __STDC__ && !defined(__MINGW32__)
 inline pid_t getpid(void) { return _getpid(); }
 #endif
 inline pid_t getppid(void) { return 0; }
 
 /* Handle case when poll is used to simulate sleep. */
 inline int poll(struct pollfd* fds, int nfds, int timeout) {
   assert(fds == NULL);
   assert(nfds == 0);
   Sleep(timeout);
   return 0;
 }
 
 EXTERN_C int getpagesize();   /* in port.cc */
 
 /* ----------------------------------- OTHER */
 
 inline void srandom(unsigned int seed) { srand(seed); }
 inline long random(void) { return rand(); }
 inline unsigned int sleep(unsigned int seconds) {
   Sleep(seconds * 1000);
   return 0;
 }
 
+// mingw64 seems to define timespec (though mingw.org mingw doesn't),
+// protected by the _TIMESPEC_DEFINED macro.
+#ifndef _TIMESPEC_DEFINED
 struct timespec {
   int tv_sec;
   int tv_nsec;
 };
+#endif
 
 inline int nanosleep(const struct timespec *req, struct timespec *rem) {
   Sleep(req->tv_sec * 1000 + req->tv_nsec / 1000000);
   return 0;
 }
 
 #ifndef __MINGW32__
 inline long long int strtoll(const char *nptr, char **endptr, int base) {
     return _strtoi64(nptr, endptr, base);
 }
@@ skipping 29 matching lines @@
  */
 #define GOOGLE_MAYBE_THREADS_H_ 1
 
 
 #endif  /* _WIN32 */
 
 #undef inline
 #undef EXTERN_C
 
 #endif  /* GOOGLE_BASE_WINDOWS_H_ */