[libc][rpc] Treat pointers as arrays consistently

[JonChesterfield]

Summary

Noticed in passing. Either way compiles.

[jhuber6]

This is done inside D149598, might make the change easier to read?

[JonChesterfield]

Anything that gets the red/green noise down tends to help

libc/src/__support/RPC/rpc.h

 
 /// Attempts to open a port to use as the client. The client can only open a
 /// port if we find an index that is in a valid sending state. That is, there
 /// are send operations pending that haven't been serviced on this port. Each
 /// port instance uses an associated \p opcode to tell the server what to do.
 LIBC_INLINE cpp::optional<Client::Port> Client::try_open(uint16_t opcode) {
   constexpr uint64_t index = 0;
   // Attempt to acquire the lock on this index.
-  if (lock->fetch_or(1, cpp::MemoryOrder::RELAXED))
+  if (lock[index].fetch_or(1, cpp::MemoryOrder::RELAXED))
     return cpp::nullopt;
 
   // The mailbox state must be read with the lock held.
   atomic_thread_fence(cpp::MemoryOrder::ACQUIRE);
 
   uint32_t in = load_inbox(index);
-  uint32_t out = outbox->load(cpp::MemoryOrder::RELAXED);
+  uint32_t out = outbox[index].load(cpp::MemoryOrder::RELAXED);
 
   // Once we acquire the index we need to check if we are in a valid sending
   // state.
   if (!can_send_data(in, out)) {
-    lock->store(0, cpp::MemoryOrder::RELAXED);
+    lock[index].store(0, cpp::MemoryOrder::RELAXED);
     return cpp::nullopt;
   }
 
   buffer->opcode = opcode;
   return Port(*this, index, out);
 }
 
 LIBC_INLINE Client::Port Client::open(uint16_t opcode) {
   for (;;) {
     if (cpp::optional<Client::Port> p = try_open(opcode))
       return p.value();
     sleep_briefly();
   }
 }
 
 /// Attempts to open a port to use as the server. The server can only open a
 /// port if it has a pending receive operation
 LIBC_INLINE cpp::optional<Server::Port> Server::try_open() {
   constexpr uint64_t index = 0;
   uint32_t in = load_inbox(index);
-  uint32_t out = outbox->load(cpp::MemoryOrder::RELAXED);
+  uint32_t out = outbox[index].load(cpp::MemoryOrder::RELAXED);
 
   // The server is passive, if there is no work pending don't bother
   // opening a port.
   if (!can_recv_data(in, out))
     return cpp::nullopt;
 
   // Attempt to acquire the lock on this index.
-  if (lock->fetch_or(1, cpp::MemoryOrder::RELAXED))
+  if (lock[index].fetch_or(1, cpp::MemoryOrder::RELAXED))
     return cpp::nullopt;
 
   // The mailbox state must be read with the lock held.
   atomic_thread_fence(cpp::MemoryOrder::ACQUIRE);
 
   in = load_inbox(index);
-  out = outbox->load(cpp::MemoryOrder::RELAXED);
+  out = outbox[index].load(cpp::MemoryOrder::RELAXED);
 
   if (!can_recv_data(in, out)) {
-    lock->store(0, cpp::MemoryOrder::RELAXED);
+    lock[index].store(0, cpp::MemoryOrder::RELAXED);
     return cpp::nullopt;
   }
 
   return Port(*this, index, out);
 }
 
 LIBC_INLINE Server::Port Server::open() {
   for (;;) {