Diff 482242

libc/src/__support/CMakeLists.txt

Show All 25 Lines	add_header_library(
HDRS		HDRS
architectures.h		architectures.h
common.h		common.h
endian.h		endian.h
sanitizer.h		sanitizer.h
)		)

add_header_library(		add_header_library(
		error_or
		HDRS
		error_or.h
		DEPENDS
		libc.src.__support.CPP.expected
		)

		add_header_library(
ctype_utils		ctype_utils
HDRS		HDRS
ctype_utils.h		ctype_utils.h
)		)

add_header_library(		add_header_library(
str_to_num_result		str_to_num_result
HDRS		HDRS
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

libc/src/__support/CPP/CMakeLists.txt

	Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines

	add_header_library(			add_header_library(
	atomic			atomic
	HDRS			HDRS
	atomic.h			atomic.h
	)			)

	add_header_library(			add_header_library(
	error			expected
	HDRS			HDRS
	error.h			expected.h
	)			)

libc/src/__support/CPP/error.h

This file was deleted.

	//===-- A simple classes to manage error return vals ----------- 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_SUPPORT_CPP_ERROR_H
	#define LLVM_LIBC_SRC_SUPPORT_CPP_ERROR_H

	namespace __llvm_libc {
	namespace cpp {
	// Many C functions return an error val and/or the actual result of the
	// evaluation/operation performed by the function. This file defines a simple
	// convenience data structure to encapsulate the error and the actual val in
	// a single place.

	struct Error {
	int error_code;
	};

	// This class is implemented in a simple fashion as the intention is it add
	// more generality as required. Currently, it only supports simple copyable
	// types for T.
	template <typename T> class ErrorOr {
	bool is_error;

	union {
	T val;
	Error error;
	};

	public:
	ErrorOr(const T &value) : is_error(false), val(value) {}

	ErrorOr(const Error &error) : is_error(true), error(error) {}

	operator bool() { return !is_error; }

	operator T &() { return val; }

	T &value() { return val; }

	int error_code() { return is_error ? error.error_code : 0; }
	};

	} // namespace cpp
	} // namespace __llvm_libc

	#endif // LLVM_LIBC_SRC_SUPPORT_CPP_ERROR_H

libc/src/__support/CPP/expected.h

This file was added.

				//===-- Holds an expected or unexpected value -------------------- 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_SUPPORT_CPP_EXPECTED_H
				#define LLVM_LIBC_SUPPORT_CPP_EXPECTED_H

				namespace __llvm_libc::cpp {

				// This is used to hold an unexpected value so that a different constructor is
				// selected.
				template <class T> class unexpected {
				T value;

				sivachandraUnsubmitted Done Reply Inline Actions I think, per https://eel.is/c++draft/expected.unexpected, this should be private? sivachandra: I think, per https://eel.is/c++draft/expected.unexpected, this should be private?
				public:
				constexpr explicit unexpected(T value) : value(value) {}
				sivachandraUnsubmitted Done Reply Inline Actions `explicit` ? Without explicit, the constructor on line 30 below can become ambiguous if `T` and `E` are same. sivachandra: `explicit` ? Without explicit, the constructor on line 30 below can become ambiguous if `T` and…
				constexpr T error() { return value; }
				};
				sivachandraUnsubmitted Done Reply Inline Actions The getter should be named `error` according to this: https://en.cppreference.com/w/cpp/utility/expected/unexpected sivachandra: The getter should be named `error` according to this: https://en.cppreference.

				template <class T, class E> class expected {
				union {
				T exp;
				E unexp;
				};
				bool is_expected;

				public:
				constexpr expected(T exp) : exp(exp), is_expected(true) {}
				constexpr expected(unexpected<E> unexp)
				sivachandraUnsubmitted Done Reply Inline Actions Does `std::expected` have constructors of this kind? If no, then we should not add incompatible constructors. sivachandra: Does `std::expected` have constructors of this kind? If no, then we should not add incompatible…
				michaelrjAuthorUnsubmitted Done Reply Inline Actions Yes, this is how the `std::expected` constructors are defined. michaelrj: Yes, this is how the `std::expected` constructors are defined.
				sivachandraUnsubmitted Done Reply Inline Actions Can you point me to a link or section in the standard where its listed? I am looking at cppreference.com and I don't see an `unexpected` type. I see one which takes `std::unexpect_t` followed by args for in-place construction of the error value. sivachandra: Can you point me to a link or section in the standard where its listed? I am looking at…
				michaelrjAuthorUnsubmitted Done Reply Inline Actions here is std::unexpected: https://en.cppreference.com/w/cpp/error/unexpected It's used in constructors 7 and 8 in the list on this page: https://en.cppreference.com/w/cpp/utility/expected/expected michaelrj: here is std::unexpected: https://en.cppreference.com/w/cpp/error/unexpected It's used in…
				sivachandraUnsubmitted Done Reply Inline Actions here is std::unexpected: https://en.cppreference.com/w/cpp/error/unexpected Ah! That stale cppreference page threw me off! That page is actually talking about a removed function `std::unexpected` and not a type named `std::unexpected`. But, your interpretation is correct and according to the C++23 draft: https://eel.is/c++draft/expected.unexpected It's used in constructors 7 and 8 in the list on this page: https://en.cppreference.com/w/cpp/utility/expected/expected Thanks! sivachandra: > here is std::unexpected: https://en.cppreference.com/w/cpp/error/unexpected Ah! That stale…
				: unexp(unexp.error()), is_expected(false) {}

				constexpr bool has_value() { return is_expected; }
				sivachandraUnsubmitted Done Reply Inline Actions Likewise, if `has_error` is not present, do not include it here. sivachandra: Likewise, if `has_error` is not present, do not include it here.

				constexpr T value() { return exp; }
				constexpr E error() { return unexp; }

				constexpr operator T() { return exp; }
				constexpr operator bool() { return is_expected; }

				constexpr T &operator*() { return exp; }
				constexpr const T &operator*() const { return exp; }
				constexpr T *operator->() { return &exp; }
				constexpr const T *operator->() const { return &exp; }
				};

				} // namespace __llvm_libc::cpp

				#endif // LLVM_LIBC_SUPPORT_CPP_EXPECTED_H

libc/src/__support/File/CMakeLists.txt

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

add_object_library(		add_object_library(
file		file
SRCS		SRCS
file.cpp		file.cpp
HDRS		HDRS
file.h		file.h
DEPENDS		DEPENDS
libc.include.errno		libc.include.errno
libc.src.__support.CPP.span		libc.src.__support.CPP.span
libc.src.__support.threads.mutex		libc.src.__support.threads.mutex
libc.src.errno.errno		libc.src.__support.error_or
)		)

add_object_library(		add_object_library(
dir		dir
SRCS		SRCS
dir.cpp		dir.cpp
HDRS		HDRS
dir.h		dir.h
Show All 10 Lines	add_object_library(
DEPENDS		DEPENDS
.file		.file
libc.include.errno		libc.include.errno
libc.include.fcntl		libc.include.fcntl
libc.include.stdio		libc.include.stdio
libc.include.sys_syscall		libc.include.sys_syscall
libc.src.__support.OSUtil.osutil		libc.src.__support.OSUtil.osutil
libc.src.errno.errno		libc.src.errno.errno
		libc.src.__support.error_or
)		)
endif()		endif()

if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}_dir.cpp)		if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}_dir.cpp)
add_object_library(		add_object_library(
platform_dir		platform_dir
SRCS		SRCS
${LIBC_TARGET_OS}_dir.cpp		${LIBC_TARGET_OS}_dir.cpp
Show All 9 Lines

libc/src/__support/File/file.h

//===--- A platform independent file data structure -------------- C++ --===//		//===--- A platform independent file data structure -------------- C++ --===//
//		//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.		// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#ifndef LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H		#ifndef LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H
#define LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H		#define LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H

		#include "src/__support/error_or.h"
#include "src/__support/threads/mutex.h"		#include "src/__support/threads/mutex.h"

#include <stddef.h>		#include <stddef.h>
#include <stdint.h>		#include <stdint.h>

namespace __llvm_libc {		namespace __llvm_libc {

		struct FileIOResult {
		sivachandraUnsubmitted Done Reply Inline Actions Is it used with `T` != `size_t` anywhere? If not, it need not be a template. sivachandra: Is it used with `T` != `size_t` anywhere? If not, it need not be a template.
		sivachandraUnsubmitted Done Reply Inline Actions I have read this patch on three different days and all those three times the name `FileResult` has made me a bit uncomfortable. Can we give it a less general name, say `FileIOResult` or something which makes it clear that this only relates to read/write operations? sivachandra: I have read this patch on three different days and all those three times the name `FileResult`…
		size_t value;
		int error;

		constexpr FileIOResult(size_t val) : value(val), error(0) {}
		constexpr FileIOResult(size_t val, int error) : value(val), error(error) {}

		constexpr bool has_error() { return error != 0; }

		constexpr operator size_t() { return value; }
		};

// This a generic base class to encapsulate a platform independent file data		// This a generic base class to encapsulate a platform independent file data
// structure. Platform specific specializations should create a subclass as		// structure. Platform specific specializations should create a subclass as
// suitable for their platform.		// suitable for their platform.
		lntueUnsubmitted Done Reply Inline Actions Is this used in the test somewhere? So far all the tests I've seen are directly tested with `get_value()`? lntue: Is this used in the test somewhere? So far all the tests I've seen are directly tested with…
class File {		class File {
public:		public:
static constexpr size_t DEFAULT_BUFFER_SIZE = 1024;		static constexpr size_t DEFAULT_BUFFER_SIZE = 1024;

using LockFunc = void(File *);		using LockFunc = void(File *);
using UnlockFunc = void(File *);		using UnlockFunc = void(File *);

using WriteFunc = size_t(File , const void , size_t);		using WriteFunc = FileIOResult(File , const void , size_t);
using ReadFunc = size_t(File , void , size_t);		using ReadFunc = FileIOResult(File , void , size_t);
		sivachandraUnsubmitted Done Reply Inline Actions For read and write operations, I think is fine with a slight modification. Instead of calling the result type `FileResult` and making it a template, just define it this way: struct FileIOResult { size_t size; int error; constexpr FileResult(size_t s) : size(s), error(0) {} constexpr FileResult(size_t s, int err) : size(s), error(err) {} constexpr operator size_t() const { return size; } constexpr operator bool() const { return error != 0; } }; The call sites will be like: const auto result = file.write(...) if (!result) errno = result.error; return result; // OK because of operator size_t sivachandra: For read and write operations, I think is fine with a slight modification. Instead of calling…
// The SeekFunc is expected to return the current offset of the external		// The SeekFunc is expected to return the current offset of the external
// file position indicator.		// file position indicator.
using SeekFunc = long(File *, long, int);		using SeekFunc = ErrorOr<long>(File *, long, int);
using CloseFunc = int(File *);		using CloseFunc = int(File *);
using FlushFunc = int(File *);		using FlushFunc = int(File *);
		sivachandraUnsubmitted Done Reply Inline Actions This is an example of an `ErrorOr` or `StatusOr` return value. sivachandra: This is an example of an `ErrorOr` or `StatusOr` return value.
		sivachandraUnsubmitted Done Reply Inline Actions Actually, we should be use an equivalent of `std::expected`: https://en.cppreference.com/w/cpp/utility/expected sivachandra: Actually, we should be use an equivalent of `std::expected`: https://en.cppreference.

using ModeFlags = uint32_t;		using ModeFlags = uint32_t;
		sivachandraUnsubmitted Done Reply Inline Actions The close and flush operation functions can return the error value directly. Call sites will detect an error if they see a non-zero return value. sivachandra: The close and flush operation functions can return the error value directly. Call sites will…
		michaelrjAuthorUnsubmitted Done Reply Inline Actions close and flush call write, meaning that they can theoretically have any error that write can, not just EBADF. michaelrj: close and flush call write, meaning that they can theoretically have any error that write can…
		sivachandraUnsubmitted Done Reply Inline Actions `EBADF` or any error that write returns is still of an integer type. So, call sites can detect error if return value is non-zero. That non-zero value is itself the error. Otherwise, what meaning would the `int` value in `ErrorOr` have for `flush` and `close`? sivachandra: `EBADF` or any error that write returns is still of an integer type. So, call sites can detect…
		michaelrjAuthorUnsubmitted Done Reply Inline Actions while theoretically we could say that the int result for `flush` and `close` actually represents the error instead of the usual return value (which is effectively a boolean for success) I feel like that would be confusing for someone trying to read the codebase. If you're used to a file function named flush that returns 0 on success and -1 on failure (as laid out in the standard), then the internal version of the function actually returning 0 on success and any positive integer on failure could be unexpected. This way it's unambiguous what the error state is. michaelrj: while theoretically we could say that the int result for `flush` and `close` actually…
		sivachandraUnsubmitted Done Reply Inline Actions I would actually say using `ErrorOr` is confusing because one will then start looking for the meaning of the non-error `int` value. I am not sure the "used to a file function named flush that return 0 ..." is an argument to use - when you return an error `ErrorOr` value there is no 0 or -1. But, if you actually return `int` value, then you can still do: if (flush_result != 0) { // Error handling } sivachandra: I would actually say using `ErrorOr` is confusing because one will then start looking for the…

// The three different types of flags below are to be used with '\|' operator.		// 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		// 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		// integer value. A flag set can include both READ and WRITE if the file
// is opened in update mode (ie. if the file was opened with a '+' the mode		// is opened in update mode (ie. if the file was opened with a '+' the mode
// string.)		// string.)
enum class OpenMode : ModeFlags {		enum class OpenMode : ModeFlags {
READ = 0x1,		READ = 0x1,
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines	static void init(File f, WriteFunc wf, ReadFunc rf, SeekFunc sf,
f->prev_op = FileOp::NONE;		f->prev_op = FileOp::NONE;
f->read_limit = f->pos = 0;		f->read_limit = f->pos = 0;
f->eof = f->err = false;		f->eof = f->err = false;

f->adjust_buf();		f->adjust_buf();
}		}

// Buffered write of \|len\| bytes from \|data\| without the file lock.		// Buffered write of \|len\| bytes from \|data\| without the file lock.
size_t write_unlocked(const void *data, size_t len);		FileIOResult write_unlocked(const void *data, size_t len);

// Buffered write of \|len\| bytes from \|data\| under the file lock.		// Buffered write of \|len\| bytes from \|data\| under the file lock.
size_t write(const void *data, size_t len) {		FileIOResult write(const void *data, size_t len) {
FileLock l(this);		FileLock l(this);
return write_unlocked(data, len);		return write_unlocked(data, len);
}		}

// Buffered read of \|len\| bytes into \|data\| without the file lock.		// Buffered read of \|len\| bytes into \|data\| without the file lock.
size_t read_unlocked(void *data, size_t len);		FileIOResult read_unlocked(void *data, size_t len);

// Buffered read of \|len\| bytes into \|data\| under the file lock.		// Buffered read of \|len\| bytes into \|data\| under the file lock.
size_t read(void *data, size_t len) {		FileIOResult read(void *data, size_t len) {
FileLock l(this);		FileLock l(this);
return read_unlocked(data, len);		return read_unlocked(data, len);
}		}

int seek(long offset, int whence);		ErrorOr<int> seek(long offset, int whence);

long tell();		ErrorOr<long> tell();

// If buffer has data written to it, flush it out. Does nothing if the		// If buffer has data written to it, flush it out. Does nothing if the
// buffer is currently being used as a read buffer.		// buffer is currently being used as a read buffer.
int flush() {		int flush() {
FileLock lock(this);		FileLock lock(this);
return flush_unlocked();		return flush_unlocked();
}		}

▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines	bool iseof() {
return iseof_unlocked();		return iseof_unlocked();
}		}

// Returns an bit map of flags corresponding to enumerations of		// Returns an bit map of flags corresponding to enumerations of
// OpenMode, ContentType and CreateType.		// OpenMode, ContentType and CreateType.
static ModeFlags mode_flags(const char *mode);		static ModeFlags mode_flags(const char *mode);

private:		private:
size_t write_unlocked_lbf(const uint8_t *data, size_t len);		FileIOResult write_unlocked_lbf(const uint8_t *data, size_t len);
size_t write_unlocked_fbf(const uint8_t *data, size_t len);		FileIOResult write_unlocked_fbf(const uint8_t *data, size_t len);
size_t write_unlocked_nbf(const uint8_t *data, size_t len);		FileIOResult write_unlocked_nbf(const uint8_t *data, size_t len);

constexpr void adjust_buf() {		constexpr void adjust_buf() {
if (read_allowed() && (buf == nullptr \|\| bufsize == 0)) {		if (read_allowed() && (buf == nullptr \|\| bufsize == 0)) {
// We should allow atleast one ungetc operation.		// We should allow atleast one ungetc operation.
// This might give an impression that a buffer will be used even when		// This might give an impression that a buffer will be used even when
// the user does not want a buffer. But, that will not be the case.		// the user does not want a buffer. But, that will not be the case.
// For reading, the buffering does not come into play. For writing, let		// For reading, the buffering does not come into play. For writing, let
// us take up the three different kinds of buffering separately:		// us take up the three different kinds of buffering separately:
Show All 10 Lines	if (read_allowed() && (buf == nullptr \|\| bufsize == 0)) {
bufsize = 1;		bufsize = 1;
own_buf = false; // We shouldn't call free on \|buf\| when closing the file.		own_buf = false; // We shouldn't call free on \|buf\| when closing the file.
}		}
}		}
};		};

// The implementaiton of this function is provided by the platfrom_file		// The implementaiton of this function is provided by the platfrom_file
// library.		// library.
File openfile(const char path, const char *mode);		ErrorOr<File > openfile(const char path, const char *mode);

// The platform_file library should implement it if it relevant for that		// The platform_file library should implement it if it relevant for that
// platform.		// platform.
int get_fileno(File *f);		int get_fileno(File *f);

extern File *stdin;		extern File *stdin;
extern File *stdout;		extern File *stdout;
extern File *stderr;		extern File *stderr;

} // namespace __llvm_libc		} // namespace __llvm_libc

#endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H		#endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H

libc/src/__support/File/file.cpp

//===--- Implementation of a platform independent file data structure -----===//		//===--- Implementation of a platform independent file data structure -----===//
//		//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.		// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "file.h"		#include "file.h"

#include "src/__support/CPP/span.h"		#include "src/__support/CPP/span.h"

#include <errno.h>		#include <errno.h> // For error macros
#include <stdio.h>		#include <stdio.h>
#include <stdlib.h>		#include <stdlib.h>

namespace __llvm_libc {		namespace __llvm_libc {

size_t File::write_unlocked(const void *data, size_t len) {		FileIOResult File::write_unlocked(const void *data, size_t len) {
if (!write_allowed()) {		if (!write_allowed()) {
errno = EBADF;
err = true;		err = true;
return 0;		return {0, EBADF};
}		}

prev_op = FileOp::WRITE;		prev_op = FileOp::WRITE;

if (bufmode == _IOFBF) { // fully buffered		if (bufmode == _IOFBF) { // fully buffered
return write_unlocked_fbf(static_cast<const uint8_t *>(data), len);		return write_unlocked_fbf(static_cast<const uint8_t *>(data), len);
} else if (bufmode == _IOLBF) { // line buffered		} else if (bufmode == _IOLBF) { // line buffered
return write_unlocked_lbf(static_cast<const uint8_t *>(data), len);		return write_unlocked_lbf(static_cast<const uint8_t *>(data), len);
} else /if (bufmode == _IONBF) / { // unbuffered		} else /if (bufmode == _IONBF) / { // unbuffered
size_t ret_val =		size_t ret_val =
write_unlocked_nbf(static_cast<const uint8_t *>(data), len);		write_unlocked_nbf(static_cast<const uint8_t *>(data), len);
flush_unlocked();		flush_unlocked();
return ret_val;		return ret_val;
}		}
}		}

size_t File::write_unlocked_nbf(const uint8_t *data, size_t len) {		FileIOResult File::write_unlocked_nbf(const uint8_t *data, size_t len) {
if (pos > 0) { // If the buffer is not empty		if (pos > 0) { // If the buffer is not empty
// Flush the buffer		// Flush the buffer
const size_t write_size = pos;		const size_t write_size = pos;
size_t bytes_written = platform_write(this, buf, write_size);		auto write_result = platform_write(this, buf, write_size);
		sivachandraUnsubmitted Done Reply Inline Actions Do you need a var like `buf_result` ? Could we just do: auto bytes_written = platform_write(...); if (bytes_written < write_size) { // This should OK because of operator size_t ? ... } sivachandra: Do you need a var like `buf_result` ? Could we just do: ``` auto bytes_written =…
		michaelrjAuthorUnsubmitted Done Reply Inline Actions yes. If you look below, we extract the error from buf_result if we're returning an error. michaelrj: yes. If you look below, we extract the error from buf_result if we're returning an error.
		sivachandraUnsubmitted Done Reply Inline Actions You can still do `return {0, bytes_written.error}`, no? sivachandra: You can still do `return {0, bytes_written.error}`, no?
pos = 0; // Buffer is now empty so reset pos to the beginning.		pos = 0; // Buffer is now empty so reset pos to the beginning.
// If less bytes were written than expected, then an error occurred.		// If less bytes were written than expected, then an error occurred.
if (bytes_written < write_size) {		if (write_result < write_size) {
err = true;		err = true;
return 0; // No bytes from data were written, so return 0.		// No bytes from data were written, so return 0.
		return {0, write_result.error};
}		}
}		}

size_t written = platform_write(this, data, len);		auto write_result = platform_write(this, data, len);
		sivachandraUnsubmitted Done Reply Inline Actions Same here? sivachandra: Same here?
		michaelrjAuthorUnsubmitted Done Reply Inline Actions Same as above, by returning `result` we preserve the error information. `written` is only used to determine if the error flag should be set. michaelrj: Same as above, by returning `result` we preserve the error information. `written` is only used…
		sivachandraUnsubmitted Done Reply Inline Actions Over here, you shouldn't need the `written` var because you can still compare `result < len`? I am not advocating for keeping the names as is though. For example, here and above, you can name the var capturing the return value from `platform_write` as `write_result`. sivachandra: Over here, you shouldn't need the `written` var because you can still compare `result < len`? I…
if (written < len)		if (write_result < len)
err = true;		err = true;
return written;		return write_result;
}		}

size_t File::write_unlocked_fbf(const uint8_t *data, size_t len) {		FileIOResult File::write_unlocked_fbf(const uint8_t *data, size_t len) {
const size_t init_pos = pos;		const size_t init_pos = pos;
const size_t bufspace = bufsize - pos;		const size_t bufspace = bufsize - pos;

// If data is too large to be buffered at all, then just write it unbuffered.		// If data is too large to be buffered at all, then just write it unbuffered.
if (len > bufspace + bufsize)		if (len > bufspace + bufsize)
return write_unlocked_nbf(data, len);		return write_unlocked_nbf(data, len);

// we split \|data\| (conceptually) using the split point. Then we handle the		// we split \|data\| (conceptually) using the split point. Then we handle the
Show All 23 Lines	FileIOResult File::write_unlocked_fbf(const uint8_t *data, size_t len) {
// If there is no remainder, we can return early, since the first piece has		// If there is no remainder, we can return early, since the first piece has
// fit completely into the buffer.		// fit completely into the buffer.
if (remainder.size() == 0)		if (remainder.size() == 0)
return len;		return len;

// We need to flush the buffer now, since there is still data and the buffer		// We need to flush the buffer now, since there is still data and the buffer
// is full.		// is full.
const size_t write_size = pos;		const size_t write_size = pos;
size_t bytes_written = platform_write(this, buf, write_size);
		auto buf_result = platform_write(this, buf, write_size);
		size_t bytes_written = buf_result.value;

pos = 0; // Buffer is now empty so reset pos to the beginning.		pos = 0; // Buffer is now empty so reset pos to the beginning.
// If less bytes were written than expected, then an error occurred. Return		// If less bytes were written than expected, then an error occurred. Return
// the number of bytes that have been written from \|data\|.		// the number of bytes that have been written from \|data\|.
if (bytes_written < write_size) {		if (buf_result.has_error() \|\| bytes_written < write_size) {
err = true;		err = true;
return bytes_written <= init_pos ? 0 : bytes_written - init_pos;		return {bytes_written <= init_pos ? 0 : bytes_written - init_pos,
		buf_result.error};
}		}

// The second piece is handled basically the same as the first, although we		// The second piece is handled basically the same as the first, although we
// know that if the second piece has data in it then the buffer has been		// know that if the second piece has data in it then the buffer has been
// flushed, meaning that pos is always 0.		// flushed, meaning that pos is always 0.
if (remainder.size() < bufsize) {		if (remainder.size() < bufsize) {
// TODO: Replace the for loop below with a call to internal memcpy.		// TODO: Replace the for loop below with a call to internal memcpy.
for (size_t i = 0; i < remainder.size(); ++i)		for (size_t i = 0; i < remainder.size(); ++i)
bufref[i] = remainder[i];		bufref[i] = remainder[i];
pos = remainder.size();		pos = remainder.size();
} else {		} else {
size_t bytes_written =
platform_write(this, remainder.data(), remainder.size());		auto result = platform_write(this, remainder.data(), remainder.size());
		size_t bytes_written = buf_result.value;

// If less bytes were written than expected, then an error occurred. Return		// If less bytes were written than expected, then an error occurred. Return
// the number of bytes that have been written from \|data\|.		// the number of bytes that have been written from \|data\|.
if (bytes_written < remainder.size()) {		if (result.has_error() \|\| bytes_written < remainder.size()) {
err = true;		err = true;
return primary.size() + bytes_written;		return {primary.size() + bytes_written, result.error};
}		}
}		}

return len;		return len;
}		}

size_t File::write_unlocked_lbf(const uint8_t *data, size_t len) {		FileIOResult File::write_unlocked_lbf(const uint8_t *data, size_t len) {
constexpr uint8_t NEWLINE_CHAR = '\n';		constexpr uint8_t NEWLINE_CHAR = '\n';
size_t last_newline = len;		size_t last_newline = len;
for (size_t i = len; i >= 1; --i) {		for (size_t i = len; i >= 1; --i) {
if (data[i - 1] == NEWLINE_CHAR) {		if (data[i - 1] == NEWLINE_CHAR) {
last_newline = i - 1;		last_newline = i - 1;
break;		break;
}		}
}		}
Show All 30 Lines	FileIOResult File::write_unlocked_lbf(const uint8_t *data, size_t len) {
if (written < len) {		if (written < len) {
err = true;		err = true;
return written;		return written;
}		}

return len;		return len;
}		}

size_t File::read_unlocked(void *data, size_t len) {		FileIOResult File::read_unlocked(void *data, size_t len) {
if (!read_allowed()) {		if (!read_allowed()) {
errno = EBADF;
err = true;		err = true;
return 0;		return {0, EBADF};
}		}

prev_op = FileOp::READ;		prev_op = FileOp::READ;

cpp::span<uint8_t> bufref(static_cast<uint8_t *>(buf), bufsize);		cpp::span<uint8_t> bufref(static_cast<uint8_t *>(buf), bufsize);
cpp::span<uint8_t> dataref(static_cast<uint8_t *>(data), len);		cpp::span<uint8_t> dataref(static_cast<uint8_t *>(data), len);

// Because read_limit is always greater than equal to pos,		// Because read_limit is always greater than equal to pos,
Show All 14 Lines	FileIOResult File::read_unlocked(void *data, size_t len) {
read_limit = pos = 0; // Reset the pointers.		read_limit = pos = 0; // Reset the pointers.
// Update the dataref to reflect that fact that we have already		// Update the dataref to reflect that fact that we have already
// copied \|available_data\| into \|data\|.		// copied \|available_data\| into \|data\|.
dataref = cpp::span<uint8_t>(dataref.data() + available_data,		dataref = cpp::span<uint8_t>(dataref.data() + available_data,
dataref.size() - available_data);		dataref.size() - available_data);

size_t to_fetch = len - available_data;		size_t to_fetch = len - available_data;
if (to_fetch > bufsize) {		if (to_fetch > bufsize) {
size_t fetched_size = platform_read(this, dataref.data(), to_fetch);		auto result = platform_read(this, dataref.data(), to_fetch);
if (fetched_size < to_fetch) {		size_t fetched_size = result.value;
if (errno == 0)		if (result.has_error() \|\| fetched_size < to_fetch) {
		if (!result.has_error())
eof = true;		eof = true;
else		else
err = true;		err = true;
return available_data + fetched_size;		return {available_data + fetched_size, result.has_error()};
}		}
return len;		return len;
}		}

// Fetch and buffer another buffer worth of data.		// Fetch and buffer another buffer worth of data.
size_t fetched_size = platform_read(this, buf, bufsize);		auto result = platform_read(this, buf, bufsize);
		size_t fetched_size = result.value;
read_limit += fetched_size;		read_limit += fetched_size;
size_t transfer_size = fetched_size >= to_fetch ? to_fetch : fetched_size;		size_t transfer_size = fetched_size >= to_fetch ? to_fetch : fetched_size;
for (size_t i = 0; i < transfer_size; ++i)		for (size_t i = 0; i < transfer_size; ++i)
dataref[i] = bufref[i];		dataref[i] = bufref[i];
pos += transfer_size;		pos += transfer_size;
if (fetched_size < to_fetch) {		if (result.has_error() \|\| fetched_size < to_fetch) {
if (errno == 0)		if (!result.has_error())
eof = true;		eof = true;
else		else
err = true;		err = true;
}		}
return transfer_size + available_data;		return {transfer_size + available_data, result.error};
}		}

int File::ungetc_unlocked(int c) {		int File::ungetc_unlocked(int c) {
// There is no meaning to unget if:		// There is no meaning to unget if:
// 1. You are trying to push back EOF.		// 1. You are trying to push back EOF.
// 2. Read operations are not allowed on this file.		// 2. Read operations are not allowed on this file.
// 3. The previous operation was a write operation.		// 3. The previous operation was a write operation.
if (c == EOF \|\| !read_allowed() \|\| (prev_op == FileOp::WRITE))		if (c == EOF \|\| !read_allowed() \|\| (prev_op == FileOp::WRITE))
Show All 24 Lines	if (read_limit == 0) {
bufref[pos] = static_cast<unsigned char>(c);		bufref[pos] = static_cast<unsigned char>(c);
}		}

eof = false; // There is atleast one character that can be read now.		eof = false; // There is atleast one character that can be read now.
err = false; // This operation was a success.		err = false; // This operation was a success.
return c;		return c;
}		}

int File::seek(long offset, int whence) {		ErrorOr<int> File::seek(long offset, int whence) {
FileLock lock(this);		FileLock lock(this);
if (prev_op == FileOp::WRITE && pos > 0) {		if (prev_op == FileOp::WRITE && pos > 0) {
size_t transferred_size = platform_write(this, buf, pos);
if (transferred_size < pos) {		auto buf_result = platform_write(this, buf, pos);
		if (buf_result.has_error() \|\| buf_result.value < pos) {
err = true;		err = true;
return -1;		return Error(buf_result.error);
}		}
} else if (prev_op == FileOp::READ && whence == SEEK_CUR) {		} else if (prev_op == FileOp::READ && whence == SEEK_CUR) {
// More data could have been read out from the platform file than was		// More data could have been read out from the platform file than was
// required. So, we have to adjust the offset we pass to platform seek		// required. So, we have to adjust the offset we pass to platform seek
// function. Note that read_limit >= pos is always true.		// function. Note that read_limit >= pos is always true.
offset -= (read_limit - pos);		offset -= (read_limit - pos);
}		}
pos = read_limit = 0;		pos = read_limit = 0;
prev_op = FileOp::SEEK;		prev_op = FileOp::SEEK;
// Reset the eof flag as a seek might move the file positon to some place		// Reset the eof flag as a seek might move the file positon to some place
// readable.		// readable.
eof = false;		eof = false;
long platform_pos = platform_seek(this, offset, whence);		auto result = platform_seek(this, offset, whence);
if (platform_pos >= 0)		if (!result.has_value())
return 0;		return Error(result.error());
else		else
return -1;		return 0;
}		}

long File::tell() {		ErrorOr<long> File::tell() {
FileLock lock(this);		FileLock lock(this);
long platform_offset;		auto seek_target = eof ? SEEK_END : SEEK_CUR;
if (eof)		auto result = platform_seek(this, 0, seek_target);
platform_offset = platform_seek(this, 0, SEEK_END);		if (!result.has_value() \|\| result.value() < 0)
else		return Error(result.error());
platform_offset = platform_seek(this, 0, SEEK_CUR);		long platform_offset = result.value();
if (platform_offset < 0)
return -1;
if (prev_op == FileOp::READ)		if (prev_op == FileOp::READ)
return platform_offset - (read_limit - pos);		return platform_offset - (read_limit - pos);
else if (prev_op == FileOp::WRITE)		else if (prev_op == FileOp::WRITE)
return platform_offset + pos;		return platform_offset + pos;
else		else
return platform_offset;		return platform_offset;
}		}

int File::flush_unlocked() {		int File::flush_unlocked() {
if (prev_op == FileOp::WRITE && pos > 0) {		if (prev_op == FileOp::WRITE && pos > 0) {
size_t transferred_size = platform_write(this, buf, pos);		auto buf_result = platform_write(this, buf, pos);
if (transferred_size < pos) {		if (buf_result.has_error() \|\| buf_result.value < pos) {
err = true;		err = true;
return -1;		return buf_result.error;
}		}
pos = 0;		pos = 0;
return platform_flush(this);		return platform_flush(this);
}		}
// TODO: Add POSIX behavior for input streams.		// TODO: Add POSIX behavior for input streams.
return 0;		return 0;
}		}

int File::close() {		int File::close() {
{		{
FileLock lock(this);		FileLock lock(this);
if (prev_op == FileOp::WRITE && pos > 0) {		if (prev_op == FileOp::WRITE && pos > 0) {
size_t transferred_size = platform_write(this, buf, pos);		auto buf_result = platform_write(this, buf, pos);
if (transferred_size < pos) {		if (buf_result.has_error() \|\| buf_result.value < pos) {
err = true;		err = true;
return -1;		return buf_result.error;
}		}
}		}
if (platform_close(this) != 0)		int result = platform_close(this);
return -1;		if (result != 0)
		return result;
if (own_buf)		if (own_buf)
free(buf);		free(buf);
}		}
free(this);		free(this);
return 0;		return 0;
}		}

int File::set_buffer(void *buffer, size_t size, int buffer_mode) {		int File::set_buffer(void *buffer, size_t size, int buffer_mode) {
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

libc/src/__support/File/linux_file.cpp

//===--- Linux specialization of the File data structure ------------------===//		//===--- Linux specialization of the File data structure ------------------===//
//		//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.		// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "file.h"		#include "file.h"

#include "src/__support/OSUtil/syscall.h" // For internal syscall function.		#include "src/__support/OSUtil/syscall.h" // For internal syscall function.

#include <errno.h>		#include <errno.h> // For error macros
#include <fcntl.h> // For mode_t and other flags to the open syscall		#include <fcntl.h> // For mode_t and other flags to the open syscall
#include <stdio.h>		#include <stdio.h>
#include <stdlib.h> // For malloc		#include <stdlib.h> // For malloc
#include <sys/syscall.h> // For syscall numbers		#include <sys/syscall.h> // For syscall numbers

namespace __llvm_libc {		namespace __llvm_libc {

namespace {		namespace {

size_t write_func(File , const void , size_t);		FileIOResult write_func(File , const void , size_t);
size_t read_func(File , void , size_t);		FileIOResult read_func(File , void , size_t);
long seek_func(File *, long, int);		ErrorOr<long> seek_func(File *, long, int);
int close_func(File *);		int close_func(File *);
int flush_func(File *);		int flush_func(File *);

} // anonymous namespace		} // anonymous namespace

class LinuxFile : public File {		class LinuxFile : public File {
int fd;		int fd;

Show All 12 Lines	static void init(LinuxFile f, int file_descriptor, void buffer,
f->fd = file_descriptor;		f->fd = file_descriptor;
}		}

int get_fd() const { return fd; }		int get_fd() const { return fd; }
};		};

namespace {		namespace {

size_t write_func(File f, const void data, size_t size) {		FileIOResult write_func(File f, const void data, size_t size) {
auto lf = reinterpret_cast<LinuxFile >(f);		auto lf = reinterpret_cast<LinuxFile >(f);
long ret = __llvm_libc::syscall_impl(SYS_write, lf->get_fd(), data, size);		int ret = __llvm_libc::syscall_impl(SYS_write, lf->get_fd(), data, size);
if (ret < 0) {		if (ret < 0) {
errno = -ret;		return {0, -ret};
return 0;
}		}
return ret;		return ret;
}		}

size_t read_func(File f, void buf, size_t size) {		FileIOResult read_func(File f, void buf, size_t size) {
auto lf = reinterpret_cast<LinuxFile >(f);		auto lf = reinterpret_cast<LinuxFile >(f);
long ret = __llvm_libc::syscall_impl(SYS_read, lf->get_fd(), buf, size);		int ret = __llvm_libc::syscall_impl(SYS_read, lf->get_fd(), buf, size);
if (ret < 0) {		if (ret < 0) {
errno = -ret;		return {0, -ret};
return 0;
}		}
return ret;		return ret;
}		}

long seek_func(File *f, long offset, int whence) {		ErrorOr<long> seek_func(File *f, long offset, int whence) {
auto lf = reinterpret_cast<LinuxFile >(f);		auto lf = reinterpret_cast<LinuxFile >(f);
long result;		long result;
#ifdef SYS_lseek		#ifdef SYS_lseek
long ret = __llvm_libc::syscall_impl(SYS_lseek, lf->get_fd(), offset, whence);		int ret = __llvm_libc::syscall_impl(SYS_lseek, lf->get_fd(), offset, whence);
result = ret;		result = ret;
#elif defined(SYS__llseek)		#elif defined(SYS__llseek)
long result;		long result;
long ret = __llvm_libc::syscall_impl(SYS__llseek, lf->get_fd(), offset >> 32,		int ret = __llvm_libc::syscall_impl(SYS__llseek, lf->get_fd(), offset >> 32,
offset, &result, whence);		offset, &result, whence);
#else		#else
#error "lseek and _llseek syscalls not available to perform a seek operation."		#error "lseek and _llseek syscalls not available to perform a seek operation."
#endif		#endif

if (ret < 0) {		if (ret < 0)
errno = -ret;		return Error(-ret);
return -1;
}
return result;		return result;
}		}

int close_func(File *f) {		int close_func(File *f) {
auto lf = reinterpret_cast<LinuxFile >(f);		auto lf = reinterpret_cast<LinuxFile >(f);
long ret = __llvm_libc::syscall_impl(SYS_close, lf->get_fd());		int ret = __llvm_libc::syscall_impl(SYS_close, lf->get_fd());
if (ret < 0) {		if (ret < 0) {
errno = -ret;		return -ret;
return -1;
}		}
return 0;		return 0;
}		}

int flush_func(File *f) {		int flush_func(File *f) {
auto lf = reinterpret_cast<LinuxFile >(f);		auto lf = reinterpret_cast<LinuxFile >(f);
long ret = __llvm_libc::syscall_impl(SYS_fsync, lf->get_fd());		int ret = __llvm_libc::syscall_impl(SYS_fsync, lf->get_fd());
if (ret < 0) {		if (ret < 0) {
errno = -ret;		return -ret;
return -1;
}		}
return 0;		return 0;
}		}

} // anonymous namespace		} // anonymous namespace

File openfile(const char path, const char *mode) {		ErrorOr<File > openfile(const char path, const char *mode) {
using ModeFlags = File::ModeFlags;		using ModeFlags = File::ModeFlags;
auto modeflags = File::mode_flags(mode);		auto modeflags = File::mode_flags(mode);
if (modeflags == 0) {		if (modeflags == 0) {
errno = EINVAL;		// return {nullptr, EINVAL};
return nullptr;		return Error(EINVAL);
}		}
long open_flags = 0;		long open_flags = 0;
if (modeflags & ModeFlags(File::OpenMode::APPEND)) {		if (modeflags & ModeFlags(File::OpenMode::APPEND)) {
open_flags = O_CREAT \| O_APPEND;		open_flags = O_CREAT \| O_APPEND;
if (modeflags & ModeFlags(File::OpenMode::PLUS))		if (modeflags & ModeFlags(File::OpenMode::PLUS))
open_flags \|= O_RDWR;		open_flags \|= O_RDWR;
else		else
open_flags \|= O_WRONLY;		open_flags \|= O_WRONLY;
Show All 19 Lines
#elif defined(SYS_openat)		#elif defined(SYS_openat)
int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, open_flags,		int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, open_flags,
OPEN_MODE);		OPEN_MODE);
#else		#else
#error "SYS_open and SYS_openat syscalls not available to perform a file open."		#error "SYS_open and SYS_openat syscalls not available to perform a file open."
#endif		#endif

if (fd < 0) {		if (fd < 0) {
errno = -fd;		return Error(-fd);
return nullptr;		// return {nullptr, -fd};
}		}

void *buffer = malloc(File::DEFAULT_BUFFER_SIZE);		void *buffer = malloc(File::DEFAULT_BUFFER_SIZE);
auto file = reinterpret_cast<LinuxFile >(malloc(sizeof(LinuxFile)));		auto file = reinterpret_cast<LinuxFile >(malloc(sizeof(LinuxFile)));
LinuxFile::init(file, fd, buffer, File::DEFAULT_BUFFER_SIZE, _IOFBF, true,		LinuxFile::init(file, fd, buffer, File::DEFAULT_BUFFER_SIZE, _IOFBF, true,
modeflags);		modeflags);
return file;		return file;
}		}
Show All 24 Lines

libc/src/__support/error_or.h

This file was added.

				//===-- A data structure for returning an error or a value ------- 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_SUPPORT_ERROR_OR_RESULT_H
				#define LLVM_LIBC_SUPPORT_ERROR_OR_RESULT_H

				#include "src/__support/CPP/expected.h"

				namespace __llvm_libc {

				template <class T> using ErrorOr = cpp::expected<T, int>;

				using Error = cpp::unexpected<int>;

				// template <typename T> struct ErrorOr {
				// union {
				// T value;
				// int error;
				// };
				// bool is_error;

				// constexpr ErrorOr(T value) : value(value), is_error(false) {}
				// constexpr ErrorOr(int error, bool is_error)
				// : error(error), is_error(is_error) {}

				// constexpr bool has_error() { return is_error; }

				// constexpr operator bool() { return is_error; }
				// constexpr operator T() { return value; }
				// };

				} // namespace __llvm_libc

				#endif // LLVM_LIBC_SUPPORT_ERROR_OR_RESULT_H

libc/src/__support/threads/linux/CMakeLists.txt

Show All 23 Lines	add_object_library(
thread		thread
SRCS		SRCS
thread.cpp		thread.cpp
DEPENDS		DEPENDS
.futex_word_type		.futex_word_type
libc.config.linux.app_h		libc.config.linux.app_h
libc.include.sys_syscall		libc.include.sys_syscall
libc.src.__support.CPP.atomic		libc.src.__support.CPP.atomic
libc.src.__support.CPP.error		libc.src.__support.error_or
libc.src.__support.CPP.stringstream		libc.src.__support.CPP.stringstream
libc.src.__support.CPP.string_view		libc.src.__support.CPP.string_view
libc.src.__support.threads.thread_common		libc.src.__support.threads.thread_common
COMPILE_OPTIONS		COMPILE_OPTIONS
-O3		-O3
-fno-omit-frame-pointer # This allows us to sniff out the thread args from		-fno-omit-frame-pointer # This allows us to sniff out the thread args from
# the new thread's stack reliably.		# the new thread's stack reliably.
)		)

libc/src/__support/threads/linux/thread.cpp

//===--- Implementation of a Linux thread class ------------------ C++ --===//		//===--- Implementation of a Linux thread class ------------------ C++ --===//
//		//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.		// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "src/__support/threads/thread.h"		#include "src/__support/threads/thread.h"
#include "config/linux/app.h"		#include "config/linux/app.h"
#include "src/__support/CPP/string_view.h"
#include "src/__support/CPP/atomic.h"		#include "src/__support/CPP/atomic.h"
#include "src/__support/CPP/error.h"		#include "src/__support/CPP/string_view.h"
#include "src/__support/CPP/stringstream.h"		#include "src/__support/CPP/stringstream.h"
#include "src/__support/OSUtil/syscall.h" // For syscall functions.		#include "src/__support/OSUtil/syscall.h" // For syscall functions.
		#include "src/__support/error_or.h"
#include "src/__support/threads/linux/futex_word.h" // For FutexWordType		#include "src/__support/threads/linux/futex_word.h" // For FutexWordType

#ifdef LLVM_LIBC_ARCH_AARCH64		#ifdef LLVM_LIBC_ARCH_AARCH64
#include <arm_acle.h>		#include <arm_acle.h>
#endif		#endif

#include <errno.h>		#include <errno.h>
#include <fcntl.h>		#include <fcntl.h>
Show All 25 Lines	static constexpr unsigned CLONE_SYSCALL_FLAGS =
\| CLONE_THREAD // Same thread group as the parent.		\| CLONE_THREAD // Same thread group as the parent.
\| CLONE_SYSVSEM // Share a single list of System V semaphore adjustment		\| CLONE_SYSVSEM // Share a single list of System V semaphore adjustment
// values		// values
\| CLONE_PARENT_SETTID // Set child thread ID in \|ptid\| of the parent.		\| CLONE_PARENT_SETTID // Set child thread ID in \|ptid\| of the parent.
\| CLONE_CHILD_CLEARTID // Let the kernel clear the tid address		\| CLONE_CHILD_CLEARTID // Let the kernel clear the tid address
// wake the joining thread.		// wake the joining thread.
\| CLONE_SETTLS; // Setup the thread pointer of the new thread.		\| CLONE_SETTLS; // Setup the thread pointer of the new thread.

static inline cpp::ErrorOr<void *> alloc_stack(size_t size) {		static inline ErrorOr<void *> alloc_stack(size_t size) {
long mmap_result =		long mmap_result =
__llvm_libc::syscall_impl(MMAP_SYSCALL_NUMBER,		__llvm_libc::syscall_impl(MMAP_SYSCALL_NUMBER,
0, // No special address		0, // No special address
size,		size,
PROT_READ \| PROT_WRITE, // Read and write stack		PROT_READ \| PROT_WRITE, // Read and write stack
MAP_ANONYMOUS \| MAP_PRIVATE, // Process private		MAP_ANONYMOUS \| MAP_PRIVATE, // Process private
-1, // Not backed by any file		-1, // Not backed by any file
0 // No offset		0 // No offset
);		);
if (mmap_result < 0 && (uintptr_t(mmap_result) >= UINTPTR_MAX - size))		if (mmap_result < 0 && (uintptr_t(mmap_result) >= UINTPTR_MAX - size))
return cpp::Error{int(-mmap_result)};		return Error{int(-mmap_result)};
return reinterpret_cast<void *>(mmap_result);		return reinterpret_cast<void *>(mmap_result);
}		}

static inline void free_stack(void *stack, size_t size) {		static inline void free_stack(void *stack, size_t size) {
__llvm_libc::syscall_impl(SYS_munmap, stack, size);		__llvm_libc::syscall_impl(SYS_munmap, stack, size);
}		}

struct Thread;		struct Thread;
Show All 31 Lines
#elif defined(LLVM_LIBC_ARCH_AARCH64)		#elif defined(LLVM_LIBC_ARCH_AARCH64)
// The frame pointer after cloning the new thread in the Thread::run method		// The frame pointer after cloning the new thread in the Thread::run method
// is set to the stack pointer where start args are stored. So, we fetch		// is set to the stack pointer where start args are stored. So, we fetch
// from there.		// from there.
return reinterpret_cast<uintptr_t>(__builtin_frame_address(1));		return reinterpret_cast<uintptr_t>(__builtin_frame_address(1));
#endif		#endif
}		}

__attribute__((noinline))		__attribute__((noinline)) static void start_thread() {
static void start_thread() {
auto start_args = reinterpret_cast<StartArgs >(get_start_args_addr());		auto start_args = reinterpret_cast<StartArgs >(get_start_args_addr());
auto *attrib = start_args->thread_attrib;		auto *attrib = start_args->thread_attrib;
self.attrib = attrib;		self.attrib = attrib;
self.attrib->atexit_callback_mgr = internal::get_thread_atexit_callback_mgr();		self.attrib->atexit_callback_mgr = internal::get_thread_atexit_callback_mgr();

if (attrib->style == ThreadStyle::POSIX) {		if (attrib->style == ThreadStyle::POSIX) {
attrib->retval.posix_retval =		attrib->retval.posix_retval =
start_args->runner.posix_runner(start_args->arg);		start_args->runner.posix_runner(start_args->arg);
Show All 10 Lines
int Thread::run(ThreadStyle style, ThreadRunner runner, void arg, void stack,		int Thread::run(ThreadStyle style, ThreadRunner runner, void arg, void stack,
size_t size, bool detached) {		size_t size, bool detached) {
bool owned_stack = false;		bool owned_stack = false;
if (stack == nullptr) {		if (stack == nullptr) {
if (size == 0)		if (size == 0)
size = DEFAULT_STACK_SIZE;		size = DEFAULT_STACK_SIZE;
auto alloc = alloc_stack(size);		auto alloc = alloc_stack(size);
if (!alloc)		if (!alloc)
return alloc.error_code();		return alloc.error();
else		else
stack = alloc.value();		stack = alloc.value();
owned_stack = true;		owned_stack = true;
}		}

TLSDescriptor tls;		TLSDescriptor tls;
init_tls(tls);		init_tls(tls);

▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines

void thread_exit(ThreadReturnValue retval, ThreadStyle style) {		void thread_exit(ThreadReturnValue retval, ThreadStyle style) {
auto attrib = self.attrib;		auto attrib = self.attrib;

// The very first thing we do is to call the thread's atexit callbacks.		// The very first thing we do is to call the thread's atexit callbacks.
// These callbacks could be the ones registered by the language runtimes,		// These callbacks could be the ones registered by the language runtimes,
// for example, the destructors of thread local objects. They can also		// for example, the destructors of thread local objects. They can also
// be destructors of the TSS objects set using API like pthread_setspecific.		// be destructors of the TSS objects set using API like pthread_setspecific.
// NOTE: We cannot call the atexit callbacks as part of the		// NOTE: We cannot call the atexit callbacks as part of the
// cleanup_thread_resources function as that function can be called from a		// cleanup_thread_resources function as that function can be called from a
// different thread. The destructors of thread local and TSS objects should		// different thread. The destructors of thread local and TSS objects should
// be called by the thread which owns them.		// be called by the thread which owns them.
internal::call_atexit_callbacks(attrib);		internal::call_atexit_callbacks(attrib);

uint32_t joinable_state = uint32_t(DetachState::JOINABLE);		uint32_t joinable_state = uint32_t(DetachState::JOINABLE);
if (!attrib->detach_state.compare_exchange_strong(		if (!attrib->detach_state.compare_exchange_strong(
joinable_state, uint32_t(DetachState::EXITING))) {		joinable_state, uint32_t(DetachState::EXITING))) {
Show All 15 Lines

libc/src/pthread/pthread_setname_np.cpp

	//===-- Linux implementation of the pthread_setname_np function -----------===//			//===-- Linux implementation of the pthread_setname_np function -----------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "pthread_setname_np.h"			#include "pthread_setname_np.h"

	#include "src/__support/CPP/string_view.h"			#include "src/__support/CPP/string_view.h"
	#include "src/__support/CPP/error.h"
	#include "src/__support/common.h"			#include "src/__support/common.h"
	#include "src/__support/threads/thread.h"			#include "src/__support/threads/thread.h"

	#include <pthread.h>			#include <pthread.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),			static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
	"Mismatch between pthread_t and internal Thread.");			"Mismatch between pthread_t and internal Thread.");

	LLVM_LIBC_FUNCTION(int, pthread_setname_np, (pthread_t th, const char *name)) {			LLVM_LIBC_FUNCTION(int, pthread_setname_np, (pthread_t th, const char *name)) {
	auto thread = reinterpret_cast<__llvm_libc::Thread >(&th);			auto thread = reinterpret_cast<__llvm_libc::Thread >(&th);
	return thread->set_name(cpp::string_view(name));			return thread->set_name(cpp::string_view(name));
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/CMakeLists.txt

	Show All 19 Lines
	add_entrypoint_object(			add_entrypoint_object(
	fclose			fclose
	SRCS			SRCS
	fclose.cpp			fclose.cpp
	HDRS			HDRS
	fclose.h			fclose.h
	DEPENDS			DEPENDS
	libc.include.stdio			libc.include.stdio
				libc.include.errno
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	clearerr			clearerr
	SRCS			SRCS
	clearerr.cpp			clearerr.cpp
	▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines

	add_entrypoint_object(			add_entrypoint_object(
	fgetc			fgetc
	SRCS			SRCS
	fgetc.cpp			fgetc.cpp
	HDRS			HDRS
	fgetc.h			fgetc.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	fgetc_unlocked			fgetc_unlocked
	SRCS			SRCS
	fgetc_unlocked.cpp			fgetc_unlocked.cpp
	HDRS			HDRS
	fgetc_unlocked.h			fgetc_unlocked.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	getc			getc
	SRCS			SRCS
	getc.cpp			getc.cpp
	HDRS			HDRS
	getc.h			getc.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	getc_unlocked			getc_unlocked
	SRCS			SRCS
	getc_unlocked.cpp			getc_unlocked.cpp
	HDRS			HDRS
	getc_unlocked.h			getc_unlocked.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	fgets			fgets
	SRCS			SRCS
	fgets.cpp			fgets.cpp
	HDRS			HDRS
	fgets.h			fgets.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

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

	add_entrypoint_object(			add_entrypoint_object(
	flockfile			flockfile
	SRCS			SRCS
	Show All 20 Lines

	add_entrypoint_object(			add_entrypoint_object(
	fread_unlocked			fread_unlocked
	SRCS			SRCS
	fread_unlocked.cpp			fread_unlocked.cpp
	HDRS			HDRS
	fread_unlocked.h			fread_unlocked.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	fread			fread
	SRCS			SRCS
	fread.cpp			fread.cpp
	HDRS			HDRS
	fread.h			fread.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	fwrite_unlocked			fwrite_unlocked
	SRCS			SRCS
	fwrite_unlocked.cpp			fwrite_unlocked.cpp
	HDRS			HDRS
	fwrite_unlocked.h			fwrite_unlocked.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	fwrite			fwrite
	SRCS			SRCS
	fwrite.cpp			fwrite.cpp
	HDRS			HDRS
	fwrite.h			fwrite.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	fputc			fputc
	SRCS			SRCS
	fputc.cpp			fputc.cpp
	HDRS			HDRS
	fputc.h			fputc.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	putc			putc
	SRCS			SRCS
	putc.cpp			putc.cpp
	HDRS			HDRS
	putc.h			putc.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	putchar			putchar
	SRCS			SRCS
	putchar.cpp			putchar.cpp
	HDRS			HDRS
	putchar.h			putchar.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	fputs			fputs
	SRCS			SRCS
	fputs.cpp			fputs.cpp
	HDRS			HDRS
	fputs.h			fputs.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)


	add_entrypoint_object(			add_entrypoint_object(
	puts			puts
	SRCS			SRCS
	puts.cpp			puts.cpp
	HDRS			HDRS
	puts.h			puts.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	fseek			fseek
	SRCS			SRCS
	fseek.cpp			fseek.cpp
	HDRS			HDRS
	fseek.h			fseek.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	ungetc			ungetc
	SRCS			SRCS
	▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Lines

	add_entrypoint_object(			add_entrypoint_object(
	ftell			ftell
	SRCS			SRCS
	ftell.cpp			ftell.cpp
	HDRS			HDRS
	ftell.h			ftell.h
	DEPENDS			DEPENDS
				libc.include.errno
	libc.include.stdio			libc.include.stdio
	libc.src.__support.File.file			libc.src.__support.File.file
	libc.src.__support.File.platform_file			libc.src.__support.File.platform_file
	)			)

	add_entrypoint_object(			add_entrypoint_object(
	remove			remove
	ALIAS			ALIAS
	DEPENDS			DEPENDS
	.${LIBC_TARGET_OS}.remove			.${LIBC_TARGET_OS}.remove
	)			)

libc/src/stdio/fclose.cpp

	//===-- Implementation of fclose ------------------------------------------===//			//===-- Implementation of fclose ------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fclose.h"			#include "src/stdio/fclose.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, fclose, (::FILE * stream)) {			LLVM_LIBC_FUNCTION(int, fclose, (::FILE * stream)) {
	return reinterpret_cast<__llvm_libc::File *>(stream)->close();			int result = reinterpret_cast<__llvm_libc::File *>(stream)->close();
				if (result != 0) {
				errno = result;
				return EOF;
				}
				return 0;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fflush.cpp

	//===-- Implementation of fflush ------------------------------------------===//			//===-- Implementation of fflush ------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fflush.h"			#include "src/stdio/fflush.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, fflush, (::FILE * stream)) {			LLVM_LIBC_FUNCTION(int, fflush, (::FILE * stream)) {
	return reinterpret_cast<__llvm_libc::File *>(stream)->flush();			int result = reinterpret_cast<__llvm_libc::File *>(stream)->flush();
				if (result != 0) {
				errno = result;
				return EOF;
				}
				return 0;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fgetc.cpp

	//===-- Implementation of fgetc -------------------------------------------===//			//===-- Implementation of fgetc -------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fgetc.h"			#include "src/stdio/fgetc.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, fgetc, (::FILE * stream)) {			LLVM_LIBC_FUNCTION(int, fgetc, (::FILE * stream)) {
	unsigned char c;			unsigned char c;
	size_t r = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);			auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);
				size_t r = result.value;
				if (result.has_error())
				errno = result.error;

	if (r != 1)			if (r != 1)
	return EOF;			return EOF;
	return c;			return c;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fgetc_unlocked.cpp

	//===-- Implementation of fgetc_unlocked ----------------------------------===//			//===-- Implementation of fgetc_unlocked ----------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fgetc_unlocked.h"			#include "src/stdio/fgetc_unlocked.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, fgetc_unlocked, (::FILE * stream)) {			LLVM_LIBC_FUNCTION(int, fgetc_unlocked, (::FILE * stream)) {
	unsigned char c;			unsigned char c;
	size_t r =			auto result =
	reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(&c, 1);			reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(&c, 1);
				size_t r = result.value;
				if (result.has_error())
				errno = result.error;
	if (r != 1)			if (r != 1)
	return EOF;			return EOF;
	return c;			return c;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fgets.cpp

	//===-- Implementation of fgets -------------------------------------------===//			//===-- Implementation of fgets -------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fgets.h"			#include "src/stdio/fgets.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stddef.h>			#include <stddef.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(char *, fgets,			LLVM_LIBC_FUNCTION(char *, fgets,
	(char *__restrict str, int count,			(char *__restrict str, int count,
	::FILE *__restrict raw_stream)) {			::FILE *__restrict raw_stream)) {
	if (count < 1)			if (count < 1)
	return nullptr;			return nullptr;

	unsigned char c = '\0';			unsigned char c = '\0';
	auto stream = reinterpret_cast<__llvm_libc::File *__restrict>(raw_stream);			auto stream = reinterpret_cast<__llvm_libc::File *__restrict>(raw_stream);
	stream->lock();			stream->lock();

	// i is an int because it's frequently compared to count, which is also int.			// i is an int because it's frequently compared to count, which is also int.
	int i = 0;			int i = 0;

	for (; i < (count - 1) && c != '\n'; ++i) {			for (; i < (count - 1) && c != '\n'; ++i) {
	size_t r = stream->read_unlocked(&c, 1);			auto result = stream->read_unlocked(&c, 1);
				size_t r = result.value;
				if (result.has_error())
				errno = result.error;

	if (r != 1)			if (r != 1)
	break;			break;
	str[i] = c;			str[i] = c;
	}			}

	bool has_error = stream->error_unlocked();			bool has_error = stream->error_unlocked();
	bool has_eof = stream->iseof_unlocked();			bool has_eof = stream->iseof_unlocked();
	stream->unlock();			stream->unlock();
	Show All 11 Lines

libc/src/stdio/fopen.cpp

	//===-- Implementation of fopen -------------------------------------------===//			//===-- Implementation of fopen -------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fopen.h"			#include "src/stdio/fopen.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(::FILE *, fopen,			LLVM_LIBC_FUNCTION(::FILE *, fopen,
	(const char __restrict name, const char __restrict mode)) {			(const char __restrict name, const char __restrict mode)) {
	return reinterpret_cast<::FILE *>(__llvm_libc::openfile(name, mode));			auto result = __llvm_libc::openfile(name, mode);
				if (!result.has_value()) {
				errno = result.error();
				return nullptr;
				}
				return reinterpret_cast<::FILE *>(result.value());
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fopencookie.cpp

	Show All 17 Lines
	namespace {			namespace {

	class CookieFile : public __llvm_libc::File {			class CookieFile : public __llvm_libc::File {
	public:			public:
	void *cookie;			void *cookie;
	cookie_io_functions_t ops;			cookie_io_functions_t ops;
	};			};

	size_t write_func(File f, const void data, size_t size) {			FileIOResult write_func(File f, const void data, size_t size) {
	auto cookie_file = reinterpret_cast<CookieFile *>(f);			auto cookie_file = reinterpret_cast<CookieFile *>(f);
	if (cookie_file->ops.write == nullptr)			if (cookie_file->ops.write == nullptr)
	return 0;			return 0;
	return cookie_file->ops.write(cookie_file->cookie,			return cookie_file->ops.write(cookie_file->cookie,
	reinterpret_cast<const char *>(data), size);			reinterpret_cast<const char *>(data), size);
	}			}

	size_t read_func(File f, void data, size_t size) {			FileIOResult read_func(File f, void data, size_t size) {
	auto cookie_file = reinterpret_cast<CookieFile *>(f);			auto cookie_file = reinterpret_cast<CookieFile *>(f);
	if (cookie_file->ops.read == nullptr)			if (cookie_file->ops.read == nullptr)
	return 0;			return 0;
	return cookie_file->ops.read(cookie_file->cookie,			return cookie_file->ops.read(cookie_file->cookie,
	reinterpret_cast<char *>(data), size);			reinterpret_cast<char *>(data), size);
	}			}

	long seek_func(File *f, long offset, int whence) {			ErrorOr<long> seek_func(File *f, long offset, int whence) {
	auto cookie_file = reinterpret_cast<CookieFile *>(f);			auto cookie_file = reinterpret_cast<CookieFile *>(f);
	if (cookie_file->ops.seek == nullptr) {			if (cookie_file->ops.seek == nullptr) {
	errno = EINVAL;			return Error(EINVAL);
	return -1;
	}			}
	off64_t offset64 = offset;			off64_t offset64 = offset;
	int result = cookie_file->ops.seek(cookie_file->cookie, &offset64, whence);			int result = cookie_file->ops.seek(cookie_file->cookie, &offset64, whence);
	if (result == 0)			if (result == 0)
	return offset64;			return offset64;
	else			else
	return -1;			return -1;
	}			}
	Show All 33 Lines

libc/src/stdio/fputc.cpp

	//===-- Implementation of fputc -------------------------------------------===//			//===-- Implementation of fputc -------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fputc.h"			#include "src/stdio/fputc.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, fputc, (int c, ::FILE *stream)) {			LLVM_LIBC_FUNCTION(int, fputc, (int c, ::FILE *stream)) {
	unsigned char uc = static_cast<unsigned char>(c);			unsigned char uc = static_cast<unsigned char>(c);
	size_t written = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
				auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
				if (result.has_error())
				errno = result.error;
				size_t written = result.value;

	if (1 != written) {			if (1 != written) {
	// The stream should be in an error state in this case.			// The stream should be in an error state in this case.
	return EOF;			return EOF;
	}			}
	return 0;			return 0;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fputs.cpp

	//===-- Implementation of fputs -------------------------------------------===//			//===-- Implementation of fputs -------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fputs.h"			#include "src/stdio/fputs.h"
	#include "src/__support/CPP/string_view.h"			#include "src/__support/CPP/string_view.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, fputs,			LLVM_LIBC_FUNCTION(int, fputs,
	(const char __restrict str, ::FILE __restrict stream)) {			(const char __restrict str, ::FILE __restrict stream)) {
	cpp::string_view str_view(str);			cpp::string_view str_view(str);

	size_t written = reinterpret_cast<__llvm_libc::File *>(stream)->write(			auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(
	str, str_view.size());			str, str_view.size());
				if (result.has_error())
				errno = result.error;
				size_t written = result.value;

	if (str_view.size() != written) {			if (str_view.size() != written) {
	// The stream should be in an error state in this case.			// The stream should be in an error state in this case.
	return EOF;			return EOF;
	}			}
	return 0;			return 0;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fread.cpp

	//===-- Implementation of fread -------------------------------------------===//			//===-- Implementation of fread -------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fread.h"			#include "src/stdio/fread.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(size_t, fread,			LLVM_LIBC_FUNCTION(size_t, fread,
	(void *__restrict buffer, size_t size, size_t nmemb,			(void *__restrict buffer, size_t size, size_t nmemb,
	::FILE *stream)) {			::FILE *stream)) {
	if (size == 0 \|\| nmemb == 0)			if (size == 0 \|\| nmemb == 0)
	return 0;			return 0;
	return reinterpret_cast<__llvm_libc::File *>(stream)->read(buffer,			auto result =
	size * nmemb) /			reinterpret_cast<__llvm_libc::File >(stream)->read(buffer, size nmemb);
	size;			if (result.has_error())
				errno = result.error;
				return result.value / size;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fread_unlocked.cpp

	//===-- Implementation of fread_unlocked ----------------------------------===//			//===-- Implementation of fread_unlocked ----------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fread_unlocked.h"			#include "src/stdio/fread_unlocked.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(size_t, fread_unlocked,			LLVM_LIBC_FUNCTION(size_t, fread_unlocked,
	(void *__restrict buffer, size_t size, size_t nmemb,			(void *__restrict buffer, size_t size, size_t nmemb,
	::FILE *stream)) {			::FILE *stream)) {
	return reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(			if (size == 0 \|\| nmemb == 0)
				return 0;
				auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(
	buffer, size * nmemb);			buffer, size * nmemb);
				if (result.has_error())
				errno = result.error;
				return result.value / size;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fseek.cpp

	//===-- Implementation of fseek -------------------------------------------===//			//===-- Implementation of fseek -------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fseek.h"			#include "src/stdio/fseek.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, fseek, (::FILE * stream, long offset, int whence)) {			LLVM_LIBC_FUNCTION(int, fseek, (::FILE * stream, long offset, int whence)) {
	return reinterpret_cast<__llvm_libc::File *>(stream)->seek(offset, whence);			auto result =
				reinterpret_cast<__llvm_libc::File *>(stream)->seek(offset, whence);
				if (!result.has_value()) {
				errno = result.error();
				return -1;
				}
				return 0;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/ftell.cpp

	//===-- Implementation of ftell -------------------------------------------===//			//===-- Implementation of ftell -------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/ftell.h"			#include "src/stdio/ftell.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(long, ftell, (::FILE * stream)) {			LLVM_LIBC_FUNCTION(long, ftell, (::FILE * stream)) {
	return reinterpret_cast<__llvm_libc::File *>(stream)->tell();			auto result = reinterpret_cast<__llvm_libc::File *>(stream)->tell();
				if (!result.has_value()) {
				errno = result.error();
				return -1;
				}
				return result.value();
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fwrite.cpp

	//===-- Implementation of fwrite ------------------------------------------===//			//===-- Implementation of fwrite ------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fwrite.h"			#include "src/stdio/fwrite.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(size_t, fwrite,			LLVM_LIBC_FUNCTION(size_t, fwrite,
	(const void *__restrict buffer, size_t size, size_t nmemb,			(const void *__restrict buffer, size_t size, size_t nmemb,
	::FILE *stream)) {			::FILE *stream)) {
	if (size == 0 \|\| nmemb == 0)			if (size == 0 \|\| nmemb == 0)
	return 0;			return 0;
	return reinterpret_cast<__llvm_libc::File *>(stream)->write(buffer,			auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(
	size * nmemb) /			buffer, size * nmemb);
	size;			if (result.has_error())
				errno = result.error;

				return result.value / size;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/fwrite_unlocked.cpp

	//===-- Implementation of fwrite_unlocked ---------------------------------===//			//===-- Implementation of fwrite_unlocked ---------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/fwrite_unlocked.h"			#include "src/stdio/fwrite_unlocked.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(size_t, fwrite_unlocked,			LLVM_LIBC_FUNCTION(size_t, fwrite_unlocked,
	(const void *__restrict buffer, size_t size, size_t nmemb,			(const void *__restrict buffer, size_t size, size_t nmemb,
	::FILE *stream)) {			::FILE *stream)) {
	return reinterpret_cast<__llvm_libc::File *>(stream)->write_unlocked(
				if (size == 0 \|\| nmemb == 0)
				return 0;
				auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write_unlocked(
	buffer, size * nmemb);			buffer, size * nmemb);
				if (result.has_error())
				errno = result.error;

				return result.value / size;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/getc.cpp

	//===-- Implementation of getc --------------------------------------------===//			//===-- Implementation of getc --------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/getc.h"			#include "src/stdio/getc.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, getc, (::FILE * stream)) {			LLVM_LIBC_FUNCTION(int, getc, (::FILE * stream)) {
	unsigned char c;			unsigned char c;
	size_t r = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);			auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);
				size_t r = result.value;
				if (result.has_error())
				errno = result.error;

	if (r != 1)			if (r != 1)
	return EOF;			return EOF;
	return c;			return c;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/getc_unlocked.cpp

	//===-- Implementation of getc_unlocked ----------------------------------===//			//===-- Implementation of getc_unlocked ----------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/getc_unlocked.h"			#include "src/stdio/getc_unlocked.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, getc_unlocked, (::FILE * stream)) {			LLVM_LIBC_FUNCTION(int, getc_unlocked, (::FILE * stream)) {
	unsigned char c;			unsigned char c;
	size_t r =			auto result =
	reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(&c, 1);			reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(&c, 1);
				size_t r = result.value;
				if (result.has_error())
				errno = result.error;

	if (r != 1)			if (r != 1)
	return EOF;			return EOF;
	return c;			return c;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/printf_core/file_writer.cpp

	Show All 10 Lines
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"
	#include "src/stdio/printf_core/core_structs.h"			#include "src/stdio/printf_core/core_structs.h"
	#include <stddef.h>			#include <stddef.h>

	namespace __llvm_libc {			namespace __llvm_libc {
	namespace printf_core {			namespace printf_core {

	int FileWriter::write(const char *__restrict to_write, size_t len) {			int FileWriter::write(const char *__restrict to_write, size_t len) {
	int written = file->write_unlocked(to_write, len);			auto result = file->write_unlocked(to_write, len);
	if (written != static_cast<int>(len))			int written = result.value;
				if (written != static_cast<int>(len) \|\| result.has_error())
	written = FILE_WRITE_ERROR;			written = FILE_WRITE_ERROR;
	if (file->error_unlocked())			if (file->error_unlocked())
	written = FILE_STATUS_ERROR;			written = FILE_STATUS_ERROR;
	return written;			return written;
	}			}

	int FileWriter::write_str(void *raw_pointer, cpp::string_view new_string) {			int FileWriter::write_str(void *raw_pointer, cpp::string_view new_string) {
	FileWriter file_writer = reinterpret_cast<FileWriter >(raw_pointer);			FileWriter file_writer = reinterpret_cast<FileWriter >(raw_pointer);
	Show All 25 Lines

libc/src/stdio/putc.cpp

	//===-- Implementation of putc --------------------------------------------===//			//===-- Implementation of putc --------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/putc.h"			#include "src/stdio/putc.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, putc, (int c, ::FILE *stream)) {			LLVM_LIBC_FUNCTION(int, putc, (int c, ::FILE *stream)) {
	unsigned char uc = static_cast<unsigned char>(c);			unsigned char uc = static_cast<unsigned char>(c);
	size_t written = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
				auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
				if (result.has_error())
				errno = result.error;
				size_t written = result.value;

	if (1 != written) {			if (1 != written) {
	// The stream should be in an error state in this case.			// The stream should be in an error state in this case.
	return EOF;			return EOF;
	}			}
	return 0;			return 0;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/putchar.cpp

	//===-- Implementation of putchar -----------------------------------------===//			//===-- Implementation of putchar -----------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/putchar.h"			#include "src/stdio/putchar.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, putchar, (int c)) {			LLVM_LIBC_FUNCTION(int, putchar, (int c)) {
	unsigned char uc = static_cast<unsigned char>(c);			unsigned char uc = static_cast<unsigned char>(c);
	size_t written = __llvm_libc::stdout->write(&uc, 1);
				auto result = __llvm_libc::stdout->write(&uc, 1);
				if (result.has_error())
				errno = result.error;
				size_t written = result.value;

	if (1 != written) {			if (1 != written) {
	// The stream should be in an error state in this case.			// The stream should be in an error state in this case.
	return EOF;			return EOF;
	}			}
	return 0;			return 0;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/puts.cpp

	//===-- Implementation of puts --------------------------------------------===//			//===-- Implementation of puts --------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "src/stdio/puts.h"			#include "src/stdio/puts.h"
	#include "src/__support/CPP/string_view.h"			#include "src/__support/CPP/string_view.h"
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"

				#include <errno.h>
	#include <stdio.h>			#include <stdio.h>

	namespace __llvm_libc {			namespace __llvm_libc {

	LLVM_LIBC_FUNCTION(int, puts, (const char *__restrict str)) {			LLVM_LIBC_FUNCTION(int, puts, (const char *__restrict str)) {
	cpp::string_view str_view(str);			cpp::string_view str_view(str);
	size_t written = __llvm_libc::stdout->write(str, str_view.size());			auto result = __llvm_libc::stdout->write(str, str_view.size());
				if (result.has_error())
				errno = result.error;
				size_t written = result.value;
	if (str_view.size() != written) {			if (str_view.size() != written) {
	// The stream should be in an error state in this case.			// The stream should be in an error state in this case.
	return EOF;			return EOF;
	}			}
	written = __llvm_libc::stdout->write("\n", 1);			result = __llvm_libc::stdout->write("\n", 1);
				if (result.has_error())
				errno = result.error;
				written = result.value;
	if (1 != written) {			if (1 != written) {
	// The stream should be in an error state in this case.			// The stream should be in an error state in this case.
	return EOF;			return EOF;
	}			}
	return 0;			return 0;
	}			}

	} // namespace __llvm_libc			} // namespace __llvm_libc

libc/src/stdio/scanf_core/file_reader.cpp

	Show All 9 Lines
	#include "src/__support/File/file.h"			#include "src/__support/File/file.h"
	#include <stddef.h>			#include <stddef.h>

	namespace __llvm_libc {			namespace __llvm_libc {
	namespace scanf_core {			namespace scanf_core {

	char FileReader::get_char() {			char FileReader::get_char() {
	char tiny_buff = 0;			char tiny_buff = 0;
	if (file->read_unlocked(&tiny_buff, 1) != 1)			auto result = file->read_unlocked(&tiny_buff, 1);
				if (result.value != 1 \|\| result.has_error())
	return 0;			return 0;
	return tiny_buff;			return tiny_buff;
	}			}

	void FileReader::unget_char(char c) { file->ungetc_unlocked(c); }			void FileReader::unget_char(char c) { file->ungetc_unlocked(c); }

	} // namespace scanf_core			} // namespace scanf_core
	} // namespace __llvm_libc			} // namespace __llvm_libc

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

//===-- Unittests for platform independent file class ---------------------===//		//===-- Unittests for platform independent file class ---------------------===//
//		//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.		// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "src/__support/File/file.h"		#include "src/__support/File/file.h"
		#include "src/__support/error_or.h"
#include "utils/UnitTest/MemoryMatcher.h"		#include "utils/UnitTest/MemoryMatcher.h"
#include "utils/UnitTest/Test.h"		#include "utils/UnitTest/Test.h"

#include <errno.h>
#include <stdio.h>		#include <stdio.h>
#include <stdlib.h>		#include <stdlib.h>

using ModeFlags = __llvm_libc::File::ModeFlags;		using ModeFlags = __llvm_libc::File::ModeFlags;
using MemoryView = __llvm_libc::memory::testing::MemoryView;		using MemoryView = __llvm_libc::memory::testing::MemoryView;
		using __llvm_libc::ErrorOr;
		using __llvm_libc::FileIOResult;

class StringFile : public __llvm_libc::File {		class StringFile : public __llvm_libc::File {
static constexpr size_t SIZE = 512;		static constexpr size_t SIZE = 512;
size_t pos;		size_t pos;
char str[SIZE] = {0};		char str[SIZE] = {0};
size_t eof_marker;		size_t eof_marker;
bool write_append;		bool write_append;

static size_t str_read(__llvm_libc::File f, void data, size_t len);		static FileIOResult 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 FileIOResult str_write(__llvm_libc::File f, const void data,
static long str_seek(__llvm_libc::File *f, long offset, int whence);		size_t len);
		static ErrorOr<long> str_seek(__llvm_libc::File *f, long offset, int whence);
static int str_close(__llvm_libc::File *f) { return 0; }		static int str_close(__llvm_libc::File *f) { return 0; }
static int str_flush(__llvm_libc::File *f) { return 0; }		static int str_flush(__llvm_libc::File *f) { return 0; }

public:		public:
explicit StringFile(char *buffer, size_t buflen, int bufmode, bool owned,		explicit StringFile(char *buffer, size_t buflen, int bufmode, bool owned,
ModeFlags modeflags)		ModeFlags modeflags)
: __llvm_libc::File(&str_write, &str_read, &str_seek, &str_close,		: __llvm_libc::File(&str_write, &str_read, &str_seek, &str_close,
&str_flush, buffer, buflen, bufmode, owned,		&str_flush, buffer, buflen, bufmode, owned,
Show All 24 Lines	void reset_and_fill(const char *data, size_t len) {
for (i = 0; i < len && i < SIZE; ++i) {		for (i = 0; i < len && i < SIZE; ++i) {
str[i] = data[i];		str[i] = data[i];
}		}
pos = 0;		pos = 0;
eof_marker = i;		eof_marker = i;
}		}
};		};

size_t StringFile::str_read(__llvm_libc::File f, void data, size_t len) {		FileIOResult StringFile::str_read(__llvm_libc::File f, void data,
		size_t len) {
StringFile sf = static_cast<StringFile >(f);		StringFile sf = static_cast<StringFile >(f);
if (sf->pos >= sf->eof_marker)		if (sf->pos >= sf->eof_marker)
return 0;		return 0;
size_t i = 0;		size_t i = 0;
for (i = 0; i < len; ++i)		for (i = 0; i < len; ++i)
reinterpret_cast<char *>(data)[i] = sf->str[sf->pos + i];		reinterpret_cast<char *>(data)[i] = sf->str[sf->pos + i];
sf->pos += i;		sf->pos += i;
return i;		return i;
}		}

size_t StringFile::str_write(__llvm_libc::File f, const void data,		FileIOResult StringFile::str_write(__llvm_libc::File f, const void data,
size_t len) {		size_t len) {
StringFile sf = static_cast<StringFile >(f);		StringFile sf = static_cast<StringFile >(f);
if (sf->write_append)		if (sf->write_append)
sf->pos = sf->eof_marker;		sf->pos = sf->eof_marker;
if (sf->pos >= SIZE)		if (sf->pos >= SIZE)
return 0;		return 0;
size_t i = 0;		size_t i = 0;
for (i = 0; i < len && sf->pos < SIZE; ++i, ++sf->pos)		for (i = 0; i < len && sf->pos < SIZE; ++i, ++sf->pos)
sf->str[sf->pos] = reinterpret_cast<const char *>(data)[i];		sf->str[sf->pos] = reinterpret_cast<const char *>(data)[i];
// Move the eof marker if the data was written beyond the current eof marker.		// Move the eof marker if the data was written beyond the current eof marker.
if (sf->pos > sf->eof_marker)		if (sf->pos > sf->eof_marker)
sf->eof_marker = sf->pos;		sf->eof_marker = sf->pos;
return i;		return i;
}		}

long StringFile::str_seek(__llvm_libc::File *f, long offset, int whence) {		ErrorOr<long> StringFile::str_seek(__llvm_libc::File *f, long offset,
		int whence) {
StringFile sf = static_cast<StringFile >(f);		StringFile sf = static_cast<StringFile >(f);
if (whence == SEEK_SET)		if (whence == SEEK_SET)
sf->pos = offset;		sf->pos = offset;
if (whence == SEEK_CUR)		if (whence == SEEK_CUR)
sf->pos += offset;		sf->pos += offset;
if (whence == SEEK_END)		if (whence == SEEK_END)
sf->pos = SIZE + offset;		sf->pos = SIZE + offset;
return sf->pos;		return sf->pos;
}		}

StringFile new_string_file(char buffer, size_t buflen, int bufmode,		StringFile new_string_file(char buffer, size_t buflen, int bufmode,
bool owned, const char *mode) {		bool owned, const char *mode) {
StringFile f = reinterpret_cast<StringFile >(malloc(sizeof(StringFile)));		StringFile f = reinterpret_cast<StringFile >(malloc(sizeof(StringFile)));
f->init(buffer, buflen, bufmode, owned, __llvm_libc::File::mode_flags(mode));		f->init(buffer, buflen, bufmode, owned, __llvm_libc::File::mode_flags(mode));
return f;		return f;
}		}

TEST(LlvmLibcFileTest, WriteOnly) {		TEST(LlvmLibcFileTest, WriteOnly) {
const char data[] = "hello, file";		const char data[] = "hello, file";
constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;		constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w");

ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream		EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
ASSERT_EQ(f->flush(), 0);		ASSERT_EQ(f->flush(), 0);
EXPECT_EQ(f->get_pos(), sizeof(data)); // Data should now be available		EXPECT_EQ(f->get_pos(), sizeof(data)); // Data should now be available
EXPECT_STREQ(f->get_str(), data);		EXPECT_STREQ(f->get_str(), data);

f->reset();		f->reset();
ASSERT_EQ(f->get_pos(), size_t(0));		ASSERT_EQ(f->get_pos(), size_t(0));
ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream		EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
// The second write should trigger a buffer flush.		// The second write should trigger a buffer flush.
ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
EXPECT_GE(f->get_pos(), size_t(0));		EXPECT_GE(f->get_pos(), size_t(0));
ASSERT_EQ(f->flush(), 0);		ASSERT_EQ(f->flush(), 0);
EXPECT_EQ(f->get_pos(), 2 * sizeof(data));		EXPECT_EQ(f->get_pos(), 2 * sizeof(data));
MemoryView src1("hello, file\0hello, file", sizeof(data) * 2),		MemoryView src1("hello, file\0hello, file", sizeof(data) * 2),
dst1(f->get_str(), sizeof(data) * 2);		dst1(f->get_str(), sizeof(data) * 2);
EXPECT_MEM_EQ(src1, dst1);		EXPECT_MEM_EQ(src1, dst1);

char read_data[sizeof(data)];		char read_data[sizeof(data)];
		{
// This is not a readable file.		// This is not a readable file.
EXPECT_EQ(f->read(read_data, sizeof(data)), size_t(0));		auto result = f->read(read_data, sizeof(data));
		EXPECT_EQ(result.value, size_t(0));
EXPECT_TRUE(f->error());		EXPECT_TRUE(f->error());
EXPECT_NE(errno, 0);		EXPECT_TRUE(result.has_error());
errno = 0;		}

ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, WriteLineBuffered) {		TEST(LlvmLibcFileTest, WriteLineBuffered) {
const char data[] = "hello\n file";		const char data[] = "hello\n file";
constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;		constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;

char file_buffer_line[FILE_BUFFER_SIZE];		char file_buffer_line[FILE_BUFFER_SIZE];
char file_buffer_full[FILE_BUFFER_SIZE];		char file_buffer_full[FILE_BUFFER_SIZE];

StringFile *f_line =		StringFile *f_line =
new_string_file(file_buffer_line, FILE_BUFFER_SIZE, _IOLBF, false, "w");		new_string_file(file_buffer_line, FILE_BUFFER_SIZE, _IOLBF, false, "w");
// We also initialize a fully buffered file we'll do the same writes to for		// We also initialize a fully buffered file we'll do the same writes to for
// comparison.		// comparison.
StringFile *f_full =		StringFile *f_full =
new_string_file(file_buffer_full, FILE_BUFFER_SIZE, _IOFBF, false, "w");		new_string_file(file_buffer_full, FILE_BUFFER_SIZE, _IOFBF, false, "w");

ASSERT_EQ(sizeof(data), f_line->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f_line->write(data, sizeof(data)).value);
ASSERT_EQ(sizeof(data), f_full->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f_full->write(data, sizeof(data)).value);

EXPECT_EQ(f_line->get_pos(), size_t(6)); // buffer after the newline		EXPECT_EQ(f_line->get_pos(), size_t(6)); // buffer after the newline
EXPECT_EQ(f_full->get_pos(), size_t(0)); // buffer all of data		EXPECT_EQ(f_full->get_pos(), size_t(0)); // buffer all of data

MemoryView src1("hello\n", 6), dst1(f_line->get_str(), 6);		MemoryView src1("hello\n", 6), dst1(f_line->get_str(), 6);
EXPECT_MEM_EQ(src1, dst1);		EXPECT_MEM_EQ(src1, dst1);

// We can't check the data in f_full, since no data has been written.		// We can't check the data in f_full, since no data has been written.

const char data2[] = "longer for an \n overflow";		const char data2[] = "longer for an \n overflow";

ASSERT_EQ(sizeof(data2), f_line->write(data2, sizeof(data2)));		ASSERT_EQ(sizeof(data2), f_line->write(data2, sizeof(data2)).value);
// The line buffer's initial contents should be " file\0"		// The line buffer's initial contents should be " file\0"
// Writing data2 should write up until the newline, even though that doesn't		// Writing data2 should write up until the newline, even though that doesn't
// all fit in the buffer.		// all fit in the buffer.

ASSERT_EQ(sizeof(data2), f_full->write(data2, sizeof(data2)));		ASSERT_EQ(sizeof(data2), f_full->write(data2, sizeof(data2)).value);
// The full buffer's initial contents should be "hello\n file\0"		// The full buffer's initial contents should be "hello\n file\0"
// Writing data2 should cause a flush of the buffer, as well as the remainder		// Writing data2 should cause a flush of the buffer, as well as the remainder
// to be written directly since it doesn't fit in the buffer.		// to be written directly since it doesn't fit in the buffer.

EXPECT_EQ(f_line->get_pos(), size_t(27));		EXPECT_EQ(f_line->get_pos(), size_t(27));
EXPECT_EQ(f_full->get_pos(), sizeof(data) + sizeof(data2));		EXPECT_EQ(f_full->get_pos(), sizeof(data) + sizeof(data2));

MemoryView src2("hello\n file\0longer for an \n", 27),		MemoryView src2("hello\n file\0longer for an \n", 27),
Show All 18 Lines

TEST(LlvmLibcFileTest, WriteUnbuffered) {		TEST(LlvmLibcFileTest, WriteUnbuffered) {
const char data[] = "written immediately";		const char data[] = "written immediately";
constexpr size_t FILE_BUFFER_SIZE = sizeof(data) + 1;		constexpr size_t FILE_BUFFER_SIZE = sizeof(data) + 1;
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IONBF, false, "w");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IONBF, false, "w");

ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
EXPECT_EQ(f->get_pos(),		EXPECT_EQ(f->get_pos(),
sizeof(data)); // no buffering means this is written immediately.		sizeof(data)); // no buffering means this is written immediately.
EXPECT_STREQ(f->get_str(), data);		EXPECT_STREQ(f->get_str(), data);

ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, ReadOnly) {		TEST(LlvmLibcFileTest, ReadOnly) {
const char initial_content[] = "1234567890987654321";		const char initial_content[] = "1234567890987654321";
constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);		constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r");
f->reset_and_fill(initial_content, sizeof(initial_content));		f->reset_and_fill(initial_content, sizeof(initial_content));

constexpr size_t READ_SIZE = sizeof(initial_content) / 2;		constexpr size_t READ_SIZE = sizeof(initial_content) / 2;
char read_data[READ_SIZE];		char read_data[READ_SIZE];
ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));		ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
EXPECT_FALSE(f->iseof());		EXPECT_FALSE(f->iseof());
// Reading less than file buffer worth will still read one		// Reading less than file buffer worth will still read one
// full buffer worth of data.		// full buffer worth of data.
EXPECT_STREQ(file_buffer, initial_content);		EXPECT_STREQ(file_buffer, initial_content);
EXPECT_STREQ(file_buffer, f->get_str());		EXPECT_STREQ(file_buffer, f->get_str());
EXPECT_EQ(FILE_BUFFER_SIZE, f->get_pos());		EXPECT_EQ(FILE_BUFFER_SIZE, f->get_pos());
// The read data should match what was supposed to be read anyway.		// The read data should match what was supposed to be read anyway.
MemoryView src1(initial_content, READ_SIZE), dst1(read_data, READ_SIZE);		MemoryView src1(initial_content, READ_SIZE), dst1(read_data, READ_SIZE);
EXPECT_MEM_EQ(src1, dst1);		EXPECT_MEM_EQ(src1, dst1);

// Reading another buffer worth should read out everything in		// Reading another buffer worth should read out everything in
// the file.		// the file.
ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));		ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
EXPECT_FALSE(f->iseof());		EXPECT_FALSE(f->iseof());
MemoryView src2(initial_content + READ_SIZE, READ_SIZE),		MemoryView src2(initial_content + READ_SIZE, READ_SIZE),
dst2(read_data, READ_SIZE);		dst2(read_data, READ_SIZE);
EXPECT_MEM_EQ(src2, dst2);		EXPECT_MEM_EQ(src2, dst2);

// Another read should trigger an EOF.		// Another read should trigger an EOF.
ASSERT_GT(READ_SIZE, f->read(read_data, READ_SIZE));		ASSERT_GT(READ_SIZE, f->read(read_data, READ_SIZE).value);
EXPECT_TRUE(f->iseof());		EXPECT_TRUE(f->iseof());

// Reset the pos to the beginning of the file which should allow		// Reset the pos to the beginning of the file which should allow
// reading again.		// reading again.
for (size_t i = 0; i < READ_SIZE; ++i)		for (size_t i = 0; i < READ_SIZE; ++i)
read_data[i] = 0;		read_data[i] = 0;
f->seek(0, SEEK_SET);		f->seek(0, SEEK_SET);
ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));		ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
MemoryView src3(initial_content, READ_SIZE), dst3(read_data, READ_SIZE);		MemoryView src3(initial_content, READ_SIZE), dst3(read_data, READ_SIZE);
EXPECT_MEM_EQ(src3, dst3);		EXPECT_MEM_EQ(src3, dst3);

		{
// This is not a writable file.		// This is not a writable file.
EXPECT_EQ(f->write(initial_content, sizeof(initial_content)), size_t(0));		auto result = f->write(initial_content, sizeof(initial_content));
		EXPECT_EQ(result.value, size_t(0));
EXPECT_TRUE(f->error());		EXPECT_TRUE(f->error());
EXPECT_NE(errno, 0);		EXPECT_TRUE(result.has_error());
errno = 0;		}

ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, ReadSeekCurAndRead) {		TEST(LlvmLibcFileTest, ReadSeekCurAndRead) {
const char initial_content[] = "1234567890987654321";		const char initial_content[] = "1234567890987654321";
constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);		constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r");
f->reset_and_fill(initial_content, sizeof(initial_content));		f->reset_and_fill(initial_content, sizeof(initial_content));

constexpr size_t READ_SIZE = 5;		constexpr size_t READ_SIZE = 5;
char data[READ_SIZE];		char data[READ_SIZE];
data[READ_SIZE - 1] = '\0';		data[READ_SIZE - 1] = '\0';
ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);		ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
ASSERT_STREQ(data, "1234");		ASSERT_STREQ(data, "1234");
ASSERT_EQ(f->seek(5, SEEK_CUR), 0);		ASSERT_EQ(f->seek(5, SEEK_CUR).value(), 0);
ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);		ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
ASSERT_STREQ(data, "0987");		ASSERT_STREQ(data, "0987");
ASSERT_EQ(f->seek(-5, SEEK_CUR), 0);		ASSERT_EQ(f->seek(-5, SEEK_CUR).value(), 0);
ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);		ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
ASSERT_STREQ(data, "9098");		ASSERT_STREQ(data, "9098");
ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, AppendOnly) {		TEST(LlvmLibcFileTest, AppendOnly) {
const char initial_content[] = "1234567890987654321";		const char initial_content[] = "1234567890987654321";
const char write_data[] = "append";		const char write_data[] = "append";
constexpr size_t FILE_BUFFER_SIZE = sizeof(write_data) * 3 / 2;		constexpr size_t FILE_BUFFER_SIZE = sizeof(write_data) * 3 / 2;
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "a");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "a");
f->reset_and_fill(initial_content, sizeof(initial_content));		f->reset_and_fill(initial_content, sizeof(initial_content));

constexpr size_t READ_SIZE = 5;		constexpr size_t READ_SIZE = 5;
char read_data[READ_SIZE];		char read_data[READ_SIZE];

		{
// This is not a readable file.		// This is not a readable file.
ASSERT_EQ(f->read(read_data, READ_SIZE), size_t(0));		auto result = f->read(read_data, READ_SIZE);
		EXPECT_EQ(result.value, size_t(0));
EXPECT_TRUE(f->error());		EXPECT_TRUE(f->error());
EXPECT_NE(errno, 0);		EXPECT_TRUE(result.has_error());
errno = 0;		}

// Write should succeed but will be buffered in the file stream.		// Write should succeed but will be buffered in the file stream.
ASSERT_EQ(f->write(write_data, sizeof(write_data)), sizeof(write_data));		ASSERT_EQ(f->write(write_data, sizeof(write_data)).value, sizeof(write_data));
EXPECT_EQ(f->get_pos(), size_t(0));		EXPECT_EQ(f->get_pos(), size_t(0));
// Flushing will write to the file.		// Flushing will write to the file.
EXPECT_EQ(f->flush(), int(0));		EXPECT_EQ(f->flush(), int(0));
EXPECT_EQ(f->get_pos(), sizeof(write_data) + sizeof(initial_content));		EXPECT_EQ(f->get_pos(), sizeof(write_data) + sizeof(initial_content));

ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, WriteUpdate) {		TEST(LlvmLibcFileTest, WriteUpdate) {
const char data[] = "hello, file";		const char data[] = "hello, file";
constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;		constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w+");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w+");

ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream		EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream

ASSERT_EQ(f->seek(0, SEEK_SET), 0);		ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);

// Seek flushes the stream buffer so we can read the previously written data.		// Seek flushes the stream buffer so we can read the previously written data.
char read_data[sizeof(data)];		char read_data[sizeof(data)];
ASSERT_EQ(f->read(read_data, sizeof(data)), sizeof(data));		ASSERT_EQ(f->read(read_data, sizeof(data)).value, sizeof(data));
EXPECT_STREQ(read_data, data);		EXPECT_STREQ(read_data, data);

ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, ReadUpdate) {		TEST(LlvmLibcFileTest, ReadUpdate) {
const char initial_content[] = "1234567890987654321";		const char initial_content[] = "1234567890987654321";
constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);		constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r+");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r+");
f->reset_and_fill(initial_content, sizeof(initial_content));		f->reset_and_fill(initial_content, sizeof(initial_content));

constexpr size_t READ_SIZE = sizeof(initial_content) / 2;		constexpr size_t READ_SIZE = sizeof(initial_content) / 2;
char read_data[READ_SIZE];		char read_data[READ_SIZE];
ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));		ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
EXPECT_FALSE(f->iseof());		EXPECT_FALSE(f->iseof());
// Reading less than file buffer worth will still read one		// Reading less than file buffer worth will still read one
// full buffer worth of data.		// full buffer worth of data.
EXPECT_STREQ(file_buffer, initial_content);		EXPECT_STREQ(file_buffer, initial_content);
EXPECT_STREQ(file_buffer, f->get_str());		EXPECT_STREQ(file_buffer, f->get_str());
EXPECT_EQ(FILE_BUFFER_SIZE, f->get_pos());		EXPECT_EQ(FILE_BUFFER_SIZE, f->get_pos());
// The read data should match what was supposed to be read anyway.		// The read data should match what was supposed to be read anyway.
MemoryView src1(initial_content, READ_SIZE), dst1(read_data, READ_SIZE);		MemoryView src1(initial_content, READ_SIZE), dst1(read_data, READ_SIZE);
EXPECT_MEM_EQ(src1, dst1);		EXPECT_MEM_EQ(src1, dst1);

ASSERT_EQ(f->seek(0, SEEK_SET), 0);		ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
const char write_data[] = "hello, file";		const char write_data[] = "hello, file";
ASSERT_EQ(sizeof(write_data), f->write(write_data, sizeof(write_data)));		ASSERT_EQ(sizeof(write_data), f->write(write_data, sizeof(write_data)).value);
EXPECT_STREQ(file_buffer, write_data);		EXPECT_STREQ(file_buffer, write_data);
ASSERT_EQ(f->flush(), 0);		ASSERT_EQ(f->flush(), 0);
MemoryView dst2(f->get_str(), sizeof(write_data)),		MemoryView dst2(f->get_str(), sizeof(write_data)),
src2(write_data, sizeof(write_data));		src2(write_data, sizeof(write_data));
EXPECT_MEM_EQ(src2, dst2);		EXPECT_MEM_EQ(src2, dst2);

ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, AppendUpdate) {		TEST(LlvmLibcFileTest, AppendUpdate) {
const char initial_content[] = "1234567890987654321";		const char initial_content[] = "1234567890987654321";
const char data[] = "hello, file";		const char data[] = "hello, file";
constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;		constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "a+");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "a+");
f->reset_and_fill(initial_content, sizeof(initial_content));		f->reset_and_fill(initial_content, sizeof(initial_content));

ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream		EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
ASSERT_EQ(f->flush(), 0);		ASSERT_EQ(f->flush(), 0);
// The flush should write \|data\| to the endof the file.		// The flush should write \|data\| to the endof the file.
EXPECT_EQ(f->get_pos(), sizeof(data) + sizeof(initial_content));		EXPECT_EQ(f->get_pos(), sizeof(data) + sizeof(initial_content));

ASSERT_EQ(f->seek(0, SEEK_SET), 0);		ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
// Seeking to the beginning of the file should not affect the place		// Seeking to the beginning of the file should not affect the place
// where write happens.		// where write happens.
ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));		ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
ASSERT_EQ(f->flush(), 0);		ASSERT_EQ(f->flush(), 0);
EXPECT_EQ(f->get_pos(), sizeof(data) * 2 + sizeof(initial_content));		EXPECT_EQ(f->get_pos(), sizeof(data) * 2 + sizeof(initial_content));
MemoryView src1(initial_content, sizeof(initial_content)),		MemoryView src1(initial_content, sizeof(initial_content)),
dst1(f->get_str(), sizeof(initial_content));		dst1(f->get_str(), sizeof(initial_content));
EXPECT_MEM_EQ(src1, dst1);		EXPECT_MEM_EQ(src1, dst1);
MemoryView src2(data, sizeof(data)),		MemoryView src2(data, sizeof(data)),
dst2(f->get_str() + sizeof(initial_content), sizeof(data));		dst2(f->get_str() + sizeof(initial_content), sizeof(data));
EXPECT_MEM_EQ(src2, dst2);		EXPECT_MEM_EQ(src2, dst2);
MemoryView src3(data, sizeof(data)),		MemoryView src3(data, sizeof(data)),
dst3(f->get_str() + sizeof(initial_content) + sizeof(data), sizeof(data));		dst3(f->get_str() + sizeof(initial_content) + sizeof(data), sizeof(data));
EXPECT_MEM_EQ(src3, dst3);		EXPECT_MEM_EQ(src3, dst3);

// Reads can happen from any point.		// Reads can happen from any point.
ASSERT_EQ(f->seek(0, SEEK_SET), 0);		ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
constexpr size_t READ_SIZE = 10;		constexpr size_t READ_SIZE = 10;
char read_data[READ_SIZE];		char read_data[READ_SIZE];
ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));		ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
MemoryView src4(initial_content, READ_SIZE), dst4(read_data, READ_SIZE);		MemoryView src4(initial_content, READ_SIZE), dst4(read_data, READ_SIZE);
EXPECT_MEM_EQ(src4, dst4);		EXPECT_MEM_EQ(src4, dst4);

ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, SmallBuffer) {		TEST(LlvmLibcFileTest, SmallBuffer) {
const char WRITE_DATA[] = "small buffer";		const char WRITE_DATA[] = "small buffer";
constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);		constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);
constexpr size_t FILE_BUFFER_SIZE = sizeof(WRITE_DATA) / 2 - 1;		constexpr size_t FILE_BUFFER_SIZE = sizeof(WRITE_DATA) / 2 - 1;
char file_buffer[FILE_BUFFER_SIZE];		char file_buffer[FILE_BUFFER_SIZE];
StringFile *f =		StringFile *f =
new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w");		new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w");

ASSERT_EQ(WRITE_SIZE, f->write(WRITE_DATA, WRITE_SIZE));		ASSERT_EQ(WRITE_SIZE, f->write(WRITE_DATA, WRITE_SIZE).value);
// Since data much larger than the buffer is being written, all of it should		// Since data much larger than the buffer is being written, all of it should
// be available in the file without a flush operation.		// be available in the file without a flush operation.
EXPECT_EQ(f->get_pos(), sizeof(WRITE_DATA));		EXPECT_EQ(f->get_pos(), sizeof(WRITE_DATA));
ASSERT_STREQ(f->get_str(), WRITE_DATA);		ASSERT_STREQ(f->get_str(), WRITE_DATA);

ASSERT_EQ(f->close(), 0);		ASSERT_EQ(f->close(), 0);
}		}

TEST(LlvmLibcFileTest, ZeroLengthBuffer) {		TEST(LlvmLibcFileTest, ZeroLengthBuffer) {
const char WRITE_DATA[] = "small buffer";		const char WRITE_DATA[] = "small buffer";
constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);		constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);
StringFile *f_fbf = new_string_file(nullptr, 0, _IOFBF, true, "w");		StringFile *f_fbf = new_string_file(nullptr, 0, _IOFBF, true, "w");
StringFile *f_lbf = new_string_file(nullptr, 0, _IOLBF, true, "w");		StringFile *f_lbf = new_string_file(nullptr, 0, _IOLBF, true, "w");
StringFile *f_nbf = new_string_file(nullptr, 0, _IONBF, true, "w");		StringFile *f_nbf = new_string_file(nullptr, 0, _IONBF, true, "w");

ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE));		ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE).value);
ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE));		ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE).value);
ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE));		ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE).value);
// Since there is no buffer space, all of the written data should		// Since there is no buffer space, all of the written data should
// be available in the file without a flush operation.		// be available in the file without a flush operation.
EXPECT_EQ(f_fbf->get_pos(), sizeof(WRITE_DATA));		EXPECT_EQ(f_fbf->get_pos(), sizeof(WRITE_DATA));
EXPECT_EQ(f_lbf->get_pos(), sizeof(WRITE_DATA));		EXPECT_EQ(f_lbf->get_pos(), sizeof(WRITE_DATA));
EXPECT_EQ(f_nbf->get_pos(), sizeof(WRITE_DATA));		EXPECT_EQ(f_nbf->get_pos(), sizeof(WRITE_DATA));
ASSERT_STREQ(f_fbf->get_str(), WRITE_DATA);		ASSERT_STREQ(f_fbf->get_str(), WRITE_DATA);
ASSERT_STREQ(f_lbf->get_str(), WRITE_DATA);		ASSERT_STREQ(f_lbf->get_str(), WRITE_DATA);
ASSERT_STREQ(f_nbf->get_str(), WRITE_DATA);		ASSERT_STREQ(f_nbf->get_str(), WRITE_DATA);
Show All 12 Lines	TEST(LlvmLibcFileTest, WriteNothing) {
char file_buffer_nbf[FILE_BUFFER_SIZE];		char file_buffer_nbf[FILE_BUFFER_SIZE];
StringFile *f_fbf =		StringFile *f_fbf =
new_string_file(file_buffer_fbf, FILE_BUFFER_SIZE, _IOFBF, false, "w");		new_string_file(file_buffer_fbf, FILE_BUFFER_SIZE, _IOFBF, false, "w");
StringFile *f_lbf =		StringFile *f_lbf =
new_string_file(file_buffer_lbf, FILE_BUFFER_SIZE, _IOLBF, false, "w");		new_string_file(file_buffer_lbf, FILE_BUFFER_SIZE, _IOLBF, false, "w");
StringFile *f_nbf =		StringFile *f_nbf =
new_string_file(file_buffer_nbf, FILE_BUFFER_SIZE, _IONBF, false, "w");		new_string_file(file_buffer_nbf, FILE_BUFFER_SIZE, _IONBF, false, "w");

ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE));		ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE).value);
ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE));		ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE).value);
ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE));		ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE).value);

