[libc] Rework the file handling for the GPU

[jhuber6]

Summary

The GPU has much tighter requirements for handling IO functions.
Previously we attempted to define the GPU as one of the platform files.
Using a common interface allowed us to easily define these functions
without much extra work. However, it became more clear that this was a
poor fit for the GPU. The file interface uses function pointers, which
prevented inlining and caused bad perfromance and resource usage on the
GPU. Further, using an actual FILE type rather than referring to it as
a host stub prevented us from usin files coming from the host on the GPU
device.

After talking with @sivachandra, the approach now is to simply define
GPU specific versions of the functions we intend to support. Also, we
are ignoring errno for the time being as it is unlikely we will ever
care about supporting it fully.

[jhuber6]

Fix namespace not being applied to the struct in handle entrypoints.

[sivachandra]

libc/config/gpu/entrypoints.txt

88

I suppose you want to add these back in a future patch?

libc/src/__support/File/CMakeLists.txt

1–2

In a different patch, you can may be get rid of the GPU mutex also?

libc/src/stdio/CMakeLists.txt

37

This can be confusing or misleading. For example, if GPU libc does not use the buffered file abstraction, why do we have these dependencies listed here? I think a structuring like this might be more natural and explicit:

# All all entrypoints with generic implementations will be listed with a "generic_" prefix in the name.
# For example:
add_entrypoint_object(
  generic_fclose
  ...
)

# The helper function chooses the OS specialization if available, else falls back to the generic version.
function(add_stdio_entrypoint_object name)
  if(TARGET libc.src.stdio.${LIBC_TARGET_OS}.${name})
    add_entrypoint_object(
      ${name}
      ALIAS
      DEPENDS
        .${LIBC_TARGET_OS}.${name}
    )
  elif(TARGET libc.src.stdio.generic_${name})
    add_entrypoint_object(
      ${name}
      ALIAS
      DEPENDS
        .generic_${entrypoint}
    )
endfunction(add_stdio_entrypoint_object)

add_stdio_entrypoint_object(fclose)
...

397

These should be listed - the actual global vars come from the deps.

[jhuber6]

libc/config/gpu/entrypoints.txt

88

Yes, wanted to keep this patch smaller.

libc/src/__support/File/CMakeLists.txt

1–2

We also use that for atexit.

libc/src/stdio/CMakeLists.txt

37

Alright, I can do that and then only change the files that are overridden currently.

397

So we'll need an if(LIBC_TARGET_ARCHITECTURE_IS_GPU) version since the file dependency isn't built.

[sivachandra]

libc/src/stdio/CMakeLists.txt

397

No, I mean't for the generic flavors.

add_entrypoint_object(
  generic_stdin
  ...
  DEPENDS
    libc.src.__support.File.file
    libc.src.__support.File.platform_file
)

...

add_stdio_entyrpoint_object(stdin)

[jhuber6]

Updating

[sivachandra]

libc/src/stdio/gpu/stderr.cpp

13

Missed this: Do you need these ifdef conditionals now?

[jhuber6]

Remove ifdefs

libc/src/stdio/gpu/stderr.cpp

13

You beat me fixing it by a few seconds.

[sivachandra]

libc/src/stdio/CMakeLists.txt

16

This line should be fixed to get the bots to green I think.

[jhuber6]

libc/src/stdio/CMakeLists.txt

16

Yep, already pushed a fix. Sorry about that, copy paste strikes again.

libc/config/gpu/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.stdlib.free
 
     # errno.h entrypoints
     libc.src.errno.errno
 
     # stdio.h entrypoints
     libc.src.stdio.puts
     libc.src.stdio.fputs
-    libc.src.stdio.fread
-    libc.src.stdio.fclose
-    libc.src.stdio.fopen
     libc.src.stdio.stdin
     libc.src.stdio.stdout
     libc.src.stdio.stderr
 
     # inttypes.h entrypoints
     libc.src.inttypes.imaxabs
     libc.src.inttypes.imaxdiv
     libc.src.inttypes.strtoimax

libc/docs/gpu/support.rst

 stdio.h
 --------
 
 =============  =========  ============
 Function Name  Available  RPC Required
 =============  =========  ============
 puts           |check|    |check|
 fputs          |check|    |check|
-fclose         |check|    |check|
-fopen          |check|    |check|
+fclose                    |check|
+fopen                     |check|
 =============  =========  ============

