[libc] Export GPU extensions to `libc` for external use

[jhuber6]

Summary

The GPU port of the LLVM C library needs to export a few extensions to
the interface such that users can interface with it. This patch adds the
necessary logic to define a GPU extension. Currently, this only exports
a rpc_reset_client function. This allows us to use the server in
D147054 to set up the RPC interface outside of libc.

Depends on https://reviews.llvm.org/D147054

[jhuber6]

@sivachandra This isn't exporting the function rpc_reset_client in the header. Where does that need to be added?

[sivachandra]

libc/config/gpu/entrypoints.txt

95

The CMake machinery will look for an entrypoint named reset but more importantly, libc-hdrgen will also look for a function named reset in a spec. Since you do not have a function with name reset, I would have expected libc-hdrgen to error out somewhere. To solve your problem, rename the entrypoint target to match the function name.

libc/src/gpu/CMakeLists.txt

3

We have to match the target name with the entrypoint name.

[jhuber6]

Change entrypoint to rpc_reset. Still doesn't seem to be appearing in the output function lists.

[jhuber6]

Exports the function now. Trying ot get it to provide the Opcodes with the enum handling, but it's not showing up.

[sivachandra]

In D152283#4401585, @jhuber6 wrote:

Exports the function now. Trying ot get it to provide the Opcodes with the enum handling, but it's not showing up.

I suppose you want to add something like:

enum rpc_opcode {
  ...
};

If yes, you will have to add a type header like any of these: https://github.com/llvm/llvm-project/tree/main/libc/include/llvm-libc-types

[sivachandra]

libc/spec/gpu_ext.td

19

This is good if you want to add type less enumerations. You will also have to add the list in api.td like this: https://github.com/llvm/llvm-project/blob/main/libc/config/linux/api.td#L149.

[jhuber6]

Add enumerations for the opcodes and switch over to using the generated header / types file.

[sivachandra]

OK for the file structuring.

libc/include/llvm-libc-types/rpc_opcodes_t.h

13

This would be C++ - is that OK?

[jhuber6]

libc/include/llvm-libc-types/rpc_opcodes_t.h

13

I thought that this was legal C, https://godbolt.org/z/aonTa87Me.

[sivachandra]

libc/include/llvm-libc-types/rpc_opcodes_t.h

13

I thought that this was legal C, https://godbolt.org/z/aonTa87Me.

Using gcc and passing -std=c99 -pedantic shows you this warning:

warning: ISO C does not support specifying 'enum' underlying types before C2X [-Wpedantic]x86-64 gcc (trunk) #1

So, may be OK because it does go through fine with c23. But, we want LLVM's libc to be C11 compliant. Up to you for the GPU side though.

[jhuber6]

libc/include/llvm-libc-types/rpc_opcodes_t.h

13

I see, well the size is relevant so we could probably do one of those OPCODE_LAST = 0xFFFF things instead.

libc/config/gpu/api.td

 include "config/public_api.td"
 
 include "spec/stdc.td"
+include "spec/gpu_ext.td"
 
 def StringAPI : PublicAPI<"string.h"> {
   let Types = ["size_t"];
 }
 
 def StdlibAPI : PublicAPI<"stdlib.h"> {
   let Types = [
     "size_t",

libc/config/gpu/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.errno.errno
 
     # stdio.h entrypoints
     libc.src.stdio.puts
     libc.src.stdio.fputs
     libc.src.stdio.stdin
     libc.src.stdio.stdout
     libc.src.stdio.stderr
+
+    # gpu/rpc.h entrypoints
+    libc.src.gpu.rpc_reset
 )
 
 set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.fma
     libc.src.math.fmaf
     libc.src.math.sin
     libc.src.math.round
     libc.src.math.roundf
     libc.src.math.roundl
 )
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/config/gpu/headers.txt

 set(TARGET_PUBLIC_HEADERS
     libc.include.ctype
     libc.include.string
     libc.include.math
     libc.include.fenv
     libc.include.errno
     libc.include.stdlib
     libc.include.stdio
+
+    # Header for RPC extensions
+    libc.include.gpu_rpc
 )

