Home | History | Annotate | Download | only in windows 
      1 /* Copyright (c) 2007, Google Inc.
      2  * All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  *
     30  * ---
     31  * Author: Craig Silverstein
     32  *
     33  * These are some portability typedefs and defines to make it a bit
     34  * easier to compile this code under VC++.
     35  *
     36  * Several of these are taken from glib:
     37  *    http://developer.gnome.org/doc/API/glib/glib-windows-compatability-functions.html
     38  */
     39 
     40 #ifndef GOOGLE_BASE_WINDOWS_H_
     41 #define GOOGLE_BASE_WINDOWS_H_
     42 
     43 /* You should never include this file directly, but always include it
     44    from either config.h (MSVC) or mingw.h (MinGW/msys). */
     45 #if !defined(GOOGLE_PERFTOOLS_WINDOWS_CONFIG_H_) && \
     46     !defined(GOOGLE_PERFTOOLS_WINDOWS_MINGW_H_)
     47 # error "port.h should only be included from config.h or mingw.h"
     48 #endif
     49 
     50 #ifdef _WIN32
     51 
     52 #ifndef NOMINMAX
     53 #define NOMINMAX             /* Do not define min and max macros. */
     54 #endif
     55 #ifndef WIN32_LEAN_AND_MEAN
     56 #define WIN32_LEAN_AND_MEAN  /* We always want minimal includes */
     57 #endif
     58 #include <windows.h>
     59 #include <io.h>              /* because we so often use open/close/etc */
     60 #include <direct.h>          /* for _getcwd */
     61 #include <process.h>         /* for _getpid */
     62 #include <limits.h>          /* for PATH_MAX */
     63 #include <stdarg.h>          /* for va_list */
     64 #include <stdio.h>           /* need this to override stdio's (v)snprintf */
     65 #include <sys/types.h>       /* for _off_t */
     66 #include <assert.h>
     67 #include <stdlib.h>          /* for rand, srand, _strtoxxx */
     68 
     69 /*
     70  * 4018: signed/unsigned mismatch is common (and ok for signed_i < unsigned_i)
     71  * 4244: otherwise we get problems when subtracting two size_t's to an int
     72  * 4288: VC++7 gets confused when a var is defined in a loop and then after it
     73  * 4267: too many false positives for "conversion gives possible data loss"
     74  * 4290: it's ok windows ignores the "throw" directive
     75  * 4996: Yes, we're ok using "unsafe" functions like vsnprintf and getenv()
     76  * 4146: internal_logging.cc intentionally negates an unsigned value
     77  */
     78 #ifdef _MSC_VER
     79 #pragma warning(disable:4018 4244 4288 4267 4290 4996 4146)
     80 #endif
     81 
     82 #ifndef __cplusplus
     83 /* MSVC does not support C99 */
     84 # if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L
     85 #  ifdef _MSC_VER
     86 #    define inline __inline
     87 #  else
     88 #    define inline static
     89 #  endif
     90 # endif
     91 #endif
     92 
     93 #ifdef __cplusplus
     94 # define EXTERN_C  extern "C"
     95 #else
     96 # define EXTERN_C  extern
     97 #endif
     98 
     99 /* ----------------------------------- BASIC TYPES */
    100 
    101 #ifndef HAVE_STDINT_H
    102 #ifndef HAVE___INT64    /* we need to have all the __intX names */
    103 # error  Do not know how to set up type aliases.  Edit port.h for your system.
    104 #endif
    105 
    106 typedef __int8 int8_t;
    107 typedef __int16 int16_t;
    108 typedef __int32 int32_t;
    109 typedef __int64 int64_t;
    110 typedef unsigned __int8 uint8_t;
    111 typedef unsigned __int16 uint16_t;
    112 typedef unsigned __int32 uint32_t;
    113 typedef unsigned __int64 uint64_t;
    114 #endif  /* #ifndef HAVE_STDINT_H */
    115 
    116 /* I guess MSVC's <types.h> doesn't include ssize_t by default? */
    117 #ifdef _MSC_VER
    118 typedef intptr_t ssize_t;
    119 #endif
    120 
    121 /* ----------------------------------- THREADS */
    122 
    123 #ifndef HAVE_PTHREAD   /* not true for MSVC, but may be true for MSYS */
    124 typedef DWORD pthread_t;
    125 typedef DWORD pthread_key_t;
    126 typedef LONG pthread_once_t;
    127 enum { PTHREAD_ONCE_INIT = 0 };   /* important that this be 0! for SpinLock */
    128 
    129 inline pthread_t pthread_self(void) {
    130   return GetCurrentThreadId();
    131 }
    132 
    133 #ifdef __cplusplus
    134 inline bool pthread_equal(pthread_t left, pthread_t right) {
    135   return left == right;
    136 }
    137 
    138 /* This replaces maybe_threads.{h,cc} */
    139 EXTERN_C pthread_key_t PthreadKeyCreate(void (*destr_fn)(void*));  /* port.cc */
    140 
    141 inline int perftools_pthread_key_create(pthread_key_t *pkey,
    142                                         void (*destructor)(void*)) {
    143   pthread_key_t key = PthreadKeyCreate(destructor);
    144   if (key != TLS_OUT_OF_INDEXES) {
    145     *(pkey) = key;
    146     return 0;
    147   } else {
    148     return GetLastError();
    149   }
    150 }
    151 
    152 inline void* perftools_pthread_getspecific(DWORD key) {
    153   DWORD err = GetLastError();
    154   void* rv = TlsGetValue(key);
    155   if (err) SetLastError(err);
    156   return rv;
    157 }
    158 
    159 inline int perftools_pthread_setspecific(pthread_key_t key, const void *value) {
    160   if (TlsSetValue(key, (LPVOID)value))
    161     return 0;
    162   else
    163     return GetLastError();
    164 }
    165 
    166 EXTERN_C int perftools_pthread_once(pthread_once_t *once_control,
    167                                     void (*init_routine)(void));
    168 
    169 #endif  /* __cplusplus */
    170 #endif  /* HAVE_PTHREAD */
    171 
    172 inline void sched_yield(void) {
    173   Sleep(0);
    174 }
    175 
    176 /*
    177  * __declspec(thread) isn't usable in a dll opened via LoadLibrary().
    178  * But it doesn't work to LoadLibrary() us anyway, because of all the
    179  * things we need to do before main()!  So this kind of TLS is safe for us.
    180  */
    181 #define __thread __declspec(thread)
    182 
    183 /*
    184  * This code is obsolete, but I keep it around in case we are ever in
    185  * an environment where we can't or don't want to use google spinlocks
    186  * (from base/spinlock.{h,cc}).  In that case, uncommenting this out,
    187  * and removing spinlock.cc from the build, should be enough to revert
    188  * back to using native spinlocks.
    189  */
    190 #if 0
    191 // Windows uses a spinlock internally for its mutexes, making our life easy!
    192 // However, the Windows spinlock must always be initialized, making life hard,
    193 // since we want LINKER_INITIALIZED.  We work around this by having the
    194 // linker initialize a bool to 0, and check that before accessing the mutex.
    195 // This replaces spinlock.{h,cc}, and all the stuff it depends on (atomicops)
    196 #ifdef __cplusplus
    197 class SpinLock {
    198  public:
    199   SpinLock() : initialize_token_(PTHREAD_ONCE_INIT) {}
    200   // Used for global SpinLock vars (see base/spinlock.h for more details).
    201   enum StaticInitializer { LINKER_INITIALIZED };
    202   explicit SpinLock(StaticInitializer) : initialize_token_(PTHREAD_ONCE_INIT) {
    203     perftools_pthread_once(&initialize_token_, InitializeMutex);
    204   }
    205 
    206   // It's important SpinLock not have a destructor: otherwise we run
    207   // into problems when the main thread has exited, but other threads
    208   // are still running and try to access a main-thread spinlock.  This
    209   // means we leak mutex_ (we should call DeleteCriticalSection()
    210   // here).  However, I've verified that all SpinLocks used in
    211   // perftools have program-long scope anyway, so the leak is
    212   // perfectly fine.  But be aware of this for the future!
    213 
    214   void Lock() {
    215     // You'd thionk this would be unnecessary, since we call
    216     // InitializeMutex() in our constructor.  But sometimes Lock() can
    217     // be called before our constructor is!  This can only happen in
    218     // global constructors, when this is a global.  If we live in
    219     // bar.cc, and some global constructor in foo.cc calls a routine
    220     // in bar.cc that calls this->Lock(), then Lock() may well run
    221     // before our global constructor does.  To protect against that,
    222     // we do this check.  For SpinLock objects created after main()
    223     // has started, this pthread_once call will always be a noop.
    224     perftools_pthread_once(&initialize_token_, InitializeMutex);
    225     EnterCriticalSection(&mutex_);
    226   }
    227   void Unlock() {
    228     LeaveCriticalSection(&mutex_);
    229   }
    230 
    231   // Used in assertion checks: assert(lock.IsHeld()) (see base/spinlock.h).
    232   inline bool IsHeld() const {
    233     // This works, but probes undocumented internals, so I've commented it out.
    234     // c.f. http://msdn.microsoft.com/msdnmag/issues/03/12/CriticalSections/
    235     //return mutex_.LockCount>=0 && mutex_.OwningThread==GetCurrentThreadId();
    236     return true;
    237   }
    238  private:
    239   void InitializeMutex() { InitializeCriticalSection(&mutex_); }
    240 
    241   pthread_once_t initialize_token_;
    242   CRITICAL_SECTION mutex_;
    243 };
    244 
    245 class SpinLockHolder {  // Acquires a spinlock for as long as the scope lasts
    246  private:
    247   SpinLock* lock_;
    248  public:
    249   inline explicit SpinLockHolder(SpinLock* l) : lock_(l) { l->Lock(); }
    250   inline ~SpinLockHolder() { lock_->Unlock(); }
    251 };
    252 #endif  // #ifdef __cplusplus
    253 
    254 // This keeps us from using base/spinlock.h's implementation of SpinLock.
    255 #define BASE_SPINLOCK_H_ 1
    256 
    257 #endif  /* #if 0 */
    258 
    259 /* ----------------------------------- MMAP and other memory allocation */
    260 
    261 #ifndef HAVE_MMAP   /* not true for MSVC, but may be true for msys */
    262 #define MAP_FAILED  0
    263 #define MREMAP_FIXED  2  /* the value in linux, though it doesn't really matter */
    264 /* These, when combined with the mmap invariants below, yield the proper action */
    265 #define PROT_READ      PAGE_READWRITE
    266 #define PROT_WRITE     PAGE_READWRITE
    267 #define MAP_ANONYMOUS  MEM_RESERVE
    268 #define MAP_PRIVATE    MEM_COMMIT
    269 #define MAP_SHARED     MEM_RESERVE   /* value of this #define is 100% arbitrary */
    270 
    271 #if __STDC__ && !defined(__MINGW32__)
    272 typedef _off_t off_t;
    273 #endif
    274 
    275 /* VirtualAlloc only replaces for mmap when certain invariants are kept. */
    276 inline void *mmap(void *addr, size_t length, int prot, int flags,
    277                   int fd, off_t offset) {
    278   if (addr == NULL && fd == -1 && offset == 0 &&
    279       prot == (PROT_READ|PROT_WRITE) && flags == (MAP_PRIVATE|MAP_ANONYMOUS)) {
    280     return VirtualAlloc(0, length, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
    281   } else {
    282     return NULL;
    283   }
    284 }
    285 
    286 inline int munmap(void *addr, size_t length) {
    287   return VirtualFree(addr, 0, MEM_RELEASE) ? 0 : -1;
    288 }
    289 #endif  /* HAVE_MMAP */
    290 
    291 /* We could maybe use VirtualAlloc for sbrk as well, but no need */
    292 inline void *sbrk(intptr_t increment) {
    293   // sbrk returns -1 on failure
    294   return (void*)-1;
    295 }
    296 
    297 
    298 /* ----------------------------------- STRING ROUTINES */
    299 
    300 /*
    301  * We can't just use _vsnprintf and _snprintf as drop-in-replacements,
    302  * because they don't always NUL-terminate. :-(  We also can't use the
    303  * name vsnprintf, since windows defines that (but not snprintf (!)).
    304  */
    305 #if defined(_MSC_VER) && _MSC_VER >= 1400
    306 /* We can use safe CRT functions, which the required functionality */
    307 inline int perftools_vsnprintf(char *str, size_t size, const char *format,
    308                                va_list ap) {
    309   return vsnprintf_s(str, size, _TRUNCATE, format, ap);
    310 }
    311 #else
    312 inline int perftools_vsnprintf(char *str, size_t size, const char *format,
    313                                va_list ap) {
    314   if (size == 0)        /* not even room for a \0? */
    315     return -1;        /* not what C99 says to do, but what windows does */
    316   str[size-1] = '\0';
    317   return _vsnprintf(str, size-1, format, ap);
    318 }
    319 #endif
    320 
    321 #ifndef HAVE_SNPRINTF
    322 inline int snprintf(char *str, size_t size, const char *format, ...) {
    323   va_list ap;
    324   int r;
    325   va_start(ap, format);
    326   r = perftools_vsnprintf(str, size, format, ap);
    327   va_end(ap);
    328   return r;
    329 }
    330 #endif
    331 
    332 #define PRIx64  "I64x"
    333 #define SCNx64  "I64x"
    334 #define PRId64  "I64d"
    335 #define SCNd64  "I64d"
    336 #define PRIu64  "I64u"
    337 #ifdef _WIN64
    338 # define PRIuPTR "llu"
    339 # define PRIxPTR "llx"
    340 #else
    341 # define PRIuPTR "lu"
    342 # define PRIxPTR "lx"
    343 #endif
    344 
    345 /* ----------------------------------- FILE IO */
    346 
    347 #ifndef PATH_MAX
    348 #define PATH_MAX 1024
    349 #endif
    350 #ifndef __MINGW32__
    351 enum { STDIN_FILENO = 0, STDOUT_FILENO = 1, STDERR_FILENO = 2 };
    352 #endif
    353 #ifndef O_RDONLY
    354 #define O_RDONLY  _O_RDONLY
    355 #endif
    356 
    357 #if __STDC__ && !defined(__MINGW32__)
    358 /* These functions are considered non-standard */
    359 inline int access(const char *pathname, int mode) {
    360   return _access(pathname, mode);
    361 }
    362 inline int open(const char *pathname, int flags, int mode = 0) {
    363   return _open(pathname, flags, mode);
    364 }
    365 inline int close(int fd) {
    366   return _close(fd);
    367 }
    368 inline ssize_t read(int fd, void *buf, size_t count) {
    369   return _read(fd, buf, count);
    370 }
    371 inline ssize_t write(int fd, const void *buf, size_t count) {
    372   return _write(fd, buf, count);
    373 }
    374 inline off_t lseek(int fd, off_t offset, int whence) {
    375   return _lseek(fd, offset, whence);
    376 }
    377 inline char *getcwd(char *buf, size_t size) {
    378   return _getcwd(buf, size);
    379 }
    380 inline int mkdir(const char *pathname, int) {
    381   return _mkdir(pathname);
    382 }
    383 
    384 inline FILE *popen(const char *command, const char *type) {
    385   return _popen(command, type);
    386 }
    387 inline int pclose(FILE *stream) {
    388   return _pclose(stream);
    389 }
    390 #endif
    391 
    392 EXTERN_C PERFTOOLS_DLL_DECL void WriteToStderr(const char* buf, int len);
    393 
    394 /* ----------------------------------- SYSTEM/PROCESS */
    395 
    396 typedef int pid_t;
    397 #if __STDC__ && !defined(__MINGW32__)
    398 inline pid_t getpid(void) { return _getpid(); }
    399 #endif
    400 inline pid_t getppid(void) { return 0; }
    401 
    402 /* Handle case when poll is used to simulate sleep. */
    403 inline int poll(struct pollfd* fds, int nfds, int timeout) {
    404   assert(fds == NULL);
    405   assert(nfds == 0);
    406   Sleep(timeout);
    407   return 0;
    408 }
    409 
    410 EXTERN_C int getpagesize();   /* in port.cc */
    411 
    412 /* ----------------------------------- OTHER */
    413 
    414 inline void srandom(unsigned int seed) { srand(seed); }
    415 inline long random(void) { return rand(); }
    416 inline unsigned int sleep(unsigned int seconds) {
    417   Sleep(seconds * 1000);
    418   return 0;
    419 }
    420 
    421 // mingw64 seems to define timespec (though mingw.org mingw doesn't),
    422 // protected by the _TIMESPEC_DEFINED macro.
    423 #ifndef _TIMESPEC_DEFINED
    424 struct timespec {
    425   int tv_sec;
    426   int tv_nsec;
    427 };
    428 #endif
    429 
    430 inline int nanosleep(const struct timespec *req, struct timespec *rem) {
    431   Sleep(req->tv_sec * 1000 + req->tv_nsec / 1000000);
    432   return 0;
    433 }
    434 
    435 #ifndef __MINGW32__
    436 #if _MSC_VER < 1800  // Not required >= VS2013.
    437 inline long long int strtoll(const char *nptr, char **endptr, int base) {
    438     return _strtoi64(nptr, endptr, base);
    439 }
    440 inline unsigned long long int strtoull(const char *nptr, char **endptr,
    441                                        int base) {
    442     return _strtoui64(nptr, endptr, base);
    443 }
    444 inline long long int strtoq(const char *nptr, char **endptr, int base) {
    445     return _strtoi64(nptr, endptr, base);
    446 }
    447 #endif
    448 inline unsigned long long int strtouq(const char *nptr, char **endptr,
    449                                       int base) {
    450     return _strtoui64(nptr, endptr, base);
    451 }
    452 inline long long atoll(const char *nptr) {
    453   return _atoi64(nptr);
    454 }
    455 #endif
    456 
    457 #define __THROW throw()
    458 
    459 /* ----------------------------------- TCMALLOC-SPECIFIC */
    460 
    461 /* tcmalloc.cc calls this so we can patch VirtualAlloc() et al. */
    462 extern void PatchWindowsFunctions();
    463 
    464 // ----------------------------------- BUILD-SPECIFIC
    465 
    466 /*
    467  * windows/port.h defines compatibility APIs for several .h files, which
    468  * we therefore shouldn't be #including directly.  This hack keeps us from
    469  * doing so.  TODO(csilvers): do something more principled.
    470  */
    471 #define GOOGLE_MAYBE_THREADS_H_ 1
    472 
    473 
    474 #endif  /* _WIN32 */
    475 
    476 #undef inline
    477 #undef EXTERN_C
    478 
    479 #endif  /* GOOGLE_BASE_WINDOWS_H_ */
    480