ASSERT_FALSE(f_fbf->error_unlocked());		ASSERT_FALSE(f_fbf->error_unlocked());
ASSERT_FALSE(f_lbf->error_unlocked());		ASSERT_FALSE(f_lbf->error_unlocked());
ASSERT_FALSE(f_nbf->error_unlocked());		ASSERT_FALSE(f_nbf->error_unlocked());

ASSERT_EQ(f_fbf->close(), 0);		ASSERT_EQ(f_fbf->close(), 0);
ASSERT_EQ(f_lbf->close(), 0);		ASSERT_EQ(f_lbf->close(), 0);
ASSERT_EQ(f_nbf->close(), 0);		ASSERT_EQ(f_nbf->close(), 0);
}		}

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

	Show All 13 Lines
	using File = __llvm_libc::File;			using File = __llvm_libc::File;
	constexpr char TEXT[] = "Hello, File";			constexpr char TEXT[] = "Hello, File";
	constexpr size_t TEXT_SIZE = sizeof(TEXT) - 1; // Ignore the null terminator			constexpr size_t TEXT_SIZE = sizeof(TEXT) - 1; // Ignore the null terminator

	TEST(LlvmLibcPlatformFileTest, CreateWriteCloseAndReadBack) {			TEST(LlvmLibcPlatformFileTest, CreateWriteCloseAndReadBack) {
	constexpr char FILENAME[] = "testdata/create_write_close_and_readback.test";			constexpr char FILENAME[] = "testdata/create_write_close_and_readback.test";
	File *file = __llvm_libc::openfile(FILENAME, "w");			File *file = __llvm_libc::openfile(FILENAME, "w");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	ASSERT_EQ(file->write(TEXT, TEXT_SIZE), TEXT_SIZE);			ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);

	file = __llvm_libc::openfile(FILENAME, "r");			file = __llvm_libc::openfile(FILENAME, "r");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	char data[sizeof(TEXT)];			char data[sizeof(TEXT)];
	ASSERT_EQ(file->read(data, TEXT_SIZE), TEXT_SIZE);			ASSERT_EQ(file->read(data, TEXT_SIZE).value, TEXT_SIZE);
	data[TEXT_SIZE] = '\0';			data[TEXT_SIZE] = '\0';
	ASSERT_STREQ(data, TEXT);			ASSERT_STREQ(data, TEXT);

	// Reading more data should trigger EOF.			// Reading more data should trigger EOF.
	ASSERT_EQ(file->read(data, TEXT_SIZE), size_t(0));			ASSERT_EQ(file->read(data, TEXT_SIZE).value, size_t(0));
	ASSERT_TRUE(file->iseof());			ASSERT_TRUE(file->iseof());

	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);
	}			}

	TEST(LlvmLibcPlatformFileTest, CreateWriteSeekAndReadBack) {			TEST(LlvmLibcPlatformFileTest, CreateWriteSeekAndReadBack) {
	constexpr char FILENAME[] = "testdata/create_write_seek_and_readback.test";			constexpr char FILENAME[] = "testdata/create_write_seek_and_readback.test";
	File *file = __llvm_libc::openfile(FILENAME, "w+");			File *file = __llvm_libc::openfile(FILENAME, "w+");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	ASSERT_EQ(file->write(TEXT, TEXT_SIZE), TEXT_SIZE);			ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);

	ASSERT_EQ(file->seek(0, SEEK_SET), 0);			ASSERT_EQ(file->seek(0, SEEK_SET).value(), 0);

	char data[sizeof(TEXT)];			char data[sizeof(TEXT)];
	ASSERT_EQ(file->read(data, TEXT_SIZE), TEXT_SIZE);			ASSERT_EQ(file->read(data, TEXT_SIZE).value, TEXT_SIZE);
	data[TEXT_SIZE] = '\0';			data[TEXT_SIZE] = '\0';
	ASSERT_STREQ(data, TEXT);			ASSERT_STREQ(data, TEXT);

	// Reading more data should trigger EOF.			// Reading more data should trigger EOF.
	ASSERT_EQ(file->read(data, TEXT_SIZE), size_t(0));			ASSERT_EQ(file->read(data, TEXT_SIZE).value, size_t(0));
	ASSERT_TRUE(file->iseof());			ASSERT_TRUE(file->iseof());

	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);
	}			}

	TEST(LlvmLibcPlatformFileTest, CreateAppendCloseAndReadBack) {			TEST(LlvmLibcPlatformFileTest, CreateAppendCloseAndReadBack) {
	constexpr char FILENAME[] = "testdata/create_append_close_and_readback.test";			constexpr char FILENAME[] = "testdata/create_append_close_and_readback.test";
	File *file = __llvm_libc::openfile(FILENAME, "w");			File *file = __llvm_libc::openfile(FILENAME, "w");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	ASSERT_EQ(file->write(TEXT, TEXT_SIZE), TEXT_SIZE);			ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);

	file = __llvm_libc::openfile(FILENAME, "a");			file = __llvm_libc::openfile(FILENAME, "a");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	constexpr char APPEND_TEXT[] = " Append Text";			constexpr char APPEND_TEXT[] = " Append Text";
	constexpr size_t APPEND_TEXT_SIZE = sizeof(APPEND_TEXT) - 1;			constexpr size_t APPEND_TEXT_SIZE = sizeof(APPEND_TEXT) - 1;
	ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE), APPEND_TEXT_SIZE);			ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);
	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);

	file = __llvm_libc::openfile(FILENAME, "r");			file = __llvm_libc::openfile(FILENAME, "r");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	constexpr size_t READ_SIZE = TEXT_SIZE + APPEND_TEXT_SIZE;			constexpr size_t READ_SIZE = TEXT_SIZE + APPEND_TEXT_SIZE;
	char data[READ_SIZE + 1];			char data[READ_SIZE + 1];
	ASSERT_EQ(file->read(data, READ_SIZE), READ_SIZE);			ASSERT_EQ(file->read(data, READ_SIZE).value, READ_SIZE);
	data[READ_SIZE] = '\0';			data[READ_SIZE] = '\0';
	ASSERT_STREQ(data, "Hello, File Append Text");			ASSERT_STREQ(data, "Hello, File Append Text");

	// Reading more data should trigger EOF.			// Reading more data should trigger EOF.
	ASSERT_EQ(file->read(data, READ_SIZE), size_t(0));			ASSERT_EQ(file->read(data, READ_SIZE).value, size_t(0));
	ASSERT_TRUE(file->iseof());			ASSERT_TRUE(file->iseof());

	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);
	}			}

	TEST(LlvmLibcPlatformFileTest, CreateAppendSeekAndReadBack) {			TEST(LlvmLibcPlatformFileTest, CreateAppendSeekAndReadBack) {
	constexpr char FILENAME[] = "testdata/create_append_seek_and_readback.test";			constexpr char FILENAME[] = "testdata/create_append_seek_and_readback.test";
	File *file = __llvm_libc::openfile(FILENAME, "w");			File *file = __llvm_libc::openfile(FILENAME, "w");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	ASSERT_EQ(file->write(TEXT, TEXT_SIZE), TEXT_SIZE);			ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);

	file = __llvm_libc::openfile(FILENAME, "a+");			file = __llvm_libc::openfile(FILENAME, "a+");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	constexpr char APPEND_TEXT[] = " Append Text";			constexpr char APPEND_TEXT[] = " Append Text";
	constexpr size_t APPEND_TEXT_SIZE = sizeof(APPEND_TEXT) - 1;			constexpr size_t APPEND_TEXT_SIZE = sizeof(APPEND_TEXT) - 1;
	ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE), APPEND_TEXT_SIZE);			ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);

	ASSERT_EQ(file->seek(-APPEND_TEXT_SIZE, SEEK_END), 0);			ASSERT_EQ(file->seek(-APPEND_TEXT_SIZE, SEEK_END).value(), 0);
	char data[APPEND_TEXT_SIZE + 1];			char data[APPEND_TEXT_SIZE + 1];
	ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE), APPEND_TEXT_SIZE);			ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);
	data[APPEND_TEXT_SIZE] = '\0';			data[APPEND_TEXT_SIZE] = '\0';
	ASSERT_STREQ(data, APPEND_TEXT);			ASSERT_STREQ(data, APPEND_TEXT);

	// Reading more data should trigger EOF.			// Reading more data should trigger EOF.
	ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE), size_t(0));			ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE).value, size_t(0));
	ASSERT_TRUE(file->iseof());			ASSERT_TRUE(file->iseof());

	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);
	}			}

	TEST(LlvmLibcPlatformFileTest, LargeFile) {			TEST(LlvmLibcPlatformFileTest, LargeFile) {
	constexpr size_t DATA_SIZE = File::DEFAULT_BUFFER_SIZE >> 2;			constexpr size_t DATA_SIZE = File::DEFAULT_BUFFER_SIZE >> 2;
	constexpr char BYTE = 123;			constexpr char BYTE = 123;
	char write_data[DATA_SIZE];			char write_data[DATA_SIZE];
	for (size_t i = 0; i < DATA_SIZE; ++i)			for (size_t i = 0; i < DATA_SIZE; ++i)
	write_data[i] = BYTE;			write_data[i] = BYTE;

	constexpr char FILENAME[] = "testdata/large_file.test";			constexpr char FILENAME[] = "testdata/large_file.test";
	File *file = __llvm_libc::openfile(FILENAME, "w");			File *file = __llvm_libc::openfile(FILENAME, "w");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);

	constexpr int REPEAT = 5;			constexpr int REPEAT = 5;
	for (int i = 0; i < REPEAT; ++i) {			for (int i = 0; i < REPEAT; ++i) {
	ASSERT_EQ(file->write(write_data, DATA_SIZE), DATA_SIZE);			ASSERT_EQ(file->write(write_data, DATA_SIZE).value, DATA_SIZE);
	}			}
	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);

	file = __llvm_libc::openfile(FILENAME, "r");			file = __llvm_libc::openfile(FILENAME, "r");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	constexpr size_t READ_SIZE = DATA_SIZE * REPEAT;			constexpr size_t READ_SIZE = DATA_SIZE * REPEAT;
	char data[READ_SIZE] = {0};			char data[READ_SIZE] = {0};
	ASSERT_EQ(file->read(data, READ_SIZE), READ_SIZE);			ASSERT_EQ(file->read(data, READ_SIZE).value, READ_SIZE);

	for (size_t i = 0; i < READ_SIZE; ++i)			for (size_t i = 0; i < READ_SIZE; ++i)
	ASSERT_EQ(data[i], BYTE);			ASSERT_EQ(data[i], BYTE);

	// Reading more data should trigger EOF.			// Reading more data should trigger EOF.
	ASSERT_EQ(file->read(data, 1), size_t(0));			ASSERT_EQ(file->read(data, 1).value, size_t(0));
	ASSERT_TRUE(file->iseof());			ASSERT_TRUE(file->iseof());

	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);
	}			}

	TEST(LlvmLibcPlatformFileTest, ReadSeekCurAndRead) {			TEST(LlvmLibcPlatformFileTest, ReadSeekCurAndRead) {
	constexpr char FILENAME[] = "testdata/read_seek_cur_and_read.test";			constexpr char FILENAME[] = "testdata/read_seek_cur_and_read.test";
	File *file = __llvm_libc::openfile(FILENAME, "w");			File *file = __llvm_libc::openfile(FILENAME, "w");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	constexpr char CONTENT[] = "1234567890987654321";			constexpr char CONTENT[] = "1234567890987654321";
	ASSERT_EQ(sizeof(CONTENT) - 1, file->write(CONTENT, sizeof(CONTENT) - 1));			ASSERT_EQ(sizeof(CONTENT) - 1,
				file->write(CONTENT, sizeof(CONTENT) - 1).value);
	ASSERT_EQ(0, file->close());			ASSERT_EQ(0, file->close());

	file = __llvm_libc::openfile(FILENAME, "r");			file = __llvm_libc::openfile(FILENAME, "r");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);

	constexpr size_t READ_SIZE = 5;			constexpr size_t READ_SIZE = 5;
	char data[READ_SIZE];			char data[READ_SIZE];
	data[READ_SIZE - 1] = '\0';			data[READ_SIZE - 1] = '\0';
	ASSERT_EQ(file->read(data, READ_SIZE - 1), READ_SIZE - 1);			ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
	ASSERT_STREQ(data, "1234");			ASSERT_STREQ(data, "1234");
	ASSERT_EQ(file->seek(5, SEEK_CUR), 0);			ASSERT_EQ(file->seek(5, SEEK_CUR).value(), 0);
	ASSERT_EQ(file->read(data, READ_SIZE - 1), READ_SIZE - 1);			ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
	ASSERT_STREQ(data, "0987");			ASSERT_STREQ(data, "0987");
	ASSERT_EQ(file->seek(-5, SEEK_CUR), 0);			ASSERT_EQ(file->seek(-5, SEEK_CUR).value(), 0);
	ASSERT_EQ(file->read(data, READ_SIZE - 1), READ_SIZE - 1);			ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
	ASSERT_STREQ(data, "9098");			ASSERT_STREQ(data, "9098");

	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);
	}			}

	TEST(LlvmLibcPlatformFileTest, IncorrectOperation) {			TEST(LlvmLibcPlatformFileTest, IncorrectOperation) {
	constexpr char FILENAME[] = "testdata/incorrect_operation.test";			constexpr char FILENAME[] = "testdata/incorrect_operation.test";
	char data[1] = {123};			char data[1] = {123};

	File *file = __llvm_libc::openfile(FILENAME, "w");			File *file = __llvm_libc::openfile(FILENAME, "w");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	ASSERT_EQ(file->read(data, 1), size_t(0)); // Cannot read			ASSERT_EQ(file->read(data, 1).value, size_t(0)); // Cannot read
	ASSERT_FALSE(file->iseof());			ASSERT_FALSE(file->iseof());
	ASSERT_TRUE(file->error());			ASSERT_TRUE(file->error());
	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);

	file = __llvm_libc::openfile(FILENAME, "r");			file = __llvm_libc::openfile(FILENAME, "r");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	ASSERT_EQ(file->write(data, 1), size_t(0)); // Cannot write			ASSERT_EQ(file->write(data, 1).value, size_t(0)); // Cannot write
	ASSERT_FALSE(file->iseof());			ASSERT_FALSE(file->iseof());
	ASSERT_TRUE(file->error());			ASSERT_TRUE(file->error());
	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);

	file = __llvm_libc::openfile(FILENAME, "a");			file = __llvm_libc::openfile(FILENAME, "a");
	ASSERT_FALSE(file == nullptr);			ASSERT_FALSE(file == nullptr);
	ASSERT_EQ(file->read(data, 1), size_t(0)); // Cannot read			ASSERT_EQ(file->read(data, 1).value, size_t(0)); // Cannot read
	ASSERT_FALSE(file->iseof());			ASSERT_FALSE(file->iseof());
	ASSERT_TRUE(file->error());			ASSERT_TRUE(file->error());
	ASSERT_EQ(file->close(), 0);			ASSERT_EQ(file->close(), 0);
	}			}

	TEST(LlvmLibcPlatformFileTest, StdOutStdErrSmokeTest) {			TEST(LlvmLibcPlatformFileTest, StdOutStdErrSmokeTest) {
	EXPECT_FALSE(__llvm_libc::stdout == nullptr);			EXPECT_FALSE(__llvm_libc::stdout == nullptr);
	EXPECT_FALSE(__llvm_libc::stderr == nullptr);			EXPECT_FALSE(__llvm_libc::stderr == nullptr);
	}			}

