[libc] Add implementations of ftell.

[sivachandra]

Sorry, this is WiP and not complete - not sure why I did an arc diff instead of saving the work with git commit. I will update and ping when ready.

[sivachandra]

Uploading a complete implementation of ftell and ftello.

[sivachandra]

The patch is now complete.

[sivachandra]

Remove ftello - we will add it when we are more prepared to deal with
off_t variances.

[lntue]

libc/config/linux/api.td

160 ↗

(On Diff #473476)

Is off_t being used any where in the patch? Or just definition to be included in the headers?

[sivachandra]

Remove off_t from spec and config for stdio.h as it is not used anymore.

[sivachandra]

libc/config/linux/api.td

160 ↗

(On Diff #473476)

Ah yes! Removed now, from here and from spec/posix.td.

[michaelrj]

LGTM

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.stdio.fflush
     libc.src.stdio.fopen
     libc.src.stdio.fputc
     libc.src.stdio.fputs
     libc.src.stdio.fopencookie
     libc.src.stdio.fread
     libc.src.stdio.fread_unlocked
     libc.src.stdio.fseek
+    libc.src.stdio.ftell
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite
     libc.src.stdio.fwrite_unlocked
     libc.src.stdio.fprintf
     libc.src.stdio.printf
     libc.src.stdio.putc
     libc.src.stdio.putchar
     libc.src.stdio.puts

libc/include/CMakeLists.txt

add_gen_header(
   DEF_FILE stdio.h.def
   GEN_HDR stdio.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-macros.file_seek_macros
     .llvm-libc-macros.stdio_macros
     .llvm-libc-types.cookie_io_functions_t
     .llvm-libc-types.FILE
+    .llvm-libc-types.off_t
     .llvm-libc-types.size_t
 )
 
 add_gen_header(
   stdlib
   DEF_FILE stdlib.h.def
   GEN_HDR stdlib.h
   DEPENDS

libc/spec/stdc.td

HeaderSpec StdIO = HeaderSpec<
           >,
           FunctionSpec<
               "fputc",
               RetValSpec<IntType>,
               [ArgSpec<IntType>,
                ArgSpec<FILEPtr>]
           >,
           FunctionSpec<
+              "ftell",
+              RetValSpec<LongType>,
+              [ArgSpec<FILEPtr>]
+          >,
+          FunctionSpec<
               "putc",
               RetValSpec<IntType>,
               [ArgSpec<IntType>,
                ArgSpec<FILEPtr>]
           >,
           FunctionSpec<
               "putchar",
               RetValSpec<IntType>,

libc/src/__support/File/file.h

 public:
   static constexpr size_t DEFAULT_BUFFER_SIZE = 1024;
 
   using LockFunc = void(File *);
   using UnlockFunc = void(File *);
 
   using WriteFunc = size_t(File *, const void *, size_t);
   using ReadFunc = size_t(File *, void *, size_t);
-  using SeekFunc = int(File *, long, int);
+  // The SeekFunc is expected to return the current offset of the external
+  // file position indicator.
+  using SeekFunc = long(File *, long, int);
   using CloseFunc = int(File *);
   using FlushFunc = int(File *);
 
   using ModeFlags = uint32_t;
 
   // The three different types of flags below are to be used with '|' operator.
   // Their values correspond to mutually exclusive bits in a 32-bit unsigned
   // integer value. A flag set can include both READ and WRITE if the file
public:
   // Buffered read of |len| bytes into |data| under the file lock.
   size_t read(void *data, size_t len) {
     FileLock l(this);
     return read_unlocked(data, len);
   }
 
   int seek(long offset, int whence);
 
+  long tell();
+
   // If buffer has data written to it, flush it out. Does nothing if the
   // buffer is currently being used as a read buffer.
   int flush() {
     FileLock lock(this);
     return flush_unlocked();
   }
 
   int flush_unlocked();
constexpr void adjust_buf() {
     }
   }
 };
 
 // The implementaiton of this function is provided by the platfrom_file
 // library.
 File *openfile(const char *path, const char *mode);
 
+// The platform_file library should implement it if it relevant for that
+// platform.
+int get_fileno(File *f);
+
 extern File *stdin;
 extern File *stdout;
 extern File *stderr;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H

libc/src/__support/File/file.cpp

if (prev_op == FileOp::WRITE && pos > 0) {
     // function. Note that read_limit >= pos is always true.
     offset -= (read_limit - pos);
   }
   pos = read_limit = 0;
   prev_op = FileOp::SEEK;
   // Reset the eof flag as a seek might move the file positon to some place
   // readable.
   eof = false;
-  return platform_seek(this, offset, whence);
+  long platform_pos = platform_seek(this, offset, whence);
+  if (platform_pos >= 0)
+    return 0;
+  else
+    return -1;
+}
+
+long File::tell() {
+  FileLock lock(this);
+  long platform_offset;
+  if (eof)
+    platform_offset = platform_seek(this, 0, SEEK_END);
+  else
+    platform_offset = platform_seek(this, 0, SEEK_CUR);
+  if (platform_offset < 0)
+    return -1;
+  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 (prev_op == FileOp::WRITE && pos > 0) {
     size_t transferred_size = platform_write(this, buf, pos);
     if (transferred_size < pos) {
       err = true;
       return -1;

libc/src/__support/File/linux_file.cpp

 #include <sys/syscall.h> // For syscall numbers
 
 namespace __llvm_libc {
 
 namespace {
 
 size_t write_func(File *, const void *, size_t);
 size_t read_func(File *, void *, size_t);
-int seek_func(File *, long, int);
+long seek_func(File *, long, int);
 int close_func(File *);
 int flush_func(File *);
 
 } // anonymous namespace
 
 class LinuxFile : public File {
   int fd;
 
size_t read_func(File *f, void *buf, size_t size) {
   long ret = __llvm_libc::syscall_impl(SYS_read, lf->get_fd(), buf, size);
   if (ret < 0) {
     errno = -ret;
     return 0;
   }
   return ret;
 }
 
-int seek_func(File *f, long offset, int whence) {
+long seek_func(File *f, long offset, int whence) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
+  long result;
 #ifdef SYS_lseek
   long ret = __llvm_libc::syscall_impl(SYS_lseek, lf->get_fd(), offset, whence);
+  result = ret;
 #elif defined(SYS__llseek)
   long result;
   long ret = __llvm_libc::syscall_impl(SYS__llseek, lf->get_fd(), offset >> 32,
                                        offset, &result, whence);
 #else
 #error "lseek and _llseek syscalls not available to perform a seek operation."
 #endif
 
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
-  return 0;
+  return result;
 }
 
 int close_func(File *f) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   long ret = __llvm_libc::syscall_impl(SYS_close, lf->get_fd());
   if (ret < 0) {
     errno = -ret;
     return -1;
#endif
 
   void *buffer = malloc(File::DEFAULT_BUFFER_SIZE);
   auto *file = reinterpret_cast<LinuxFile *>(malloc(sizeof(LinuxFile)));
   LinuxFile::init(file, fd, buffer, File::DEFAULT_BUFFER_SIZE, _IOFBF, true,
                   modeflags);
   return file;
 }
 
+int get_fileno(File *f) {
+  auto *lf = reinterpret_cast<LinuxFile *>(f);
+  return lf->get_fd();
+}
+
 constexpr size_t STDIN_BUFFER_SIZE = 512;
 char stdin_buffer[STDIN_BUFFER_SIZE];
 static LinuxFile StdIn(0, stdin_buffer, STDIN_BUFFER_SIZE, _IOFBF, false,
                        File::ModeFlags(File::OpenMode::READ));
 File *stdin = &StdIn;
 
 constexpr size_t STDOUT_BUFFER_SIZE = 1024;
 char stdout_buffer[STDOUT_BUFFER_SIZE];

libc/src/stdio/CMakeLists.txt

add_entrypoint_object(
   DEPENDS
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
     libc.src.__support.arg_list
     libc.src.stdio.printf_core.vfprintf_internal
 )
 
 add_entrypoint_object(
+  ftell
+  SRCS
+    ftell.cpp
+  HDRS
+    ftell.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
 )

libc/src/stdio/fopencookie.cpp

 size_t read_func(File *f, void *data, size_t size) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.read == nullptr)
     return 0;
   return cookie_file->ops.read(cookie_file->cookie,
                                reinterpret_cast<char *>(data), size);
 }
 
-int seek_func(File *f, long offset, int whence) {
+long seek_func(File *f, long offset, int whence) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.seek == nullptr) {
     errno = EINVAL;
     return -1;
   }
   off64_t offset64 = offset;
-  return cookie_file->ops.seek(cookie_file->cookie, &offset64, whence);
+  int result = cookie_file->ops.seek(cookie_file->cookie, &offset64, whence);
+  if (result == 0)
+    return offset64;
+  else
+    return -1;
 }
 
 int close_func(File *f) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.close == nullptr)
     return 0;
   return cookie_file->ops.close(cookie_file->cookie);
 }

