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
|
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/debug_helpers.h"
#include <cstdint>
#include <limits>
inline const int ptrGarbageContent[16] = {
0x0131, 0x133, 0xA, 0xEF,
0x0131, 0x133, 0xA, 0xEF,
0x0131, 0x133, 0xA, 0xEF,
0x0131, 0x133, 0xA, 0xEF};
inline const auto ptrGarbage = (void *)ptrGarbageContent;
template <typename T>
inline T ptrOffset(T ptrBefore, size_t offset) {
auto addrBefore = (uintptr_t)ptrBefore;
auto addrAfter = addrBefore + offset;
return (T)addrAfter;
}
template <>
inline uint64_t ptrOffset(uint64_t ptrBefore, size_t offset) {
return ptrBefore + offset;
}
template <typename TA, typename TB>
inline size_t ptrDiff(TA ptrAfter, TB ptrBefore) {
auto addrBefore = (uintptr_t)ptrBefore;
auto addrAfter = (uintptr_t)ptrAfter;
return addrAfter - addrBefore;
}
template <typename T>
inline uint64_t ptrDiff(uint64_t ptrAfter, T ptrBefore) {
return ptrAfter - ptrBefore;
}
template <typename T, typename P>
constexpr bool byteRangeContains(T rangeBase, size_t rangeSizeInBytes, P ptr) noexcept {
const auto begin = reinterpret_cast<uintptr_t>(rangeBase);
const auto end = begin + rangeSizeInBytes;
const auto p = reinterpret_cast<uintptr_t>(ptr);
return (p >= begin) && (p < end);
}
template <typename IntegerAddressType>
inline void *addrToPtr(IntegerAddressType addr) {
uintptr_t correctBitnessAddress = static_cast<uintptr_t>(addr);
void *ptrReturn = reinterpret_cast<void *>(correctBitnessAddress);
return ptrReturn;
}
struct PatchStoreOperation {
template <typename T>
void operator()(T *memory, T value) {
*memory = value;
}
};
inline void patchWithRequiredSize(void *memoryToBePatched, uint32_t patchSize, uint64_t patchValue) {
if (patchSize == sizeof(uint64_t)) {
if (isAligned<sizeof(uint64_t)>(memoryToBePatched)) {
uint64_t *curbeAddress = reinterpret_cast<uint64_t *>(memoryToBePatched);
PatchStoreOperation{}(curbeAddress, patchValue);
} else {
memcpy_s(memoryToBePatched, patchSize, &patchValue, sizeof(patchValue));
}
} else if (patchSize == sizeof(uint32_t)) {
uint32_t *curbeAddress = reinterpret_cast<uint32_t *>(memoryToBePatched);
PatchStoreOperation{}(curbeAddress, static_cast<uint32_t>(patchValue));
} else {
UNRECOVERABLE_IF(patchSize != 0);
}
}
inline uint64_t castToUint64(const void *address) {
return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(const_cast<void *>(address)));
}
inline uint32_t getLowPart(uint64_t value) {
return static_cast<uint32_t>(value & std::numeric_limits<uint32_t>::max());
}
inline uint32_t getHighPart(uint64_t value) {
return static_cast<uint32_t>(value >> 32);
}
|
