[libc] Add the implementation of the fflush function.

[sivachandra]

Summary

Note that the underlying flush implementation does not yet fully implement
the POSIX standard. It is complete with respect to the C standard
however. A future change will add the POSIX behavior. It should not affect
the implementation of the fflush function however as the POSIX behavior
will be added in a lower layer.

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     # libc.src.stdlib.abort
     libc.src.stdlib.atexit
     libc.src.stdlib.exit
     libc.src.stdlib.getenv
 
     # stdio.h entrypoints
     libc.src.stdio.fclose
     libc.src.stdio.flockfile
+    libc.src.stdio.fflush
     libc.src.stdio.fopen
     libc.src.stdio.fread
     libc.src.stdio.fread_unlocked
     libc.src.stdio.fseek
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite
     libc.src.stdio.fwrite_unlocked
 

libc/spec/stdc.td

HeaderSpec StdIO = HeaderSpec<
       [], // Enumerations
       [
           FunctionSpec<
               "fclose",
               RetValSpec<IntType>,
               [ArgSpec<FILEPtr>]
           >,
           FunctionSpec<
+              "fflush",
+              RetValSpec<IntType>,
+              [ArgSpec<FILEPtr>]
+          >,
+          FunctionSpec<
               "fopen",
               RetValSpec<FILEPtr>,
               [ArgSpec<ConstCharPtr>,
                ArgSpec<ConstCharPtr>]
           >,
           FunctionSpec<
               "fread",
               RetValSpec<SizeTType>,

libc/src/__support/File/file.cpp

if (prev_op == FileOp::WRITE && pos > 0) {
     size_t transferred_size = platform_write(this, buf, pos);
     if (transferred_size < pos) {
       err = true;
       return -1;
     }
     pos = 0;
     return platform_flush(this);
   }
+  // TODO: Add POSIX behavior for input streams.
   return 0;
 }
 
 int File::close() {
   {
     FileLock lock(this);
     if (prev_op == FileOp::WRITE && pos > 0) {
       size_t transferred_size = platform_write(this, buf, pos);

libc/src/stdio/CMakeLists.txt

HDRS
     fclose.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
+  fflush
+  SRCS
+    fflush.cpp
+  HDRS
+    fflush.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
   flockfile
   SRCS
     flockfile.cpp
   HDRS
     flockfile.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file

libc/src/stdio/fflush.h

+//===-- Implementation header of fflush -------------------------*- 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_STDIO_FFLUSH_H
+#define LLVM_LIBC_SRC_STDIO_FFLUSH_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int fflush(::FILE *stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_FFLUSH_H

libc/src/stdio/fflush.cpp

+//===-- Implementation of fflush ------------------------------------------===//
+//
+// 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/fflush.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, fflush, (::FILE * stream)) {
+  return reinterpret_cast<__llvm_libc::File *>(stream)->flush();
+}
+
+} // namespace __llvm_libc

libc/test/src/stdio/CMakeLists.txt

 add_libc_testsuite(libc_stdio_unittests)
 
 add_libc_unittest(
   fileop_test
   SUITE
     libc_stdio_unittests
   SRCS
     fileop_test.cpp
   DEPENDS
     libc.src.stdio.fclose
+    libc.src.stdio.fflush
     libc.src.stdio.fopen
     libc.src.stdio.fread
     libc.src.stdio.fseek
     libc.src.stdio.fwrite
 )
 
 add_libc_unittest(
   unlocked_fileop_test

libc/test/src/stdio/fileop_test.cpp

 //===-- Unittests for file operations like fopen, flcose etc --------------===//
 //
 // 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/fclose.h"
+#include "src/stdio/fflush.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fseek.h"
 #include "src/stdio/fwrite.h"
 #include "utils/UnitTest/Test.h"
 
 #include <stdio.h>
 
TEST(LlvmLibcStdio, SimpleOperations) {
   ASSERT_EQ(__llvm_libc::fread(data, 1, READ_SIZE - 1, file), READ_SIZE - 1);
   ASSERT_STREQ(data, "0987");
   ASSERT_EQ(__llvm_libc::fseek(file, -5, SEEK_CUR), 0);
   ASSERT_EQ(__llvm_libc::fread(data, 1, READ_SIZE - 1, file), READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
 
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
 }
+
+TEST(LlvmLibcFILE, FFlushTest) {
+  constexpr char FILENAME[] = "testdata/fflush.test";
+  ::FILE *file = __llvm_libc::fopen(FILENAME, "w+");
+  ASSERT_FALSE(file == nullptr);
+  constexpr char CONTENT[] = "1234567890987654321";
+  ASSERT_EQ(sizeof(CONTENT),
+            __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT), file));
+
+  // Flushing at this point should write the data to disk. So, we should be
+  // able to read it back.
+  ASSERT_EQ(0, __llvm_libc::fflush(file));
+
+  char data[sizeof(CONTENT)];
+  ASSERT_EQ(__llvm_libc::fseek(file, 0, SEEK_SET), 0);
+  ASSERT_EQ(__llvm_libc::fread(data, 1, sizeof(CONTENT), file),
+            sizeof(CONTENT));
+  ASSERT_STREQ(data, CONTENT);
+
+  ASSERT_EQ(__llvm_libc::fclose(file), 0);
+}