libc/src/__support/File/CMakeLists.txt

-if(NOT (TARGET libc.src.__support.threads.mutex))
+if(NOT (TARGET libc.src.__support.threads.mutex)
+   OR LIBC_TARGET_ARCHITECTURE_IS_GPU)
   # Not all platforms have a mutex implementation. If mutex is unvailable,
   # we just skip everything about files.
   return()
 endif()
 
 add_object_library(
   file
   SRCS

libc/src/__support/File/file.h

 
 // This a generic base class to encapsulate a platform independent file data
 // structure. Platform specific specializations should create a subclass as
 // suitable for their platform.
 class File {
 public:
   static constexpr size_t DEFAULT_BUFFER_SIZE = 1024;
 
-// Some platforms like the GPU build cannot support buffering due to extra
-// resource usage or hardware constraints. This function allows us to optimize
-// out the buffering portions of the code in the general implementation.
-#if defined(LIBC_TARGET_ARCH_IS_GPU)
-  static constexpr bool ENABLE_BUFFER = false;
-#else
-  static constexpr bool ENABLE_BUFFER = true;
-#endif
-
   using LockFunc = void(File *);
   using UnlockFunc = void(File *);
 
   using WriteFunc = FileIOResult(File *, const void *, size_t);
   using ReadFunc = FileIOResult(File *, void *, size_t);
   // The SeekFunc is expected to return the current offset of the external
   // file position indicator.
   using SeekFunc = ErrorOr<long>(File *, long, int);
public:
   constexpr File(WriteFunc *wf, ReadFunc *rf, SeekFunc *sf, CloseFunc *cf,
                  uint8_t *buffer, size_t buffer_size, int buffer_mode,
                  bool owned, ModeFlags modeflags)
       : platform_write(wf), platform_read(rf), platform_seek(sf),
         platform_close(cf), mutex(false, false, false), ungetc_buf(0),
         buf(buffer), bufsize(buffer_size), bufmode(buffer_mode), own_buf(owned),
         mode(modeflags), pos(0), prev_op(FileOp::NONE), read_limit(0),
         eof(false), err(false) {
-    if constexpr (ENABLE_BUFFER)
-      adjust_buf();
   }
 
   // Buffered write of |len| bytes from |data| without the file lock.
   FileIOResult write_unlocked(const void *data, size_t len);
 
   // Buffered write of |len| bytes from |data| under the file lock.
   FileIOResult write(const void *data, size_t len) {
     FileLock l(this);

libc/src/__support/File/file.cpp

 FileIOResult File::write_unlocked(const void *data, size_t len) {
   if (!write_allowed()) {
     err = true;
     return {0, EBADF};
   }
 
   prev_op = FileOp::WRITE;
 
-  if (!ENABLE_BUFFER || bufmode == _IONBF) { // unbuffered.
+  if (bufmode == _IONBF) { // unbuffered.
     size_t ret_val =
         write_unlocked_nbf(static_cast<const uint8_t *>(data), len);
     flush_unlocked();
     return ret_val;
   } else if (bufmode == _IOFBF) { // fully buffered
     return write_unlocked_fbf(static_cast<const uint8_t *>(data), len);
   } else /*if (bufmode == _IOLBF) */ { // line buffered
     return write_unlocked_lbf(static_cast<const uint8_t *>(data), len);
   }
 }
 
 FileIOResult File::write_unlocked_nbf(const uint8_t *data, size_t len) {
-  if (ENABLE_BUFFER && pos > 0) { // If the buffer is not empty
+  if (pos > 0) { // If the buffer is not empty
     // Flush the buffer
     const size_t write_size = pos;
     auto write_result = platform_write(this, buf, write_size);
     pos = 0; // Buffer is now empty so reset pos to the beginning.
     // If less bytes were written than expected, then an error occurred.
     if (write_result < write_size) {
       err = true;
       // No bytes from data were written, so return 0.
if (prev_op == FileOp::READ)
     return platform_offset - (read_limit - pos);
   else if (prev_op == FileOp::WRITE)
     return platform_offset + pos;
   else
     return platform_offset;
 }
 
 int File::flush_unlocked() {
-  if constexpr (!ENABLE_BUFFER)
-    return 0;
-
   if (prev_op == FileOp::WRITE && pos > 0) {
     auto buf_result = platform_write(this, buf, pos);
     if (buf_result.has_error() || buf_result.value < pos) {
       err = true;
       return buf_result.error;
     }
     pos = 0;
   }
   // TODO: Add POSIX behavior for input streams.
   return 0;
 }
 
 int File::set_buffer(void *buffer, size_t size, int buffer_mode) {
-  if constexpr (!ENABLE_BUFFER)
-    return EINVAL;
-
   // We do not need to lock the file as this method should be called before
   // other operations are performed on the file.
   if (buffer != nullptr && size == 0)
     return EINVAL;
 
   switch (buffer_mode) {
   case _IOFBF:
   case _IOLBF:

libc/src/__support/File/gpu/CMakeLists.txt

-add_object_library(
-  gpu_file
-  SRCS
-    file.cpp
-  DEPENDS
-    libc.include.stdio
-    libc.src.errno.errno
-    libc.src.__support.CPP.new
-    libc.src.__support.error_or
-    libc.src.__support.File.file
-)
-
-add_object_library(
-  gpu_dir
-  SRCS
-    dir.cpp
-  DEPENDS
-    libc.src.errno.errno
-    libc.src.__support.error_or
-    libc.src.__support.File.dir
-)

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

-//===--- GPU specialization of the File data structure --------------------===//
-//
-// 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/__support/File/file.h"
-
-#include "src/__support/RPC/rpc_client.h"
-#include "src/errno/libc_errno.h" // For error macros
-#include "src/string/string_utils.h"
-
-#include <stdio.h>
-
-namespace __llvm_libc {
-
-namespace {
-
-FileIOResult write_func(File *, const void *, size_t);
-FileIOResult read_func(File *, void *, size_t);
-int close_func(File *);
-
-} // namespace
-
-class GPUFile : public File {
-  uintptr_t file;
-
-public:
-  constexpr GPUFile(uintptr_t file, File::ModeFlags modeflags)
-      : File(&write_func, &read_func, nullptr, &close_func, nullptr, 0, _IONBF,
-             false, modeflags),
-        file(file) {}
-
-  uintptr_t get_file() const { return file; }
-};
-
-namespace {
-
-int write_to_stdout(const void *data, size_t size) {
-  uint64_t ret = 0;
-  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDOUT>();
-  port.send_n(data, size);
-  port.recv([&](rpc::Buffer *buffer) {
-    ret = reinterpret_cast<uint64_t *>(buffer->data)[0];
-  });
-  port.close();
-  return ret;
-}
-
-int write_to_stderr(const void *data, size_t size) {
-  uint64_t ret = 0;
-  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDERR>();
-  port.send_n(data, size);
-  port.recv([&](rpc::Buffer *buffer) {
-    ret = reinterpret_cast<uint64_t *>(buffer->data)[0];
-  });
-  port.close();
-  return ret;
-}
-
-int write_to_stream(uintptr_t file, const void *data, size_t size) {
-  uint64_t ret = 0;
-  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<uint64_t *>(buffer->data)[0];
-  });
-  port.close();
-  return ret;
-}
-
-FileIOResult write_func(File *f, const void *data, size_t size) {
-  auto *gpu_file = reinterpret_cast<GPUFile *>(f);
-  int ret = 0;
-  if (gpu_file == stdout)
-    ret = write_to_stdout(data, size);
-  else if (gpu_file == stderr)
-    ret = write_to_stderr(data, size);
-  else
-    ret = write_to_stream(gpu_file->get_file(), data, size);
-  if (ret < 0)
-    return {0, -ret};
-  return ret;
-}
-
-int read_from_stdin(void *buf, size_t size) {
-  int ret = 0;
-  uint64_t recv_size;
-  rpc::Client::Port port = rpc::client.open<RPC_READ_FROM_STDIN>();
-  port.send([=](rpc::Buffer *buffer) { buffer->data[0] = size; });
-  port.recv_n(&buf, &recv_size, [&](uint64_t) { return buf; });
-  port.recv([&](rpc::Buffer *buffer) { ret = buffer->data[0]; });
-  port.close();
-  return ret;
-}
-
-int read_from_stream(uintptr_t file, void *buf, size_t size) {
-  int ret = 0;
-  uint64_t recv_size;
-  // TODO: For large sizes being written to a pointer in global memory, we
-  // should be able to initiate a H2D memcpy via a separate RPC call at high
-  // bandwidth.
-  rpc::Client::Port port = rpc::client.open<RPC_READ_FROM_STREAM>();
-  port.send([=](rpc::Buffer *buffer) {
-    buffer->data[0] = size;
-    buffer->data[1] = file;
-  });
-  port.recv_n(&buf, &recv_size, [&](uint64_t) { return buf; });
-  port.recv([&](rpc::Buffer *buffer) { ret = buffer->data[0]; });
-  port.close();
-  return ret;
-}
-
-FileIOResult read_func(File *f, void *buf, size_t size) {
-  auto *gpu_file = reinterpret_cast<GPUFile *>(f);
-  int ret = 0;
-  if (gpu_file == stdin)
-    ret = read_from_stdin(buf, size);
-  else
-    ret = read_from_stream(gpu_file->get_file(), buf, size);
-  if (ret < 0)
-    return {0, -ret};
-  return ret;
-}
-
-int close_func(File *file) {
-  int ret = 0;
-  GPUFile *gpu_file = reinterpret_cast<GPUFile *>(file);
-  rpc::Client::Port port = rpc::client.open<RPC_CLOSE_FILE>();
-  port.send_and_recv(
-      [=](rpc::Buffer *buffer) { buffer->data[0] = gpu_file->get_file(); },
-      [&](rpc::Buffer *buffer) { ret = buffer->data[0]; });
-  port.close();
-
-  return ret;
-}
-
-} // namespace
-
-void *ptr;
-
-ErrorOr<File *> openfile(const char *path, const char *mode) {
-  auto modeflags = File::mode_flags(mode);
-  if (modeflags == 0)
-    return Error(EINVAL);
-
-  uintptr_t file;
-  rpc::Client::Port port = rpc::client.open<RPC_OPEN_FILE>();
-  port.send_n(path, internal::string_length(path) + 1);
-  port.send_and_recv(
-      [=](rpc::Buffer *buffer) {
-        inline_memcpy(buffer->data, mode, internal::string_length(mode) + 1);
-      },
-      [&](rpc::Buffer *buffer) { file = buffer->data[0]; });
-  port.close();
-
-  static GPUFile gpu_file(0, 0);
-  gpu_file = GPUFile(file, modeflags);
-  return &gpu_file;
-}
-
-static GPUFile StdIn(0UL, File::ModeFlags(File::OpenMode::READ));
-File *stdin = &StdIn;
-
-static GPUFile StdOut(0UL, File::ModeFlags(File::OpenMode::APPEND));
-File *stdout = &StdOut;
-
-static GPUFile StdErr(0UL, File::ModeFlags(File::OpenMode::APPEND));
-File *stderr = &StdErr;
-
-} // namespace __llvm_libc
-
-// Provide the external defintitions of the standard IO streams.
-extern "C" {
-FILE *stdin = reinterpret_cast<FILE *>(&__llvm_libc::StdIn);
-FILE *stderr = reinterpret_cast<FILE *>(&__llvm_libc::StdErr);
-FILE *stdout = reinterpret_cast<FILE *>(&__llvm_libc::StdOut);
-}

libc/src/stdio/CMakeLists.txt

+# Helper function that creates an alias if a target specific implementation
+# exists, otherwise it uses a generic one.
+function(add_stdio_entrypoint_object name)
+  if(TARGET libc.src.stdio.${LIBC_TARGET_OS}.${name})
+    add_entrypoint_object(
+      ${name}
+      ALIAS
+      DEPENDS
+        .${LIBC_TARGET_OS}.${name}
+    )
+  elseif(TARGET libc.src.stdio.generic_${name})
+    add_entrypoint_object(
+      ${name}
+      ALIAS
+      DEPENDS
+        .${LIBC_TARGET_OS}.${name}
+    )
+  endif()
+endfunction(add_stdio_entrypoint_object)
+
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
 endif()
 
 add_subdirectory(printf_core)
 add_subdirectory(scanf_core)
 
 add_entrypoint_object(
   fopen
   SRCS
     fopen.cpp
   HDRS
     fopen.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fclose
   SRCS
     fclose.cpp
   HDRS
     fclose.h
add_entrypoint_object(
   DEPENDS
     libc.src.errno.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
-  fputs
+  generic_fputs
   SRCS
     fputs.cpp
   HDRS
     fputs.h
   DEPENDS
     libc.src.errno.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 
 add_entrypoint_object(
-  puts
+  generic_puts
   SRCS
     puts.cpp
   HDRS
     puts.h
   DEPENDS
     libc.src.errno.errno
     libc.include.stdio
     libc.src.__support.File.file
HDRS
     fopencookie.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.CPP.new
     libc.src.__support.File.file
 )
 
 add_entrypoint_object(
-  stdin
+  generic_stdin
   SRCS
     stdin.cpp
   HDRS
     stdin.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
-  stdout
+  generic_stdout
   SRCS
     stdout.cpp
   HDRS
     stdout.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
-  stderr
+  generic_stderr
   SRCS
     stderr.cpp
   HDRS
     stderr.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file

 )
 
 add_entrypoint_object(
   remove
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.remove
 )
+
+# These entrypoints have multiple potential implementations.
+add_stdio_entrypoint_object(puts)
+add_stdio_entrypoint_object(fputs)
+add_stdio_entrypoint_object(stdin)
+add_stdio_entrypoint_object(stdout)
+add_stdio_entrypoint_object(stderr)

libc/src/stdio/gpu/CMakeLists.txt

+add_header_library(
+  gpu_file
+  HDRS
+    file.h
+  DEPENDS
+    libc.src.__support.common
+    libc.src.__support.CPP.string_view
+    libc.src.__support.RPC.rpc_client
+)
+
+add_entrypoint_object(
+  puts
+  SRCS
+    puts.cpp
+  HDRS
+    ../puts.h
+  DEPENDS
+    libc.include.stdio
+    .gpu_file
+)
+
+add_entrypoint_object(
+  fputs
+  SRCS
+    fputs.cpp
+  HDRS
+    ../fputs.h
+  DEPENDS
+    libc.include.stdio
+    .gpu_file
+)
+
+add_entrypoint_object(
+  stdin
+  SRCS
+    stdin.cpp
+  HDRS
+    ../stdin.h
+  DEPENDS
+    libc.include.stdio
+)
+
+add_entrypoint_object(
+  stdout
+  SRCS
+    stdout.cpp
+  HDRS
+    ../stdout.h
+  DEPENDS
+    libc.include.stdio
+)
+
+add_entrypoint_object(
+  stderr
+  SRCS
+    stderr.cpp
+  HDRS
+    ../stderr.h
+  DEPENDS
+    libc.include.stdio
+)

libc/src/stdio/gpu/file.h

+//===--- GPU helper functions--------------------===//
+//
+// 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/__support/RPC/rpc_client.h"
+#include "src/string/string_utils.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+namespace file {
+
+LIBC_INLINE uint64_t write_to_stdout(const void *data, size_t size) {
+  uint64_t ret = 0;
+  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDOUT>();
+  port.send_n(data, size);
+  port.recv([&](rpc::Buffer *buffer) {
+    ret = reinterpret_cast<uint64_t *>(buffer->data)[0];
+  });
+  port.close();
+  return ret;
+}
+
+LIBC_INLINE uint64_t write_to_stderr(const void *data, size_t size) {
+  uint64_t ret = 0;
+  rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDERR>();
+  port.send_n(data, size);
+  port.recv([&](rpc::Buffer *buffer) {
+    ret = reinterpret_cast<uint64_t *>(buffer->data)[0];
+  });
+  port.close();
+  return ret;
+}
+
+LIBC_INLINE uint64_t write_to_stream(uintptr_t file, const void *data,
+                                     size_t size) {
+  uint64_t ret = 0;
+  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<uint64_t *>(buffer->data)[0];
+  });
+  port.close();
+  return ret;
+}
+
+LIBC_INLINE uint64_t write(FILE *f, const void *data, size_t size) {
+  if (f == stdout)
+    return write_to_stdout(data, size);
+  else if (f == stderr)
+    return write_to_stderr(data, size);
+  else
+    return write_to_stream(reinterpret_cast<uintptr_t>(f), data, size);
+}
+
+LIBC_INLINE uint64_t read_from_stdin(void *buf, size_t size) {
+  uint64_t ret = 0;
+  uint64_t recv_size;
+  rpc::Client::Port port = rpc::client.open<RPC_READ_FROM_STDIN>();
+  port.send([=](rpc::Buffer *buffer) { buffer->data[0] = size; });
+  port.recv_n(&buf, &recv_size, [&](uint64_t) { return buf; });
+  port.recv([&](rpc::Buffer *buffer) { ret = buffer->data[0]; });
+  port.close();
+  return ret;
+}
+
+LIBC_INLINE uint64_t read_from_stream(uintptr_t file, void *buf, size_t size) {
+  uint64_t ret = 0;
+  uint64_t recv_size;
+  rpc::Client::Port port = rpc::client.open<RPC_READ_FROM_STREAM>();
+  port.send([=](rpc::Buffer *buffer) {
+    buffer->data[0] = size;
+    buffer->data[1] = file;
+  });
+  port.recv_n(&buf, &recv_size, [&](uint64_t) { return buf; });
+  port.recv([&](rpc::Buffer *buffer) { ret = buffer->data[0]; });
+  port.close();
+  return ret;
+}
+
+} // namespace file
+} // namespace __llvm_libc

libc/src/stdio/gpu/fputs.cpp

+//===-- GPU Implementation of fputs ---------------------------------------===//
+//
+// 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/stdio/fputs.h"
+#include "src/__support/CPP/string_view.h"
+#include "src/errno/libc_errno.h"
+#include "src/stdio/gpu/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, fputs,
+                   (const char *__restrict str, ::FILE *__restrict stream)) {
+  cpp::string_view str_view(str);
+  auto written = file::write(stream, str, str_view.size());
+  if (written != str_view.size())
+    return EOF;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/stdio/gpu/puts.cpp

+//===-- GPU Implementation of puts ----------------------------------------===//
+//
+// 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/stdio/puts.h"
+#include "src/__support/CPP/string_view.h"
+#include "src/errno/libc_errno.h"
+#include "src/stdio/gpu/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, puts, (const char *__restrict str)) {
+  cpp::string_view str_view(str);
+  auto written = file::write(stdout, str, str_view.size());
+  if (written != str_view.size())
+    return EOF;
+  written = file::write(stdout, "\n", 1);
+  if (written != 1)
+    return EOF;
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/stdio/gpu/stderr.cpp

-//===--- GPU implementation of the Dir helpers ----------------------------===//
+//===-- Definition of the global stderr object ----------------------------===//
 //
 // 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/__support/File/dir.h"
+#include <stdio.h>
 
-#include "src/__support/error_or.h"
-
-namespace __llvm_libc {} // namespace __llvm_libc
+namespace __llvm_libc {
+static struct {
+} stub;
+FILE *stderr = reinterpret_cast<FILE *>(&stub);
+} // namespace __llvm_libc
+extern "C" FILE *stderr = reinterpret_cast<FILE *>(&__llvm_libc::stub);

libc/src/stdio/gpu/stdin.cpp

-//===--- GPU implementation of the Dir helpers ----------------------------===//
+//===-- Definition of the global stdin object -----------------------------===//
 //
 // 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/__support/File/dir.h"
+#include <stdio.h>
 
-#include "src/__support/error_or.h"
-
-namespace __llvm_libc {} // namespace __llvm_libc
+namespace __llvm_libc {
+static struct {
+} stub;
+FILE *stdin = reinterpret_cast<FILE *>(&stub);
+} // namespace __llvm_libc
+extern "C" FILE *stdin = reinterpret_cast<FILE *>(&__llvm_libc::stub);

libc/src/stdio/gpu/stdout.cpp

-//===--- GPU implementation of the Dir helpers ----------------------------===//
+//===-- Definition of the global stdout object ----------------------------===//
 //
 // 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/__support/File/dir.h"
+#include <stdio.h>
 
-#include "src/__support/error_or.h"
-
-namespace __llvm_libc {} // namespace __llvm_libc
+namespace __llvm_libc {
+static struct {
+} stub;
+FILE *stdout = reinterpret_cast<FILE *>(&stub);
+} // namespace __llvm_libc
+extern "C" FILE *stdout = reinterpret_cast<FILE *>(&__llvm_libc::stub);

libc/test/src/stdio/CMakeLists.txt

 add_libc_test(
   fputs_test
   SUITE
     libc_stdio_unittests
   SRCS
     fputs_test.cpp
   DEPENDS
     libc.src.stdio.fputs
+    libc.src.stdio.stdout
+    libc.src.stdio.stderr
 )
 
 add_libc_test(
   fopen_test
   SUITE
     libc_stdio_unittests
   SRCS
     fopen_test.cpp