libc/test/src/stdio/fileop_test.cpp

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines	TEST(LlvmLibcFILETest, SimpleFileOperations) {
ASSERT_EQ(EOF, __llvm_libc::fputs(CONTENT, file));		ASSERT_EQ(EOF, __llvm_libc::fputs(CONTENT, file));
ASSERT_NE(__llvm_libc::ferror(file), 0);		ASSERT_NE(__llvm_libc::ferror(file), 0);
ASSERT_NE(errno, 0);		ASSERT_NE(errno, 0);
errno = 0;		errno = 0;

__llvm_libc::clearerr(file);		__llvm_libc::clearerr(file);
ASSERT_EQ(__llvm_libc::ferror(file), 0);		ASSERT_EQ(__llvm_libc::ferror(file), 0);

		errno = 0;
		ASSERT_EQ(__llvm_libc::fwrite("nothing", 1, 1, file), size_t(0));
		ASSERT_NE(errno, 0);
		errno = 0;

ASSERT_EQ(__llvm_libc::fclose(file), 0);		ASSERT_EQ(__llvm_libc::fclose(file), 0);

// Now try puts.		// Now try puts.
file = __llvm_libc::fopen(FILENAME, "w");		file = __llvm_libc::fopen(FILENAME, "w");
ASSERT_FALSE(file == nullptr);		ASSERT_FALSE(file == nullptr);
// fputs returns a negative value on error (EOF) or any non-negative value on		// fputs returns a negative value on error (EOF) or any non-negative value on
// success. This assert checks that the return value is non-negative.		// success. This assert checks that the return value is non-negative.
ASSERT_GE(__llvm_libc::fputs(CONTENT, file), 0);		ASSERT_GE(__llvm_libc::fputs(CONTENT, file), 0);

__llvm_libc::clearerr(file);		__llvm_libc::clearerr(file);
ASSERT_EQ(__llvm_libc::ferror(file), 0);		ASSERT_EQ(__llvm_libc::ferror(file), 0);

		// This is not a readable file.
		errno = 0;
		ASSERT_EQ(__llvm_libc::fread(data, 1, 1, file), size_t(0));
		ASSERT_NE(errno, 0);
		errno = 0;

ASSERT_EQ(0, __llvm_libc::fclose(file));		ASSERT_EQ(0, __llvm_libc::fclose(file));

file = __llvm_libc::fopen(FILENAME, "r");		file = __llvm_libc::fopen(FILENAME, "r");
ASSERT_FALSE(file == nullptr);		ASSERT_FALSE(file == nullptr);

ASSERT_EQ(__llvm_libc::fread(read_data, 1, sizeof(CONTENT) - 1, file),		ASSERT_EQ(__llvm_libc::fread(read_data, 1, sizeof(CONTENT) - 1, file),
sizeof(CONTENT) - 1);		sizeof(CONTENT) - 1);
read_data[sizeof(CONTENT) - 1] = '\0';		read_data[sizeof(CONTENT) - 1] = '\0';
ASSERT_STREQ(read_data, CONTENT);		ASSERT_STREQ(read_data, CONTENT);
ASSERT_EQ(__llvm_libc::fclose(file), 0);		ASSERT_EQ(__llvm_libc::fclose(file), 0);

		// Check that the other functions correctly set errno.

		errno = 0;
		ASSERT_NE(__llvm_libc::fseek(file, 0, SEEK_SET), 0);
		EXPECT_NE(errno, 0);

		errno = 0;
		ASSERT_NE(__llvm_libc::fclose(file), 0);
		EXPECT_NE(errno, 0);

		errno = 0;
		ASSERT_EQ(__llvm_libc::fopen("INVALID FILE NAME", "r"),
		static_cast<FILE *>(nullptr));
		EXPECT_NE(errno, 0);
}		}