libc/include/CMakeLists.txt

add_gen_header(
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-macros.wchar_macros
     .llvm-libc-types.size_t
     .llvm-libc-types.wint_t
     .llvm-libc-types.wchar_t
 )
 
+if(LIBC_TARGET_ARCHITECTURE_IS_GPU)
+  file(MAKE_DIRECTORY "gpu")
+
+  add_gen_header(
+    gpu_rpc
+    DEF_FILE gpu/rpc.h.def
+    GEN_HDR gpu/rpc.h
+    DEPENDS
+      .llvm_libc_common_h
+      .llvm-libc-types.rpc_opcodes_t
+  )
+endif()
+
 if(NOT LLVM_LIBC_FULL_BUILD)
   # We don't install headers in non-fullbuild mode.
   return()
 endif()
 
 function(get_all_install_header_targets out_var)
   set(all_deps ${ARGN})
   foreach(target IN LISTS ARGN)

libc/include/gpu/rpc.h.def

+//===-- GPU header rpc.h --------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_GPU_RPC_H
+#define LLVM_LIBC_GPU_RPC_H
+
+#include <__llvm-libc-common.h>
+
+#include <llvm-libc-types/rpc_opcodes_t.h>
+
+%%public_api()
+
+#endif // LLVM_LIBC_GPU_RPC_H

libc/include/llvm-libc-types/CMakeLists.txt

 add_header(speed_t HDR speed_t.h)
 add_header(tcflag_t HDR tcflag_t.h)
 add_header(struct_termios HDR struct_termios.h DEPENDS .cc_t .speed_t .tcflag_t)
 add_header(__getoptargv_t HDR __getoptargv_t.h)
 add_header(wchar_t HDR wchar_t.h)
 add_header(wint_t HDR wint_t.h)
 add_header(sa_family_t HDR sa_family_t.h)
 add_header(struct_sockaddr HDR struct_sockaddr.h)
+add_header(rpc_opcodes_t HDR rpc_opcodes_t.h)

libc/include/llvm-libc-types/rpc_opcodes_t.h

+//===-- Definition of RPC opcodes -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_RPC_OPCODE_H__
+#define __LLVM_LIBC_TYPES_RPC_OPCODE_H__
+
+typedef enum : unsigned short {
+  RPC_NOOP = 0,
+  RPC_EXIT = 1,
+  RPC_WRITE_TO_STDOUT = 2,
+  RPC_WRITE_TO_STDERR = 3,
+  RPC_WRITE_TO_STREAM = 4,
+  RPC_MALLOC = 5,
+  RPC_FREE = 6,
+  RPC_TEST_INCREMENT = 7,
+  RPC_TEST_INTERFACE = 8,
+  RPC_TEST_STREAM = 9,
+} rpc_opcode_t;
+
+#endif // __LLVM_LIBC_TYPES_RPC_OPCODE_H__

libc/spec/gpu_ext.td

+def GPUExtensions : StandardSpec<"GPUExtensions"> {
+  HeaderSpec RPC = HeaderSpec<
+    "gpu/rpc.h",
+    [], // Macros
+    [], // Types
+    [], // Enumerations
+    [
+        FunctionSpec<
+            "rpc_reset",
+            RetValSpec<VoidType>,
+            [ArgSpec<UnsignedIntType>, ArgSpec<VoidPtr>]
+        >,
+    ]
+  >;
+  let Headers = [
+    RPC,
+  ];
+}

libc/src/CMakeLists.txt

if(${LIBC_TARGET_OS} STREQUAL "linux")
   add_subdirectory(fcntl)
   add_subdirectory(pthread)
   add_subdirectory(sched)
   add_subdirectory(sys)
   add_subdirectory(termios)
   add_subdirectory(unistd)
 endif()
 
