[libc][NFC] Cleanup the RPC server implementation prior to installing

[jhuber6]

Summary

This does some simple cleanup prior to landing the patch to install
these.

libc/utils/gpu/server/Server.h

 /// status codes.
 typedef enum {
   RPC_STATUS_SUCCESS = 0x0,
   RPC_STATUS_CONTINUE = 0x1,
   RPC_STATUS_ERROR = 0x1000,
   RPC_STATUS_OUT_OF_RANGE = 0x1001,
   RPC_STATUS_UNHANDLED_OPCODE = 0x1002,
   RPC_STATUS_INVALID_LANE_SIZE = 0x1003,
+  RPC_STATUS_NOT_INITIALIZED = 0x1004,
 } rpc_status_t;
 
 /// A struct containing an opaque handle to an RPC port. This is what allows the
 /// server to communicate with the client.
 typedef struct rpc_port_s {
   uint64_t handle;
   uint32_t lane_size;
 } rpc_port_t;

libc/utils/gpu/server/Server.cpp

 //===-- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Server.h"
 
 #include "src/__support/RPC/rpc.h"
 #include <atomic>
 #include <cstdio>
+#include <cstring>
 #include <memory>
 #include <mutex>
 #include <unordered_map>
 #include <variant>
 #include <vector>
 
 using namespace __llvm_libc;
 
case RPC_WRITE_TO_STDOUT: {
       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_WRITE_TO_STDOUT
                 ? 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;
+        ret = ret >= 0 ? sizes[id] : ret;
+        std::memcpy(buffer->data, &ret, sizeof(int));
       });
       for (uint64_t i = 0; i < rpc::MAX_LANE_SIZE; ++i) {
         if (strs[i])
           delete[] reinterpret_cast<uint8_t *>(strs[i]);
       }
       break;
     }
     case RPC_EXIT: {
       port->recv([](rpc::Buffer *buffer) {
-        exit(reinterpret_cast<uint32_t *>(buffer->data)[0]);
+        int status = 0;
+        std::memcpy(&status, buffer->data, sizeof(int));
+        exit(status);
       });
       break;
     }
     // TODO: Move handling of these  test cases to the loader implementation.
     case RPC_TEST_INCREMENT: {
       port->recv_and_send([](rpc::Buffer *buffer) {
         reinterpret_cast<uint64_t *>(buffer->data)[0] += 1;
       });
case RPC_TEST_STREAM: {
       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_NOOP: {
-      port->recv([](rpc::Buffer *buffer) {});
+      port->recv([](rpc::Buffer *) {});
       break;
     }
     default: {
       auto handler =
           callbacks.find(static_cast<rpc_opcode_t>(port->get_opcode()));
 
       // We error out on an unhandled opcode.
       if (handler == callbacks.end())
if (state->reference_count-- == 1)
     delete state;
 
   return RPC_STATUS_SUCCESS;
 }
 
 rpc_status_t rpc_server_init(uint32_t device_id, uint64_t num_ports,
                              uint32_t lane_size, rpc_alloc_ty alloc,
                              void *data) {
+  if (!state)
+    return RPC_STATUS_NOT_INITIALIZED;
   if (device_id >= state->num_devices)
     return RPC_STATUS_OUT_OF_RANGE;
 
   if (!state->devices[device_id]) {
     switch (lane_size) {
     case 1:
       state->devices[device_id] =
           std::make_unique<Device>(std::make_unique<rpc::Server<1>>());
rpc_status_t rpc_server_init(uint32_t device_id, uint64_t num_ports,
 
   state->devices[device_id]->server.reset(num_ports, buffer);
 
   return RPC_STATUS_SUCCESS;
 }
 
 rpc_status_t rpc_server_shutdown(uint32_t device_id, rpc_free_ty dealloc,
                                  void *data) {
+  if (!state)
+    return RPC_STATUS_NOT_INITIALIZED;
   if (device_id >= state->num_devices)
     return RPC_STATUS_OUT_OF_RANGE;
   if (!state->devices[device_id])
     return RPC_STATUS_ERROR;
 
   dealloc(rpc_get_buffer(device_id), data);
   if (state->devices[device_id])
     state->devices[device_id].release();
 
   return RPC_STATUS_SUCCESS;
 }
 
 rpc_status_t rpc_handle_server(uint32_t device_id) {
+  if (!state)
+    return RPC_STATUS_NOT_INITIALIZED;
   if (device_id >= state->num_devices)
     return RPC_STATUS_OUT_OF_RANGE;
   if (!state->devices[device_id])
     return RPC_STATUS_ERROR;
 
   for (;;) {
     auto &device = *state->devices[device_id];
     rpc_status_t status =
         device.server.handle_server(device.callbacks, device.callback_data);
     if (status != RPC_STATUS_CONTINUE)
       return status;
   }
 }
 
 rpc_status_t rpc_register_callback(uint32_t device_id, rpc_opcode_t opcode,
                                    rpc_opcode_callback_ty callback,
                                    void *data) {
+  if (!state)
+    return RPC_STATUS_NOT_INITIALIZED;
   if (device_id >= state->num_devices)
     return RPC_STATUS_OUT_OF_RANGE;
   if (!state->devices[device_id])
     return RPC_STATUS_ERROR;
 
   state->devices[device_id]->callbacks[opcode] = callback;
   state->devices[device_id]->callback_data[opcode] = data;
   return RPC_STATUS_SUCCESS;
 }
 
 void *rpc_get_buffer(uint32_t device_id) {
+  if (!state)
+    return nullptr;
   if (device_id >= state->num_devices)
     return nullptr;
   if (!state->devices[device_id])
     return nullptr;
   return state->devices[device_id]->server.get_buffer_start();
 }
 
 void rpc_recv_and_send(rpc_port_t ref, rpc_port_callback_ty callback,