libc/src/stdio/ftell.h

+//===-- Implementation header of ftell --------------------------*- 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_FTELL_H
+#define LLVM_LIBC_SRC_STDIO_FTELL_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+long ftell(::FILE *f);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_FTELL_H

libc/src/stdio/ftell.cpp

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

libc/test/src/__support/File/file_test.cpp

class StringFile : public __llvm_libc::File {
   static constexpr size_t SIZE = 512;
   size_t pos;
   char str[SIZE] = {0};
   size_t eof_marker;
   bool write_append;
 
   static size_t str_read(__llvm_libc::File *f, void *data, size_t len);
   static size_t str_write(__llvm_libc::File *f, const void *data, size_t len);
-  static int str_seek(__llvm_libc::File *f, long offset, int whence);
+  static long str_seek(__llvm_libc::File *f, long offset, int whence);
   static int str_close(__llvm_libc::File *f) { return 0; }
   static int str_flush(__llvm_libc::File *f) { return 0; }
 
 public:
   explicit StringFile(char *buffer, size_t buflen, int bufmode, bool owned,
                       ModeFlags modeflags)
       : __llvm_libc::File(&str_write, &str_read, &str_seek, &str_close,
                           &str_flush, buffer, buflen, bufmode, owned,
size_t StringFile::str_write(__llvm_libc::File *f, const void *data,
   for (i = 0; i < len && sf->pos < SIZE; ++i, ++sf->pos)
     sf->str[sf->pos] = reinterpret_cast<const char *>(data)[i];
   // Move the eof marker if the data was written beyond the current eof marker.
   if (sf->pos > sf->eof_marker)
     sf->eof_marker = sf->pos;
   return i;
 }
 
-int StringFile::str_seek(__llvm_libc::File *f, long offset, int whence) {
+long StringFile::str_seek(__llvm_libc::File *f, long offset, int whence) {
   StringFile *sf = static_cast<StringFile *>(f);
   if (whence == SEEK_SET)
     sf->pos = offset;
   if (whence == SEEK_CUR)
     sf->pos += offset;
   if (whence == SEEK_END)
     sf->pos = SIZE + offset;
-  return 0;
+  return sf->pos;
 }
 
 StringFile *new_string_file(char *buffer, size_t buflen, int bufmode,
                             bool owned, const char *mode) {
   StringFile *f = reinterpret_cast<StringFile *>(malloc(sizeof(StringFile)));
   f->init(buffer, buflen, bufmode, owned, __llvm_libc::File::mode_flags(mode));
   return f;
 }

libc/test/src/stdio/CMakeLists.txt

DEPENDS
     libc.src.stdio.fclose
     libc.src.stdio.feof
     libc.src.stdio.ferror
     libc.src.stdio.fgets
     libc.src.stdio.fopen
     libc.src.stdio.fwrite
 )
 
+add_libc_unittest(
+  ftell_test
+  SUITE
+    libc_stdio_unittests
+  SRCS
+    ftell_test.cpp
+  DEPENDS
+    libc.include.errno
+    libc.include.stdio
+    libc.src.stdio.fclose
+    libc.src.stdio.fflush
+    libc.src.stdio.fopen
+    libc.src.stdio.fread
+    libc.src.stdio.fseek
+    libc.src.stdio.ftell
+    libc.src.stdio.fwrite
+    libc.src.stdio.setvbuf
+)
+
 add_subdirectory(printf_core)
 add_subdirectory(scanf_core)
 add_subdirectory(testdata)

libc/test/src/stdio/ftell_test.cpp

+//===-- Unittests for ftell -----------------------------------------------===//
+//
+// 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/ftell.h"
+#include "src/stdio/fwrite.h"
+#include "src/stdio/setvbuf.h"
+#include "utils/UnitTest/Test.h"
+
+#include <stdio.h>
+
+class LlvmLibcFTellTest : public __llvm_libc::testing::Test {
+protected:
+  void test_with_bufmode(int bufmode) {
+    constexpr char FILENAME[] = "testdata/ftell.test";
+    // We will set a special buffer to the file so that we guarantee buffering.
+    constexpr size_t BUFFER_SIZE = 1024;
+    char buffer[BUFFER_SIZE];
+    ::FILE *file = __llvm_libc::fopen(FILENAME, "w+");
+    ASSERT_FALSE(file == nullptr);
+    ASSERT_EQ(__llvm_libc::setvbuf(file, buffer, bufmode, BUFFER_SIZE), 0);
+
+    // Include few '\n' chars to test when |bufmode| is _IOLBF.
+    constexpr char CONTENT[] = "12\n345\n6789";
+    constexpr size_t WRITE_SIZE = sizeof(CONTENT) - 1;
+    ASSERT_EQ(WRITE_SIZE, __llvm_libc::fwrite(CONTENT, 1, WRITE_SIZE, file));
+    // The above write should have buffered the written data and not have
+    // trasferred it to the underlying stream. But, ftell operation should
+    // still return the correct effective offset.
+    ASSERT_EQ(size_t(__llvm_libc::ftell(file)), WRITE_SIZE);
+
+    long offset = 5;
+    ASSERT_EQ(0, __llvm_libc::fseek(file, offset, SEEK_SET));
+    ASSERT_EQ(__llvm_libc::ftell(file), offset);
+    ASSERT_EQ(0, __llvm_libc::fseek(file, -offset, SEEK_END));
+    ASSERT_EQ(size_t(__llvm_libc::ftell(file)), size_t(WRITE_SIZE - offset));
+
+    ASSERT_EQ(0, __llvm_libc::fseek(file, 0, SEEK_SET));
+    constexpr size_t READ_SIZE = WRITE_SIZE / 2;
+    char data[READ_SIZE];
+    // Reading a small amount will actually read out much more data and
+    // buffer it. But, ftell should return the correct effective offset.
+    ASSERT_EQ(READ_SIZE, __llvm_libc::fread(data, 1, READ_SIZE, file));
+    ASSERT_EQ(size_t(__llvm_libc::ftell(file)), READ_SIZE);
+
+    ASSERT_EQ(0, __llvm_libc::fclose(file));
+  }
+};
+
+TEST_F(LlvmLibcFTellTest, TellWithFBF) { test_with_bufmode(_IOFBF); }
+
+TEST_F(LlvmLibcFTellTest, TellWithNBF) { test_with_bufmode(_IONBF); }
+
+TEST_F(LlvmLibcFTellTest, TellWithLBF) { test_with_bufmode(_IOLBF); }