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 244