[libc][memfunctions] Explicit error when platform in not supported

[JonChesterfield]

I think this has broken amdgpu. Why are author and reviewer the same name?

Broke CI two hours ago. https://lab.llvm.org/staging/#/builders/247/builds/3194

[gchatelet]

In D155597#4510934, @JonChesterfield wrote:

I think this has broken amdgpu. Why are author and reviewer the same name?

Normally I would commit such small (and presumably benign) changes without review but I've been told that all libc patches should go through Phabricator.
I made sure to run the patch on all our CI machines before submitting (ARM, aarch64, riscv and x86).

Broke CI two hours ago. https://lab.llvm.org/staging/#/builders/247/builds/3194

Thx for the heads up.
I'm monitoring https://lab.llvm.org/buildbot/#/grid?tag=libc for breakage when I submit such patches, it seems that openmp-offload-libc-amdgpu-runtime is not tagged with libc. If you are the maintainer of the build bot can you make sure it is tagged with libc?

I still want to make it explicitly visible what platform we support for memory functions. Do I understand correctly that AMDGPU will receive trivial implementations as defined in https://github.com/llvm/llvm-project/blob/main/libc/src/string/memory_utils/generic/byte_per_byte.h?

Thx.

[gchatelet]

@JonChesterfield I will reland this patch with an explicit support for AMDGPU. I'll add you as a reviewer when it's ready.

[gchatelet]

• Add explicit support for AMDGPU

[JonChesterfield]

I think Joseph is running that bot. My understanding is that amdgpu would like faster implementations but hasn't written them yet, so the generic one will do for now

[JonChesterfield]

Change looks good here. I'm away from desk, asked Joseph if he's available to check it builds. Suggest you land it in a few minutes if he doesn't say anything and the linked bot can serve as the sanity check. Thanks!

[jhuber6]

Works on my machine, thanks.

[gchatelet]

Thx for checking the patch!
@jhuber6 any chance you can add the libc tag to the bot? That would be helpful.

Also I'd be happy to add GPU specific implementations but I'm not too familiar with the specifics of these architectures. Let me know if you already have optimized versions on your side and I can try to integrate them.

[jhuber6]

In D155597#4513903, @gchatelet wrote:

Thx for checking the patch!
@jhuber6 any chance you can add the libc tag to the bot? That would be helpful.

Also I'd be happy to add GPU specific implementations but I'm not too familiar with the specifics of these architectures. Let me know if you already have optimized versions on your side and I can try to integrate them.

According to @arsenm, for the GPU these should just map to intrinsics, but I don't have a good view of the benefits of having something impolemented in source, vs leaving it to the backend.

[arsenm]

In D155597#4514709, @jhuber6 wrote:

In D155597#4513903, @gchatelet wrote:

Thx for checking the patch!
@jhuber6 any chance you can add the libc tag to the bot? That would be helpful.

Also I'd be happy to add GPU specific implementations but I'm not too familiar with the specifics of these architectures. Let me know if you already have optimized versions on your side and I can try to integrate them.

According to @arsenm, for the GPU these should just map to intrinsics, but I don't have a good view of the benefits of having something impolemented in source, vs leaving it to the backend.

These should just emit llvm.{memcpy|memmove|memset}. If you implemented it source ideally we would pattern recognize it into the intrinsics

libc/src/string/memory_utils/bcmp_implementations.h

 #include "src/string/memory_utils/x86_64/bcmp_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_BCMP inline_bcmp_x86
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #include "src/string/memory_utils/aarch64/bcmp_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_BCMP inline_bcmp_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
 #include "src/string/memory_utils/riscv/bcmp_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_BCMP inline_bcmp_riscv
-#else
-// We may want to error instead of defaulting to suboptimal implementation.
+#elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_BCMP inline_bcmp_byte_per_byte
+#else
+#error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE int inline_bcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(LIBC_SRC_STRING_MEMORY_UTILS_BCMP(
       reinterpret_cast<CPtr>(p1), reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #undef LIBC_SRC_STRING_MEMORY_UTILS_BCMP
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcmp_implementations.h

 #include "src/string/memory_utils/x86_64/memcmp_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP inline_memcmp_x86
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #include "src/string/memory_utils/aarch64/memcmp_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP inline_memcmp_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
 #include "src/string/memory_utils/riscv/memcmp_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP inline_memcmp_riscv
-#else
-// We may want to error instead of defaulting to suboptimal implementation.
+#elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP inline_memcmp_byte_per_byte
+#else
+#error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE int inline_memcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP(
       reinterpret_cast<CPtr>(p1), reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #undef LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcpy_implementations.h

 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY                                    \
   inline_memcpy_x86_maybe_interpose_repmovsb
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #include "src/string/memory_utils/aarch64/memcpy_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY inline_memcpy_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
 #include "src/string/memory_utils/riscv/memcpy_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY inline_memcpy_riscv
-#else
-// We may want to error instead of defaulting to suboptimal implementation.
+#elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY inline_memcpy_byte_per_byte
+#else
+#error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE void inline_memcpy(void *__restrict dst, const void *__restrict src,
                                size_t count) {
   LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY(reinterpret_cast<Ptr>(dst),
                                       reinterpret_cast<CPtr>(src), count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memmove_implementations.h

 #include "src/string/memory_utils/x86_64/memmove_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_x86
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #include "src/string/memory_utils/aarch64/memmove_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
 #include "src/string/memory_utils/riscv/memmove_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_riscv
-#else
-// We may want to error instead of defaulting to suboptimal implementation.
+#elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_byte_per_byte
+#else
+#error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE void inline_memmove(void *dst, const void *src, size_t count) {
   LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE(reinterpret_cast<Ptr>(dst),
                                        reinterpret_cast<CPtr>(src), count);
 }
 
 } // namespace __llvm_libc
 
 #endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */

libc/src/string/memory_utils/memset_implementations.h

 #include "src/string/memory_utils/x86_64/memset_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMSET inline_memset_x86
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #include "src/string/memory_utils/aarch64/memset_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMSET inline_memset_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
 #include "src/string/memory_utils/riscv/memset_implementations.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMSET inline_memset_riscv
-#else
-// We may want to error instead of defaulting to suboptimal implementation.
+#elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMSET inline_memset_byte_per_byte
+#else
+#error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE static void inline_memset(void *dst, uint8_t value, size_t count) {
   LIBC_SRC_STRING_MEMORY_UTILS_MEMSET(reinterpret_cast<Ptr>(dst), value, count);
 }
 
 } // namespace __llvm_libc
 
 #undef LIBC_SRC_STRING_MEMORY_UTILS_MEMSET
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H