TEST(LlvmLibcFILETest, FFlush) {		TEST(LlvmLibcFILETest, FFlush) {
constexpr char FILENAME[] = "testdata/fflush.test";		constexpr char FILENAME[] = "testdata/fflush.test";
::FILE *file = __llvm_libc::fopen(FILENAME, "w+");		::FILE *file = __llvm_libc::fopen(FILENAME, "w+");
ASSERT_FALSE(file == nullptr);		ASSERT_FALSE(file == nullptr);
constexpr char CONTENT[] = "1234567890987654321";		constexpr char CONTENT[] = "1234567890987654321";
ASSERT_EQ(sizeof(CONTENT),		ASSERT_EQ(sizeof(CONTENT),
Show All 16 Lines	TEST(LlvmLibcFILETest, FOpenFWriteSizeGreaterThanOne) {
using MyStruct = struct {		using MyStruct = struct {
char c;		char c;
unsigned long long i;		unsigned long long i;
};		};
constexpr MyStruct WRITE_DATA[] = {{'a', 1}, {'b', 2}, {'c', 3}};		constexpr MyStruct WRITE_DATA[] = {{'a', 1}, {'b', 2}, {'c', 3}};
constexpr size_t WRITE_NMEMB = sizeof(WRITE_DATA) / sizeof(MyStruct);		constexpr size_t WRITE_NMEMB = sizeof(WRITE_DATA) / sizeof(MyStruct);
constexpr char FILENAME[] = "testdata/fread_fwrite.test";		constexpr char FILENAME[] = "testdata/fread_fwrite.test";

		errno = 0;
FILE *file = __llvm_libc::fopen(FILENAME, "w");		FILE *file = __llvm_libc::fopen(FILENAME, "w");
ASSERT_FALSE(file == nullptr);		ASSERT_FALSE(file == nullptr);
ASSERT_EQ(size_t(0), __llvm_libc::fwrite(WRITE_DATA, 0, 1, file));		ASSERT_EQ(size_t(0), __llvm_libc::fwrite(WRITE_DATA, 0, 1, file));
ASSERT_EQ(WRITE_NMEMB, __llvm_libc::fwrite(WRITE_DATA, sizeof(MyStruct),		ASSERT_EQ(WRITE_NMEMB, __llvm_libc::fwrite(WRITE_DATA, sizeof(MyStruct),
WRITE_NMEMB, file));		WRITE_NMEMB, file));
EXPECT_EQ(errno, 0);		EXPECT_EQ(errno, 0);
ASSERT_EQ(__llvm_libc::fclose(file), 0);		ASSERT_EQ(__llvm_libc::fclose(file), 0);

Show All 20 Lines

libc/test/src/stdio/ftell_test.cpp

Show All 10 Lines
#include "src/stdio/fopen.h"		#include "src/stdio/fopen.h"
#include "src/stdio/fread.h"		#include "src/stdio/fread.h"
#include "src/stdio/fseek.h"		#include "src/stdio/fseek.h"
#include "src/stdio/ftell.h"		#include "src/stdio/ftell.h"
#include "src/stdio/fwrite.h"		#include "src/stdio/fwrite.h"
#include "src/stdio/setvbuf.h"		#include "src/stdio/setvbuf.h"
#include "utils/UnitTest/Test.h"		#include "utils/UnitTest/Test.h"

		#include <errno.h>
#include <stdio.h>		#include <stdio.h>

class LlvmLibcFTellTest : public __llvm_libc::testing::Test {		class LlvmLibcFTellTest : public __llvm_libc::testing::Test {
protected:		protected:
void test_with_bufmode(int bufmode) {		void test_with_bufmode(int bufmode) {
constexpr char FILENAME[] = "testdata/ftell.test";		constexpr char FILENAME[] = "testdata/ftell.test";
// We will set a special buffer to the file so that we guarantee buffering.		// We will set a special buffer to the file so that we guarantee buffering.
constexpr size_t BUFFER_SIZE = 1024;		constexpr size_t BUFFER_SIZE = 1024;
Show All 21 Lines	void test_with_bufmode(int bufmode) {
constexpr size_t READ_SIZE = WRITE_SIZE / 2;		constexpr size_t READ_SIZE = WRITE_SIZE / 2;
char data[READ_SIZE];		char data[READ_SIZE];
// Reading a small amount will actually read out much more data and		// Reading a small amount will actually read out much more data and
// buffer it. But, ftell should return the correct effective offset.		// buffer it. But, ftell should return the correct effective offset.
ASSERT_EQ(READ_SIZE, __llvm_libc::fread(data, 1, READ_SIZE, file));		ASSERT_EQ(READ_SIZE, __llvm_libc::fread(data, 1, READ_SIZE, file));
ASSERT_EQ(size_t(__llvm_libc::ftell(file)), READ_SIZE);		ASSERT_EQ(size_t(__llvm_libc::ftell(file)), READ_SIZE);

ASSERT_EQ(0, __llvm_libc::fclose(file));		ASSERT_EQ(0, __llvm_libc::fclose(file));

		errno = 0;
		ASSERT_EQ(__llvm_libc::ftell(file), long(-1));
		ASSERT_NE(errno, 0);
}		}
};		};

TEST_F(LlvmLibcFTellTest, TellWithFBF) { test_with_bufmode(_IOFBF); }		TEST_F(LlvmLibcFTellTest, TellWithFBF) { test_with_bufmode(_IOFBF); }

TEST_F(LlvmLibcFTellTest, TellWithNBF) { test_with_bufmode(_IONBF); }		TEST_F(LlvmLibcFTellTest, TellWithNBF) { test_with_bufmode(_IONBF); }

TEST_F(LlvmLibcFTellTest, TellWithLBF) { test_with_bufmode(_IOLBF); }		TEST_F(LlvmLibcFTellTest, TellWithLBF) { test_with_bufmode(_IOLBF); }

This is an archive of the discontinued LLVM Phabricator instance.

[libc] move errno out of file internalsClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 482242

libc/src/__support/CMakeLists.txt

libc/src/__support/CPP/CMakeLists.txt

libc/src/__support/CPP/error.h

libc/src/__support/CPP/expected.h

libc/src/__support/File/CMakeLists.txt

libc/src/__support/File/file.h

libc/src/__support/File/file.cpp

libc/src/__support/File/linux_file.cpp

libc/src/__support/error_or.h

libc/src/__support/threads/linux/CMakeLists.txt

libc/src/__support/threads/linux/thread.cpp

libc/src/pthread/pthread_setname_np.cpp

libc/src/stdio/CMakeLists.txt

libc/src/stdio/fclose.cpp

libc/src/stdio/fflush.cpp

libc/src/stdio/fgetc.cpp

libc/src/stdio/fgetc_unlocked.cpp

libc/src/stdio/fgets.cpp

libc/src/stdio/fopen.cpp

libc/src/stdio/fopencookie.cpp

libc/src/stdio/fputc.cpp

libc/src/stdio/fputs.cpp

libc/src/stdio/fread.cpp

libc/src/stdio/fread_unlocked.cpp

libc/src/stdio/fseek.cpp

libc/src/stdio/ftell.cpp

libc/src/stdio/fwrite.cpp

libc/src/stdio/fwrite_unlocked.cpp

libc/src/stdio/getc.cpp

libc/src/stdio/getc_unlocked.cpp

libc/src/stdio/printf_core/file_writer.cpp

libc/src/stdio/putc.cpp

libc/src/stdio/putchar.cpp

libc/src/stdio/puts.cpp

libc/src/stdio/scanf_core/file_reader.cpp

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

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

libc/test/src/stdio/fileop_test.cpp

libc/test/src/stdio/ftell_test.cpp

[libc] move errno out of file internals
ClosedPublic