+if(${LIBC_TARGET_OS} STREQUAL "gpu")
+  add_subdirectory(gpu)
+endif()
+
 if(NOT LLVM_LIBC_FULL_BUILD)
   return()
 endif()
 
 add_subdirectory(assert)
 add_subdirectory(network)
 add_subdirectory(setjmp)
 add_subdirectory(signal)
 add_subdirectory(spawn)
 add_subdirectory(threads)
 add_subdirectory(time)

libc/src/__support/File/gpu/file.cpp

public:
 
   uintptr_t get_file() const { return file; }
 };
 
 namespace {
 
 int write_to_stdout(const void *data, size_t size) {
   int ret = 0;
-  rpc::Client::Port port = rpc::client.open<rpc::WRITE_TO_STDOUT>();
+  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDOUT>();
   port.send_n(data, size);
   port.recv([&](rpc::Buffer *buffer) {
     ret = reinterpret_cast<int *>(buffer->data)[0];
   });
   port.close();
   return ret;
 }
 
 int write_to_stderr(const void *data, size_t size) {
   int ret = 0;
-  rpc::Client::Port port = rpc::client.open<rpc::WRITE_TO_STDERR>();
+  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDERR>();
   port.send_n(data, size);
   port.recv([&](rpc::Buffer *buffer) {
     ret = reinterpret_cast<int *>(buffer->data)[0];
   });
   port.close();
   return ret;
 }
 
 int write_to_stream(uintptr_t file, const void *data, size_t size) {
   int ret = 0;
-  rpc::Client::Port port = rpc::client.open<rpc::WRITE_TO_STREAM>();
+  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STREAM>();
   port.send([&](rpc::Buffer *buffer) {
     reinterpret_cast<uintptr_t *>(buffer->data)[0] = file;
   });
   port.send_n(data, size);
   port.recv([&](rpc::Buffer *buffer) {
     ret = reinterpret_cast<int *>(buffer->data)[0];
   });
   port.close();

libc/src/__support/OSUtil/gpu/io.cpp

 
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/RPC/rpc_client.h"
 #include "src/string/memory_utils/memcpy_implementations.h"
 
 namespace __llvm_libc {
 
 void write_to_stderr(cpp::string_view msg) {
-  rpc::Client::Port port = rpc::client.open<rpc::WRITE_TO_STDERR>();
+  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDERR>();
   port.send_n(msg.data(), msg.size());
   port.recv([](rpc::Buffer *) { /* void */ });
   port.close();
 }
 
 } // namespace __llvm_libc

libc/src/__support/OSUtil/gpu/quick_exit.cpp

 #include "quick_exit.h"
 
 #include "src/__support/RPC/rpc_client.h"
 #include "src/__support/macros/properties/architectures.h"
 
 namespace __llvm_libc {
 
 void quick_exit(int status) {
-  rpc::Client::Port port = rpc::client.open<rpc::EXIT>();
+  rpc::Client::Port port = rpc::client.open<RPC_EXIT>();
   port.send([&](rpc::Buffer *buffer) {
     reinterpret_cast<uint32_t *>(buffer->data)[0] = status;
   });
   port.close();
 
 #if defined(LIBC_TARGET_ARCH_IS_NVPTX)
   LIBC_INLINE_ASM("exit;" ::: "memory");
 #elif defined(LIBC_TARGET_ARCH_IS_AMDGPU)

libc/src/__support/RPC/CMakeLists.txt

 
 add_object_library(
   rpc_client
   SRCS
     rpc_client.cpp
   HDRS
     rpc_client.h
   DEPENDS
+    libc.include.gpu_rpc
     libc.src.__support.GPU.utils
     .rpc
 )

libc/src/__support/RPC/rpc.h

 #include "src/__support/GPU/utils.h"
 #include "src/string/memory_utils/memcpy_implementations.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace rpc {
 
-/// A list of opcodes that we use to invoke certain actions on the server.
-enum Opcode : uint16_t {
-  NOOP = 0,
-  EXIT = 1,
-  WRITE_TO_STDOUT = 2,
-  WRITE_TO_STDERR = 3,
-  WRITE_TO_STREAM = 4,
-  MALLOC = 5,
-  FREE = 6,
-  TEST_INCREMENT = 7,
-  TEST_INTERFACE = 8,
-  TEST_STREAM = 9,
-};
-
 /// A fixed size channel used to communicate between the RPC client and server.
 struct Buffer {
   uint64_t data[8];
 };
 static_assert(sizeof(Buffer) == 64, "Buffer size mismatch");
 
 /// The information associated with a packet. This indicates which operations to
 /// perform and which threads are active in the slots.

libc/src/__support/RPC/rpc_client.h

 //===-- Shared memory RPC client instantiation ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_RPC_RPC_CLIENT_H
 #define LLVM_LIBC_SRC_SUPPORT_RPC_RPC_CLIENT_H
 
 #include "rpc.h"
 
+#include <gpu/rpc.h>
+
 namespace __llvm_libc {
 namespace rpc {
 
 /// The libc client instance used to communicate with the server.
 extern Client client;
 
 } // namespace rpc
 } // namespace __llvm_libc
 
 #endif

libc/src/gpu/CMakeLists.txt

+add_entrypoint_object(
+  rpc_reset
+  SRCS
+    rpc_reset.cpp
+  HDRS
+    rpc_reset.h
+  DEPENDS
+    libc.src.__support.RPC.rpc_client
+    libc.src.__support.GPU.utils
+)

libc/src/gpu/rpc_reset.h

-//===-- Shared memory RPC client instantiation ------------------*- C++ -*-===//
+//===-- Implementation header for RPC functions -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_SUPPORT_RPC_RPC_CLIENT_H
-#define LLVM_LIBC_SRC_SUPPORT_RPC_RPC_CLIENT_H
-
-#include "rpc.h"
+#ifndef LLVM_LIBC_SRC_GPU_RPC_H
+#define LLVM_LIBC_SRC_GPU_RPC_H
 
 namespace __llvm_libc {
-namespace rpc {
 
-/// The libc client instance used to communicate with the server.
-extern Client client;
+void rpc_reset(unsigned int num_ports, void *buffer);
 
-} // namespace rpc
 } // namespace __llvm_libc
 
-#endif
+#endif // LLVM_LIBC_SRC_GPU_RPC_H

libc/src/gpu/rpc_reset.cpp

+//===---------- GPU implementation of the external RPC functionion --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/gpu/rpc_reset.h"
+
+#include "src/__support/GPU/utils.h"
+#include "src/__support/RPC/rpc_client.h"
+#include "src/__support/common.h"
+
+namespace __llvm_libc {
+
+// This is the external interface to initialize the RPC client with the
+// shared buffer.
+LLVM_LIBC_FUNCTION(void, rpc_reset,
+                   (unsigned int num_ports, void *rpc_shared_buffer)) {
+  __llvm_libc::rpc::client.reset(num_ports, __llvm_libc::gpu::get_lane_size(),
+                                 rpc_shared_buffer);
+}
+
+} // namespace __llvm_libc

libc/src/stdlib/gpu/free.cpp

 //===-- GPU Implementation of free ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdlib/free.h"
 #include "src/__support/RPC/rpc_client.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void, free, (void *ptr)) {
-  rpc::Client::Port port = rpc::client.open<rpc::FREE>();
+  rpc::Client::Port port = rpc::client.open<RPC_FREE>();
   port.send([=](rpc::Buffer *buffer) {
     buffer->data[0] = reinterpret_cast<uintptr_t>(ptr);
   });
   port.close();
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/gpu/malloc.cpp

 //===-- GPU Implementation of malloc --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdlib/malloc.h"
 #include "src/__support/RPC/rpc_client.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, malloc, (size_t size)) {
   void *ptr = nullptr;
-  rpc::Client::Port port = rpc::client.open<rpc::MALLOC>();
+  rpc::Client::Port port = rpc::client.open<RPC_MALLOC>();
   port.send_and_recv([=](rpc::Buffer *buffer) { buffer->data[0] = size; },
                      [&](rpc::Buffer *buffer) {
                        ptr = reinterpret_cast<void *>(buffer->data[0]);
                      });
   port.close();
   return ptr;
 }
 
 } // namespace __llvm_libc

libc/test/integration/startup/gpu/rpc_interface_test.cpp

 #include "test/IntegrationTest/test.h"
 
 using namespace __llvm_libc;
 
 // Test to ensure that we can use aribtrary combinations of sends and recieves
 // as long as they are mirrored.
 static void test_interface(bool end_with_send) {
   uint64_t cnt = 0;
-  rpc::Client::Port port = rpc::client.open<rpc::TEST_INTERFACE>();
+  rpc::Client::Port port = rpc::client.open<RPC_TEST_INTERFACE>();
   port.send([&](rpc::Buffer *buffer) { buffer->data[0] = end_with_send; });
   port.send([&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
   port.recv([&](rpc::Buffer *buffer) { cnt = buffer->data[0]; });
   port.send([&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
   port.recv([&](rpc::Buffer *buffer) { cnt = buffer->data[0]; });
   port.send([&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
   port.send([&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
   port.recv([&](rpc::Buffer *buffer) { cnt = buffer->data[0]; });

libc/test/integration/startup/gpu/rpc_stream_test.cpp

static const char str[] =
       "ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxy";
   uint64_t send_size = sizeof(str);
   void *send_ptr = malloc(send_size);
   void *recv_ptr;
   uint64_t recv_size;
 
   inline_memcpy(send_ptr, str, send_size);
   ASSERT_TRUE(inline_memcmp(send_ptr, str, send_size) == 0 && "Data mismatch");
-  rpc::Client::Port port = rpc::client.open<rpc::TEST_STREAM>();
+  rpc::Client::Port port = rpc::client.open<RPC_TEST_STREAM>();
   port.send_n(send_ptr, send_size);
   port.recv_n(&recv_ptr, &recv_size,
               [](uint64_t size) { return malloc(size); });
   port.close();
   ASSERT_TRUE(inline_memcmp(recv_ptr, str, recv_size) == 0 && "Data mismatch");
   ASSERT_TRUE(recv_size == send_size && "Data size mismatch");
 
   free(send_ptr);
static void test_divergent() {
   uint64_t offset =
       (gpu::get_thread_id() + gpu::get_num_threads() * gpu::get_block_id()) %
       128;
   void *recv_ptr;
   uint64_t recv_size;
   inline_memcpy(buffer, &data[offset], offset);
   ASSERT_TRUE(inline_memcmp(buffer, &data[offset], offset) == 0 &&
               "Data mismatch");
-  rpc::Client::Port port = rpc::client.open<rpc::TEST_STREAM>();
+  rpc::Client::Port port = rpc::client.open<RPC_TEST_STREAM>();
   port.send_n(buffer, offset);
   inline_memset(buffer, offset, 0);
   port.recv_n(&recv_ptr, &recv_size, [&](uint64_t) { return buffer; });
   port.close();
 
   ASSERT_TRUE(inline_memcmp(recv_ptr, &data[offset], recv_size) == 0 &&
               "Data mismatch");
   ASSERT_TRUE(recv_size == offset && "Data size mismatch");
 }
 
 TEST_MAIN(int argc, char **argv, char **envp) {
   test_stream();
   test_divergent();
 
   return 0;
 }

libc/test/integration/startup/gpu/rpc_test.cpp

 
 using namespace __llvm_libc;
 
 static void test_add_simple() {
   uint32_t num_additions =
       10 + 10 * gpu::get_thread_id() + 10 * gpu::get_block_id();
   uint64_t cnt = 0;
   for (uint32_t i = 0; i < num_additions; ++i) {
-    rpc::Client::Port port = rpc::client.open<rpc::TEST_INCREMENT>();
+    rpc::Client::Port port = rpc::client.open<RPC_TEST_INCREMENT>();
     port.send_and_recv(
         [=](rpc::Buffer *buffer) {
           reinterpret_cast<uint64_t *>(buffer->data)[0] = cnt;
         },
         [&](rpc::Buffer *buffer) {
           cnt = reinterpret_cast<uint64_t *>(buffer->data)[0];
         });
     port.close();
   }
   ASSERT_TRUE(cnt == num_additions && "Incorrect sum");
 }
 
 // Test to ensure that the RPC mechanism doesn't hang on divergence.
 static void test_noop(uint8_t data) {
-  rpc::Client::Port port = rpc::client.open<rpc::NOOP>();
+  rpc::Client::Port port = rpc::client.open<RPC_NOOP>();
   port.send([=](rpc::Buffer *buffer) { buffer->data[0] = data; });
   port.close();
 }
 
 TEST_MAIN(int argc, char **argv, char **envp) {
   test_add_simple();
 
   if (gpu::get_thread_id() % 2)
     test_noop(1);
   else
     test_noop(2);
 
   return 0;
 }

libc/utils/gpu/loader/CMakeLists.txt

 add_library(gpu_loader OBJECT Main.cpp)
 target_include_directories(gpu_loader PUBLIC
   ${CMAKE_CURRENT_SOURCE_DIR}
+  ${LIBC_SOURCE_DIR}/include
   ${LIBC_SOURCE_DIR}
 )
 
 find_package(hsa-runtime64 QUIET 1.2.0 HINTS ${CMAKE_INSTALL_PREFIX} PATHS /opt/rocm)
 if(hsa-runtime64_FOUND)
   add_subdirectory(amdgpu)
 else()
   message(STATUS "Skipping HSA loader for gpu target, no HSA was detected")

libc/utils/gpu/server/CMakeLists.txt

 add_library(rpc_server STATIC Server.cpp)
 
 # Include the RPC implemenation from libc.
 add_dependencies(rpc_server libc.src.__support.RPC.rpc)
 target_include_directories(rpc_server PRIVATE ${LIBC_SOURCE_DIR})
+# TODO: This is for the opcodes, we will copy the file here when installed.
+target_include_directories(rpc_server PUBLIC ${LIBC_SOURCE_DIR}/include)
 target_include_directories(rpc_server PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

libc/utils/gpu/server/Server.h

 //===-- Shared memory RPC server instantiation ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_UTILS_GPU_SERVER_RPC_SERVER_H
 #define LLVM_LIBC_UTILS_GPU_SERVER_RPC_SERVER_H
 
 #include <stdint.h>
 
+#include "llvm-libc-types/rpc_opcodes_t.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /// The maxium number of ports that can be opened for any server.
 const uint64_t RPC_MAXIMUM_PORT_COUNT = 64;
 
-// TODO: Move these to a header exported by the C library.
-typedef enum : uint16_t {
-  RPC_NOOP = 0,
-  RPC_EXIT = 1,
-  RPC_WRITE_TO_STDOUT = 2,
-  RPC_WRITE_TO_STDERR = 3,
-  RPC_WRITE_TO_STREAM = 4,
-  RPC_MALLOC = 5,
-  RPC_FREE = 6,
-} rpc_opcode_t;
-
 /// status codes.
 typedef enum {
   RPC_STATUS_SUCCESS = 0x0,
   RPC_STATUS_ERROR = 0x1000,
   RPC_STATUS_OUT_OF_RANGE = 0x1001,
   RPC_STATUS_UNHANDLED_OPCODE = 0x1002,
 } rpc_status_t;
 

libc/utils/gpu/server/Server.cpp

if (device_id >= state->num_devices)
     return RPC_STATUS_OUT_OF_RANGE;
 
   for (;;) {
     auto port = state->devices[device_id].server.try_open();
     if (!port)
       return RPC_STATUS_SUCCESS;
 
     switch (port->get_opcode()) {
-    case rpc::Opcode::WRITE_TO_STREAM:
-    case rpc::Opcode::WRITE_TO_STDERR:
-    case rpc::Opcode::WRITE_TO_STDOUT: {
+    case RPC_WRITE_TO_STREAM:
+    case RPC_WRITE_TO_STDERR:
+    case RPC_WRITE_TO_STDOUT: {
       uint64_t sizes[rpc::MAX_LANE_SIZE] = {0};
       void *strs[rpc::MAX_LANE_SIZE] = {nullptr};
       FILE *files[rpc::MAX_LANE_SIZE] = {nullptr};
-      if (port->get_opcode() == rpc::Opcode::WRITE_TO_STREAM)
+      if (port->get_opcode() == RPC_WRITE_TO_STREAM)
         port->recv([&](rpc::Buffer *buffer, uint32_t id) {
           files[id] = reinterpret_cast<FILE *>(buffer->data[0]);
         });
       port->recv_n(strs, sizes, [&](uint64_t size) { return new char[size]; });
       port->send([&](rpc::Buffer *buffer, uint32_t id) {
-        FILE *file = port->get_opcode() == rpc::Opcode::WRITE_TO_STDOUT
-                         ? stdout
-                         : (port->get_opcode() == rpc::Opcode::WRITE_TO_STDERR
-                                ? stderr
+        FILE *file =
+            port->get_opcode() == RPC_WRITE_TO_STDOUT
+                : (port->get_opcode() == RPC_WRITE_TO_STDERR ? stderr
                                                              : files[id]);
         int ret = fwrite(strs[id], sizes[id], 1, file);
         reinterpret_cast<int *>(buffer->data)[0] = ret >= 0 ? sizes[id] : ret;
       });
       for (uint64_t i = 0; i < rpc::MAX_LANE_SIZE; ++i) {
         if (strs[i])
           delete[] reinterpret_cast<uint8_t *>(strs[i]);
       }
       break;
     }
-    case rpc::Opcode::EXIT: {
+    case RPC_EXIT: {
       port->recv([](rpc::Buffer *buffer) {
         exit(reinterpret_cast<uint32_t *>(buffer->data)[0]);
       });
       break;
     }
     // TODO: Move handling of these  test cases to the loader implementation.
-    case rpc::Opcode::TEST_INCREMENT: {
+    case RPC_TEST_INCREMENT: {
       port->recv_and_send([](rpc::Buffer *buffer) {
         reinterpret_cast<uint64_t *>(buffer->data)[0] += 1;
       });
       break;
     }
-    case rpc::Opcode::TEST_INTERFACE: {
+    case RPC_TEST_INTERFACE: {
       uint64_t cnt = 0;
       bool end_with_recv;
       port->recv([&](rpc::Buffer *buffer) { end_with_recv = buffer->data[0]; });
       port->recv([&](rpc::Buffer *buffer) { cnt = buffer->data[0]; });
       port->send([&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
       port->recv([&](rpc::Buffer *buffer) { cnt = buffer->data[0]; });
       port->send([&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
       port->recv([&](rpc::Buffer *buffer) { cnt = buffer->data[0]; });
       port->recv([&](rpc::Buffer *buffer) { cnt = buffer->data[0]; });
       port->send([&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
       port->send([&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
       if (end_with_recv)
         port->recv([&](rpc::Buffer *buffer) { cnt = buffer->data[0]; });
       else
         port->send(
             [&](rpc::Buffer *buffer) { buffer->data[0] = cnt = cnt + 1; });
       break;
     }
-    case rpc::Opcode::TEST_STREAM: {
+    case RPC_TEST_STREAM: {
       uint64_t sizes[rpc::MAX_LANE_SIZE] = {0};
       void *dst[rpc::MAX_LANE_SIZE] = {nullptr};
       port->recv_n(dst, sizes, [](uint64_t size) { return new char[size]; });
       port->send_n(dst, sizes);
       for (uint64_t i = 0; i < rpc::MAX_LANE_SIZE; ++i) {
         if (dst[i])
           delete[] reinterpret_cast<uint8_t *>(dst[i]);
       }
       break;
     }
-    case rpc::Opcode::NOOP: {
+    case RPC_NOOP: {
       port->recv([](rpc::Buffer *buffer) {});
       break;
     }
     default: {
       auto handler = state->devices[device_id].callbacks.find(
           static_cast<rpc_opcode_t>(port->get_opcode()));
 
       // We error out on an unhandled opcode.