Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-10-07 10:54:01 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

[libc] Fix the GPU build for the hashing support (#73799)

Browse Source 
Summary:
For reasons unknown to me, this function is undefined only on the GPU
build if you use `uintptr_t` but not `uint64_t` directly. This patch
makes an ifdef to use this directly for the GPU build to fix the bots.
This commit is contained in:
Joseph Huber 2023-11-29 09:04:36 -06:00 committed by GitHub
parent 244389ad17
commit 0468867c98
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 17 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
libc/src/__support/HashTable/CMakeLists.txt
View File

@ -5,6 +5,7 @@ add_header_library(
FLAGS
PREFER_GENERIC
DEPENDS
libc.src.__support.common
libc.src.__support.bit
libc.src.__support.macros.properties.cpu_features
)

23
libc/src/__support/HashTable/generic/bitmask_impl.inc
View File

@ -6,38 +6,47 @@
//
//===----------------------------------------------------------------------===//
#include "src/__support/common.h"
#include "src/__support/endian.h"
namespace LIBC_NAMESPACE {
namespace internal {
// GPU architectures are 64-bit but use 32-bit general purpose registers.
#ifdef LIBC_TARGET_ARCH_IS_GPU
using bitmask_t = uint32_t;
#else
using bitmask_t = uintptr_t;
#endif
// Helper function to spread a byte across the whole word.
// Accumutively, the procedure looks like:
// byte = 0x00000000000000ff
// byte | (byte << 8) = 0x000000000000ffff
// byte | (byte << 16) = 0x00000000ffffffff
// byte | (byte << 32) = 0xffffffffffffffff
LIBC_INLINE constexpr uintptr_t repeat_byte(uintptr_t byte) {
LIBC_INLINE constexpr bitmask_t repeat_byte(bitmask_t byte) {
size_t shift_amount = 8;
while (shift_amount < sizeof(uintptr_t) * 8) {
while (shift_amount < sizeof(bitmask_t) * 8) {
byte |= byte << shift_amount;
shift_amount <<= 1;
}
return byte;
}
using BitMask = BitMaskAdaptor<uintptr_t, repeat_byte(0x80), 0x8ull>;
using BitMask = BitMaskAdaptor<bitmask_t, repeat_byte(0x80), 0x8ull>;
using IteratableBitMask = IteratableBitMaskAdaptor<BitMask>;
struct Group {
uintptr_t data;
bitmask_t data;
// Load a group of control words from an arbitary address.
LIBC_INLINE static Group load(const void *__restrict addr) {
union {
uintptr_t value;
char bytes[sizeof(uintptr_t)];
bitmask_t value;
char bytes[sizeof(bitmask_t)];
} data;
for (size_t i = 0; i < sizeof(uintptr_t); ++i)
for (size_t i = 0; i < sizeof(bitmask_t); ++i)
data.bytes[i] = static_cast<const char *>(addr)[i];
return {data.value};
}