contrib/llvm-project/llvm/include/llvm/Support/Windows/WindowsSupport.h

   1 //===- WindowsSupport.h - Common Windows Include File -----------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines things specific to Windows implementations.  In addition to
  10 // providing some helpers for working with win32 APIs, this header wraps
  11 // <windows.h> with some portability macros.  Always include WindowsSupport.h
  12 // instead of including <windows.h> directly.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 //===----------------------------------------------------------------------===//
  17 //=== WARNING: Implementation here must contain only generic Win32 code that
  18 //===          is guaranteed to work on *all* Win32 variants.
  19 //===----------------------------------------------------------------------===//
  20
  21 #ifndef LLVM_SUPPORT_WINDOWSSUPPORT_H
  22 #define LLVM_SUPPORT_WINDOWSSUPPORT_H
  23
  24 // mingw-w64 tends to define it as 0x0502 in its headers.
  25 #undef _WIN32_WINNT
  26 #undef _WIN32_IE
  27
  28 // Require at least Windows 7 API.
  29 #define _WIN32_WINNT 0x0601
  30 #define _WIN32_IE    0x0800 // MinGW at it again. FIXME: verify if still needed.
  31 #define WIN32_LEAN_AND_MEAN
  32 #ifndef NOMINMAX
  33 #define NOMINMAX
  34 #endif
  35
  36 #include "llvm/ADT/SmallVector.h"
  37 #include "llvm/ADT/StringExtras.h"
  38 #include "llvm/ADT/StringRef.h"
  39 #include "llvm/ADT/Twine.h"
  40 #include "llvm/Config/config.h" // Get build system configuration settings
  41 #include "llvm/Support/Allocator.h"
  42 #include "llvm/Support/Chrono.h"
  43 #include "llvm/Support/Compiler.h"
  44 #include "llvm/Support/ErrorHandling.h"
  45 #include "llvm/Support/VersionTuple.h"
  46 #include <cassert>
  47 #include <string>
  48 #include <system_error>
  49 #include <windows.h>
  50
  51 // Must be included after windows.h
  52 #include <wincrypt.h>
  53
  54 namespace llvm {
  55
  56 /// Determines if the program is running on Windows 8 or newer. This
  57 /// reimplements one of the helpers in the Windows 8.1 SDK, which are intended
  58 /// to supercede raw calls to GetVersionEx. Old SDKs, Cygwin, and MinGW don't
  59 /// yet have VersionHelpers.h, so we have our own helper.
  60 bool RunningWindows8OrGreater();
  61
  62 /// Returns the Windows version as Major.Minor.0.BuildNumber. Uses
  63 /// RtlGetVersion or GetVersionEx under the hood depending on what is available.
  64 /// GetVersionEx is deprecated, but this API exposes the build number which can
  65 /// be useful for working around certain kernel bugs.
  66 llvm::VersionTuple GetWindowsOSVersion();
  67
  68 bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix);
  69
  70 // Include GetLastError() in a fatal error message.
  71 LLVM_ATTRIBUTE_NORETURN inline void ReportLastErrorFatal(const char *Msg) {
  72   std::string ErrMsg;
  73   MakeErrMsg(&ErrMsg, Msg);
  74   llvm::report_fatal_error(ErrMsg);
  75 }
  76
  77 template <typename HandleTraits>
  78 class ScopedHandle {
  79   typedef typename HandleTraits::handle_type handle_type;
  80   handle_type Handle;
  81
  82   ScopedHandle(const ScopedHandle &other) = delete;
  83   void operator=(const ScopedHandle &other) = delete;
  84 public:
  85   ScopedHandle()
  86     : Handle(HandleTraits::GetInvalid()) {}
  87
  88   explicit ScopedHandle(handle_type h)
  89     : Handle(h) {}
  90
  91   ~ScopedHandle() {
  92     if (HandleTraits::IsValid(Handle))
  93       HandleTraits::Close(Handle);
  94   }
  95
  96   handle_type take() {
  97     handle_type t = Handle;
  98     Handle = HandleTraits::GetInvalid();
  99     return t;
 100   }
 101
 102   ScopedHandle &operator=(handle_type h) {
 103     if (HandleTraits::IsValid(Handle))
 104       HandleTraits::Close(Handle);
 105     Handle = h;
 106     return *this;
 107   }
 108
 109   // True if Handle is valid.
 110   explicit operator bool() const {
 111     return HandleTraits::IsValid(Handle) ? true : false;
 112   }
 113
 114   operator handle_type() const {
 115     return Handle;
 116   }
 117 };
 118
 119 struct CommonHandleTraits {
 120   typedef HANDLE handle_type;
 121
 122   static handle_type GetInvalid() {
 123     return INVALID_HANDLE_VALUE;
 124   }
 125
 126   static void Close(handle_type h) {
 127     ::CloseHandle(h);
 128   }
 129
 130   static bool IsValid(handle_type h) {
 131     return h != GetInvalid();
 132   }
 133 };
 134
 135 struct JobHandleTraits : CommonHandleTraits {
 136   static handle_type GetInvalid() {
 137     return NULL;
 138   }
 139 };
 140
 141 struct CryptContextTraits : CommonHandleTraits {
 142   typedef HCRYPTPROV handle_type;
 143
 144   static handle_type GetInvalid() {
 145     return 0;
 146   }
 147
 148   static void Close(handle_type h) {
 149     ::CryptReleaseContext(h, 0);
 150   }
 151
 152   static bool IsValid(handle_type h) {
 153     return h != GetInvalid();
 154   }
 155 };
 156
 157 struct RegTraits : CommonHandleTraits {
 158   typedef HKEY handle_type;
 159
 160   static handle_type GetInvalid() {
 161     return NULL;
 162   }
 163
 164   static void Close(handle_type h) {
 165     ::RegCloseKey(h);
 166   }
 167
 168   static bool IsValid(handle_type h) {
 169     return h != GetInvalid();
 170   }
 171 };
 172
 173 struct FindHandleTraits : CommonHandleTraits {
 174   static void Close(handle_type h) {
 175     ::FindClose(h);
 176   }
 177 };
 178
 179 struct FileHandleTraits : CommonHandleTraits {};
 180
 181 typedef ScopedHandle<CommonHandleTraits> ScopedCommonHandle;
 182 typedef ScopedHandle<FileHandleTraits>   ScopedFileHandle;
 183 typedef ScopedHandle<CryptContextTraits> ScopedCryptContext;
 184 typedef ScopedHandle<RegTraits>          ScopedRegHandle;
 185 typedef ScopedHandle<FindHandleTraits>   ScopedFindHandle;
 186 typedef ScopedHandle<JobHandleTraits>    ScopedJobHandle;
 187
 188 template <class T>
 189 class SmallVectorImpl;
 190
 191 template <class T>
 192 typename SmallVectorImpl<T>::const_pointer
 193 c_str(SmallVectorImpl<T> &str) {
 194   str.push_back(0);
 195   str.pop_back();
 196   return str.data();
 197 }
 198
 199 namespace sys {
 200
 201 inline std::chrono::nanoseconds toDuration(FILETIME Time) {
 202   ULARGE_INTEGER TimeInteger;
 203   TimeInteger.LowPart = Time.dwLowDateTime;
 204   TimeInteger.HighPart = Time.dwHighDateTime;
 205
 206   // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
 207   return std::chrono::nanoseconds(100 * TimeInteger.QuadPart);
 208 }
 209
 210 inline TimePoint<> toTimePoint(FILETIME Time) {
 211   ULARGE_INTEGER TimeInteger;
 212   TimeInteger.LowPart = Time.dwLowDateTime;
 213   TimeInteger.HighPart = Time.dwHighDateTime;
 214
 215   // Adjust for different epoch
 216   TimeInteger.QuadPart -= 11644473600ll * 10000000;
 217
 218   // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
 219   return TimePoint<>(std::chrono::nanoseconds(100 * TimeInteger.QuadPart));
 220 }
 221
 222 inline FILETIME toFILETIME(TimePoint<> TP) {
 223   ULARGE_INTEGER TimeInteger;
 224   TimeInteger.QuadPart = TP.time_since_epoch().count() / 100;
 225   TimeInteger.QuadPart += 11644473600ll * 10000000;
 226
 227   FILETIME Time;
 228   Time.dwLowDateTime = TimeInteger.LowPart;
 229   Time.dwHighDateTime = TimeInteger.HighPart;
 230   return Time;
 231 }
 232
 233 namespace windows {
 234 // Returns command line arguments. Unlike arguments given to main(),
 235 // this function guarantees that the returned arguments are encoded in
 236 // UTF-8 regardless of the current code page setting.
 237 std::error_code GetCommandLineArguments(SmallVectorImpl<const char *> &Args,
 238                                         BumpPtrAllocator &Alloc);
 239 } // end namespace windows
 240 } // end namespace sys
 241 } // end namespace llvm.
 242
 243 #endif