Hash :
f4e901b4
        
        Author :
  
        
        Date :
2023-08-07T10:52:09
        
      
Validate program binaries are the same CPU bit-ness. ANGLE's program binary serialize/deserialize logic uses size_t and other non-fixed sized integer types. This can cause crashes if the CPU architecture changes between saving and loading of binaries. Bug: chromium:1470074 Bug: angleproject:8223 Change-Id: Ib2529e0e6e66e28a184aa1ec94075e343e1f1d5e Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4752265 Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
//
// Copyright 2023 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// platform_helpers.cpp: implementations for platform identification functions
// which require runtime detections.
#include "common/platform_helpers.h"
#include "common/debug.h"
#include <tuple>
#ifdef ANGLE_PLATFORM_WINDOWS
#    include <windows.h>
#endif
namespace angle
{
namespace
{
// Windows version constants, for range check functions
constexpr VersionTriple kVersionWindowsXP    = VersionTriple(5, 1, 0);
constexpr VersionTriple kVersionWindowsVista = VersionTriple(6, 0, 0);
constexpr VersionTriple kVersionWindows7     = VersionTriple(6, 1, 0);
constexpr VersionTriple kVersionWindows8     = VersionTriple(6, 2, 0);
constexpr VersionTriple kVersionWindows10    = VersionTriple(10, 0, 0);
constexpr VersionTriple kVersionWindows11    = VersionTriple(10, 0, 22000);
bool IsWindowsVersionOrLater(VersionTriple greaterOrEqual)
{
#if defined(ANGLE_PLATFORM_WINDOWS)
#    if defined(ANGLE_ENABLE_WINDOWS_UWP)
    // Windows UWP does not provide access to the VerifyVersionInfo API, nor
    // the versionhelpers.h functions. To work around this, always treat UWP
    // applications as running on Windows 10 (which is when UWP was
    // introduced).
    return greaterOrEqual >= kVersionWindows10;
#    else
    OSVERSIONINFOEXW osvi;
    DWORDLONG dwlConditionMask = 0;
    dwlConditionMask = VerSetConditionMask(dwlConditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);
    dwlConditionMask = VerSetConditionMask(dwlConditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);
    dwlConditionMask = VerSetConditionMask(dwlConditionMask, VER_BUILDNUMBER, VER_GREATER_EQUAL);
    osvi                     = {};
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    osvi.dwMajorVersion      = greaterOrEqual.majorVersion;
    osvi.dwMinorVersion      = greaterOrEqual.minorVersion;
    osvi.dwBuildNumber       = greaterOrEqual.patchVersion;
    return VerifyVersionInfoW(&osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_BUILDNUMBER,
                              dwlConditionMask) != FALSE;
#    endif  // ANGLE_ENABLE_WINDOWS_UWP
#else
    return false;
#endif  // ANGLE_PLATFORM_WINDOWS
}
bool IsWindowsVersionInRange(VersionTriple greaterOrEqual, VersionTriple lessThan)
{
    // This function is checking (greaterOrEqual <= WindowsVersion < lessThan),
    // for when you need to match a specific Windows release.
    ASSERT(greaterOrEqual < lessThan);
    return IsWindowsVersionOrLater(greaterOrEqual) && !IsWindowsVersionOrLater(lessThan);
}
}  // namespace
bool operator==(const VersionTriple &a, const VersionTriple &b)
{
    return std::tie(a.majorVersion, a.minorVersion, a.patchVersion) ==
           std::tie(b.majorVersion, b.minorVersion, b.patchVersion);
}
bool operator!=(const VersionTriple &a, const VersionTriple &b)
{
    return std::tie(a.majorVersion, a.minorVersion, a.patchVersion) !=
           std::tie(b.majorVersion, b.minorVersion, b.patchVersion);
}
bool operator<(const VersionTriple &a, const VersionTriple &b)
{
    return std::tie(a.majorVersion, a.minorVersion, a.patchVersion) <
           std::tie(b.majorVersion, b.minorVersion, b.patchVersion);
}
bool operator>=(const VersionTriple &a, const VersionTriple &b)
{
    return std::tie(a.majorVersion, a.minorVersion, a.patchVersion) >=
           std::tie(b.majorVersion, b.minorVersion, b.patchVersion);
}
//
// Exact Windows version checks
//
bool IsWindowsXP()
{
    return IsWindowsVersionInRange(kVersionWindowsXP, kVersionWindowsVista);
}
bool IsWindowsVista()
{
    return IsWindowsVersionInRange(kVersionWindowsVista, kVersionWindows7);
}
bool IsWindows7()
{
    return IsWindowsVersionInRange(kVersionWindows7, kVersionWindows8);
}
bool IsWindows8()
{
    return IsWindowsVersionInRange(kVersionWindows8, kVersionWindows10);
}
bool IsWindows10()
{
    return IsWindowsVersionInRange(kVersionWindows10, kVersionWindows11);
}
bool IsWindows11()
{
    // There's no post-Windows 11 release yet, so this is functionally a
    // "Windows 11 or later" check right now.
    return IsWindowsVersionOrLater(kVersionWindows11);
}
//
// Windows version or later helpers
//
bool IsWindowsXPOrLater()
{
    return IsWindowsVersionOrLater(kVersionWindowsXP);
}
bool IsWindowsVistaOrLater()
{
    return IsWindowsVersionOrLater(kVersionWindowsVista);
}
bool IsWindows7OrLater()
{
    return IsWindowsVersionOrLater(kVersionWindows7);
}
bool IsWindows8OrLater()
{
    return IsWindowsVersionOrLater(kVersionWindows8);
}
bool IsWindows10OrLater()
{
    return IsWindowsVersionOrLater(kVersionWindows10);
}
bool IsWindows11OrLater()
{
    return IsWindowsVersionOrLater(kVersionWindows11);
}
bool Is64Bit()
{
#if defined(ANGLE_IS_64_BIT_CPU)
    return true;
#else
    return false;
#endif  // defined(ANGLE_IS_64_BIT_CPU)
}
}  // namespace angle