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