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
|
#ifndef NW4R_UT_ALGORITHM_H
#define NW4R_UT_ALGORITHM_H
#include "nw4r/types_nw4r.h"
namespace nw4r {
namespace ut {
namespace {
/**
* Value operations
*/
template <typename T>
inline T Max(T t1, T t2) {
return (t1 < t2) ? t2 : t1;
}
template <typename T>
inline T Min(T t1, T t2) {
return (t1 > t2) ? t2 : t1;
}
template <typename T>
inline T Clamp(T value, T min, T max) {
return value > max ? max : (value < min ? min : value);
}
template <typename T>
inline T Abs(T x) {
// Static cast needed to break abs optimization during instruction selection
return x < 0 ? static_cast<T>(-x) : static_cast<T>(x);
}
template <>
f32 inline Abs(register f32 x) {
register f32 ax;
// clang-format off
asm {
fabs ax, x
}
// clang-format on
return ax;
}
/**
* Bit operations
*/
template <typename T>
inline T BitExtract(T bits, int pos, int len) {
T mask = (1 << len) - 1;
return (bits >> pos) & mask;
}
template <typename T>
inline bool TestBit(T t, int pos) {
return BitExtract<T>(t, sizeof(T), pos);
}
/**
* Pointer operations
*/
inline u32 GetIntPtr(const void *pPtr) {
return reinterpret_cast<u32>(pPtr);
}
template <typename T>
inline const void *AddOffsetToPtr(const void *pBase, T offset) {
return reinterpret_cast<const void *>(GetIntPtr(pBase) + offset);
}
template <typename T>
inline void *AddOffsetToPtr(void *pBase, T offset) {
return reinterpret_cast<void *>(GetIntPtr(pBase) + offset);
}
inline s32 GetOffsetFromPtr(const void *pStart, const void *pEnd) {
return static_cast<s32>(GetIntPtr(pEnd) - GetIntPtr(pStart));
}
inline int ComparePtr(const void *pPtr1, const void *pPtr2) {
return static_cast<int>(GetIntPtr(pPtr1) - GetIntPtr(pPtr2));
}
/**
* Rounding
*/
template <typename T>
inline T RoundUp(T t, unsigned int alignment) {
return (alignment + t - 1) & ~(alignment - 1);
}
template <typename T>
inline void *RoundUp(T *pPtr, unsigned int alignment) {
u32 value = reinterpret_cast<u32>(pPtr);
u32 rounded = (alignment + value - 1) & ~(alignment - 1);
return reinterpret_cast<void *>(rounded);
}
template <typename T>
inline T RoundDown(T t, unsigned int alignment) {
return t & ~(alignment - 1);
}
template <typename T>
inline void *RoundDown(T *pPtr, unsigned int alignment) {
u32 value = reinterpret_cast<u32>(pPtr);
u32 rounded = value & ~(alignment - 1);
return reinterpret_cast<void *>(rounded);
}
} // namespace
} // namespace ut
} // namespace nw4r
#endif
|
