This is an archive of the discontinued LLVM Phabricator instance.

Differential D141041

[libc] Mark public C++ functions noexcept
AbandonedPublic

Authored by gchatelet on Jan 5 2023, 3:03 AM.

Details

Reviewers
sivachandra

Diff Detail

Event Timeline

gchatelet created this revision.Jan 5 2023, 3:03 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJan 5 2023, 3:03 AM
Herald added subscribers: libc-commits, ecnelises, tschuett. · View Herald Transcript
gchatelet requested review of this revision.Jan 5 2023, 3:03 AM
Harbormaster completed remote builds in B205869: Diff 486513.Jan 5 2023, 3:22 AM
gchatelet added a reviewer: sivachandra.Jan 5 2023, 4:46 AM
abrachet added a subscriber: abrachet.Jan 5 2023, 8:06 AM

These aren't the public headers, so this is only marking it noexcept in a context where we likely already build without exceptions. We also don't every query if a function is noexcept in the code base either for the same reason. So I'm not sure what this is accomplishing.

gchatelet abandoned this revision.Jan 6 2023, 1:10 AM
gchatelet added a subscriber: michaelrj.
In D141041#4028944, @abrachet wrote:

These aren't the public headers, so this is only marking it noexcept in a context where we likely already build without exceptions. We also don't every query if a function is noexcept in the code base either for the same reason. So I'm not sure what this is accomplishing.

Correct. @michaelrj patch is the correct approach in this case then.

Revision Contents

PathSize
libc/
src/
__support/
6 lines
assert/
2 lines
ctype/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
dirent/
2 lines
2 lines
2 lines
2 lines
fcntl/
2 lines
2 lines
2 lines
fenv/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
inttypes/
2 lines
2 lines
2 lines
2 lines
math/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
pthread/
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
sched/
2 lines
2 lines
3 lines
setjmp/
2 lines
2 lines
signal/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
spawn/
3 lines
2 lines
2 lines
2 lines
3 lines
2 lines
stdio/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
3 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
2 lines
stdlib/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
2 lines
2 lines
2 lines
string/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
2 lines
3 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
sys/
mman/
2 lines
3 lines
2 lines
2 lines
2 lines
random/
2 lines
resource/
2 lines
2 lines
select/
3 lines
sendfile/
2 lines
stat/
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
utsname/
2 lines
wait/
2 lines
3 lines
2 lines
termios/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
threads/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
time/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
unistd/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines

Diff 486513

libc/src/__support/common.h

Show All 30 Lines#define LLVM_LIBC_DECLARE_DEVICE(name) \
_Pragma(STR(omp declare target to(name) device_type(nohost))) _Pragma(STR(omp declare target to(name) device_type(nohost)))
// GPU targets do not support aliasing and must be declared on the device. // GPU targets do not support aliasing and must be declared on the device.
#if defined(LLVM_LIBC_PUBLIC_PACKAGING) && defined(_OPENMP) #if defined(LLVM_LIBC_PUBLIC_PACKAGING) && defined(_OPENMP)
#define LLVM_LIBC_FUNCTION(type, name, arglist) \ #define LLVM_LIBC_FUNCTION(type, name, arglist) \
LLVM_LIBC_FUNCTION_ATTR decltype(__llvm_libc::name) \ LLVM_LIBC_FUNCTION_ATTR decltype(__llvm_libc::name) \
__##name##_impl__ __asm__(#name); \ __##name##_impl__ __asm__(#name); \
LLVM_LIBC_DECLARE_DEVICE(__##name##_impl__) \ LLVM_LIBC_DECLARE_DEVICE(__##name##_impl__) \
type __##name##_impl__ arglist type __##name##_impl__ arglist noexcept
// MacOS needs to be excluded because it does not support aliasing. // MacOS needs to be excluded because it does not support aliasing.
#elif defined(LLVM_LIBC_PUBLIC_PACKAGING) && (!defined(__APPLE__)) #elif defined(LLVM_LIBC_PUBLIC_PACKAGING) && (!defined(__APPLE__))
#define LLVM_LIBC_FUNCTION(type, name, arglist) \ #define LLVM_LIBC_FUNCTION(type, name, arglist) \
LLVM_LIBC_FUNCTION_ATTR decltype(__llvm_libc::name) \ LLVM_LIBC_FUNCTION_ATTR decltype(__llvm_libc::name) \
__##name##_impl__ __asm__(#name); \ __##name##_impl__ __asm__(#name); \
decltype(__llvm_libc::name) name [[gnu::alias(#name)]]; \ decltype(__llvm_libc::name) name [[gnu::alias(#name)]]; \
type __##name##_impl__ arglist type __##name##_impl__ arglist noexcept
#else #else
#define LLVM_LIBC_FUNCTION(type, name, arglist) type name arglist #define LLVM_LIBC_FUNCTION(type, name, arglist) type name arglist noexcept
#endif #endif
namespace __llvm_libc { namespace __llvm_libc {
namespace internal { namespace internal {
constexpr bool same_string(char const *lhs, char const *rhs) { constexpr bool same_string(char const *lhs, char const *rhs) {
for (; *lhs || *rhs; ++lhs, ++rhs) for (; *lhs || *rhs; ++lhs, ++rhs)
if (*lhs != *rhs) if (*lhs != *rhs)
return false; return false;
Show All 18 Lines

libc/src/assert/__assert_fail.h

//===-- Internal header for __assert_fail -----------------------*- C++ -*-===// //===-- Internal header for __assert_fail -----------------------*- 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_ASSERT_ASSERT_FAIL_H #ifndef LLVM_LIBC_SRC_ASSERT_ASSERT_FAIL_H
#define LLVM_LIBC_SRC_ASSERT_ASSERT_FAIL_H #define LLVM_LIBC_SRC_ASSERT_ASSERT_FAIL_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
[[noreturn]] void __assert_fail(const char *assertion, const char *file, [[noreturn]] void __assert_fail(const char *assertion, const char *file,
unsigned line, const char *function); unsigned line, const char *function) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_ASSERT_ASSERT_FAIL_H #endif // LLVM_LIBC_SRC_ASSERT_ASSERT_FAIL_H

libc/src/ctype/isalnum.h

//===-- Implementation header for isalnum -------------------------*-C++-*-===// //===-- Implementation header for isalnum -------------------------*-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_CTYPE_ISALNUM_H #ifndef LLVM_LIBC_SRC_CTYPE_ISALNUM_H
#define LLVM_LIBC_SRC_CTYPE_ISALNUM_H #define LLVM_LIBC_SRC_CTYPE_ISALNUM_H
namespace __llvm_libc { namespace __llvm_libc {
int isalnum(int c); int isalnum(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISALNUM_H #endif // LLVM_LIBC_SRC_CTYPE_ISALNUM_H

libc/src/ctype/isalpha.h

//===-- Implementation header for isalpha -------------------------*-C++-*-===// //===-- Implementation header for isalpha -------------------------*-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_CTYPE_ISALPHA_H #ifndef LLVM_LIBC_SRC_CTYPE_ISALPHA_H
#define LLVM_LIBC_SRC_CTYPE_ISALPHA_H #define LLVM_LIBC_SRC_CTYPE_ISALPHA_H
namespace __llvm_libc { namespace __llvm_libc {
int isalpha(int c); int isalpha(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISALPHA_H #endif // LLVM_LIBC_SRC_CTYPE_ISALPHA_H

libc/src/ctype/isascii.h

//===-- Implementation header for isascii -------------------------*-C++-*-===// //===-- Implementation header for isascii -------------------------*-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_CTYPE_ISASCII_H #ifndef LLVM_LIBC_SRC_CTYPE_ISASCII_H
#define LLVM_LIBC_SRC_CTYPE_ISASCII_H #define LLVM_LIBC_SRC_CTYPE_ISASCII_H
#undef isascii #undef isascii
namespace __llvm_libc { namespace __llvm_libc {
int isascii(int c); int isascii(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISASCII_H #endif // LLVM_LIBC_SRC_CTYPE_ISASCII_H

libc/src/ctype/isblank.h

//===-- Implementation header for isblank -------------------------*-C++-*-===// //===-- Implementation header for isblank -------------------------*-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_CTYPE_ISBLANK_H #ifndef LLVM_LIBC_SRC_CTYPE_ISBLANK_H
#define LLVM_LIBC_SRC_CTYPE_ISBLANK_H #define LLVM_LIBC_SRC_CTYPE_ISBLANK_H
namespace __llvm_libc { namespace __llvm_libc {
int isblank(int c); int isblank(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISBLANK_H #endif // LLVM_LIBC_SRC_CTYPE_ISBLANK_H

libc/src/ctype/iscntrl.h

//===-- Implementation header for iscntrl -------------------------*-C++-*-===// //===-- Implementation header for iscntrl -------------------------*-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_CTYPE_ISCNTRL_H #ifndef LLVM_LIBC_SRC_CTYPE_ISCNTRL_H
#define LLVM_LIBC_SRC_CTYPE_ISCNTRL_H #define LLVM_LIBC_SRC_CTYPE_ISCNTRL_H
namespace __llvm_libc { namespace __llvm_libc {
int iscntrl(int c); int iscntrl(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISCNTRL_H #endif // LLVM_LIBC_SRC_CTYPE_ISCNTRL_H

libc/src/ctype/isdigit.h

//===-- Implementation header for isdigit -------------------------*-C++-*-===// //===-- Implementation header for isdigit -------------------------*-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_CTYPE_ISDIGIT_H #ifndef LLVM_LIBC_SRC_CTYPE_ISDIGIT_H
#define LLVM_LIBC_SRC_CTYPE_ISDIGIT_H #define LLVM_LIBC_SRC_CTYPE_ISDIGIT_H
namespace __llvm_libc { namespace __llvm_libc {
int isdigit(int c); int isdigit(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISDIGIT_H #endif // LLVM_LIBC_SRC_CTYPE_ISDIGIT_H

libc/src/ctype/isgraph.h

//===-- Implementation header for isgraph -------------------------*-C++-*-===// //===-- Implementation header for isgraph -------------------------*-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_CTYPE_ISGRAPH_H #ifndef LLVM_LIBC_SRC_CTYPE_ISGRAPH_H
#define LLVM_LIBC_SRC_CTYPE_ISGRAPH_H #define LLVM_LIBC_SRC_CTYPE_ISGRAPH_H
namespace __llvm_libc { namespace __llvm_libc {
int isgraph(int c); int isgraph(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISGRAPH_H #endif // LLVM_LIBC_SRC_CTYPE_ISGRAPH_H

libc/src/ctype/islower.h

//===-- Implementation header for islower -------------------------*-C++-*-===// //===-- Implementation header for islower -------------------------*-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_CTYPE_ISLOWER_H #ifndef LLVM_LIBC_SRC_CTYPE_ISLOWER_H
#define LLVM_LIBC_SRC_CTYPE_ISLOWER_H #define LLVM_LIBC_SRC_CTYPE_ISLOWER_H
namespace __llvm_libc { namespace __llvm_libc {
int islower(int c); int islower(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISLOWER_H #endif // LLVM_LIBC_SRC_CTYPE_ISLOWER_H

libc/src/ctype/isprint.h

//===-- Implementation header for isprint -------------------------*-C++-*-===// //===-- Implementation header for isprint -------------------------*-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_CTYPE_ISPRINT_H #ifndef LLVM_LIBC_SRC_CTYPE_ISPRINT_H
#define LLVM_LIBC_SRC_CTYPE_ISPRINT_H #define LLVM_LIBC_SRC_CTYPE_ISPRINT_H
namespace __llvm_libc { namespace __llvm_libc {
int isprint(int c); int isprint(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISPRINT_H #endif // LLVM_LIBC_SRC_CTYPE_ISPRINT_H

libc/src/ctype/ispunct.h

//===-- Implementation header for ispunct -------------------------*-C++-*-===// //===-- Implementation header for ispunct -------------------------*-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_CTYPE_ISPUNCT_H #ifndef LLVM_LIBC_SRC_CTYPE_ISPUNCT_H
#define LLVM_LIBC_SRC_CTYPE_ISPUNCT_H #define LLVM_LIBC_SRC_CTYPE_ISPUNCT_H
namespace __llvm_libc { namespace __llvm_libc {
int ispunct(int c); int ispunct(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISPUNCT_H #endif // LLVM_LIBC_SRC_CTYPE_ISPUNCT_H

libc/src/ctype/isspace.h

//===-- Implementation header for isspace -------------------------*-C++-*-===// //===-- Implementation header for isspace -------------------------*-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_CTYPE_ISSPACE_H #ifndef LLVM_LIBC_SRC_CTYPE_ISSPACE_H
#define LLVM_LIBC_SRC_CTYPE_ISSPACE_H #define LLVM_LIBC_SRC_CTYPE_ISSPACE_H
namespace __llvm_libc { namespace __llvm_libc {
int isspace(int c); int isspace(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISSPACE_H #endif // LLVM_LIBC_SRC_CTYPE_ISSPACE_H

libc/src/ctype/isupper.h

//===-- Implementation header for isupper -------------------------*-C++-*-===// //===-- Implementation header for isupper -------------------------*-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_CTYPE_ISUPPER_H #ifndef LLVM_LIBC_SRC_CTYPE_ISUPPER_H
#define LLVM_LIBC_SRC_CTYPE_ISUPPER_H #define LLVM_LIBC_SRC_CTYPE_ISUPPER_H
namespace __llvm_libc { namespace __llvm_libc {
int isupper(int c); int isupper(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISUPPER_H #endif // LLVM_LIBC_SRC_CTYPE_ISUPPER_H

libc/src/ctype/isxdigit.h

//===-- Implementation header for isxdigit ------------------------*-C++-*-===// //===-- Implementation header for isxdigit ------------------------*-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_CTYPE_ISXDIGIT_H #ifndef LLVM_LIBC_SRC_CTYPE_ISXDIGIT_H
#define LLVM_LIBC_SRC_CTYPE_ISXDIGIT_H #define LLVM_LIBC_SRC_CTYPE_ISXDIGIT_H
namespace __llvm_libc { namespace __llvm_libc {
int isxdigit(int c); int isxdigit(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_ISXDIGIT_H #endif // LLVM_LIBC_SRC_CTYPE_ISXDIGIT_H

libc/src/ctype/toascii.h

//===-- Implementation header for toascii -------------------------*-C++-*-===// //===-- Implementation header for toascii -------------------------*-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_CTYPE_TOASCII_H #ifndef LLVM_LIBC_SRC_CTYPE_TOASCII_H
#define LLVM_LIBC_SRC_CTYPE_TOASCII_H #define LLVM_LIBC_SRC_CTYPE_TOASCII_H
namespace __llvm_libc { namespace __llvm_libc {
int toascii(int c); int toascii(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_TOASCII_H #endif // LLVM_LIBC_SRC_CTYPE_TOASCII_H

libc/src/ctype/tolower.h

//===-- Implementation header for tolower -------------------------*-C++-*-===// //===-- Implementation header for tolower -------------------------*-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_CTYPE_TOLOWER_H #ifndef LLVM_LIBC_SRC_CTYPE_TOLOWER_H
#define LLVM_LIBC_SRC_CTYPE_TOLOWER_H #define LLVM_LIBC_SRC_CTYPE_TOLOWER_H
namespace __llvm_libc { namespace __llvm_libc {
int tolower(int c); int tolower(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_TOLOWER_H #endif // LLVM_LIBC_SRC_CTYPE_TOLOWER_H

libc/src/ctype/toupper.h

//===-- Implementation header for toupper -------------------------*-C++-*-===// //===-- Implementation header for toupper -------------------------*-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_CTYPE_TOUPPER_H #ifndef LLVM_LIBC_SRC_CTYPE_TOUPPER_H
#define LLVM_LIBC_SRC_CTYPE_TOUPPER_H #define LLVM_LIBC_SRC_CTYPE_TOUPPER_H
namespace __llvm_libc { namespace __llvm_libc {
int toupper(int c); int toupper(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_CTYPE_TOUPPER_H #endif // LLVM_LIBC_SRC_CTYPE_TOUPPER_H

libc/src/dirent/closedir.h

//===-- Implementation header of closedir -----------------------*- C++ -*-===// //===-- Implementation header of closedir -----------------------*- 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_DIRENT_CLOSEDIR_H #ifndef LLVM_LIBC_SRC_DIRENT_CLOSEDIR_H
#define LLVM_LIBC_SRC_DIRENT_CLOSEDIR_H #define LLVM_LIBC_SRC_DIRENT_CLOSEDIR_H
#include <dirent.h> #include <dirent.h>
namespace __llvm_libc { namespace __llvm_libc {
int closedir(::DIR *dir); int closedir(::DIR *dir) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_DIRENT_CLOSEDIR_H #endif // LLVM_LIBC_SRC_DIRENT_CLOSEDIR_H

libc/src/dirent/dirfd.h

//===-- Implementation header of dirfd --------------------------*- C++ -*-===// //===-- Implementation header of dirfd --------------------------*- 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_DIRENT_DIRFD_H #ifndef LLVM_LIBC_SRC_DIRENT_DIRFD_H
#define LLVM_LIBC_SRC_DIRENT_DIRFD_H #define LLVM_LIBC_SRC_DIRENT_DIRFD_H
#include <dirent.h> #include <dirent.h>
namespace __llvm_libc { namespace __llvm_libc {
int dirfd(::DIR *dir); int dirfd(::DIR *dir) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_DIRENT_DIRFD_H #endif // LLVM_LIBC_SRC_DIRENT_DIRFD_H

libc/src/dirent/opendir.h

//===-- Implementation header of opendir ------------------------*- C++ -*-===// //===-- Implementation header of opendir ------------------------*- 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_DIRENT_OPENDIR_H #ifndef LLVM_LIBC_SRC_DIRENT_OPENDIR_H
#define LLVM_LIBC_SRC_DIRENT_OPENDIR_H #define LLVM_LIBC_SRC_DIRENT_OPENDIR_H
#include <dirent.h> #include <dirent.h>
namespace __llvm_libc { namespace __llvm_libc {
::DIR *opendir(const char *name); ::DIR *opendir(const char *name) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_DIRENT_OPENDIR_H #endif // LLVM_LIBC_SRC_DIRENT_OPENDIR_H

libc/src/dirent/readdir.h

//===-- Implementation header of readdir ------------------------*- C++ -*-===// //===-- Implementation header of readdir ------------------------*- 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_DIRENT_READDIR_H #ifndef LLVM_LIBC_SRC_DIRENT_READDIR_H
#define LLVM_LIBC_SRC_DIRENT_READDIR_H #define LLVM_LIBC_SRC_DIRENT_READDIR_H
#include <dirent.h> #include <dirent.h>
namespace __llvm_libc { namespace __llvm_libc {
struct ::dirent *readdir(DIR *dir); struct ::dirent *readdir(DIR *dir) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_DIRENT_READDIR_H #endif // LLVM_LIBC_SRC_DIRENT_READDIR_H

libc/src/fcntl/creat.h

//===-- Implementation header of creat --------------------------*- C++ -*-===// //===-- Implementation header of creat --------------------------*- 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_FCNTL_CREAT_H #ifndef LLVM_LIBC_SRC_FCNTL_CREAT_H
#define LLVM_LIBC_SRC_FCNTL_CREAT_H #define LLVM_LIBC_SRC_FCNTL_CREAT_H
#include <fcntl.h> #include <fcntl.h>
namespace __llvm_libc { namespace __llvm_libc {
int creat(const char *path, int mode); int creat(const char *path, int mode) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FCNTL_CREAT_H #endif // LLVM_LIBC_SRC_FCNTL_CREAT_H

libc/src/fcntl/open.h

//===-- Implementation header of open ---------------------------*- C++ -*-===// //===-- Implementation header of open ---------------------------*- 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_FCNTL_OPEN_H #ifndef LLVM_LIBC_SRC_FCNTL_OPEN_H
#define LLVM_LIBC_SRC_FCNTL_OPEN_H #define LLVM_LIBC_SRC_FCNTL_OPEN_H
#include <fcntl.h> #include <fcntl.h>
namespace __llvm_libc { namespace __llvm_libc {
int open(const char *path, int flags, ...); int open(const char *path, int flags, ...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FCNTL_OPEN_H #endif // LLVM_LIBC_SRC_FCNTL_OPEN_H

libc/src/fcntl/openat.h

//===-- Implementation header of openat -------------------------*- C++ -*-===// //===-- Implementation header of openat -------------------------*- 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_FCNTL_OPENAT_H #ifndef LLVM_LIBC_SRC_FCNTL_OPENAT_H
#define LLVM_LIBC_SRC_FCNTL_OPENAT_H #define LLVM_LIBC_SRC_FCNTL_OPENAT_H
#include <fcntl.h> #include <fcntl.h>
namespace __llvm_libc { namespace __llvm_libc {
int openat(int dfd, const char *path, int flags, ...); int openat(int dfd, const char *path, int flags, ...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FCNTL_OPENAT_H #endif // LLVM_LIBC_SRC_FCNTL_OPENAT_H

libc/src/fenv/feclearexcept.h

//===-- Implementation header for feclearexcept -----------------*- C++ -*-===// //===-- Implementation header for feclearexcept -----------------*- 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_FENV_FECLEAREXCEPT_H #ifndef LLVM_LIBC_SRC_FENV_FECLEAREXCEPT_H
#define LLVM_LIBC_SRC_FENV_FECLEAREXCEPT_H #define LLVM_LIBC_SRC_FENV_FECLEAREXCEPT_H
namespace __llvm_libc { namespace __llvm_libc {
int feclearexcept(int); int feclearexcept(int) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FECLEAREXCEPT_H #endif // LLVM_LIBC_SRC_FENV_FECLEAREXCEPT_H

libc/src/fenv/fedisableexcept.h

//===-- Implementation header for fedisableexcept ---------------*- C++ -*-===// //===-- Implementation header for fedisableexcept ---------------*- 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_FENV_FEDISABLEEXCEPT_H #ifndef LLVM_LIBC_SRC_FENV_FEDISABLEEXCEPT_H
#define LLVM_LIBC_SRC_FENV_FEDISABLEEXCEPT_H #define LLVM_LIBC_SRC_FENV_FEDISABLEEXCEPT_H
namespace __llvm_libc { namespace __llvm_libc {
int fedisableexcept(int); int fedisableexcept(int) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FEDISABLEEXCEPT_H #endif // LLVM_LIBC_SRC_FENV_FEDISABLEEXCEPT_H

libc/src/fenv/feenableexcept.h

//===-- Implementation header for feenableexcept ----------------*- C++ -*-===// //===-- Implementation header for feenableexcept ----------------*- 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_FENV_FEENABLEEXCEPT_H #ifndef LLVM_LIBC_SRC_FENV_FEENABLEEXCEPT_H
#define LLVM_LIBC_SRC_FENV_FEENABLEEXCEPT_H #define LLVM_LIBC_SRC_FENV_FEENABLEEXCEPT_H
namespace __llvm_libc { namespace __llvm_libc {
int feenableexcept(int); int feenableexcept(int) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FEENABLEEXCEPT_H #endif // LLVM_LIBC_SRC_FENV_FEENABLEEXCEPT_H

libc/src/fenv/fegetenv.h

//===-- Implementation header for fegetenv ----------------------*- C++ -*-===// //===-- Implementation header for fegetenv ----------------------*- 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_FENV_FEGETENV_H #ifndef LLVM_LIBC_SRC_FENV_FEGETENV_H
#define LLVM_LIBC_SRC_FENV_FEGETENV_H #define LLVM_LIBC_SRC_FENV_FEGETENV_H
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
int fegetenv(fenv_t *); int fegetenv(fenv_t *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FEGETENV_H #endif // LLVM_LIBC_SRC_FENV_FEGETENV_H

libc/src/fenv/fegetexcept.h

//===-- Implementation header for fegetexcept -------------------*- C++ -*-===// //===-- Implementation header for fegetexcept -------------------*- 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_FENV_FEGETEXCEPT_H #ifndef LLVM_LIBC_SRC_FENV_FEGETEXCEPT_H
#define LLVM_LIBC_SRC_FENV_FEGETEXCEPT_H #define LLVM_LIBC_SRC_FENV_FEGETEXCEPT_H
namespace __llvm_libc { namespace __llvm_libc {
int fegetexcept(); int fegetexcept() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FEGETEXCEPT_H #endif // LLVM_LIBC_SRC_FENV_FEGETEXCEPT_H

libc/src/fenv/fegetexceptflag.h

//===-- Implementation header for fegetexceptflag ---------------*- C++ -*-===// //===-- Implementation header for fegetexceptflag ---------------*- 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_FENV_FEGETEXCEPTFLAG_H #ifndef LLVM_LIBC_SRC_FENV_FEGETEXCEPTFLAG_H
#define LLVM_LIBC_SRC_FENV_FEGETEXCEPTFLAG_H #define LLVM_LIBC_SRC_FENV_FEGETEXCEPTFLAG_H
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
int fegetexceptflag(fexcept_t *, int excepts); int fegetexceptflag(fexcept_t *, int excepts) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FEGETEXCEPTFLAG_H #endif // LLVM_LIBC_SRC_FENV_FEGETEXCEPTFLAG_H

libc/src/fenv/fegetround.h

//===-- Implementation header for fegetround --------------------*- C++ -*-===// //===-- Implementation header for fegetround --------------------*- 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_FENV_FEGETROUND_H #ifndef LLVM_LIBC_SRC_FENV_FEGETROUND_H
#define LLVM_LIBC_SRC_FENV_FEGETROUND_H #define LLVM_LIBC_SRC_FENV_FEGETROUND_H
namespace __llvm_libc { namespace __llvm_libc {
int fegetround(); int fegetround() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FEGETROUND_H #endif // LLVM_LIBC_SRC_FENV_FEGETROUND_H

libc/src/fenv/feholdexcept.h

//===-- Implementation header for feholdexcept ------------------*- C++ -*-===// //===-- Implementation header for feholdexcept ------------------*- 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_FENV_FEHOLDEXCEPT_H #ifndef LLVM_LIBC_SRC_FENV_FEHOLDEXCEPT_H
#define LLVM_LIBC_SRC_FENV_FEHOLDEXCEPT_H #define LLVM_LIBC_SRC_FENV_FEHOLDEXCEPT_H
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
int feholdexcept(fenv_t *); int feholdexcept(fenv_t *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FEHOLDEXCEPT_H #endif // LLVM_LIBC_SRC_FENV_FEHOLDEXCEPT_H

libc/src/fenv/feraiseexcept.h

//===-- Implementation header for feraiseexcept -----------------*- C++ -*-===// //===-- Implementation header for feraiseexcept -----------------*- 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_FENV_FERAISEEXCEPT_H #ifndef LLVM_LIBC_SRC_FENV_FERAISEEXCEPT_H
#define LLVM_LIBC_SRC_FENV_FERAISEEXCEPT_H #define LLVM_LIBC_SRC_FENV_FERAISEEXCEPT_H
namespace __llvm_libc { namespace __llvm_libc {
int feraiseexcept(int); int feraiseexcept(int) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FERAISEEXCEPT_H #endif // LLVM_LIBC_SRC_FENV_FERAISEEXCEPT_H

libc/src/fenv/fesetenv.h

//===-- Implementation header for fesetenv ----------------------*- C++ -*-===// //===-- Implementation header for fesetenv ----------------------*- 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_FENV_FESETENV_H #ifndef LLVM_LIBC_SRC_FENV_FESETENV_H
#define LLVM_LIBC_SRC_FENV_FESETENV_H #define LLVM_LIBC_SRC_FENV_FESETENV_H
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
int fesetenv(const fenv_t *); int fesetenv(const fenv_t *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FESETENV_H #endif // LLVM_LIBC_SRC_FENV_FESETENV_H

libc/src/fenv/fesetexceptflag.h

//===-- Implementation header for fesetexceptflag ---------------*- C++ -*-===// //===-- Implementation header for fesetexceptflag ---------------*- 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_FENV_FESETEXCEPTFLAG_H #ifndef LLVM_LIBC_SRC_FENV_FESETEXCEPTFLAG_H
#define LLVM_LIBC_SRC_FENV_FESETEXCEPTFLAG_H #define LLVM_LIBC_SRC_FENV_FESETEXCEPTFLAG_H
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
int fesetexceptflag(const fexcept_t *, int excepts); int fesetexceptflag(const fexcept_t *, int excepts) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FESETEXCEPTFLAG_H #endif // LLVM_LIBC_SRC_FENV_FESETEXCEPTFLAG_H

libc/src/fenv/fesetround.h

//===-- Implementation header for fesetround --------------------*- C++ -*-===// //===-- Implementation header for fesetround --------------------*- 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_FENV_FESETROUND_H #ifndef LLVM_LIBC_SRC_FENV_FESETROUND_H
#define LLVM_LIBC_SRC_FENV_FESETROUND_H #define LLVM_LIBC_SRC_FENV_FESETROUND_H
namespace __llvm_libc { namespace __llvm_libc {
int fesetround(int); int fesetround(int) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FESETROUND_H #endif // LLVM_LIBC_SRC_FENV_FESETROUND_H

libc/src/fenv/fetestexcept.h

//===-- Implementation header for fetestexpect ------------------*- C++ -*-===// //===-- Implementation header for fetestexpect ------------------*- 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_FENV_FETESTEXCEPT_H #ifndef LLVM_LIBC_SRC_FENV_FETESTEXCEPT_H
#define LLVM_LIBC_SRC_FENV_FETESTEXCEPT_H #define LLVM_LIBC_SRC_FENV_FETESTEXCEPT_H
namespace __llvm_libc { namespace __llvm_libc {
int fetestexcept(int); int fetestexcept(int) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FETESTEXCEPT_H #endif // LLVM_LIBC_SRC_FENV_FETESTEXCEPT_H

libc/src/fenv/feupdateenv.h

//===-- Implementation header for feupdateenv -------------------*- C++ -*-===// //===-- Implementation header for feupdateenv -------------------*- 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_FENV_FEUPDATEENV_H #ifndef LLVM_LIBC_SRC_FENV_FEUPDATEENV_H
#define LLVM_LIBC_SRC_FENV_FEUPDATEENV_H #define LLVM_LIBC_SRC_FENV_FEUPDATEENV_H
#include <fenv.h> #include <fenv.h>
namespace __llvm_libc { namespace __llvm_libc {
int feupdateenv(const fenv_t *); int feupdateenv(const fenv_t *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_FENV_FEUPDATEENV_H #endif // LLVM_LIBC_SRC_FENV_FEUPDATEENV_H

libc/src/inttypes/imaxabs.h

//===-- Implementation header for imaxabs -----------------------*- C++ -*-===// //===-- Implementation header for imaxabs -----------------------*- 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_INTTYPES_IMAXABS_H #ifndef LLVM_LIBC_SRC_INTTYPES_IMAXABS_H
#define LLVM_LIBC_SRC_INTTYPES_IMAXABS_H #define LLVM_LIBC_SRC_INTTYPES_IMAXABS_H
#include <inttypes.h> #include <inttypes.h>
namespace __llvm_libc { namespace __llvm_libc {
intmax_t imaxabs(intmax_t j); intmax_t imaxabs(intmax_t j) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_INTTYPES_IMAXABS_H #endif // LLVM_LIBC_SRC_INTTYPES_IMAXABS_H

libc/src/inttypes/imaxdiv.h

//===-- Implementation header for imaxdiv -----------------------*- C++ -*-===// //===-- Implementation header for imaxdiv -----------------------*- 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_INTTYPES_IMAXDIV_H #ifndef LLVM_LIBC_SRC_INTTYPES_IMAXDIV_H
#define LLVM_LIBC_SRC_INTTYPES_IMAXDIV_H #define LLVM_LIBC_SRC_INTTYPES_IMAXDIV_H
#include <inttypes.h> #include <inttypes.h>
namespace __llvm_libc { namespace __llvm_libc {
imaxdiv_t imaxdiv(intmax_t x, intmax_t y); imaxdiv_t imaxdiv(intmax_t x, intmax_t y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_INTTYPES_IMAXDIV_H #endif // LLVM_LIBC_SRC_INTTYPES_IMAXDIV_H

libc/src/inttypes/strtoimax.h

//===-- Implementation header for strtoimax ---------------------*- C++ -*-===// //===-- Implementation header for strtoimax ---------------------*- 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_INTTYPES_STRTOIMAX_H #ifndef LLVM_LIBC_SRC_INTTYPES_STRTOIMAX_H
#define LLVM_LIBC_SRC_INTTYPES_STRTOIMAX_H #define LLVM_LIBC_SRC_INTTYPES_STRTOIMAX_H
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
intmax_t strtoimax(const char *__restrict str, char **__restrict str_end, intmax_t strtoimax(const char *__restrict str, char **__restrict str_end,
int base); int base) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_INTTYPES_STRTOIMAX_H #endif // LLVM_LIBC_SRC_INTTYPES_STRTOIMAX_H

libc/src/inttypes/strtoumax.h

//===-- Implementation header for strtoumax ---------------------*- C++ -*-===// //===-- Implementation header for strtoumax ---------------------*- 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_INTTYPES_STRTOUMAX_H #ifndef LLVM_LIBC_SRC_INTTYPES_STRTOUMAX_H
#define LLVM_LIBC_SRC_INTTYPES_STRTOUMAX_H #define LLVM_LIBC_SRC_INTTYPES_STRTOUMAX_H
#include <stdint.h> #include <stdint.h>
namespace __llvm_libc { namespace __llvm_libc {
uintmax_t strtoumax(const char *__restrict str, char **__restrict str_end, uintmax_t strtoumax(const char *__restrict str, char **__restrict str_end,
int base); int base) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_INTTYPES_STRTOUMAX_H #endif // LLVM_LIBC_SRC_INTTYPES_STRTOUMAX_H

libc/src/math/acosf.h

//===-- Implementation header for acosf -------------------------*- C++ -*-===// //===-- Implementation header for acosf -------------------------*- 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_MATH_ACOSF_H #ifndef LLVM_LIBC_SRC_MATH_ACOSF_H
#define LLVM_LIBC_SRC_MATH_ACOSF_H #define LLVM_LIBC_SRC_MATH_ACOSF_H
namespace __llvm_libc { namespace __llvm_libc {
float acosf(float x); float acosf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ACOSF_H #endif // LLVM_LIBC_SRC_MATH_ACOSF_H

libc/src/math/asin.h

//===-- Implementation header for asin --------------------------*- C++ -*-===// //===-- Implementation header for asin --------------------------*- 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_MATH_ASIN_H #ifndef LLVM_LIBC_SRC_MATH_ASIN_H
#define LLVM_LIBC_SRC_MATH_ASIN_H #define LLVM_LIBC_SRC_MATH_ASIN_H
namespace __llvm_libc { namespace __llvm_libc {
double asin(double x); double asin(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ASIN_H #endif // LLVM_LIBC_SRC_MATH_ASIN_H

libc/src/math/asinf.h

//===-- Implementation header for asinf -------------------------*- C++ -*-===// //===-- Implementation header for asinf -------------------------*- 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_MATH_ASINF_H #ifndef LLVM_LIBC_SRC_MATH_ASINF_H
#define LLVM_LIBC_SRC_MATH_ASINF_H #define LLVM_LIBC_SRC_MATH_ASINF_H
namespace __llvm_libc { namespace __llvm_libc {
float asinf(float x); float asinf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ASINF_H #endif // LLVM_LIBC_SRC_MATH_ASINF_H

libc/src/math/atanf.h

//===-- Implementation header for atanf -------------------------*- C++ -*-===// //===-- Implementation header for atanf -------------------------*- 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_MATH_ATANF_H #ifndef LLVM_LIBC_SRC_MATH_ATANF_H
#define LLVM_LIBC_SRC_MATH_ATANF_H #define LLVM_LIBC_SRC_MATH_ATANF_H
namespace __llvm_libc { namespace __llvm_libc {
float atanf(float x); float atanf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ATANF_H #endif // LLVM_LIBC_SRC_MATH_ATANF_H

libc/src/math/atanhf.h

//===-- Implementation header for atanhf ------------------------*- C++ -*-===// //===-- Implementation header for atanhf ------------------------*- 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_MATH_ATANHF_H #ifndef LLVM_LIBC_SRC_MATH_ATANHF_H
#define LLVM_LIBC_SRC_MATH_ATANHF_H #define LLVM_LIBC_SRC_MATH_ATANHF_H
namespace __llvm_libc { namespace __llvm_libc {
float atanhf(float x); float atanhf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ATANHF_H #endif // LLVM_LIBC_SRC_MATH_ATANHF_H

libc/src/math/ceil.h

//===-- Implementation header for ceil --------------------------*- C++ -*-===// //===-- Implementation header for ceil --------------------------*- 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_MATH_CEIL_H #ifndef LLVM_LIBC_SRC_MATH_CEIL_H
#define LLVM_LIBC_SRC_MATH_CEIL_H #define LLVM_LIBC_SRC_MATH_CEIL_H
namespace __llvm_libc { namespace __llvm_libc {
double ceil(double x); double ceil(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_CEIL_H #endif // LLVM_LIBC_SRC_MATH_CEIL_H

libc/src/math/ceilf.h

//===-- Implementation header for ceilf -------------------------*- C++ -*-===// //===-- Implementation header for ceilf -------------------------*- 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_MATH_CEILF_H #ifndef LLVM_LIBC_SRC_MATH_CEILF_H
#define LLVM_LIBC_SRC_MATH_CEILF_H #define LLVM_LIBC_SRC_MATH_CEILF_H
namespace __llvm_libc { namespace __llvm_libc {
float ceilf(float x); float ceilf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_CEILF_H #endif // LLVM_LIBC_SRC_MATH_CEILF_H

libc/src/math/ceill.h

//===-- Implementation header for ceill -------------------------*- C++ -*-===// //===-- Implementation header for ceill -------------------------*- 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_MATH_CEILL_H #ifndef LLVM_LIBC_SRC_MATH_CEILL_H
#define LLVM_LIBC_SRC_MATH_CEILL_H #define LLVM_LIBC_SRC_MATH_CEILL_H
namespace __llvm_libc { namespace __llvm_libc {
long double ceill(long double x); long double ceill(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_CEILL_H #endif // LLVM_LIBC_SRC_MATH_CEILL_H

libc/src/math/copysign.h

//===-- Implementation header for copysign ----------------------*- C++ -*-===// //===-- Implementation header for copysign ----------------------*- 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_MATH_COPYSIGN_H #ifndef LLVM_LIBC_SRC_MATH_COPYSIGN_H
#define LLVM_LIBC_SRC_MATH_COPYSIGN_H #define LLVM_LIBC_SRC_MATH_COPYSIGN_H
namespace __llvm_libc { namespace __llvm_libc {
double copysign(double x, double y); double copysign(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_COPYSIGN_H #endif // LLVM_LIBC_SRC_MATH_COPYSIGN_H

libc/src/math/copysignf.h

//===-- Implementation header for copysignf ---------------------*- C++ -*-===// //===-- Implementation header for copysignf ---------------------*- 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_MATH_COPYSIGNF_H #ifndef LLVM_LIBC_SRC_MATH_COPYSIGNF_H
#define LLVM_LIBC_SRC_MATH_COPYSIGNF_H #define LLVM_LIBC_SRC_MATH_COPYSIGNF_H
namespace __llvm_libc { namespace __llvm_libc {
float copysignf(float x, float y); float copysignf(float x, float y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_COPYSIGNF_H #endif // LLVM_LIBC_SRC_MATH_COPYSIGNF_H

libc/src/math/copysignl.h

//===-- Implementation header for copysignl ---------------------*- C++ -*-===// //===-- Implementation header for copysignl ---------------------*- 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_MATH_COPYSIGNL_H #ifndef LLVM_LIBC_SRC_MATH_COPYSIGNL_H
#define LLVM_LIBC_SRC_MATH_COPYSIGNL_H #define LLVM_LIBC_SRC_MATH_COPYSIGNL_H
namespace __llvm_libc { namespace __llvm_libc {
long double copysignl(long double x, long double y); long double copysignl(long double x, long double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_COPYSIGNL_H #endif // LLVM_LIBC_SRC_MATH_COPYSIGNL_H

libc/src/math/cos.h

//===-- Implementation header for cos ---------------------------*- C++ -*-===// //===-- Implementation header for cos ---------------------------*- 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_MATH_COS_H #ifndef LLVM_LIBC_SRC_MATH_COS_H
#define LLVM_LIBC_SRC_MATH_COS_H #define LLVM_LIBC_SRC_MATH_COS_H
namespace __llvm_libc { namespace __llvm_libc {
double cos(double x); double cos(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_COS_H #endif // LLVM_LIBC_SRC_MATH_COS_H

libc/src/math/cosf.h

//===-- Implementation header for cosf --------------------------*- C++ -*-===// //===-- Implementation header for cosf --------------------------*- 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_MATH_COSF_H #ifndef LLVM_LIBC_SRC_MATH_COSF_H
#define LLVM_LIBC_SRC_MATH_COSF_H #define LLVM_LIBC_SRC_MATH_COSF_H
namespace __llvm_libc { namespace __llvm_libc {
float cosf(float x); float cosf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_COSF_H #endif // LLVM_LIBC_SRC_MATH_COSF_H

libc/src/math/coshf.h

//===-- Implementation header for coshf -------------------------*- C++ -*-===// //===-- Implementation header for coshf -------------------------*- 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_MATH_COSHF_H #ifndef LLVM_LIBC_SRC_MATH_COSHF_H
#define LLVM_LIBC_SRC_MATH_COSHF_H #define LLVM_LIBC_SRC_MATH_COSHF_H
namespace __llvm_libc { namespace __llvm_libc {
float coshf(float x); float coshf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_COSHF_H #endif // LLVM_LIBC_SRC_MATH_COSHF_H

libc/src/math/exp10f.h

//===-- Implementation header for exp10f ------------------------*- C++ -*-===// //===-- Implementation header for exp10f ------------------------*- 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_MATH_EXP10F_H #ifndef LLVM_LIBC_SRC_MATH_EXP10F_H
#define LLVM_LIBC_SRC_MATH_EXP10F_H #define LLVM_LIBC_SRC_MATH_EXP10F_H
namespace __llvm_libc { namespace __llvm_libc {
float exp10f(float x); float exp10f(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_EXP10F_H #endif // LLVM_LIBC_SRC_MATH_EXP10F_H

libc/src/math/exp2f.h

//===-- Implementation header for exp2f -------------------------*- C++ -*-===// //===-- Implementation header for exp2f -------------------------*- 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_MATH_EXP2F_H #ifndef LLVM_LIBC_SRC_MATH_EXP2F_H
#define LLVM_LIBC_SRC_MATH_EXP2F_H #define LLVM_LIBC_SRC_MATH_EXP2F_H
namespace __llvm_libc { namespace __llvm_libc {
float exp2f(float x); float exp2f(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_EXP2F_H #endif // LLVM_LIBC_SRC_MATH_EXP2F_H

libc/src/math/expf.h

//===-- Implementation header for expf --------------------------*- C++ -*-===// //===-- Implementation header for expf --------------------------*- 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_MATH_EXPF_H #ifndef LLVM_LIBC_SRC_MATH_EXPF_H
#define LLVM_LIBC_SRC_MATH_EXPF_H #define LLVM_LIBC_SRC_MATH_EXPF_H
namespace __llvm_libc { namespace __llvm_libc {
float expf(float x); float expf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_EXPF_H #endif // LLVM_LIBC_SRC_MATH_EXPF_H

libc/src/math/expm1f.h

//===-- Implementation header for expm1f ------------------------*- C++ -*-===// //===-- Implementation header for expm1f ------------------------*- 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_MATH_EXPM1F_H #ifndef LLVM_LIBC_SRC_MATH_EXPM1F_H
#define LLVM_LIBC_SRC_MATH_EXPM1F_H #define LLVM_LIBC_SRC_MATH_EXPM1F_H
namespace __llvm_libc { namespace __llvm_libc {
float expm1f(float x); float expm1f(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_EXPM1F_H #endif // LLVM_LIBC_SRC_MATH_EXPM1F_H

libc/src/math/fabs.h

//===-- Implementation header for fabs --------------------------*- C++ -*-===// //===-- Implementation header for fabs --------------------------*- 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_MATH_FABS_H #ifndef LLVM_LIBC_SRC_MATH_FABS_H
#define LLVM_LIBC_SRC_MATH_FABS_H #define LLVM_LIBC_SRC_MATH_FABS_H
namespace __llvm_libc { namespace __llvm_libc {
double fabs(double x); double fabs(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FABS_H #endif // LLVM_LIBC_SRC_MATH_FABS_H

libc/src/math/fabsf.h

//===-- Implementation header for fabsf -------------------------*- C++ -*-===// //===-- Implementation header for fabsf -------------------------*- 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_MATH_FABSF_H #ifndef LLVM_LIBC_SRC_MATH_FABSF_H
#define LLVM_LIBC_SRC_MATH_FABSF_H #define LLVM_LIBC_SRC_MATH_FABSF_H
namespace __llvm_libc { namespace __llvm_libc {
float fabsf(float x); float fabsf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FABSF_H #endif // LLVM_LIBC_SRC_MATH_FABSF_H

libc/src/math/fabsl.h

//===-- Implementation header for fabsf -------------------------*- C++ -*-===// //===-- Implementation header for fabsf -------------------------*- 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_MATH_FABSL_H #ifndef LLVM_LIBC_SRC_MATH_FABSL_H
#define LLVM_LIBC_SRC_MATH_FABSL_H #define LLVM_LIBC_SRC_MATH_FABSL_H
namespace __llvm_libc { namespace __llvm_libc {
long double fabsl(long double x); long double fabsl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FABSL_H #endif // LLVM_LIBC_SRC_MATH_FABSL_H

libc/src/math/fdim.h

//===-- Implementation header for fdim --------------------------*- C++ -*-===// //===-- Implementation header for fdim --------------------------*- 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_MATH_FDIM_H #ifndef LLVM_LIBC_SRC_MATH_FDIM_H
#define LLVM_LIBC_SRC_MATH_FDIM_H #define LLVM_LIBC_SRC_MATH_FDIM_H
namespace __llvm_libc { namespace __llvm_libc {
double fdim(double x, double y); double fdim(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FDIM_H #endif // LLVM_LIBC_SRC_MATH_FDIM_H

libc/src/math/fdimf.h

//===-- Implementation header for fdimf -------------------------*- C++ -*-===// //===-- Implementation header for fdimf -------------------------*- 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_MATH_FDIMF_H #ifndef LLVM_LIBC_SRC_MATH_FDIMF_H
#define LLVM_LIBC_SRC_MATH_FDIMF_H #define LLVM_LIBC_SRC_MATH_FDIMF_H
namespace __llvm_libc { namespace __llvm_libc {
float fdimf(float x, float y); float fdimf(float x, float y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FDIMF_H #endif // LLVM_LIBC_SRC_MATH_FDIMF_H

libc/src/math/fdiml.h

//===-- Implementation header for fdiml -------------------------*- C++ -*-===// //===-- Implementation header for fdiml -------------------------*- 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_MATH_FDIML_H #ifndef LLVM_LIBC_SRC_MATH_FDIML_H
#define LLVM_LIBC_SRC_MATH_FDIML_H #define LLVM_LIBC_SRC_MATH_FDIML_H
namespace __llvm_libc { namespace __llvm_libc {
long double fdiml(long double x, long double y); long double fdiml(long double x, long double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FDIML_H #endif // LLVM_LIBC_SRC_MATH_FDIML_H

libc/src/math/floor.h

//===-- Implementation header for floor -------------------------*- C++ -*-===// //===-- Implementation header for floor -------------------------*- 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_MATH_FLOOR_H #ifndef LLVM_LIBC_SRC_MATH_FLOOR_H
#define LLVM_LIBC_SRC_MATH_FLOOR_H #define LLVM_LIBC_SRC_MATH_FLOOR_H
namespace __llvm_libc { namespace __llvm_libc {
double floor(double x); double floor(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FLOOR_H #endif // LLVM_LIBC_SRC_MATH_FLOOR_H

libc/src/math/floorf.h

//===-- Implementation header for floorf ------------------------*- C++ -*-===// //===-- Implementation header for floorf ------------------------*- 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_MATH_FLOORF_H #ifndef LLVM_LIBC_SRC_MATH_FLOORF_H
#define LLVM_LIBC_SRC_MATH_FLOORF_H #define LLVM_LIBC_SRC_MATH_FLOORF_H
namespace __llvm_libc { namespace __llvm_libc {
float floorf(float x); float floorf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FLOORF_H #endif // LLVM_LIBC_SRC_MATH_FLOORF_H

libc/src/math/floorl.h

//===-- Implementation header for floorl ------------------------*- C++ -*-===// //===-- Implementation header for floorl ------------------------*- 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_MATH_FLOORL_H #ifndef LLVM_LIBC_SRC_MATH_FLOORL_H
#define LLVM_LIBC_SRC_MATH_FLOORL_H #define LLVM_LIBC_SRC_MATH_FLOORL_H
namespace __llvm_libc { namespace __llvm_libc {
long double floorl(long double x); long double floorl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FLOORL_H #endif // LLVM_LIBC_SRC_MATH_FLOORL_H

libc/src/math/fma.h

//===-- Implementation header for fma ---------------------------*- C++ -*-===// //===-- Implementation header for fma ---------------------------*- 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_MATH_FMA_H #ifndef LLVM_LIBC_SRC_MATH_FMA_H
#define LLVM_LIBC_SRC_MATH_FMA_H #define LLVM_LIBC_SRC_MATH_FMA_H
namespace __llvm_libc { namespace __llvm_libc {
double fma(double x, double y, double z); double fma(double x, double y, double z) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMA_H #endif // LLVM_LIBC_SRC_MATH_FMA_H

libc/src/math/fmaf.h

//===-- Implementation header for fmaf --------------------------*- C++ -*-===// //===-- Implementation header for fmaf --------------------------*- 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_MATH_FMAF_H #ifndef LLVM_LIBC_SRC_MATH_FMAF_H
#define LLVM_LIBC_SRC_MATH_FMAF_H #define LLVM_LIBC_SRC_MATH_FMAF_H
namespace __llvm_libc { namespace __llvm_libc {
float fmaf(float x, float y, float z); float fmaf(float x, float y, float z) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMAF_H #endif // LLVM_LIBC_SRC_MATH_FMAF_H

libc/src/math/fmax.h

//===-- Implementation header for fmax --------------------------*- C++ -*-===// //===-- Implementation header for fmax --------------------------*- 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_MATH_FMAX_H #ifndef LLVM_LIBC_SRC_MATH_FMAX_H
#define LLVM_LIBC_SRC_MATH_FMAX_H #define LLVM_LIBC_SRC_MATH_FMAX_H
namespace __llvm_libc { namespace __llvm_libc {
double fmax(double x, double y); double fmax(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMAX_H #endif // LLVM_LIBC_SRC_MATH_FMAX_H

libc/src/math/fmaxf.h

//===-- Implementation header for fmaxf -------------------------*- C++ -*-===// //===-- Implementation header for fmaxf -------------------------*- 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_MATH_FMAXF_H #ifndef LLVM_LIBC_SRC_MATH_FMAXF_H
#define LLVM_LIBC_SRC_MATH_FMAXF_H #define LLVM_LIBC_SRC_MATH_FMAXF_H
namespace __llvm_libc { namespace __llvm_libc {
float fmaxf(float x, float y); float fmaxf(float x, float y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMAXF_H #endif // LLVM_LIBC_SRC_MATH_FMAXF_H

libc/src/math/fmaxl.h

//===-- Implementation header for fmaxl -------------------------*- C++ -*-===// //===-- Implementation header for fmaxl -------------------------*- 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_MATH_FMAXL_H #ifndef LLVM_LIBC_SRC_MATH_FMAXL_H
#define LLVM_LIBC_SRC_MATH_FMAXL_H #define LLVM_LIBC_SRC_MATH_FMAXL_H
namespace __llvm_libc { namespace __llvm_libc {
long double fmaxl(long double x, long double y); long double fmaxl(long double x, long double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMAXL_H #endif // LLVM_LIBC_SRC_MATH_FMAXL_H

libc/src/math/fmin.h

//===-- Implementation header for fmin --------------------------*- C++ -*-===// //===-- Implementation header for fmin --------------------------*- 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_MATH_FMIN_H #ifndef LLVM_LIBC_SRC_MATH_FMIN_H
#define LLVM_LIBC_SRC_MATH_FMIN_H #define LLVM_LIBC_SRC_MATH_FMIN_H
namespace __llvm_libc { namespace __llvm_libc {
double fmin(double x, double y); double fmin(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMIN_H #endif // LLVM_LIBC_SRC_MATH_FMIN_H

libc/src/math/fminf.h

//===-- Implementation header for fminf -------------------------*- C++ -*-===// //===-- Implementation header for fminf -------------------------*- 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_MATH_FMINF_H #ifndef LLVM_LIBC_SRC_MATH_FMINF_H
#define LLVM_LIBC_SRC_MATH_FMINF_H #define LLVM_LIBC_SRC_MATH_FMINF_H
namespace __llvm_libc { namespace __llvm_libc {
float fminf(float x, float y); float fminf(float x, float y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMINF_H #endif // LLVM_LIBC_SRC_MATH_FMINF_H

libc/src/math/fminl.h

//===-- Implementation header for fminl -------------------------*- C++ -*-===// //===-- Implementation header for fminl -------------------------*- 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_MATH_FMINL_H #ifndef LLVM_LIBC_SRC_MATH_FMINL_H
#define LLVM_LIBC_SRC_MATH_FMINL_H #define LLVM_LIBC_SRC_MATH_FMINL_H
namespace __llvm_libc { namespace __llvm_libc {
long double fminl(long double x, long double y); long double fminl(long double x, long double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMINL_H #endif // LLVM_LIBC_SRC_MATH_FMINL_H

libc/src/math/fmod.h

//===-- Implementation header for fmod --------------------------*- C++ -*-===// //===-- Implementation header for fmod --------------------------*- 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_MATH_FMOD_H #ifndef LLVM_LIBC_SRC_MATH_FMOD_H
#define LLVM_LIBC_SRC_MATH_FMOD_H #define LLVM_LIBC_SRC_MATH_FMOD_H
namespace __llvm_libc { namespace __llvm_libc {
double fmod(double x, double y); double fmod(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMOD_H #endif // LLVM_LIBC_SRC_MATH_FMOD_H

libc/src/math/fmodf.h

//===-- Implementation header for fmodf -------------------------*- C++ -*-===// //===-- Implementation header for fmodf -------------------------*- 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_MATH_FMODF_H #ifndef LLVM_LIBC_SRC_MATH_FMODF_H
#define LLVM_LIBC_SRC_MATH_FMODF_H #define LLVM_LIBC_SRC_MATH_FMODF_H
namespace __llvm_libc { namespace __llvm_libc {
float fmodf(float x, float y); float fmodf(float x, float y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FMODF_H #endif // LLVM_LIBC_SRC_MATH_FMODF_H

libc/src/math/frexp.h

//===-- Implementation header for frexp -------------------------*- C++ -*-===// //===-- Implementation header for frexp -------------------------*- 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_MATH_FREXP_H #ifndef LLVM_LIBC_SRC_MATH_FREXP_H
#define LLVM_LIBC_SRC_MATH_FREXP_H #define LLVM_LIBC_SRC_MATH_FREXP_H
namespace __llvm_libc { namespace __llvm_libc {
double frexp(double x, int *exp); double frexp(double x, int *exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FREXP_H #endif // LLVM_LIBC_SRC_MATH_FREXP_H

libc/src/math/frexpf.h

//===-- Implementation header for frexpf ------------------------*- C++ -*-===// //===-- Implementation header for frexpf ------------------------*- 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_MATH_FREXPF_H #ifndef LLVM_LIBC_SRC_MATH_FREXPF_H
#define LLVM_LIBC_SRC_MATH_FREXPF_H #define LLVM_LIBC_SRC_MATH_FREXPF_H
namespace __llvm_libc { namespace __llvm_libc {
float frexpf(float x, int *exp); float frexpf(float x, int *exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FREXPF_H #endif // LLVM_LIBC_SRC_MATH_FREXPF_H

libc/src/math/frexpl.h

//===-- Implementation header for frexpl ------------------------*- C++ -*-===// //===-- Implementation header for frexpl ------------------------*- 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_MATH_FREXPL_H #ifndef LLVM_LIBC_SRC_MATH_FREXPL_H
#define LLVM_LIBC_SRC_MATH_FREXPL_H #define LLVM_LIBC_SRC_MATH_FREXPL_H
namespace __llvm_libc { namespace __llvm_libc {
long double frexpl(long double x, int *exp); long double frexpl(long double x, int *exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_FREXPL_H #endif // LLVM_LIBC_SRC_MATH_FREXPL_H

libc/src/math/hypot.h

//===-- Implementation header for hypot -------------------------*- C++ -*-===// //===-- Implementation header for hypot -------------------------*- 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_MATH_HYPOT_H #ifndef LLVM_LIBC_SRC_MATH_HYPOT_H
#define LLVM_LIBC_SRC_MATH_HYPOT_H #define LLVM_LIBC_SRC_MATH_HYPOT_H
namespace __llvm_libc { namespace __llvm_libc {
double hypot(double x, double y); double hypot(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_HYPOT_H #endif // LLVM_LIBC_SRC_MATH_HYPOT_H

libc/src/math/hypotf.h

//===-- Implementation header for hypotf ------------------------*- C++ -*-===// //===-- Implementation header for hypotf ------------------------*- 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_MATH_HYPOTF_H #ifndef LLVM_LIBC_SRC_MATH_HYPOTF_H
#define LLVM_LIBC_SRC_MATH_HYPOTF_H #define LLVM_LIBC_SRC_MATH_HYPOTF_H
namespace __llvm_libc { namespace __llvm_libc {
float hypotf(float x, float y); float hypotf(float x, float y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_HYPOTF_H #endif // LLVM_LIBC_SRC_MATH_HYPOTF_H

libc/src/math/ilogb.h

//===-- Implementation header for ilogb -------------------------*- C++ -*-===// //===-- Implementation header for ilogb -------------------------*- 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_MATH_ILOGB_H #ifndef LLVM_LIBC_SRC_MATH_ILOGB_H
#define LLVM_LIBC_SRC_MATH_ILOGB_H #define LLVM_LIBC_SRC_MATH_ILOGB_H
namespace __llvm_libc { namespace __llvm_libc {
int ilogb(double x); int ilogb(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ILOGB_H #endif // LLVM_LIBC_SRC_MATH_ILOGB_H

libc/src/math/ilogbf.h

//===-- Implementation header for ilogbf ------------------------*- C++ -*-===// //===-- Implementation header for ilogbf ------------------------*- 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_MATH_ILOGBF_H #ifndef LLVM_LIBC_SRC_MATH_ILOGBF_H
#define LLVM_LIBC_SRC_MATH_ILOGBF_H #define LLVM_LIBC_SRC_MATH_ILOGBF_H
namespace __llvm_libc { namespace __llvm_libc {
int ilogbf(float x); int ilogbf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ILOGBF_H #endif // LLVM_LIBC_SRC_MATH_ILOGBF_H

libc/src/math/ilogbl.h

//===-- Implementation header for ilogbl ------------------------*- C++ -*-===// //===-- Implementation header for ilogbl ------------------------*- 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_MATH_ILOGBL_H #ifndef LLVM_LIBC_SRC_MATH_ILOGBL_H
#define LLVM_LIBC_SRC_MATH_ILOGBL_H #define LLVM_LIBC_SRC_MATH_ILOGBL_H
namespace __llvm_libc { namespace __llvm_libc {
int ilogbl(long double x); int ilogbl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ILOGBL_H #endif // LLVM_LIBC_SRC_MATH_ILOGBL_H

libc/src/math/ldexp.h

//===-- Implementation header for ldexp -------------------------*- C++ -*-===// //===-- Implementation header for ldexp -------------------------*- 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_MATH_LDEXP_H #ifndef LLVM_LIBC_SRC_MATH_LDEXP_H
#define LLVM_LIBC_SRC_MATH_LDEXP_H #define LLVM_LIBC_SRC_MATH_LDEXP_H
namespace __llvm_libc { namespace __llvm_libc {
double ldexp(double x, int exp); double ldexp(double x, int exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LDEXP_H #endif // LLVM_LIBC_SRC_MATH_LDEXP_H

libc/src/math/ldexpf.h

//===-- Implementation header for ldexpf ------------------------*- C++ -*-===// //===-- Implementation header for ldexpf ------------------------*- 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_MATH_LDEXPF_H #ifndef LLVM_LIBC_SRC_MATH_LDEXPF_H
#define LLVM_LIBC_SRC_MATH_LDEXPF_H #define LLVM_LIBC_SRC_MATH_LDEXPF_H
namespace __llvm_libc { namespace __llvm_libc {
float ldexpf(float x, int exp); float ldexpf(float x, int exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LDEXPF_H #endif // LLVM_LIBC_SRC_MATH_LDEXPF_H

libc/src/math/ldexpl.h

//===-- Implementation header for ldexpl ------------------------*- C++ -*-===// //===-- Implementation header for ldexpl ------------------------*- 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_MATH_ldexpl_H #ifndef LLVM_LIBC_SRC_MATH_ldexpl_H
#define LLVM_LIBC_SRC_MATH_ldexpl_H #define LLVM_LIBC_SRC_MATH_ldexpl_H
namespace __llvm_libc { namespace __llvm_libc {
long double ldexpl(long double x, int exp); long double ldexpl(long double x, int exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ldexpl_H #endif // LLVM_LIBC_SRC_MATH_ldexpl_H

libc/src/math/llrint.h

//===-- Implementation header for llrint ------------------------*- C++ -*-===// //===-- Implementation header for llrint ------------------------*- 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_MATH_LLRINT_H #ifndef LLVM_LIBC_SRC_MATH_LLRINT_H
#define LLVM_LIBC_SRC_MATH_LLRINT_H #define LLVM_LIBC_SRC_MATH_LLRINT_H
namespace __llvm_libc { namespace __llvm_libc {
long long llrint(double x); long long llrint(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LLRINT_H #endif // LLVM_LIBC_SRC_MATH_LLRINT_H

libc/src/math/llrintf.h

//===-- Implementation header for llrintf -----------------------*- C++ -*-===// //===-- Implementation header for llrintf -----------------------*- 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_MATH_LLRINTF_H #ifndef LLVM_LIBC_SRC_MATH_LLRINTF_H
#define LLVM_LIBC_SRC_MATH_LLRINTF_H #define LLVM_LIBC_SRC_MATH_LLRINTF_H
namespace __llvm_libc { namespace __llvm_libc {
long long llrintf(float x); long long llrintf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LLRINTF_H #endif // LLVM_LIBC_SRC_MATH_LLRINTF_H

libc/src/math/llrintl.h

//===-- Implementation header for llrintl -----------------------*- C++ -*-===// //===-- Implementation header for llrintl -----------------------*- 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_MATH_LLRINTL_H #ifndef LLVM_LIBC_SRC_MATH_LLRINTL_H
#define LLVM_LIBC_SRC_MATH_LLRINTL_H #define LLVM_LIBC_SRC_MATH_LLRINTL_H
namespace __llvm_libc { namespace __llvm_libc {
long long llrintl(long double x); long long llrintl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LLRINTL_H #endif // LLVM_LIBC_SRC_MATH_LLRINTL_H

libc/src/math/llround.h

//===-- Implementation header for llround -----------------------*- C++ -*-===// //===-- Implementation header for llround -----------------------*- 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_MATH_LLROUND_H #ifndef LLVM_LIBC_SRC_MATH_LLROUND_H
#define LLVM_LIBC_SRC_MATH_LLROUND_H #define LLVM_LIBC_SRC_MATH_LLROUND_H
namespace __llvm_libc { namespace __llvm_libc {
long long llround(double x); long long llround(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LLROUND_H #endif // LLVM_LIBC_SRC_MATH_LLROUND_H

libc/src/math/llroundf.h

//===-- Implementation header for llroundf ----------------------*- C++ -*-===// //===-- Implementation header for llroundf ----------------------*- 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_MATH_LLROUNDF_H #ifndef LLVM_LIBC_SRC_MATH_LLROUNDF_H
#define LLVM_LIBC_SRC_MATH_LLROUNDF_H #define LLVM_LIBC_SRC_MATH_LLROUNDF_H
namespace __llvm_libc { namespace __llvm_libc {
long long llroundf(float x); long long llroundf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LLROUNDF_H #endif // LLVM_LIBC_SRC_MATH_LLROUNDF_H

libc/src/math/llroundl.h

//===-- Implementation header for llroundl ----------------------*- C++ -*-===// //===-- Implementation header for llroundl ----------------------*- 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_MATH_LLROUNDL_H #ifndef LLVM_LIBC_SRC_MATH_LLROUNDL_H
#define LLVM_LIBC_SRC_MATH_LLROUNDL_H #define LLVM_LIBC_SRC_MATH_LLROUNDL_H
namespace __llvm_libc { namespace __llvm_libc {
long long llroundl(long double x); long long llroundl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LLROUNDL_H #endif // LLVM_LIBC_SRC_MATH_LLROUNDL_H

libc/src/math/log10f.h

//===-- Implementation header for log10f ------------------------*- C++ -*-===// //===-- Implementation header for log10f ------------------------*- 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_MATH_LOG10F_H #ifndef LLVM_LIBC_SRC_MATH_LOG10F_H
#define LLVM_LIBC_SRC_MATH_LOG10F_H #define LLVM_LIBC_SRC_MATH_LOG10F_H
namespace __llvm_libc { namespace __llvm_libc {
float log10f(float x); float log10f(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LOG10F_H #endif // LLVM_LIBC_SRC_MATH_LOG10F_H

libc/src/math/log1pf.h

//===-- Implementation header for log1pf ------------------------*- C++ -*-===// //===-- Implementation header for log1pf ------------------------*- 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_MATH_LOG1PF_H #ifndef LLVM_LIBC_SRC_MATH_LOG1PF_H
#define LLVM_LIBC_SRC_MATH_LOG1PF_H #define LLVM_LIBC_SRC_MATH_LOG1PF_H
namespace __llvm_libc { namespace __llvm_libc {
float log1pf(float x); float log1pf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LOG1PF_H #endif // LLVM_LIBC_SRC_MATH_LOG1PF_H

libc/src/math/log2f.h

//===-- Implementation header for log2f -------------------------*- C++ -*-===// //===-- Implementation header for log2f -------------------------*- 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_MATH_LOG2F_H #ifndef LLVM_LIBC_SRC_MATH_LOG2F_H
#define LLVM_LIBC_SRC_MATH_LOG2F_H #define LLVM_LIBC_SRC_MATH_LOG2F_H
namespace __llvm_libc { namespace __llvm_libc {
float log2f(float x); float log2f(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LOG2F_H #endif // LLVM_LIBC_SRC_MATH_LOG2F_H

libc/src/math/logb.h

//===-- Implementation header for logb --------------------------*- C++ -*-===// //===-- Implementation header for logb --------------------------*- 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_MATH_LOGB_H #ifndef LLVM_LIBC_SRC_MATH_LOGB_H
#define LLVM_LIBC_SRC_MATH_LOGB_H #define LLVM_LIBC_SRC_MATH_LOGB_H
namespace __llvm_libc { namespace __llvm_libc {
double logb(double x); double logb(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LOGB_H #endif // LLVM_LIBC_SRC_MATH_LOGB_H

libc/src/math/logbf.h

//===-- Implementation header for logbf -------------------------*- C++ -*-===// //===-- Implementation header for logbf -------------------------*- 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_MATH_LOGBF_H #ifndef LLVM_LIBC_SRC_MATH_LOGBF_H
#define LLVM_LIBC_SRC_MATH_LOGBF_H #define LLVM_LIBC_SRC_MATH_LOGBF_H
namespace __llvm_libc { namespace __llvm_libc {
float logbf(float x); float logbf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LOGBF_H #endif // LLVM_LIBC_SRC_MATH_LOGBF_H

libc/src/math/logbl.h

//===-- Implementation header for logbl -------------------------*- C++ -*-===// //===-- Implementation header for logbl -------------------------*- 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_MATH_LOGBL_H #ifndef LLVM_LIBC_SRC_MATH_LOGBL_H
#define LLVM_LIBC_SRC_MATH_LOGBL_H #define LLVM_LIBC_SRC_MATH_LOGBL_H
namespace __llvm_libc { namespace __llvm_libc {
long double logbl(long double x); long double logbl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LOGBL_H #endif // LLVM_LIBC_SRC_MATH_LOGBL_H

libc/src/math/logf.h

//===-- Implementation header for logf --------------------------*- C++ -*-===// //===-- Implementation header for logf --------------------------*- 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_MATH_LOGF_H #ifndef LLVM_LIBC_SRC_MATH_LOGF_H
#define LLVM_LIBC_SRC_MATH_LOGF_H #define LLVM_LIBC_SRC_MATH_LOGF_H
namespace __llvm_libc { namespace __llvm_libc {
float logf(float x); float logf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LOGF_H #endif // LLVM_LIBC_SRC_MATH_LOGF_H

libc/src/math/lrint.h

//===-- Implementation header for lrint -------------------------*- C++ -*-===// //===-- Implementation header for lrint -------------------------*- 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_MATH_LRINT_H #ifndef LLVM_LIBC_SRC_MATH_LRINT_H
#define LLVM_LIBC_SRC_MATH_LRINT_H #define LLVM_LIBC_SRC_MATH_LRINT_H
namespace __llvm_libc { namespace __llvm_libc {
long lrint(double x); long lrint(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LRINT_H #endif // LLVM_LIBC_SRC_MATH_LRINT_H

libc/src/math/lrintf.h

//===-- Implementation header for lrintf ------------------------*- C++ -*-===// //===-- Implementation header for lrintf ------------------------*- 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_MATH_LRINTF_H #ifndef LLVM_LIBC_SRC_MATH_LRINTF_H
#define LLVM_LIBC_SRC_MATH_LRINTF_H #define LLVM_LIBC_SRC_MATH_LRINTF_H
namespace __llvm_libc { namespace __llvm_libc {
long lrintf(float x); long lrintf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LRINTF_H #endif // LLVM_LIBC_SRC_MATH_LRINTF_H

libc/src/math/lrintl.h

//===-- Implementation header for lrintl ------------------------*- C++ -*-===// //===-- Implementation header for lrintl ------------------------*- 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_MATH_LRINTL_H #ifndef LLVM_LIBC_SRC_MATH_LRINTL_H
#define LLVM_LIBC_SRC_MATH_LRINTL_H #define LLVM_LIBC_SRC_MATH_LRINTL_H
namespace __llvm_libc { namespace __llvm_libc {
long lrintl(long double x); long lrintl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LRINTL_H #endif // LLVM_LIBC_SRC_MATH_LRINTL_H

libc/src/math/lround.h

//===-- Implementation header for lround ------------------------*- C++ -*-===// //===-- Implementation header for lround ------------------------*- 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_MATH_LROUND_H #ifndef LLVM_LIBC_SRC_MATH_LROUND_H
#define LLVM_LIBC_SRC_MATH_LROUND_H #define LLVM_LIBC_SRC_MATH_LROUND_H
namespace __llvm_libc { namespace __llvm_libc {
long lround(double x); long lround(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LROUND_H #endif // LLVM_LIBC_SRC_MATH_LROUND_H

libc/src/math/lroundf.h

//===-- Implementation header for lroundf -----------------------*- C++ -*-===// //===-- Implementation header for lroundf -----------------------*- 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_MATH_LROUNDF_H #ifndef LLVM_LIBC_SRC_MATH_LROUNDF_H
#define LLVM_LIBC_SRC_MATH_LROUNDF_H #define LLVM_LIBC_SRC_MATH_LROUNDF_H
namespace __llvm_libc { namespace __llvm_libc {
long lroundf(float x); long lroundf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LROUNDF_H #endif // LLVM_LIBC_SRC_MATH_LROUNDF_H

libc/src/math/lroundl.h

//===-- Implementation header for lroundl -----------------------*- C++ -*-===// //===-- Implementation header for lroundl -----------------------*- 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_MATH_LROUNDL_H #ifndef LLVM_LIBC_SRC_MATH_LROUNDL_H
#define LLVM_LIBC_SRC_MATH_LROUNDL_H #define LLVM_LIBC_SRC_MATH_LROUNDL_H
namespace __llvm_libc { namespace __llvm_libc {
long lroundl(long double x); long lroundl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_LROUNDL_H #endif // LLVM_LIBC_SRC_MATH_LROUNDL_H

libc/src/math/modf.h

//===-- Implementation header for modf --------------------------*- C++ -*-===// //===-- Implementation header for modf --------------------------*- 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_MATH_MODF_H #ifndef LLVM_LIBC_SRC_MATH_MODF_H
#define LLVM_LIBC_SRC_MATH_MODF_H #define LLVM_LIBC_SRC_MATH_MODF_H
namespace __llvm_libc { namespace __llvm_libc {
double modf(double x, double *iptr); double modf(double x, double *iptr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_MODF_H #endif // LLVM_LIBC_SRC_MATH_MODF_H

libc/src/math/modff.h

//===-- Implementation header for modff -------------------------*- C++ -*-===// //===-- Implementation header for modff -------------------------*- 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_MATH_MODFF_H #ifndef LLVM_LIBC_SRC_MATH_MODFF_H
#define LLVM_LIBC_SRC_MATH_MODFF_H #define LLVM_LIBC_SRC_MATH_MODFF_H
namespace __llvm_libc { namespace __llvm_libc {
float modff(float x, float *iptr); float modff(float x, float *iptr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_MODFF_H #endif // LLVM_LIBC_SRC_MATH_MODFF_H

libc/src/math/modfl.h

//===-- Implementation header for modfl -------------------------*- C++ -*-===// //===-- Implementation header for modfl -------------------------*- 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_MATH_MODFL_H #ifndef LLVM_LIBC_SRC_MATH_MODFL_H
#define LLVM_LIBC_SRC_MATH_MODFL_H #define LLVM_LIBC_SRC_MATH_MODFL_H
namespace __llvm_libc { namespace __llvm_libc {
long double modfl(long double x, long double *iptr); long double modfl(long double x, long double *iptr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_MODFL_H #endif // LLVM_LIBC_SRC_MATH_MODFL_H

libc/src/math/nearbyint.h

//===-- Implementation header for nearbyint ---------------------*- C++ -*-===// //===-- Implementation header for nearbyint ---------------------*- 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_MATH_NEARBYINT_H #ifndef LLVM_LIBC_SRC_MATH_NEARBYINT_H
#define LLVM_LIBC_SRC_MATH_NEARBYINT_H #define LLVM_LIBC_SRC_MATH_NEARBYINT_H
namespace __llvm_libc { namespace __llvm_libc {
double nearbyint(double x); double nearbyint(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_NEARBYINT_H #endif // LLVM_LIBC_SRC_MATH_NEARBYINT_H

libc/src/math/nearbyintf.h

//===-- Implementation header for nearbyintf --------------------*- C++ -*-===// //===-- Implementation header for nearbyintf --------------------*- 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_MATH_NEARBYINTF_H #ifndef LLVM_LIBC_SRC_MATH_NEARBYINTF_H
#define LLVM_LIBC_SRC_MATH_NEARBYINTF_H #define LLVM_LIBC_SRC_MATH_NEARBYINTF_H
namespace __llvm_libc { namespace __llvm_libc {
float nearbyintf(float x); float nearbyintf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_NEARBYINTF_H #endif // LLVM_LIBC_SRC_MATH_NEARBYINTF_H

libc/src/math/nearbyintl.h

//===-- Implementation header for nearbyintl --------------------*- C++ -*-===// //===-- Implementation header for nearbyintl --------------------*- 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_MATH_NEARBYINTL_H #ifndef LLVM_LIBC_SRC_MATH_NEARBYINTL_H
#define LLVM_LIBC_SRC_MATH_NEARBYINTL_H #define LLVM_LIBC_SRC_MATH_NEARBYINTL_H
namespace __llvm_libc { namespace __llvm_libc {
long double nearbyintl(long double x); long double nearbyintl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_NEARBYINTL_H #endif // LLVM_LIBC_SRC_MATH_NEARBYINTL_H

libc/src/math/nextafter.h

//===-- Implementation header for nextafter ---------------------*- C++ -*-===// //===-- Implementation header for nextafter ---------------------*- 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_MATH_NEXTAFTER_H #ifndef LLVM_LIBC_SRC_MATH_NEXTAFTER_H
#define LLVM_LIBC_SRC_MATH_NEXTAFTER_H #define LLVM_LIBC_SRC_MATH_NEXTAFTER_H
namespace __llvm_libc { namespace __llvm_libc {
double nextafter(double x, double y); double nextafter(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_NEXTAFTER_H #endif // LLVM_LIBC_SRC_MATH_NEXTAFTER_H

libc/src/math/nextafterf.h

//===-- Implementation header for nextafterf --------------------*- C++ -*-===// //===-- Implementation header for nextafterf --------------------*- 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_MATH_NEXTAFTERF_H #ifndef LLVM_LIBC_SRC_MATH_NEXTAFTERF_H
#define LLVM_LIBC_SRC_MATH_NEXTAFTERF_H #define LLVM_LIBC_SRC_MATH_NEXTAFTERF_H
namespace __llvm_libc { namespace __llvm_libc {
float nextafterf(float x, float y); float nextafterf(float x, float y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_NEXTAFTERF_H #endif // LLVM_LIBC_SRC_MATH_NEXTAFTERF_H

libc/src/math/nextafterl.h

//===-- Implementation header for nextafterl --------------------*- C++ -*-===// //===-- Implementation header for nextafterl --------------------*- 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_MATH_NEXTAFTERL_H #ifndef LLVM_LIBC_SRC_MATH_NEXTAFTERL_H
#define LLVM_LIBC_SRC_MATH_NEXTAFTERL_H #define LLVM_LIBC_SRC_MATH_NEXTAFTERL_H
namespace __llvm_libc { namespace __llvm_libc {
long double nextafterl(long double x, long double y); long double nextafterl(long double x, long double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_NEXTAFTERL_H #endif // LLVM_LIBC_SRC_MATH_NEXTAFTERL_H

libc/src/math/pow.h

//===-- Implementation header for pow ---------------------------*- C++ -*-===// //===-- Implementation header for pow ---------------------------*- 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_MATH_POW_H #ifndef LLVM_LIBC_SRC_MATH_POW_H
#define LLVM_LIBC_SRC_MATH_POW_H #define LLVM_LIBC_SRC_MATH_POW_H
namespace __llvm_libc { namespace __llvm_libc {
double pow(double x, double y); double pow(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_POW_H #endif // LLVM_LIBC_SRC_MATH_POW_H

libc/src/math/remainder.h

//===-- Implementation header for remainder ---------------------*- C++ -*-===// //===-- Implementation header for remainder ---------------------*- 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_MATH_REMAINDER_H #ifndef LLVM_LIBC_SRC_MATH_REMAINDER_H
#define LLVM_LIBC_SRC_MATH_REMAINDER_H #define LLVM_LIBC_SRC_MATH_REMAINDER_H
namespace __llvm_libc { namespace __llvm_libc {
double remainder(double x, double y); double remainder(double x, double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_REMAINDER_H #endif // LLVM_LIBC_SRC_MATH_REMAINDER_H

libc/src/math/remainderf.h

//===-- Implementation header for remainderf --------------------*- C++ -*-===// //===-- Implementation header for remainderf --------------------*- 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_MATH_REMAINDERF_H #ifndef LLVM_LIBC_SRC_MATH_REMAINDERF_H
#define LLVM_LIBC_SRC_MATH_REMAINDERF_H #define LLVM_LIBC_SRC_MATH_REMAINDERF_H
namespace __llvm_libc { namespace __llvm_libc {
float remainderf(float x, float y); float remainderf(float x, float y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_REMAINDERF_H #endif // LLVM_LIBC_SRC_MATH_REMAINDERF_H

libc/src/math/remainderl.h

//===-- Implementation header for remainderl --------------------*- C++ -*-===// //===-- Implementation header for remainderl --------------------*- 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_MATH_REMAINDERL_H #ifndef LLVM_LIBC_SRC_MATH_REMAINDERL_H
#define LLVM_LIBC_SRC_MATH_REMAINDERL_H #define LLVM_LIBC_SRC_MATH_REMAINDERL_H
namespace __llvm_libc { namespace __llvm_libc {
long double remainderl(long double x, long double y); long double remainderl(long double x, long double y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_REMAINDERL_H #endif // LLVM_LIBC_SRC_MATH_REMAINDERL_H

libc/src/math/remquo.h

//===-- Implementation header for remquo ------------------------*- C++ -*-===// //===-- Implementation header for remquo ------------------------*- 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_MATH_REMQUO_H #ifndef LLVM_LIBC_SRC_MATH_REMQUO_H
#define LLVM_LIBC_SRC_MATH_REMQUO_H #define LLVM_LIBC_SRC_MATH_REMQUO_H
namespace __llvm_libc { namespace __llvm_libc {
double remquo(double x, double y, int *exp); double remquo(double x, double y, int *exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_REMQUO_H #endif // LLVM_LIBC_SRC_MATH_REMQUO_H

libc/src/math/remquof.h

//===-- Implementation header for remquof -----------------------*- C++ -*-===// //===-- Implementation header for remquof -----------------------*- 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_MATH_REMQUOF_H #ifndef LLVM_LIBC_SRC_MATH_REMQUOF_H
#define LLVM_LIBC_SRC_MATH_REMQUOF_H #define LLVM_LIBC_SRC_MATH_REMQUOF_H
namespace __llvm_libc { namespace __llvm_libc {
float remquof(float x, float y, int *exp); float remquof(float x, float y, int *exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_REMQUOF_H #endif // LLVM_LIBC_SRC_MATH_REMQUOF_H

libc/src/math/remquol.h

//===-- Implementation header for remquol -----------------------*- C++ -*-===// //===-- Implementation header for remquol -----------------------*- 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_MATH_REMQUOL_H #ifndef LLVM_LIBC_SRC_MATH_REMQUOL_H
#define LLVM_LIBC_SRC_MATH_REMQUOL_H #define LLVM_LIBC_SRC_MATH_REMQUOL_H
namespace __llvm_libc { namespace __llvm_libc {
long double remquol(long double x, long double y, int *exp); long double remquol(long double x, long double y, int *exp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_REMQUOL_H #endif // LLVM_LIBC_SRC_MATH_REMQUOL_H

libc/src/math/rint.h

//===-- Implementation header for rint --------------------------*- C++ -*-===// //===-- Implementation header for rint --------------------------*- 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_MATH_RINT_H #ifndef LLVM_LIBC_SRC_MATH_RINT_H
#define LLVM_LIBC_SRC_MATH_RINT_H #define LLVM_LIBC_SRC_MATH_RINT_H
namespace __llvm_libc { namespace __llvm_libc {
double rint(double x); double rint(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_RINT_H #endif // LLVM_LIBC_SRC_MATH_RINT_H

libc/src/math/rintf.h

//===-- Implementation header for rintf -------------------------*- C++ -*-===// //===-- Implementation header for rintf -------------------------*- 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_MATH_RINTF_H #ifndef LLVM_LIBC_SRC_MATH_RINTF_H
#define LLVM_LIBC_SRC_MATH_RINTF_H #define LLVM_LIBC_SRC_MATH_RINTF_H
namespace __llvm_libc { namespace __llvm_libc {
float rintf(float x); float rintf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_RINTF_H #endif // LLVM_LIBC_SRC_MATH_RINTF_H

libc/src/math/rintl.h

//===-- Implementation header for rintl -------------------------*- C++ -*-===// //===-- Implementation header for rintl -------------------------*- 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_MATH_RINTL_H #ifndef LLVM_LIBC_SRC_MATH_RINTL_H
#define LLVM_LIBC_SRC_MATH_RINTL_H #define LLVM_LIBC_SRC_MATH_RINTL_H
namespace __llvm_libc { namespace __llvm_libc {
long double rintl(long double x); long double rintl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_RINTL_H #endif // LLVM_LIBC_SRC_MATH_RINTL_H

libc/src/math/round.h

//===-- Implementation header for round -------------------------*- C++ -*-===// //===-- Implementation header for round -------------------------*- 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_MATH_ROUND_H #ifndef LLVM_LIBC_SRC_MATH_ROUND_H
#define LLVM_LIBC_SRC_MATH_ROUND_H #define LLVM_LIBC_SRC_MATH_ROUND_H
namespace __llvm_libc { namespace __llvm_libc {
double round(double x); double round(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ROUND_H #endif // LLVM_LIBC_SRC_MATH_ROUND_H

libc/src/math/roundf.h

//===-- Implementation header for roundf ------------------------*- C++ -*-===// //===-- Implementation header for roundf ------------------------*- 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_MATH_ROUNDF_H #ifndef LLVM_LIBC_SRC_MATH_ROUNDF_H
#define LLVM_LIBC_SRC_MATH_ROUNDF_H #define LLVM_LIBC_SRC_MATH_ROUNDF_H
namespace __llvm_libc { namespace __llvm_libc {
float roundf(float x); float roundf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ROUNDF_H #endif // LLVM_LIBC_SRC_MATH_ROUNDF_H

libc/src/math/roundl.h

//===-- Implementation header for roundl ------------------------*- C++ -*-===// //===-- Implementation header for roundl ------------------------*- 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_MATH_ROUNDL_H #ifndef LLVM_LIBC_SRC_MATH_ROUNDL_H
#define LLVM_LIBC_SRC_MATH_ROUNDL_H #define LLVM_LIBC_SRC_MATH_ROUNDL_H
namespace __llvm_libc { namespace __llvm_libc {
long double roundl(long double x); long double roundl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ROUNDL_H #endif // LLVM_LIBC_SRC_MATH_ROUNDL_H

libc/src/math/sin.h

//===-- Implementation header for sin ---------------------------*- C++ -*-===// //===-- Implementation header for sin ---------------------------*- 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_MATH_SIN_H #ifndef LLVM_LIBC_SRC_MATH_SIN_H
#define LLVM_LIBC_SRC_MATH_SIN_H #define LLVM_LIBC_SRC_MATH_SIN_H
namespace __llvm_libc { namespace __llvm_libc {
double sin(double x); double sin(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_SIN_H #endif // LLVM_LIBC_SRC_MATH_SIN_H

libc/src/math/sincosf.h

//===-- Implementation header for sincosf -----------------------*- C++ -*-===// //===-- Implementation header for sincosf -----------------------*- 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_MATH_SINCOSF_H #ifndef LLVM_LIBC_SRC_MATH_SINCOSF_H
#define LLVM_LIBC_SRC_MATH_SINCOSF_H #define LLVM_LIBC_SRC_MATH_SINCOSF_H
namespace __llvm_libc { namespace __llvm_libc {
void sincosf(float x, float *sinx, float *cosx); void sincosf(float x, float *sinx, float *cosx) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_SINCOSF_H #endif // LLVM_LIBC_SRC_MATH_SINCOSF_H

libc/src/math/sinf.h

//===-- Implementation header for sinf --------------------------*- C++ -*-===// //===-- Implementation header for sinf --------------------------*- 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_MATH_SINF_H #ifndef LLVM_LIBC_SRC_MATH_SINF_H
#define LLVM_LIBC_SRC_MATH_SINF_H #define LLVM_LIBC_SRC_MATH_SINF_H
namespace __llvm_libc { namespace __llvm_libc {
float sinf(float x); float sinf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_SINF_H #endif // LLVM_LIBC_SRC_MATH_SINF_H

libc/src/math/sinhf.h

//===-- Implementation header for sinhf -------------------------*- C++ -*-===// //===-- Implementation header for sinhf -------------------------*- 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_MATH_SINHF_H #ifndef LLVM_LIBC_SRC_MATH_SINHF_H
#define LLVM_LIBC_SRC_MATH_SINHF_H #define LLVM_LIBC_SRC_MATH_SINHF_H
namespace __llvm_libc { namespace __llvm_libc {
float sinhf(float x); float sinhf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_SINHF_H #endif // LLVM_LIBC_SRC_MATH_SINHF_H

libc/src/math/sqrt.h

//===-- Implementation header for sqrt --------------------------*- C++ -*-===// //===-- Implementation header for sqrt --------------------------*- 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_MATH_SQRT_H #ifndef LLVM_LIBC_SRC_MATH_SQRT_H
#define LLVM_LIBC_SRC_MATH_SQRT_H #define LLVM_LIBC_SRC_MATH_SQRT_H
namespace __llvm_libc { namespace __llvm_libc {
double sqrt(double x); double sqrt(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_SQRT_H #endif // LLVM_LIBC_SRC_MATH_SQRT_H

libc/src/math/sqrtf.h

//===-- Implementation header for sqrtf -------------------------*- C++ -*-===// //===-- Implementation header for sqrtf -------------------------*- 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_MATH_SQRTF_H #ifndef LLVM_LIBC_SRC_MATH_SQRTF_H
#define LLVM_LIBC_SRC_MATH_SQRTF_H #define LLVM_LIBC_SRC_MATH_SQRTF_H
namespace __llvm_libc { namespace __llvm_libc {
float sqrtf(float x); float sqrtf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_SQRTF_H #endif // LLVM_LIBC_SRC_MATH_SQRTF_H

libc/src/math/sqrtl.h

//===-- Implementation header for sqrtl -------------------------*- C++ -*-===// //===-- Implementation header for sqrtl -------------------------*- 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_MATH_SQRTL_H #ifndef LLVM_LIBC_SRC_MATH_SQRTL_H
#define LLVM_LIBC_SRC_MATH_SQRTL_H #define LLVM_LIBC_SRC_MATH_SQRTL_H
namespace __llvm_libc { namespace __llvm_libc {
long double sqrtl(long double x); long double sqrtl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_SQRTL_H #endif // LLVM_LIBC_SRC_MATH_SQRTL_H

libc/src/math/tan.h

//===-- Implementation header for tan ---------------------------*- C++ -*-===// //===-- Implementation header for tan ---------------------------*- 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_MATH_TAN_H #ifndef LLVM_LIBC_SRC_MATH_TAN_H
#define LLVM_LIBC_SRC_MATH_TAN_H #define LLVM_LIBC_SRC_MATH_TAN_H
namespace __llvm_libc { namespace __llvm_libc {
double tan(double x); double tan(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_TAN_H #endif // LLVM_LIBC_SRC_MATH_TAN_H

libc/src/math/tanf.h

//===-- Implementation header for tanf --------------------------*- C++ -*-===// //===-- Implementation header for tanf --------------------------*- 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_MATH_TANF_H #ifndef LLVM_LIBC_SRC_MATH_TANF_H
#define LLVM_LIBC_SRC_MATH_TANF_H #define LLVM_LIBC_SRC_MATH_TANF_H
namespace __llvm_libc { namespace __llvm_libc {
float tanf(float x); float tanf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_TANF_H #endif // LLVM_LIBC_SRC_MATH_TANF_H

libc/src/math/tanhf.h

//===-- Implementation header for tanhf -------------------------*- C++ -*-===// //===-- Implementation header for tanhf -------------------------*- 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_MATH_TANHF_H #ifndef LLVM_LIBC_SRC_MATH_TANHF_H
#define LLVM_LIBC_SRC_MATH_TANHF_H #define LLVM_LIBC_SRC_MATH_TANHF_H
namespace __llvm_libc { namespace __llvm_libc {
float tanhf(float x); float tanhf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_TANHF_H #endif // LLVM_LIBC_SRC_MATH_TANHF_H

libc/src/math/trunc.h

//===-- Implementation header for trunc -------------------------*- C++ -*-===// //===-- Implementation header for trunc -------------------------*- 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_MATH_TRUNC_H #ifndef LLVM_LIBC_SRC_MATH_TRUNC_H
#define LLVM_LIBC_SRC_MATH_TRUNC_H #define LLVM_LIBC_SRC_MATH_TRUNC_H
namespace __llvm_libc { namespace __llvm_libc {
double trunc(double x); double trunc(double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_TRUNC_H #endif // LLVM_LIBC_SRC_MATH_TRUNC_H

libc/src/math/truncf.h

//===-- Implementation header for truncf ------------------------*- C++ -*-===// //===-- Implementation header for truncf ------------------------*- 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_MATH_TRUNCF_H #ifndef LLVM_LIBC_SRC_MATH_TRUNCF_H
#define LLVM_LIBC_SRC_MATH_TRUNCF_H #define LLVM_LIBC_SRC_MATH_TRUNCF_H
namespace __llvm_libc { namespace __llvm_libc {
float truncf(float x); float truncf(float x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_TRUNCF_H #endif // LLVM_LIBC_SRC_MATH_TRUNCF_H

libc/src/math/truncl.h

//===-- Implementation header for truncl ------------------------*- C++ -*-===// //===-- Implementation header for truncl ------------------------*- 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_MATH_TRUNCL_H #ifndef LLVM_LIBC_SRC_MATH_TRUNCL_H
#define LLVM_LIBC_SRC_MATH_TRUNCL_H #define LLVM_LIBC_SRC_MATH_TRUNCL_H
namespace __llvm_libc { namespace __llvm_libc {
long double truncl(long double x); long double truncl(long double x) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_TRUNCL_H #endif // LLVM_LIBC_SRC_MATH_TRUNCL_H

libc/src/pthread/pthread_atfork.h

//===-- Implementation header for pthread_atfork function -------*- C++ -*-===// //===-- Implementation header for pthread_atfork function -------*- 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_THREADS_PTHREAD_ATFORK_H #ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_ATFORK_H
#define LLVM_LIBC_SRC_THREADS_PTHREAD_ATFORK_H #define LLVM_LIBC_SRC_THREADS_PTHREAD_ATFORK_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_atfork(__atfork_callback_t prepare, __atfork_callback_t parent, int pthread_atfork(__atfork_callback_t prepare, __atfork_callback_t parent,
__atfork_callback_t child); __atfork_callback_t child) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_ATFORK_H #endif // LLVM_LIBC_SRC_THREADS_PTHREAD_ATFORK_H

libc/src/pthread/pthread_attr_destroy.h

//===-- Implementation header for pthread_attr_destroy ----------*- C++ -*-===// //===-- Implementation header for pthread_attr_destroy ----------*- 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_PTHREAD_PTHREAD_ATTR_DESTROY_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_DESTROY_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_DESTROY_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_DESTROY_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_destroy(pthread_attr_t *attr); int pthread_attr_destroy(pthread_attr_t *attr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_DESTROY_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_DESTROY_H

libc/src/pthread/pthread_attr_getdetachstate.h

//===-- Implementation header for pthread_attr_getdetachstate ---*- C++ -*-===// //===-- Implementation header for pthread_attr_getdetachstate ---*- 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_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detach_state); int pthread_attr_getdetachstate(const pthread_attr_t *attr,
int *detach_state) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETDETACHSTATE_H

libc/src/pthread/pthread_attr_getguardsize.h

//===-- Implementation header for pthread_attr_getguardsize -----*- C++ -*-===// //===-- Implementation header for pthread_attr_getguardsize -----*- 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_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_getguardsize(const pthread_attr_t *__restrict attr, int pthread_attr_getguardsize(const pthread_attr_t *__restrict attr,
size_t *__restrict guardsize); size_t *__restrict guardsize) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETGUARDSIZE_H

libc/src/pthread/pthread_attr_getstack.h

Show All 9 Lines
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACK_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACK_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_getstack(const pthread_attr_t *__restrict attr, int pthread_attr_getstack(const pthread_attr_t *__restrict attr,
void **__restrict stack, void **__restrict stack,
size_t *__restrict stacksize); size_t *__restrict stacksize) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACK_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACK_H

libc/src/pthread/pthread_attr_getstacksize.h

//===-- Implementation header for pthread_attr_getstacksize -----*- C++ -*-===// //===-- Implementation header for pthread_attr_getstacksize -----*- 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_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_getstacksize(const pthread_attr_t *__restrict attr, int pthread_attr_getstacksize(const pthread_attr_t *__restrict attr,
size_t *__restrict stacksize); size_t *__restrict stacksize) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_GETSTACKSIZE_H

libc/src/pthread/pthread_attr_init.h

//===-- Implementation header for pthread_attr_init -------------*- C++ -*-===// //===-- Implementation header for pthread_attr_init -------------*- 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_PTHREAD_PTHREAD_ATTR_INIT_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_INIT_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_INIT_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_INIT_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_init(pthread_attr_t *attr); int pthread_attr_init(pthread_attr_t *attr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_INIT_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_INIT_H

libc/src/pthread/pthread_attr_setdetachstate.h

//===-- Implementation header for pthread_attr_setdetachstate ---*- C++ -*-===// //===-- Implementation header for pthread_attr_setdetachstate ---*- 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_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detach_state); int pthread_attr_setdetachstate(pthread_attr_t *attr,
int detach_state) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETDETACHSTATE_H

libc/src/pthread/pthread_attr_setguardsize.h

//===-- Implementation header for pthread_attr_setguardsize -----*- C++ -*-===// //===-- Implementation header for pthread_attr_setguardsize -----*- 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_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize); int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETGUARDSIZE_H

libc/src/pthread/pthread_attr_setstack.h

//===-- Implementation header for pthread_attr_setstack ---------*- C++ -*-===// //===-- Implementation header for pthread_attr_setstack ---------*- 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_PTHREAD_PTHREAD_ATTR_SETSTACK_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACK_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACK_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACK_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_setstack(pthread_attr_t *attr, void *stack, size_t stacksize); int pthread_attr_setstack(pthread_attr_t *attr, void *stack,
size_t stacksize) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACK_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACK_H

libc/src/pthread/pthread_attr_setstacksize.h

//===-- Implementation header for pthread_attr_setstacksize -----*- C++ -*-===// //===-- Implementation header for pthread_attr_setstacksize -----*- 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_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_ATTR_SETSTACKSIZE_H

libc/src/pthread/pthread_create.h

Show All 9 Lines
#define LLVM_LIBC_SRC_THREADS_PTHREAD_CREATE_H #define LLVM_LIBC_SRC_THREADS_PTHREAD_CREATE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_create(pthread_t *__restrict thread, int pthread_create(pthread_t *__restrict thread,
const pthread_attr_t *__restrict attr, const pthread_attr_t *__restrict attr,
__pthread_start_t func, void *arg); __pthread_start_t func, void *arg) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_CREATE_H #endif // LLVM_LIBC_SRC_THREADS_PTHREAD_CREATE_H

libc/src/pthread/pthread_detach.h

//===-- Implementation header for pthread_detach function -------*- C++ -*-===// //===-- Implementation header for pthread_detach function -------*- 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_THREADS_PTHREAD_DETACH_H #ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_DETACH_H
#define LLVM_LIBC_SRC_THREADS_PTHREAD_DETACH_H #define LLVM_LIBC_SRC_THREADS_PTHREAD_DETACH_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_detach(pthread_t thread); int pthread_detach(pthread_t thread) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_DETACH_H #endif // LLVM_LIBC_SRC_THREADS_PTHREAD_DETACH_H

libc/src/pthread/pthread_equal.h

//===-- Implementation header for pthread_equal function -----------*- C++ -*-// //===-- Implementation header for pthread_equal function -----------*- 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_THREADS_PTHREAD_EQUAL_H #ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_EQUAL_H
#define LLVM_LIBC_SRC_THREADS_PTHREAD_EQUAL_H #define LLVM_LIBC_SRC_THREADS_PTHREAD_EQUAL_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_equal(pthread_t lhs, pthread_t rhs); int pthread_equal(pthread_t lhs, pthread_t rhs) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_EQUAL_H #endif // LLVM_LIBC_SRC_THREADS_PTHREAD_EQUAL_H

libc/src/pthread/pthread_exit.h

//===-- Implementation header for pthread_exit function ---------*- C++ -*-===// //===-- Implementation header for pthread_exit function ---------*- 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_THREADS_PTHREAD_EXIT_H #ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_EXIT_H
#define LLVM_LIBC_SRC_THREADS_PTHREAD_EXIT_H #define LLVM_LIBC_SRC_THREADS_PTHREAD_EXIT_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
void pthread_exit(void *retval); void pthread_exit(void *retval) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_EXIT_H #endif // LLVM_LIBC_SRC_THREADS_PTHREAD_EXIT_H

libc/src/pthread/pthread_getname_np.h

//===-- Implementation header for pthread_getname_np function ---*- C++ -*-===// //===-- Implementation header for pthread_getname_np function ---*- 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_PTHREAD_PTHREAD_GETNAME_NP_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETNAME_NP_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETNAME_NP_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETNAME_NP_H
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_getname_np(pthread_t, char *, size_t); int pthread_getname_np(pthread_t, char *, size_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETNAME_NP_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETNAME_NP_H

libc/src/pthread/pthread_getspecific.h

//===-- Implementation header for pthread_getspecific function --*- C++ -*-===// //===-- Implementation header for pthread_getspecific function --*- 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_PTHREAD_PTHREAD_GETSPECIFIC_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETSPECIFIC_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETSPECIFIC_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETSPECIFIC_H
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
void *pthread_getspecific(pthread_key_t); void *pthread_getspecific(pthread_key_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETSPECIFIC_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_GETSPECIFIC_H

libc/src/pthread/pthread_join.h

//===-- Implementation header for pthread_join function ---------*- C++ -*-===// //===-- Implementation header for pthread_join function ---------*- 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_THREADS_PTHREAD_JOIN_H #ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_JOIN_H
#define LLVM_LIBC_SRC_THREADS_PTHREAD_JOIN_H #define LLVM_LIBC_SRC_THREADS_PTHREAD_JOIN_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_join(pthread_t thread, void **retval); int pthread_join(pthread_t thread, void **retval) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_JOIN_H #endif // LLVM_LIBC_SRC_THREADS_PTHREAD_JOIN_H

libc/src/pthread/pthread_key_create.h

//===-- Implementation header for pthread_key_create ------------*- C++ -*-===// //===-- Implementation header for pthread_key_create ------------*- 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_PTHREAD_PTHREAD_KEY_CREATE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_CREATE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_CREATE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_CREATE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_key_create(pthread_key_t *key, __pthread_tss_dtor_t dtor); int pthread_key_create(pthread_key_t *key, __pthread_tss_dtor_t dtor) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_CREATE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_CREATE_H

libc/src/pthread/pthread_key_delete.h

//===-- Implementation header for pthread_key_delete ------------*- C++ -*-===// //===-- Implementation header for pthread_key_delete ------------*- 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_PTHREAD_PTHREAD_KEY_DELETE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_DELETE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_DELETE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_DELETE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_key_delete(pthread_key_t key); int pthread_key_delete(pthread_key_t key) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_DELETE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_KEY_DELETE_H

libc/src/pthread/pthread_mutex_destroy.h

//===-- Implementation header for pthread_mutex_destroy ---------*- C++ -*-===// //===-- Implementation header for pthread_mutex_destroy ---------*- 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_PTHREAD_PTHREAD_MUTEX__DESTROY_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX__DESTROY_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX__DESTROY_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX__DESTROY_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutex_destroy(pthread_mutex_t *mutex); int pthread_mutex_destroy(pthread_mutex_t *mutex) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_DESTROY_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_DESTROY_H

libc/src/pthread/pthread_mutex_init.h

//===-- Implementation header for pthread_mutex_init function ---*- C++ -*-===// //===-- Implementation header for pthread_mutex_init function ---*- 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_PTHREAD_PTHREAD_MUTEX_INIT_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_INIT_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_INIT_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_INIT_H
#include "include/pthread.h" #include "include/pthread.h"
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutex_init(pthread_mutex_t *mutex, int pthread_mutex_init(pthread_mutex_t *mutex,
const pthread_mutexattr_t *__restrict attr); const pthread_mutexattr_t *__restrict attr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_pthread_mutex_INIT_H #endif // LLVM_LIBC_SRC_PTHREAD_pthread_mutex_INIT_H

libc/src/pthread/pthread_mutex_lock.h

//===-- Implementation header for pthread_mutex_lock function ---*- C++ -*-===// //===-- Implementation header for pthread_mutex_lock function ---*- 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_PTHREAD_PTHREAD_MUTEX_LOCK_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_LOCK_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_LOCK_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_LOCK_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_lock(pthread_mutex_t *mutex) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_LOCK_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_LOCK_H

libc/src/pthread/pthread_mutex_unlock.h

//===-- Implementation header for pthread_mutex_unlock function -*- C++ -*-===// //===-- Implementation header for pthread_mutex_unlock function -*- 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_PTHREAD_PTHREAD_MUTEX_UNLOCK_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_UNLOCK_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_UNLOCK_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_UNLOCK_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutex_unlock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_UNLOCK_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_UNLOCK_H

libc/src/pthread/pthread_mutexattr_destroy.h

//===-- Implementation header for pthread_mutexattr_destroy -----*- C++ -*-===// //===-- Implementation header for pthread_mutexattr_destroy -----*- 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_PTHREAD_PTHREAD_MUTEXATTR_DESTROY_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_DESTROY_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_DESTROY_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_DESTROY_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_DESTROY_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_DESTROY_H

libc/src/pthread/pthread_mutexattr_getpshared.h

//===-- Implementation header for pthread_mutexattr_getpshared --*- C++ -*-===// //===-- Implementation header for pthread_mutexattr_getpshared --*- 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_PTHREAD_PTHREAD_MUTEXATTR_GETPSHARED_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETPSHARED_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETPSHARED_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETPSHARED_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict attr, int pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict attr,
int *__restrict pshared); int *__restrict pshared) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETPSHARED_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETPSHARED_H

libc/src/pthread/pthread_mutexattr_getrobust.h

//===-- Implementation header for pthread_mutexattr_getrobust ---*- C++ -*-===// //===-- Implementation header for pthread_mutexattr_getrobust ---*- 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_PTHREAD_PTHREAD_MUTEXATTR_GETROBUST_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETROBUST_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETROBUST_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETROBUST_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutexattr_getrobust(const pthread_mutexattr_t *__restrict attr, int pthread_mutexattr_getrobust(const pthread_mutexattr_t *__restrict attr,
int *__restrict robust); int *__restrict robust) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETROBUST_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETROBUST_H

libc/src/pthread/pthread_mutexattr_gettype.h

//===-- Implementation header for pthread_mutexattr_gettype -----*- C++ -*-===// //===-- Implementation header for pthread_mutexattr_gettype -----*- 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_PTHREAD_PTHREAD_MUTEXATTR_GETTYPE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETTYPE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETTYPE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETTYPE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict attr, int pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict attr,
int *__restrict type); int *__restrict type) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETTYPE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_GETTYPE_H

libc/src/pthread/pthread_mutexattr_init.h

//===-- Implementation header for pthread_mutexattr_init --------*- C++ -*-===// //===-- Implementation header for pthread_mutexattr_init --------*- 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_PTHREAD_PTHREAD_MUTEXATTR_INIT_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_INIT_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_INIT_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_INIT_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutexattr_init(pthread_mutexattr_t *attr); int pthread_mutexattr_init(pthread_mutexattr_t *attr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_INIT_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_INIT_H

libc/src/pthread/pthread_mutexattr_setpshared.h

//===-- Implementation header for pthread_mutexattr_setpshared --*- C++ -*-===// //===-- Implementation header for pthread_mutexattr_setpshared --*- 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_PTHREAD_PTHREAD_MUTEXATTR_SETpshared_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETpshared_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETpshared_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETpshared_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutexattr_setpshared(pthread_mutexattr_t *__restrict attr, int pthread_mutexattr_setpshared(pthread_mutexattr_t *__restrict attr,
int pshared); int pshared) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETpshared_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETpshared_H

libc/src/pthread/pthread_mutexattr_setrobust.h

//===-- Implementation header for pthread_mutexattr_setrobust ---*- C++ -*-===// //===-- Implementation header for pthread_mutexattr_setrobust ---*- 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_PTHREAD_PTHREAD_MUTEXATTR_SETROBUST_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETROBUST_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETROBUST_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETROBUST_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutexattr_setrobust(pthread_mutexattr_t *__restrict attr, int pthread_mutexattr_setrobust(pthread_mutexattr_t *__restrict attr,
int robust); int robust) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETROBUST_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETROBUST_H

libc/src/pthread/pthread_mutexattr_settype.h

//===-- Implementation header for pthread_mutexattr_settype -----*- C++ -*-===// //===-- Implementation header for pthread_mutexattr_settype -----*- 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_PTHREAD_PTHREAD_MUTEXATTR_SETTYPE_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETTYPE_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETTYPE_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETTYPE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_mutexattr_settype(pthread_mutexattr_t *__restrict attr, int type); int pthread_mutexattr_settype(pthread_mutexattr_t *__restrict attr,
int type) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETTYPE_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEXATTR_SETTYPE_H

libc/src/pthread/pthread_once.h

//===-- Implementation header for pthread_once function ---------*- C++ -*-===// //===-- Implementation header for pthread_once function ---------*- 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_THREADS_PTHREAD_ONCE_H #ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_ONCE_H
#define LLVM_LIBC_SRC_THREADS_PTHREAD_ONCE_H #define LLVM_LIBC_SRC_THREADS_PTHREAD_ONCE_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_once(pthread_once_t *flag, __pthread_once_func_t func); int pthread_once(pthread_once_t *flag, __pthread_once_func_t func) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_ONCE_H #endif // LLVM_LIBC_SRC_THREADS_PTHREAD_ONCE_H

libc/src/pthread/pthread_self.h

//===-- Implementation header for pthread_self function ---------*- C++ -*-===// //===-- Implementation header for pthread_self function ---------*- 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_THREADS_PTHREAD_SELF_H #ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_SELF_H
#define LLVM_LIBC_SRC_THREADS_PTHREAD_SELF_H #define LLVM_LIBC_SRC_THREADS_PTHREAD_SELF_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
pthread_t pthread_self(); pthread_t pthread_self() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_SELF_H #endif // LLVM_LIBC_SRC_THREADS_PTHREAD_SELF_H

libc/src/pthread/pthread_setname_np.h

//===-- Implementation header for pthread_setname_np function ---*- C++ -*-===// //===-- Implementation header for pthread_setname_np function ---*- 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_PTHREAD_PTHREAD_SETNAME_NP_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETNAME_NP_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETNAME_NP_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETNAME_NP_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_setname_np(pthread_t, const char *name); int pthread_setname_np(pthread_t, const char *name) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETNAME_NP_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETNAME_NP_H

libc/src/pthread/pthread_setspecific.h

//===-- Implementation header for pthread_setspecific function --*- C++ -*-===// //===-- Implementation header for pthread_setspecific function --*- 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_PTHREAD_PTHREAD_SETSPECIFIC_H #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETSPECIFIC_H
#define LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETSPECIFIC_H #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETSPECIFIC_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
int pthread_setspecific(pthread_key_t, const void *); int pthread_setspecific(pthread_key_t, const void *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETSPECIFIC_H #endif // LLVM_LIBC_SRC_PTHREAD_PTHREAD_SETSPECIFIC_H

libc/src/sched/sched_getaffinity.h

//===-- Implementation header for sched_getaffinity -------------*- C++ -*-===// //===-- Implementation header for sched_getaffinity -------------*- 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_UNISTD_SCHED_GETAFFINITY_H #ifndef LLVM_LIBC_SRC_UNISTD_SCHED_GETAFFINITY_H
#define LLVM_LIBC_SRC_UNISTD_SCHED_GETAFFINITY_H #define LLVM_LIBC_SRC_UNISTD_SCHED_GETAFFINITY_H
#include <sched.h> #include <sched.h>
namespace __llvm_libc { namespace __llvm_libc {
int sched_getaffinity(pid_t tid, size_t cpuset_size, cpu_set_t *mask); int sched_getaffinity(pid_t tid, size_t cpuset_size, cpu_set_t *mask) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_SCHED_GETAFFINITY_H #endif // LLVM_LIBC_SRC_UNISTD_SCHED_GETAFFINITY_H

libc/src/sched/sched_getcpucount.h

Show All 10 Lines
#include <sched.h> #include <sched.h>
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
// This function is for internal use in the CPU_COUNT macro, but since that's a // This function is for internal use in the CPU_COUNT macro, but since that's a
// macro and will be applied to client files, this must be a public entrypoint. // macro and will be applied to client files, this must be a public entrypoint.
int __sched_getcpucount(size_t cpuset_size, const cpu_set_t *mask); int __sched_getcpucount(size_t cpuset_size, const cpu_set_t *mask) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_SCHED_GETCPUCOUNT_H #endif // LLVM_LIBC_SRC_UNISTD_SCHED_GETCPUCOUNT_H

libc/src/sched/sched_setaffinity.h

//===-- Implementation header for sched_setaffinity -------------*- C++ -*-===// //===-- Implementation header for sched_setaffinity -------------*- 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_UNISTD_SCHED_SETAFFINITY_H #ifndef LLVM_LIBC_SRC_UNISTD_SCHED_SETAFFINITY_H
#define LLVM_LIBC_SRC_UNISTD_SCHED_SETAFFINITY_H #define LLVM_LIBC_SRC_UNISTD_SCHED_SETAFFINITY_H
#include <sched.h> #include <sched.h>
namespace __llvm_libc { namespace __llvm_libc {
int sched_setaffinity(pid_t pid, size_t cpuset_size, const cpu_set_t *mask); int sched_setaffinity(pid_t pid, size_t cpuset_size,
const cpu_set_t *mask) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_SCHED_SETAFFINITY_H #endif // LLVM_LIBC_SRC_UNISTD_SCHED_SETAFFINITY_H

libc/src/setjmp/longjmp.h

//===-- Implementation header for longjmp -----------------------*- C++ -*-===// //===-- Implementation header for longjmp -----------------------*- 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_LONGJMP_LONGJMP_H #ifndef LLVM_LIBC_SRC_LONGJMP_LONGJMP_H
#define LLVM_LIBC_SRC_LONGJMP_LONGJMP_H #define LLVM_LIBC_SRC_LONGJMP_LONGJMP_H
#include <setjmp.h> #include <setjmp.h>
namespace __llvm_libc { namespace __llvm_libc {
void longjmp(__jmp_buf *buf, int val); void longjmp(__jmp_buf *buf, int val) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_LONGJMP_LONGJMP_H #endif // LLVM_LIBC_SRC_LONGJMP_LONGJMP_H

libc/src/setjmp/setjmp_impl.h

Show All 9 Lines
#define LLVM_LIBC_SRC_SETJMP_SETJMP_H #define LLVM_LIBC_SRC_SETJMP_SETJMP_H
// This header has the _impl prefix in its name to avoid conflict with the // This header has the _impl prefix in its name to avoid conflict with the
// public header setjmp.h which is also included. here. // public header setjmp.h which is also included. here.
#include <setjmp.h> #include <setjmp.h>
namespace __llvm_libc { namespace __llvm_libc {
int setjmp(__jmp_buf *buf); int setjmp(__jmp_buf *buf) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SETJMP_SETJMP_H #endif // LLVM_LIBC_SRC_SETJMP_SETJMP_H

libc/src/signal/kill.h

//===-- Implementation header for kill function -----------------*- C++ -*-===// //===-- Implementation header for kill function -----------------*- 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_SIGNAL_KILL_H #ifndef LLVM_LIBC_SRC_SIGNAL_KILL_H
#define LLVM_LIBC_SRC_SIGNAL_KILL_H #define LLVM_LIBC_SRC_SIGNAL_KILL_H
#include <signal.h> #include <signal.h>
namespace __llvm_libc { namespace __llvm_libc {
int kill(pid_t pid, int sig); int kill(pid_t pid, int sig) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_KILL_H #endif // LLVM_LIBC_SRC_SIGNAL_KILL_H

libc/src/signal/raise.h

//===-- Implementation header for raise function ----------------*- C++ -*-===// //===-- Implementation header for raise function ----------------*- 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_SIGNAL_RAISE_H #ifndef LLVM_LIBC_SRC_SIGNAL_RAISE_H
#define LLVM_LIBC_SRC_SIGNAL_RAISE_H #define LLVM_LIBC_SRC_SIGNAL_RAISE_H
#include "include/signal.h" #include "include/signal.h"
namespace __llvm_libc { namespace __llvm_libc {
int raise(int sig); int raise(int sig) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_RAISE_H #endif // LLVM_LIBC_SRC_SIGNAL_RAISE_H

libc/src/signal/sigaction.h

//===-- Implementation header for sigaction ---------------------*- C++ -*-===// //===-- Implementation header for sigaction ---------------------*- 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_SIGNAL_SIGACTION_H #ifndef LLVM_LIBC_SRC_SIGNAL_SIGACTION_H
#define LLVM_LIBC_SRC_SIGNAL_SIGACTION_H #define LLVM_LIBC_SRC_SIGNAL_SIGACTION_H
#include <signal.h> #include <signal.h>
namespace __llvm_libc { namespace __llvm_libc {
int sigaction(int signal, const struct sigaction *__restrict libc_new, int sigaction(int signal, const struct sigaction *__restrict libc_new,
struct sigaction *__restrict libc_old); struct sigaction *__restrict libc_old) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_SIGACTION_H #endif // LLVM_LIBC_SRC_SIGNAL_SIGACTION_H

libc/src/signal/sigaddset.h

//===-- Implementation header for sigaddset ---------------------*- C++ -*-===// //===-- Implementation header for sigaddset ---------------------*- 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_SIGNAL_SIGEADDSET_H #ifndef LLVM_LIBC_SRC_SIGNAL_SIGEADDSET_H
#define LLVM_LIBC_SRC_SIGNAL_SIGEADDSET_H #define LLVM_LIBC_SRC_SIGNAL_SIGEADDSET_H
#include <signal.h> #include <signal.h>
namespace __llvm_libc { namespace __llvm_libc {
int sigaddset(sigset_t *set, int signum); int sigaddset(sigset_t *set, int signum) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_SIGEADDSET_H #endif // LLVM_LIBC_SRC_SIGNAL_SIGEADDSET_H

libc/src/signal/sigaltstack.h

//===-- Implementation header for sigaltstack -------------------*- C++ -*-===// //===-- Implementation header for sigaltstack -------------------*- 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_SIGNAL_SIGALSTACK_H #ifndef LLVM_LIBC_SRC_SIGNAL_SIGALSTACK_H
#define LLVM_LIBC_SRC_SIGNAL_SIGALSTACK_H #define LLVM_LIBC_SRC_SIGNAL_SIGALSTACK_H
#include <signal.h> #include <signal.h>
namespace __llvm_libc { namespace __llvm_libc {
int sigaltstack(const stack_t *__restrict ss, stack_t *__restrict oss); int sigaltstack(const stack_t *__restrict ss, stack_t *__restrict oss) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_SIGALSTACK_H #endif // LLVM_LIBC_SRC_SIGNAL_SIGALSTACK_H

libc/src/signal/sigdelset.h

//===-- Implementation header for sigdelset ---------------------*- C++ -*-===// //===-- Implementation header for sigdelset ---------------------*- 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_SIGNAL_SIGDELSET_H #ifndef LLVM_LIBC_SRC_SIGNAL_SIGDELSET_H
#define LLVM_LIBC_SRC_SIGNAL_SIGDELSET_H #define LLVM_LIBC_SRC_SIGNAL_SIGDELSET_H
#include "include/signal.h" #include "include/signal.h"
namespace __llvm_libc { namespace __llvm_libc {
int sigdelset(sigset_t *set, int signum); int sigdelset(sigset_t *set, int signum) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_SIGDELSET_H #endif // LLVM_LIBC_SRC_SIGNAL_SIGDELSET_H

libc/src/signal/sigemptyset.h

//===-- Implementation header for sigemptyset -------------------*- C++ -*-===// //===-- Implementation header for sigemptyset -------------------*- 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_SIGNAL_SIGEMPTYSET_H #ifndef LLVM_LIBC_SRC_SIGNAL_SIGEMPTYSET_H
#define LLVM_LIBC_SRC_SIGNAL_SIGEMPTYSET_H #define LLVM_LIBC_SRC_SIGNAL_SIGEMPTYSET_H
#include "include/signal.h" #include "include/signal.h"
namespace __llvm_libc { namespace __llvm_libc {
int sigemptyset(sigset_t *set); int sigemptyset(sigset_t *set) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_SIGEMPTYSET_H #endif // LLVM_LIBC_SRC_SIGNAL_SIGEMPTYSET_H

libc/src/signal/sigfillset.h

//===-- Implementation header for sigfillset --------------------*- C++ -*-===// //===-- Implementation header for sigfillset --------------------*- 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_SIGNAL_SIGFILLSET_H #ifndef LLVM_LIBC_SRC_SIGNAL_SIGFILLSET_H
#define LLVM_LIBC_SRC_SIGNAL_SIGFILLSET_H #define LLVM_LIBC_SRC_SIGNAL_SIGFILLSET_H
#include "include/signal.h" #include "include/signal.h"
namespace __llvm_libc { namespace __llvm_libc {
int sigfillset(sigset_t *set); int sigfillset(sigset_t *set) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_SIGFILLSET_H #endif // LLVM_LIBC_SRC_SIGNAL_SIGFILLSET_H

libc/src/signal/signal.h

Show All 9 Lines
#define LLVM_LIBC_SRC_SIGNAL_SIGNAL_H #define LLVM_LIBC_SRC_SIGNAL_SIGNAL_H
#include "include/signal.h" #include "include/signal.h"
namespace __llvm_libc { namespace __llvm_libc {
using sighandler_t = __sighandler_t; using sighandler_t = __sighandler_t;
sighandler_t signal(int signum, sighandler_t handler); sighandler_t signal(int signum, sighandler_t handler) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_SIGNAL_H #endif // LLVM_LIBC_SRC_SIGNAL_SIGNAL_H

libc/src/signal/sigprocmask.h

//===-- Implementation header for sigprocmask -------------------*- C++ -*-===// //===-- Implementation header for sigprocmask -------------------*- 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_SIGNAL_SIGPROCMASK_H #ifndef LLVM_LIBC_SRC_SIGNAL_SIGPROCMASK_H
#define LLVM_LIBC_SRC_SIGNAL_SIGPROCMASK_H #define LLVM_LIBC_SRC_SIGNAL_SIGPROCMASK_H
#include "include/signal.h" #include "include/signal.h"
namespace __llvm_libc { namespace __llvm_libc {
int sigprocmask(int how, const sigset_t *__restrict set, int sigprocmask(int how, const sigset_t *__restrict set,
sigset_t *__restrict oldset); sigset_t *__restrict oldset) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SIGNAL_SIGPROCMASK_H #endif // LLVM_LIBC_SRC_SIGNAL_SIGPROCMASK_H

libc/src/spawn/posix_spawn.h

Show All 10 Lines
#include <spawn.h> #include <spawn.h>
namespace __llvm_libc { namespace __llvm_libc {
int posix_spawn(pid_t *__restrict pid, const char *__restrict path, int posix_spawn(pid_t *__restrict pid, const char *__restrict path,
const posix_spawn_file_actions_t *file_actions, const posix_spawn_file_actions_t *file_actions,
const posix_spawnattr_t *__restrict attr, const posix_spawnattr_t *__restrict attr,
char *const *__restrict argv, char *const *__restrict envp); char *const *__restrict argv,
char *const *__restrict envp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_H #endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_H

libc/src/spawn/posix_spawn_file_actions_addclose.h

//===-- Impl header for posix_spawn_file_actions_addclose -------*- C++ -*-===// //===-- Impl header for posix_spawn_file_actions_addclose -------*- 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_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE_H #ifndef LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE_H
#define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE_H #define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE_H
#include <spawn.h> #include <spawn.h>
namespace __llvm_libc { namespace __llvm_libc {
int posix_spawn_file_actions_addclose( int posix_spawn_file_actions_addclose(
posix_spawn_file_actions_t *__restrict actions, int fd); posix_spawn_file_actions_t *__restrict actions, int fd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE_H #endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE_H

libc/src/spawn/posix_spawn_file_actions_adddup2.h

//===-- Impl header for posix_spawn_file_actions_adddup2 --------*- C++ -*-===// //===-- Impl header for posix_spawn_file_actions_adddup2 --------*- 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_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2_H #ifndef LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2_H
#define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2_H #define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2_H
#include <spawn.h> #include <spawn.h>
namespace __llvm_libc { namespace __llvm_libc {
int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *actions, int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *actions,
int fd, int newfd); int fd, int newfd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2_H #endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2_H

libc/src/spawn/posix_spawn_file_actions_addopen.h

Show All 9 Lines
#define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN_H #define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN_H
#include <spawn.h> #include <spawn.h>
namespace __llvm_libc { namespace __llvm_libc {
int posix_spawn_file_actions_addopen( int posix_spawn_file_actions_addopen(
posix_spawn_file_actions_t *__restrict actions, int fd, posix_spawn_file_actions_t *__restrict actions, int fd,
const char *__restrict path, int oflag, mode_t mode); const char *__restrict path, int oflag, mode_t mode) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN_H #endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN_H

libc/src/spawn/posix_spawn_file_actions_destroy.h

//===-- Impl header for posix_spawn_file_actions_destroy --------*- C++ -*-===// //===-- Impl header for posix_spawn_file_actions_destroy --------*- 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_SPAWN_POSIX_SPAWN_FILE_ACTIONS_DESTROY_H #ifndef LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_DESTROY_H
#define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_DESTROY_H #define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_DESTROY_H
#include <spawn.h> #include <spawn.h>
namespace __llvm_libc { namespace __llvm_libc {
int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *actions); int posix_spawn_file_actions_destroy(
posix_spawn_file_actions_t *actions) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_DESTROY_H #endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_DESTROY_H

libc/src/spawn/posix_spawn_file_actions_init.h

//===-- Implementation header for posix_spawn_file_actions_init -*- C++ -*-===// //===-- Implementation header for posix_spawn_file_actions_init -*- 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_SPAWN_POSIX_SPAWN_FILE_ACTIONS_INIT_H #ifndef LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_INIT_H
#define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_INIT_H #define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_INIT_H
#include <spawn.h> #include <spawn.h>
namespace __llvm_libc { namespace __llvm_libc {
int posix_spawn_file_actions_init(posix_spawn_file_actions_t *actions); int posix_spawn_file_actions_init(posix_spawn_file_actions_t *actions) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_INIT_H #endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_FILE_ACTIONS_INIT_H

libc/src/stdio/clearerr.h

//===-- Implementation header of clearerr -----------------------*- C++ -*-===// //===-- Implementation header of clearerr -----------------------*- 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_STDIO_CLEARERR_H #ifndef LLVM_LIBC_SRC_STDIO_CLEARERR_H
#define LLVM_LIBC_SRC_STDIO_CLEARERR_H #define LLVM_LIBC_SRC_STDIO_CLEARERR_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
void clearerr(::FILE *stream); void clearerr(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_CLEARERR_H #endif // LLVM_LIBC_SRC_STDIO_CLEARERR_H

libc/src/stdio/clearerr_unlocked.h

//===-- Implementation header of clearerr_unlocked --------------*- C++ -*-===// //===-- Implementation header of clearerr_unlocked --------------*- 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_STDIO_CLEARERR_UNLOCKED_H #ifndef LLVM_LIBC_SRC_STDIO_CLEARERR_UNLOCKED_H
#define LLVM_LIBC_SRC_STDIO_CLEARERR_UNLOCKED_H #define LLVM_LIBC_SRC_STDIO_CLEARERR_UNLOCKED_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
void clearerr_unlocked(::FILE *stream); void clearerr_unlocked(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_CLEARERR_UNLOCKED_H #endif // LLVM_LIBC_SRC_STDIO_CLEARERR_UNLOCKED_H

libc/src/stdio/fclose.h

//===-- Implementation header of fclose -------------------------*- C++ -*-===// //===-- Implementation header of fclose -------------------------*- 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_STDIO_FCLOSE_H #ifndef LLVM_LIBC_SRC_STDIO_FCLOSE_H
#define LLVM_LIBC_SRC_STDIO_FCLOSE_H #define LLVM_LIBC_SRC_STDIO_FCLOSE_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int fclose(::FILE *stream); int fclose(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FCLOSE_H #endif // LLVM_LIBC_SRC_STDIO_FCLOSE_H

libc/src/stdio/feof.h

//===-- Implementation header of feof ---------------------------*- C++ -*-===// //===-- Implementation header of feof ---------------------------*- 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_STDIO_FEOF_H #ifndef LLVM_LIBC_SRC_STDIO_FEOF_H
#define LLVM_LIBC_SRC_STDIO_FEOF_H #define LLVM_LIBC_SRC_STDIO_FEOF_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int feof(::FILE *stream); int feof(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FEOF_H #endif // LLVM_LIBC_SRC_STDIO_FEOF_H

libc/src/stdio/feof_unlocked.h

//===-- Implementation header of feof_unlocked ------------------*- C++ -*-===// //===-- Implementation header of feof_unlocked ------------------*- 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_STDIO_FEOF_UNLOCKED_H #ifndef LLVM_LIBC_SRC_STDIO_FEOF_UNLOCKED_H
#define LLVM_LIBC_SRC_STDIO_FEOF_UNLOCKED_H #define LLVM_LIBC_SRC_STDIO_FEOF_UNLOCKED_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int feof_unlocked(::FILE *stream); int feof_unlocked(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FEOF_UNLOCKED_H #endif // LLVM_LIBC_SRC_STDIO_FEOF_UNLOCKED_H

libc/src/stdio/ferror.h

//===-- Implementation header of ferror -------------------------*- C++ -*-===// //===-- Implementation header of ferror -------------------------*- 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_STDIO_FERROR_H #ifndef LLVM_LIBC_SRC_STDIO_FERROR_H
#define LLVM_LIBC_SRC_STDIO_FERROR_H #define LLVM_LIBC_SRC_STDIO_FERROR_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int ferror(::FILE *stream); int ferror(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FERROR_H #endif // LLVM_LIBC_SRC_STDIO_FERROR_H

libc/src/stdio/ferror_unlocked.h

//===-- Implementation header of ferror_unlocked ----------------*- C++ -*-===// //===-- Implementation header of ferror_unlocked ----------------*- 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_STDIO_FERROR_UNLOCKED_H #ifndef LLVM_LIBC_SRC_STDIO_FERROR_UNLOCKED_H
#define LLVM_LIBC_SRC_STDIO_FERROR_UNLOCKED_H #define LLVM_LIBC_SRC_STDIO_FERROR_UNLOCKED_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int ferror_unlocked(::FILE *stream); int ferror_unlocked(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FERROR_UNLOCKED_H #endif // LLVM_LIBC_SRC_STDIO_FERROR_UNLOCKED_H

libc/src/stdio/fflush.h

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

libc/src/stdio/fgetc.h

//===-- Implementation header of fgetc --------------------------*- C++ -*-===// //===-- Implementation header of fgetc --------------------------*- 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_STDIO_FGETC_H #ifndef LLVM_LIBC_SRC_STDIO_FGETC_H
#define LLVM_LIBC_SRC_STDIO_FGETC_H #define LLVM_LIBC_SRC_STDIO_FGETC_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int fgetc(::FILE *f); int fgetc(::FILE *f) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FGETC_H #endif // LLVM_LIBC_SRC_STDIO_FGETC_H

libc/src/stdio/fgetc_unlocked.h

//===-- Implementation header of fgetc_unlocked -----------------*- C++ -*-===// //===-- Implementation header of fgetc_unlocked -----------------*- 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_STDIO_FGETC_UNLOCKED_H #ifndef LLVM_LIBC_SRC_STDIO_FGETC_UNLOCKED_H
#define LLVM_LIBC_SRC_STDIO_FGETC_UNLOCKED_H #define LLVM_LIBC_SRC_STDIO_FGETC_UNLOCKED_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int fgetc_unlocked(::FILE *f); int fgetc_unlocked(::FILE *f) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FGETC_UNLOCKED_H #endif // LLVM_LIBC_SRC_STDIO_FGETC_UNLOCKED_H

libc/src/stdio/fgets.h

//===-- Implementation header of fgets --------------------------*- C++ -*-===// //===-- Implementation header of fgets --------------------------*- 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_STDIO_FGETS_H #ifndef LLVM_LIBC_SRC_STDIO_FGETS_H
#define LLVM_LIBC_SRC_STDIO_FGETS_H #define LLVM_LIBC_SRC_STDIO_FGETS_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
char *fgets(char *__restrict str, int count, ::FILE *__restrict raw_stream); char *fgets(char *__restrict str, int count,
::FILE *__restrict raw_stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FGETS_H #endif // LLVM_LIBC_SRC_STDIO_FGETS_H

libc/src/stdio/flockfile.h

//===-- Implementation header of flockfile ----------------------*- C++ -*-===// //===-- Implementation header of flockfile ----------------------*- 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_STDIO_FLOCKFILE_H #ifndef LLVM_LIBC_SRC_STDIO_FLOCKFILE_H
#define LLVM_LIBC_SRC_STDIO_FLOCKFILE_H #define LLVM_LIBC_SRC_STDIO_FLOCKFILE_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
void flockfile(::FILE *stream); void flockfile(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FLOCKFILE_H #endif // LLVM_LIBC_SRC_STDIO_FLOCKFILE_H

libc/src/stdio/fopen.h

//===-- Implementation header of fopen --------------------------*- C++ -*-===// //===-- Implementation header of fopen --------------------------*- 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_STDIO_FOPEN_H #ifndef LLVM_LIBC_SRC_STDIO_FOPEN_H
#define LLVM_LIBC_SRC_STDIO_FOPEN_H #define LLVM_LIBC_SRC_STDIO_FOPEN_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
::FILE *fopen(const char *__restrict name, const char *__restrict mode); ::FILE *fopen(const char *__restrict name,
const char *__restrict mode) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FOPEN_H #endif // LLVM_LIBC_SRC_STDIO_FOPEN_H

libc/src/stdio/fopencookie.h

//===-- Implementation header of fopencookie --------------------*- C++ -*-===// //===-- Implementation header of fopencookie --------------------*- 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_STDIO_FOPENCOOKIE_H #ifndef LLVM_LIBC_SRC_STDIO_FOPENCOOKIE_H
#define LLVM_LIBC_SRC_STDIO_FOPENCOOKIE_H #define LLVM_LIBC_SRC_STDIO_FOPENCOOKIE_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
::FILE *fopencookie(void *cookie, const char *__restrict mode, ::FILE *fopencookie(void *cookie, const char *__restrict mode,
cookie_io_functions_t desc); cookie_io_functions_t desc) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FOPENCOOKIE_H #endif // LLVM_LIBC_SRC_STDIO_FOPENCOOKIE_H

libc/src/stdio/fprintf.h

//===-- Implementation header of fprintf ------------------------*- C++ -*-===// //===-- Implementation header of fprintf ------------------------*- 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_STDIO_FPRINTF_H #ifndef LLVM_LIBC_SRC_STDIO_FPRINTF_H
#define LLVM_LIBC_SRC_STDIO_FPRINTF_H #define LLVM_LIBC_SRC_STDIO_FPRINTF_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int fprintf(::FILE *__restrict stream, const char *__restrict format, ...); int fprintf(::FILE *__restrict stream, const char *__restrict format,
...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FPRINTF_H #endif // LLVM_LIBC_SRC_STDIO_FPRINTF_H

libc/src/stdio/fputc.h

//===-- Implementation header of fputc --------------------------*- C++ -*-===// //===-- Implementation header of fputc --------------------------*- 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_STDIO_FPUTC_H #ifndef LLVM_LIBC_SRC_STDIO_FPUTC_H
#define LLVM_LIBC_SRC_STDIO_FPUTC_H #define LLVM_LIBC_SRC_STDIO_FPUTC_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int fputc(int c, ::FILE *stream); int fputc(int c, ::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FPUTC_H #endif // LLVM_LIBC_SRC_STDIO_FPUTC_H

libc/src/stdio/fputs.h

//===-- Implementation header of fputs --------------------------*- C++ -*-===// //===-- Implementation header of fputs --------------------------*- 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_STDIO_FPUTS_H #ifndef LLVM_LIBC_SRC_STDIO_FPUTS_H
#define LLVM_LIBC_SRC_STDIO_FPUTS_H #define LLVM_LIBC_SRC_STDIO_FPUTS_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int fputs(const char *__restrict str, ::FILE *__restrict stream); int fputs(const char *__restrict str, ::FILE *__restrict stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FPUTS_H #endif // LLVM_LIBC_SRC_STDIO_FPUTS_H

libc/src/stdio/fread.h

//===-- Implementation header of fread --------------------------*- C++ -*-===// //===-- Implementation header of fread --------------------------*- 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_STDIO_FREAD_H #ifndef LLVM_LIBC_SRC_STDIO_FREAD_H
#define LLVM_LIBC_SRC_STDIO_FREAD_H #define LLVM_LIBC_SRC_STDIO_FREAD_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t fread(void *__restrict buffer, size_t size, size_t nmemb, size_t fread(void *__restrict buffer, size_t size, size_t nmemb,
::FILE *stream); ::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FREAD_H #endif // LLVM_LIBC_SRC_STDIO_FREAD_H

libc/src/stdio/fread_unlocked.h

//===-- Implementation header of fread_unlocked -----------------*- C++ -*-===// //===-- Implementation header of fread_unlocked -----------------*- 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_STDIO_FREAD_UNLOCKED_H #ifndef LLVM_LIBC_SRC_STDIO_FREAD_UNLOCKED_H
#define LLVM_LIBC_SRC_STDIO_FREAD_UNLOCKED_H #define LLVM_LIBC_SRC_STDIO_FREAD_UNLOCKED_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t fread_unlocked(void *__restrict buffer, size_t size, size_t nmemb, size_t fread_unlocked(void *__restrict buffer, size_t size, size_t nmemb,
::FILE *stream); ::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FREAD_UNLOCKED_H #endif // LLVM_LIBC_SRC_STDIO_FREAD_UNLOCKED_H

libc/src/stdio/fscanf.h

//===-- Implementation header of fscanf -------------------------*- C++ -*-===// //===-- Implementation header of fscanf -------------------------*- 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_STDIO_FSCANF_H #ifndef LLVM_LIBC_SRC_STDIO_FSCANF_H
#define LLVM_LIBC_SRC_STDIO_FSCANF_H #define LLVM_LIBC_SRC_STDIO_FSCANF_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int fscanf(::FILE *__restrict stream, const char *__restrict format, ...); int fscanf(::FILE *__restrict stream, const char *__restrict format,
...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FSCANF_H #endif // LLVM_LIBC_SRC_STDIO_FSCANF_H

libc/src/stdio/fseek.h

//===-- Implementation header of fseek --------------------------*- C++ -*-===// //===-- Implementation header of fseek --------------------------*- 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_STDIO_FSEEK_H #ifndef LLVM_LIBC_SRC_STDIO_FSEEK_H
#define LLVM_LIBC_SRC_STDIO_FSEEK_H #define LLVM_LIBC_SRC_STDIO_FSEEK_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int fseek(::FILE *stream, long offset, int whence); int fseek(::FILE *stream, long offset, int whence) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FSEEK_H #endif // LLVM_LIBC_SRC_STDIO_FSEEK_H

libc/src/stdio/ftell.h

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

libc/src/stdio/funlockfile.h

//===-- Implementation header of funlockfile --------------------*- C++ -*-===// //===-- Implementation header of funlockfile --------------------*- 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_STDIO_FUNLOCKFILE_H #ifndef LLVM_LIBC_SRC_STDIO_FUNLOCKFILE_H
#define LLVM_LIBC_SRC_STDIO_FUNLOCKFILE_H #define LLVM_LIBC_SRC_STDIO_FUNLOCKFILE_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
void funlockfile(::FILE *stream); void funlockfile(::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FUNLOCKFILE_H #endif // LLVM_LIBC_SRC_STDIO_FUNLOCKFILE_H

libc/src/stdio/fwrite.h

//===-- Implementation header of fwrite -------------------------*- C++ -*-===// //===-- Implementation header of fwrite -------------------------*- 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_STDIO_FWRITE_H #ifndef LLVM_LIBC_SRC_STDIO_FWRITE_H
#define LLVM_LIBC_SRC_STDIO_FWRITE_H #define LLVM_LIBC_SRC_STDIO_FWRITE_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t fwrite(const void *__restrict ptr, size_t size, size_t nmemb, size_t fwrite(const void *__restrict ptr, size_t size, size_t nmemb,
::FILE *__restrict stream); ::FILE *__restrict stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FWRITE_H #endif // LLVM_LIBC_SRC_STDIO_FWRITE_H

libc/src/stdio/fwrite_unlocked.h

//===-- Implementation header of fwrite_unlocked ----------------*- C++ -*-===// //===-- Implementation header of fwrite_unlocked ----------------*- 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_STDIO_FWRITE_UNLOCKED_H #ifndef LLVM_LIBC_SRC_STDIO_FWRITE_UNLOCKED_H
#define LLVM_LIBC_SRC_STDIO_FWRITE_UNLOCKED_H #define LLVM_LIBC_SRC_STDIO_FWRITE_UNLOCKED_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t fwrite_unlocked(const void *__restrict ptr, size_t size, size_t nmemb, size_t fwrite_unlocked(const void *__restrict ptr, size_t size, size_t nmemb,
::FILE *__restrict stream); ::FILE *__restrict stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_FWRITE_UNLOCKED_H #endif // LLVM_LIBC_SRC_STDIO_FWRITE_UNLOCKED_H

libc/src/stdio/getc.h

//===-- Implementation header of getc ---------------------------*- C++ -*-===// //===-- Implementation header of getc ---------------------------*- 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_STDIO_GETC_H #ifndef LLVM_LIBC_SRC_STDIO_GETC_H
#define LLVM_LIBC_SRC_STDIO_GETC_H #define LLVM_LIBC_SRC_STDIO_GETC_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int getc(::FILE *f); int getc(::FILE *f) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_GETC_H #endif // LLVM_LIBC_SRC_STDIO_GETC_H

libc/src/stdio/getc_unlocked.h

//===-- Implementation header of getc_unlocked ------------------*- C++ -*-===// //===-- Implementation header of getc_unlocked ------------------*- 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_STDIO_GETC_UNLOCKED_H #ifndef LLVM_LIBC_SRC_STDIO_GETC_UNLOCKED_H
#define LLVM_LIBC_SRC_STDIO_GETC_UNLOCKED_H #define LLVM_LIBC_SRC_STDIO_GETC_UNLOCKED_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int getc_unlocked(::FILE *f); int getc_unlocked(::FILE *f) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_GETC_UNLOCKED_H #endif // LLVM_LIBC_SRC_STDIO_GETC_UNLOCKED_H

libc/src/stdio/printf.h

//===-- Implementation header of printf -------------------------*- C++ -*-===// //===-- Implementation header of printf -------------------------*- 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_STDIO_PRINTF_H #ifndef LLVM_LIBC_SRC_STDIO_PRINTF_H
#define LLVM_LIBC_SRC_STDIO_PRINTF_H #define LLVM_LIBC_SRC_STDIO_PRINTF_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int printf(const char *__restrict format, ...); int printf(const char *__restrict format, ...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_PRINTF_H #endif // LLVM_LIBC_SRC_STDIO_PRINTF_H

libc/src/stdio/putc.h

//===-- Implementation header of putc ---------------------------*- C++ -*-===// //===-- Implementation header of putc ---------------------------*- 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_STDIO_PUTC_H #ifndef LLVM_LIBC_SRC_STDIO_PUTC_H
#define LLVM_LIBC_SRC_STDIO_PUTC_H #define LLVM_LIBC_SRC_STDIO_PUTC_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int putc(int c, ::FILE *stream); int putc(int c, ::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_PUTC_H #endif // LLVM_LIBC_SRC_STDIO_PUTC_H

libc/src/stdio/putchar.h

//===-- Implementation header of putchar ------------------------*- C++ -*-===// //===-- Implementation header of putchar ------------------------*- 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_STDIO_PUTCHAR_H #ifndef LLVM_LIBC_SRC_STDIO_PUTCHAR_H
#define LLVM_LIBC_SRC_STDIO_PUTCHAR_H #define LLVM_LIBC_SRC_STDIO_PUTCHAR_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int putchar(int c); int putchar(int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_PUTCHAR_H #endif // LLVM_LIBC_SRC_STDIO_PUTCHAR_H

libc/src/stdio/puts.h

//===-- Implementation header of puts ---------------------------*- C++ -*-===// //===-- Implementation header of puts ---------------------------*- 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_STDIO_PUTS_H #ifndef LLVM_LIBC_SRC_STDIO_PUTS_H
#define LLVM_LIBC_SRC_STDIO_PUTS_H #define LLVM_LIBC_SRC_STDIO_PUTS_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int puts(const char *__restrict str); int puts(const char *__restrict str) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_PUTS_H #endif // LLVM_LIBC_SRC_STDIO_PUTS_H

libc/src/stdio/remove.h

//===-- Implementation header of remove -------------------------*- C++ -*-===// //===-- Implementation header of remove -------------------------*- 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_STDIO_REMOVE_H #ifndef LLVM_LIBC_SRC_STDIO_REMOVE_H
#define LLVM_LIBC_SRC_STDIO_REMOVE_H #define LLVM_LIBC_SRC_STDIO_REMOVE_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int remove(const char *path); int remove(const char *path) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_REMOVE_H #endif // LLVM_LIBC_SRC_STDIO_REMOVE_H

libc/src/stdio/scanf.h

//===-- Implementation header of scanf --------------------------*- C++ -*-===// //===-- Implementation header of scanf --------------------------*- 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_STDIO_SCANF_H #ifndef LLVM_LIBC_SRC_STDIO_SCANF_H
#define LLVM_LIBC_SRC_STDIO_SCANF_H #define LLVM_LIBC_SRC_STDIO_SCANF_H
namespace __llvm_libc { namespace __llvm_libc {
int scanf(const char *__restrict format, ...); int scanf(const char *__restrict format, ...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_SCANF_H #endif // LLVM_LIBC_SRC_STDIO_SCANF_H

libc/src/stdio/setbuf.h

//===-- Implementation header of setbuf -------------------------*- C++ -*-===// //===-- Implementation header of setbuf -------------------------*- 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_STDIO_SETBUF_H #ifndef LLVM_LIBC_SRC_STDIO_SETBUF_H
#define LLVM_LIBC_SRC_STDIO_SETBUF_H #define LLVM_LIBC_SRC_STDIO_SETBUF_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
void setbuf(::FILE *__restrict stream, char *__restrict buf); void setbuf(::FILE *__restrict stream, char *__restrict buf) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_SETBUF_H #endif // LLVM_LIBC_SRC_STDIO_SETBUF_H

libc/src/stdio/setvbuf.h

//===-- Implementation header of setvbuf ------------------------*- C++ -*-===// //===-- Implementation header of setvbuf ------------------------*- 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_STDIO_SETVBUF_H #ifndef LLVM_LIBC_SRC_STDIO_SETVBUF_H
#define LLVM_LIBC_SRC_STDIO_SETVBUF_H #define LLVM_LIBC_SRC_STDIO_SETVBUF_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int setvbuf(::FILE *__restrict stream, char *__restrict buf, int type, int setvbuf(::FILE *__restrict stream, char *__restrict buf, int type,
size_t size); size_t size) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_SETVBUF_H #endif // LLVM_LIBC_SRC_STDIO_SETVBUF_H

libc/src/stdio/snprintf.h

//===-- Implementation header of snprintf -----------------------*- C++ -*-===// //===-- Implementation header of snprintf -----------------------*- 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_STDIO_SNPRINTF_H #ifndef LLVM_LIBC_SRC_STDIO_SNPRINTF_H
#define LLVM_LIBC_SRC_STDIO_SNPRINTF_H #define LLVM_LIBC_SRC_STDIO_SNPRINTF_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
int snprintf(char *__restrict buffer, size_t buffsz, int snprintf(char *__restrict buffer, size_t buffsz,
const char *__restrict format, ...); const char *__restrict format, ...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_SNPRINTF_H #endif // LLVM_LIBC_SRC_STDIO_SNPRINTF_H

libc/src/stdio/sprintf.h

//===-- Implementation header of sprintf ------------------------*- C++ -*-===// //===-- Implementation header of sprintf ------------------------*- 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_STDIO_SPRINTF_H #ifndef LLVM_LIBC_SRC_STDIO_SPRINTF_H
#define LLVM_LIBC_SRC_STDIO_SPRINTF_H #define LLVM_LIBC_SRC_STDIO_SPRINTF_H
namespace __llvm_libc { namespace __llvm_libc {
int sprintf(char *__restrict buffer, const char *__restrict format, ...); int sprintf(char *__restrict buffer, const char *__restrict format,
...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_SPRINTF_H #endif // LLVM_LIBC_SRC_STDIO_SPRINTF_H

libc/src/stdio/sscanf.h

//===-- Implementation header of sscanf -------------------------*- C++ -*-===// //===-- Implementation header of sscanf -------------------------*- 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_STDIO_SSCANF_H #ifndef LLVM_LIBC_SRC_STDIO_SSCANF_H
#define LLVM_LIBC_SRC_STDIO_SSCANF_H #define LLVM_LIBC_SRC_STDIO_SSCANF_H
namespace __llvm_libc { namespace __llvm_libc {
int sscanf(const char *__restrict buffer, const char *__restrict format, ...); int sscanf(const char *__restrict buffer, const char *__restrict format,
...) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_SSCANF_H #endif // LLVM_LIBC_SRC_STDIO_SSCANF_H

libc/src/stdio/ungetc.h

//===-- Implementation header of ungetc -------------------------*- C++ -*-===// //===-- Implementation header of ungetc -------------------------*- 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_STDIO_UNGETC_H #ifndef LLVM_LIBC_SRC_STDIO_UNGETC_H
#define LLVM_LIBC_SRC_STDIO_UNGETC_H #define LLVM_LIBC_SRC_STDIO_UNGETC_H
#include <stdio.h> #include <stdio.h>
namespace __llvm_libc { namespace __llvm_libc {
int ungetc(int c, ::FILE *stream); int ungetc(int c, ::FILE *stream) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDIO_UNGETC_H #endif // LLVM_LIBC_SRC_STDIO_UNGETC_H

libc/src/stdlib/_Exit.h

//===-- Implementation header for _Exit -------------------------*- C++ -*-===// //===-- Implementation header for _Exit -------------------------*- 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__EXIT_H #ifndef LLVM_LIBC_SRC__EXIT_H
#define LLVM_LIBC_SRC__EXIT_H #define LLVM_LIBC_SRC__EXIT_H
namespace __llvm_libc { namespace __llvm_libc {
[[noreturn]] void _Exit(int status); [[noreturn]] void _Exit(int status) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC__EXIT_H #endif // LLVM_LIBC_SRC__EXIT_H

libc/src/stdlib/abort.h

//===-- Implementation header for abort -------------------------*- C++ -*-===// //===-- Implementation header for abort -------------------------*- 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_ABORT_H #ifndef LLVM_LIBC_SRC_ABORT_H
#define LLVM_LIBC_SRC_ABORT_H #define LLVM_LIBC_SRC_ABORT_H
namespace __llvm_libc { namespace __llvm_libc {
[[noreturn]] void abort(); [[noreturn]] void abort() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_ABORT_H #endif // LLVM_LIBC_SRC_ABORT_H

libc/src/stdlib/abs.h

//===-- Implementation header for abs ---------------------------*- C++ -*-===// //===-- Implementation header for abs ---------------------------*- 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_STDLIB_ABS_H #ifndef LLVM_LIBC_SRC_STDLIB_ABS_H
#define LLVM_LIBC_SRC_STDLIB_ABS_H #define LLVM_LIBC_SRC_STDLIB_ABS_H
namespace __llvm_libc { namespace __llvm_libc {
int abs(int n); int abs(int n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_ABS_H #endif // LLVM_LIBC_SRC_STDLIB_ABS_H

libc/src/stdlib/atexit.h

Show All 9 Lines
#define LLVM_LIBC_SRC_STDLIB_ATEXIT_H #define LLVM_LIBC_SRC_STDLIB_ATEXIT_H
#include <stddef.h> // For size_t #include <stddef.h> // For size_t
namespace __llvm_libc { namespace __llvm_libc {
constexpr size_t CALLBACK_LIST_SIZE_FOR_TESTS = 1024; constexpr size_t CALLBACK_LIST_SIZE_FOR_TESTS = 1024;
int atexit(void (*function)()); int atexit(void (*function)()) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_ATEXIT_H #endif // LLVM_LIBC_SRC_STDLIB_ATEXIT_H

libc/src/stdlib/atof.h

//===-- Implementation header for atof --------------------------*- C++ -*-===// //===-- Implementation header for atof --------------------------*- 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_STDLIB_ATOF_H #ifndef LLVM_LIBC_SRC_STDLIB_ATOF_H
#define LLVM_LIBC_SRC_STDLIB_ATOF_H #define LLVM_LIBC_SRC_STDLIB_ATOF_H
namespace __llvm_libc { namespace __llvm_libc {
double atof(const char *str); double atof(const char *str) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_ATOI_H #endif // LLVM_LIBC_SRC_STDLIB_ATOI_H

libc/src/stdlib/atoi.h

//===-- Implementation header for atoi --------------------------*- C++ -*-===// //===-- Implementation header for atoi --------------------------*- 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_STDLIB_ATOI_H #ifndef LLVM_LIBC_SRC_STDLIB_ATOI_H
#define LLVM_LIBC_SRC_STDLIB_ATOI_H #define LLVM_LIBC_SRC_STDLIB_ATOI_H
namespace __llvm_libc { namespace __llvm_libc {
int atoi(const char *str); int atoi(const char *str) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_ATOI_H #endif // LLVM_LIBC_SRC_STDLIB_ATOI_H

libc/src/stdlib/atol.h

//===-- Implementation header for atol --------------------------*- C++ -*-===// //===-- Implementation header for atol --------------------------*- 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_STDLIB_ATOL_H #ifndef LLVM_LIBC_SRC_STDLIB_ATOL_H
#define LLVM_LIBC_SRC_STDLIB_ATOL_H #define LLVM_LIBC_SRC_STDLIB_ATOL_H
namespace __llvm_libc { namespace __llvm_libc {
long atol(const char *str); long atol(const char *str) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_ATOL_H #endif // LLVM_LIBC_SRC_STDLIB_ATOL_H

libc/src/stdlib/atoll.h

//===-- Implementation header for atoll -------------------------*- C++ -*-===// //===-- Implementation header for atoll -------------------------*- 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_STDLIB_ATOLL_H #ifndef LLVM_LIBC_SRC_STDLIB_ATOLL_H
#define LLVM_LIBC_SRC_STDLIB_ATOLL_H #define LLVM_LIBC_SRC_STDLIB_ATOLL_H
namespace __llvm_libc { namespace __llvm_libc {
long long atoll(const char *str); long long atoll(const char *str) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_ATOLL_H #endif // LLVM_LIBC_SRC_STDLIB_ATOLL_H

libc/src/stdlib/bsearch.h

//===-- Implementation header for bsearch -----------------------*- C++ -*-===// //===-- Implementation header for bsearch -----------------------*- 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 <stdlib.h> #include <stdlib.h>
namespace __llvm_libc { namespace __llvm_libc {
void *bsearch(const void *key, const void *array, size_t array_size, void *bsearch(const void *key, const void *array, size_t array_size,
size_t elem_size, int (*compare)(const void *, const void *)); size_t elem_size,
int (*compare)(const void *, const void *)) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/stdlib/div.h

//===-- Implementation header for div ---------------------------*- C++ -*-===// //===-- Implementation header for div ---------------------------*- 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 <stdlib.h> #include <stdlib.h>
#ifndef LLVM_LIBC_SRC_STDLIB_DIV_H #ifndef LLVM_LIBC_SRC_STDLIB_DIV_H
#define LLVM_LIBC_SRC_STDLIB_DIV_H #define LLVM_LIBC_SRC_STDLIB_DIV_H
namespace __llvm_libc { namespace __llvm_libc {
div_t div(int x, int y); div_t div(int x, int y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_DIV_H #endif // LLVM_LIBC_SRC_STDLIB_DIV_H

libc/src/stdlib/exit.h

//===-- Implementation header for exit --------------------------*- C++ -*-===// //===-- Implementation header for exit --------------------------*- 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 <stdlib.h> #include <stdlib.h>
#ifndef LLVM_LIBC_SRC_STDLIB_EXIT_H #ifndef LLVM_LIBC_SRC_STDLIB_EXIT_H
#define LLVM_LIBC_SRC_STDLIB_EXIT_H #define LLVM_LIBC_SRC_STDLIB_EXIT_H
namespace __llvm_libc { namespace __llvm_libc {
void exit(int status); void exit(int status) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_EXIT_H #endif // LLVM_LIBC_SRC_STDLIB_EXIT_H

libc/src/stdlib/getenv.h

//===-- Implementation header for getenv --------------------------------*-===// //===-- Implementation header for getenv --------------------------------*-===//
// //
// 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_STDLIB_GETENV_H #ifndef LLVM_LIBC_SRC_STDLIB_GETENV_H
#define LLVM_LIBC_SRC_STDLIB_GETENV_H #define LLVM_LIBC_SRC_STDLIB_GETENV_H
namespace __llvm_libc { namespace __llvm_libc {
char *getenv(const char *name); char *getenv(const char *name) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_GETENV_H #endif // LLVM_LIBC_SRC_STDLIB_GETENV_H

libc/src/stdlib/labs.h

//===-- Implementation header for labs --------------------------*- C++ -*-===// //===-- Implementation header for labs --------------------------*- 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_STDLIB_LABS_H #ifndef LLVM_LIBC_SRC_STDLIB_LABS_H
#define LLVM_LIBC_SRC_STDLIB_LABS_H #define LLVM_LIBC_SRC_STDLIB_LABS_H
namespace __llvm_libc { namespace __llvm_libc {
long labs(long n); long labs(long n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_LABS_H #endif // LLVM_LIBC_SRC_STDLIB_LABS_H

libc/src/stdlib/ldiv.h

//===-- Implementation header for ldiv --------------------------*- C++ -*-===// //===-- Implementation header for ldiv --------------------------*- 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 <stdlib.h> #include <stdlib.h>
#ifndef LLVM_LIBC_SRC_STDLIB_LDIV_H #ifndef LLVM_LIBC_SRC_STDLIB_LDIV_H
#define LLVM_LIBC_SRC_STDLIB_LDIV_H #define LLVM_LIBC_SRC_STDLIB_LDIV_H
namespace __llvm_libc { namespace __llvm_libc {
ldiv_t ldiv(long x, long y); ldiv_t ldiv(long x, long y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_LDIV_H #endif // LLVM_LIBC_SRC_STDLIB_LDIV_H

libc/src/stdlib/llabs.h

//===-- Implementation header for llabs -------------------------*- C++ -*-===// //===-- Implementation header for llabs -------------------------*- 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_STDLIB_LLABS_H #ifndef LLVM_LIBC_SRC_STDLIB_LLABS_H
#define LLVM_LIBC_SRC_STDLIB_LLABS_H #define LLVM_LIBC_SRC_STDLIB_LLABS_H
namespace __llvm_libc { namespace __llvm_libc {
long long llabs(long long n); long long llabs(long long n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_LLABS_H #endif // LLVM_LIBC_SRC_STDLIB_LLABS_H

libc/src/stdlib/lldiv.h

//===-- Implementation header for lldiv -------------------------*- C++ -*-===// //===-- Implementation header for lldiv -------------------------*- 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 <stdlib.h> #include <stdlib.h>
#ifndef LLVM_LIBC_SRC_STDLIB_LLDIV_H #ifndef LLVM_LIBC_SRC_STDLIB_LLDIV_H
#define LLVM_LIBC_SRC_STDLIB_LLDIV_H #define LLVM_LIBC_SRC_STDLIB_LLDIV_H
namespace __llvm_libc { namespace __llvm_libc {
lldiv_t lldiv(long long x, long long y); lldiv_t lldiv(long long x, long long y) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_LDIV_H #endif // LLVM_LIBC_SRC_STDLIB_LDIV_H

libc/src/stdlib/qsort.h

//===-- Implementation header for qsort -------------------------*- C++ -*-===// //===-- Implementation header for qsort -------------------------*- 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_STDLIB_QSORT_H #ifndef LLVM_LIBC_SRC_STDLIB_QSORT_H
#define LLVM_LIBC_SRC_STDLIB_QSORT_H #define LLVM_LIBC_SRC_STDLIB_QSORT_H
#include <stdlib.h> #include <stdlib.h>
namespace __llvm_libc { namespace __llvm_libc {
void qsort(void *array, size_t array_size, size_t elem_size, void qsort(void *array, size_t array_size, size_t elem_size,
int (*compare)(const void *, const void *)); int (*compare)(const void *, const void *)) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_QSORT_H #endif // LLVM_LIBC_SRC_STDLIB_QSORT_H

libc/src/stdlib/rand.h

//===-- Implementation header for rand --------------------------*- C++ -*-===// //===-- Implementation header for rand --------------------------*- 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 <stdlib.h> #include <stdlib.h>
#ifndef LLVM_LIBC_SRC_STDLIB_RAND_H #ifndef LLVM_LIBC_SRC_STDLIB_RAND_H
#define LLVM_LIBC_SRC_STDLIB_RAND_H #define LLVM_LIBC_SRC_STDLIB_RAND_H
namespace __llvm_libc { namespace __llvm_libc {
int rand(void); int rand(void) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_RAND_H #endif // LLVM_LIBC_SRC_STDLIB_RAND_H

libc/src/stdlib/srand.h

//===-- Implementation header for srand -------------------------*- C++ -*-===// //===-- Implementation header for srand -------------------------*- 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 <stdlib.h> #include <stdlib.h>
#ifndef LLVM_LIBC_SRC_STDLIB_SRAND_H #ifndef LLVM_LIBC_SRC_STDLIB_SRAND_H
#define LLVM_LIBC_SRC_STDLIB_SRAND_H #define LLVM_LIBC_SRC_STDLIB_SRAND_H
namespace __llvm_libc { namespace __llvm_libc {
void srand(unsigned int seed); void srand(unsigned int seed) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_SRAND_H #endif // LLVM_LIBC_SRC_STDLIB_SRAND_H

libc/src/stdlib/strtod.h

//===-- Implementation header for strtod ------------------------*- C++ -*-===// //===-- Implementation header for strtod ------------------------*- 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_STDLIB_STRTOD_H #ifndef LLVM_LIBC_SRC_STDLIB_STRTOD_H
#define LLVM_LIBC_SRC_STDLIB_STRTOD_H #define LLVM_LIBC_SRC_STDLIB_STRTOD_H
namespace __llvm_libc { namespace __llvm_libc {
double strtod(const char *__restrict str, char **__restrict str_end); double strtod(const char *__restrict str, char **__restrict str_end) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_STRTOD_H #endif // LLVM_LIBC_SRC_STDLIB_STRTOD_H

libc/src/stdlib/strtof.h

//===-- Implementation header for strtof ------------------------*- C++ -*-===// //===-- Implementation header for strtof ------------------------*- 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_STDLIB_STRTOF_H #ifndef LLVM_LIBC_SRC_STDLIB_STRTOF_H
#define LLVM_LIBC_SRC_STDLIB_STRTOF_H #define LLVM_LIBC_SRC_STDLIB_STRTOF_H
namespace __llvm_libc { namespace __llvm_libc {
float strtof(const char *__restrict str, char **__restrict str_end); float strtof(const char *__restrict str, char **__restrict str_end) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_STRTOF_H #endif // LLVM_LIBC_SRC_STDLIB_STRTOF_H

libc/src/stdlib/strtol.h

//===-- Implementation header for strtol ------------------------*- C++ -*-===// //===-- Implementation header for strtol ------------------------*- 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_STDLIB_STRTOL_H #ifndef LLVM_LIBC_SRC_STDLIB_STRTOL_H
#define LLVM_LIBC_SRC_STDLIB_STRTOL_H #define LLVM_LIBC_SRC_STDLIB_STRTOL_H
namespace __llvm_libc { namespace __llvm_libc {
long strtol(const char *__restrict str, char **__restrict str_end, int base); long strtol(const char *__restrict str, char **__restrict str_end,
int base) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_STRTOL_H #endif // LLVM_LIBC_SRC_STDLIB_STRTOL_H

libc/src/stdlib/strtold.h

//===-- Implementation header for strtold -----------------------*- C++ -*-===// //===-- Implementation header for strtold -----------------------*- 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_STDLIB_STRTOLD_H #ifndef LLVM_LIBC_SRC_STDLIB_STRTOLD_H
#define LLVM_LIBC_SRC_STDLIB_STRTOLD_H #define LLVM_LIBC_SRC_STDLIB_STRTOLD_H
namespace __llvm_libc { namespace __llvm_libc {
long double strtold(const char *__restrict str, char **__restrict str_end); long double strtold(const char *__restrict str,
char **__restrict str_end) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_STRTOLD_H #endif // LLVM_LIBC_SRC_STDLIB_STRTOLD_H

libc/src/stdlib/strtoll.h

//===-- Implementation header for strtoll -----------------------*- C++ -*-===// //===-- Implementation header for strtoll -----------------------*- 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_STDLIB_STRTOLL_H #ifndef LLVM_LIBC_SRC_STDLIB_STRTOLL_H
#define LLVM_LIBC_SRC_STDLIB_STRTOLL_H #define LLVM_LIBC_SRC_STDLIB_STRTOLL_H
namespace __llvm_libc { namespace __llvm_libc {
long long strtoll(const char *__restrict str, char **__restrict str_end, long long strtoll(const char *__restrict str, char **__restrict str_end,
int base); int base) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_STRTOLL_H #endif // LLVM_LIBC_SRC_STDLIB_STRTOLL_H

libc/src/stdlib/strtoul.h

//===-- Implementation header for strtoul -----------------------*- C++ -*-===// //===-- Implementation header for strtoul -----------------------*- 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_STDLIB_STRTOUL_H #ifndef LLVM_LIBC_SRC_STDLIB_STRTOUL_H
#define LLVM_LIBC_SRC_STDLIB_STRTOUL_H #define LLVM_LIBC_SRC_STDLIB_STRTOUL_H
namespace __llvm_libc { namespace __llvm_libc {
unsigned long strtoul(const char *__restrict str, char **__restrict str_end, unsigned long strtoul(const char *__restrict str, char **__restrict str_end,
int base); int base) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_STRTOUL_H #endif // LLVM_LIBC_SRC_STDLIB_STRTOUL_H

libc/src/stdlib/strtoull.h

//===-- Implementation header for strtoull ----------------------*- C++ -*-===// //===-- Implementation header for strtoull ----------------------*- 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_STDLIB_STRTOULL_H #ifndef LLVM_LIBC_SRC_STDLIB_STRTOULL_H
#define LLVM_LIBC_SRC_STDLIB_STRTOULL_H #define LLVM_LIBC_SRC_STDLIB_STRTOULL_H
namespace __llvm_libc { namespace __llvm_libc {
unsigned long long strtoull(const char *__restrict str, unsigned long long strtoull(const char *__restrict str,
char **__restrict str_end, int base); char **__restrict str_end, int base) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STDLIB_STRTOULL_H #endif // LLVM_LIBC_SRC_STDLIB_STRTOULL_H

libc/src/string/bcmp.h

//===-- Implementation header for bzero -------------------------*- C++ -*-===// //===-- Implementation header for bzero -------------------------*- 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_STRING_BCMP_H #ifndef LLVM_LIBC_SRC_STRING_BCMP_H
#define LLVM_LIBC_SRC_STRING_BCMP_H #define LLVM_LIBC_SRC_STRING_BCMP_H
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
int bcmp(const void *lhs, const void *rhs, size_t count); int bcmp(const void *lhs, const void *rhs, size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_BCMP_H #endif // LLVM_LIBC_SRC_STRING_BCMP_H

libc/src/string/bcopy.h

//===-- Implementation header for bcopy -------------------------*- C++ -*-===// //===-- Implementation header for bcopy -------------------------*- 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_STRING_BCOPY_H #ifndef LLVM_LIBC_SRC_STRING_BCOPY_H
#define LLVM_LIBC_SRC_STRING_BCOPY_H #define LLVM_LIBC_SRC_STRING_BCOPY_H
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
void bcopy(const void *src, void *dest, size_t count); void bcopy(const void *src, void *dest, size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_BCOPY_H #endif // LLVM_LIBC_SRC_STRING_BCOPY_H

libc/src/string/bzero.h

//===-- Implementation header for bzero -------------------------*- C++ -*-===// //===-- Implementation header for bzero -------------------------*- 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_STRING_BZERO_H #ifndef LLVM_LIBC_SRC_STRING_BZERO_H
#define LLVM_LIBC_SRC_STRING_BZERO_H #define LLVM_LIBC_SRC_STRING_BZERO_H
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
void bzero(void *ptr, size_t count); void bzero(void *ptr, size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_BZERO_H #endif // LLVM_LIBC_SRC_STRING_BZERO_H

libc/src/string/memccpy.h

//===-- Implementation header for memccpy -----------------------*- C++ -*-===// //===-- Implementation header for memccpy -----------------------*- 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_STRING_MEMCCPY_H #ifndef LLVM_LIBC_SRC_STRING_MEMCCPY_H
#define LLVM_LIBC_SRC_STRING_MEMCCPY_H #define LLVM_LIBC_SRC_STRING_MEMCCPY_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
void *memccpy(void *__restrict dest, const void *__restrict src, int c, void *memccpy(void *__restrict dest, const void *__restrict src, int c,
size_t count); size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_MEMCCPY_H #endif // LLVM_LIBC_SRC_STRING_MEMCCPY_H

libc/src/string/memchr.h

//===-- Implementation header for memchr ------------------------*- C++ -*-===// //===-- Implementation header for memchr ------------------------*- 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_STRING_MEMCHR_H #ifndef LLVM_LIBC_SRC_STRING_MEMCHR_H
#define LLVM_LIBC_SRC_STRING_MEMCHR_H #define LLVM_LIBC_SRC_STRING_MEMCHR_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
void *memchr(const void *src, int c, size_t n); void *memchr(const void *src, int c, size_t n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_MEMCHR_H #endif // LLVM_LIBC_SRC_STRING_MEMCHR_H

libc/src/string/memcmp.h

//===-- Implementation header for memcmp ------------------------*- C++ -*-===// //===-- Implementation header for memcmp ------------------------*- 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_STRING_MEMCMP_H #ifndef LLVM_LIBC_SRC_STRING_MEMCMP_H
#define LLVM_LIBC_SRC_STRING_MEMCMP_H #define LLVM_LIBC_SRC_STRING_MEMCMP_H
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
int memcmp(const void *lhs, const void *rhs, size_t count); int memcmp(const void *lhs, const void *rhs, size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_MEMCMP_H #endif // LLVM_LIBC_SRC_STRING_MEMCMP_H

libc/src/string/memcpy.h

//===-- Implementation header for memcpy ------------------------*- C++ -*-===// //===-- Implementation header for memcpy ------------------------*- 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_STRING_MEMCPY_H #ifndef LLVM_LIBC_SRC_STRING_MEMCPY_H
#define LLVM_LIBC_SRC_STRING_MEMCPY_H #define LLVM_LIBC_SRC_STRING_MEMCPY_H
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
void *memcpy(void *__restrict, const void *__restrict, size_t); void *memcpy(void *__restrict, const void *__restrict, size_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_MEMCPY_H #endif // LLVM_LIBC_SRC_STRING_MEMCPY_H

libc/src/string/memmove.h

//===-- Implementation header for memmove -----------------------*- C++ -*-===// //===-- Implementation header for memmove -----------------------*- 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_STRING_MEMMOVE_H #ifndef LLVM_LIBC_SRC_STRING_MEMMOVE_H
#define LLVM_LIBC_SRC_STRING_MEMMOVE_H #define LLVM_LIBC_SRC_STRING_MEMMOVE_H
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
void *memmove(void *dst, const void *src, size_t count); void *memmove(void *dst, const void *src, size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_MEMMOVE_H #endif // LLVM_LIBC_SRC_STRING_MEMMOVE_H

libc/src/string/mempcpy.h

//===-- Implementation header for mempcpy -----------------------*- C++ -*-===// //===-- Implementation header for mempcpy -----------------------*- 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_STRING_MEMPCPY_H #ifndef LLVM_LIBC_SRC_STRING_MEMPCPY_H
#define LLVM_LIBC_SRC_STRING_MEMPCPY_H #define LLVM_LIBC_SRC_STRING_MEMPCPY_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
void *mempcpy(void *__restrict dest, const void *__restrict src, size_t count); void *mempcpy(void *__restrict dest, const void *__restrict src,
size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_MEMPCPY_H #endif // LLVM_LIBC_SRC_STRING_MEMPCPY_H

libc/src/string/memrchr.h

//===-- Implementation header for memrchr -----------------------*- C++ -*-===// //===-- Implementation header for memrchr -----------------------*- 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_STRING_MEMRCHR_H #ifndef LLVM_LIBC_SRC_STRING_MEMRCHR_H
#define LLVM_LIBC_SRC_STRING_MEMRCHR_H #define LLVM_LIBC_SRC_STRING_MEMRCHR_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
void *memrchr(const void *src, int c, size_t n); void *memrchr(const void *src, int c, size_t n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_MEMRCHR_H #endif // LLVM_LIBC_SRC_STRING_MEMRCHR_H

libc/src/string/memset.h

//===-- Implementation header for memset ------------------------*- C++ -*-===// //===-- Implementation header for memset ------------------------*- 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_STRING_MEMSET_H #ifndef LLVM_LIBC_SRC_STRING_MEMSET_H
#define LLVM_LIBC_SRC_STRING_MEMSET_H #define LLVM_LIBC_SRC_STRING_MEMSET_H
#include <stddef.h> // size_t #include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
void *memset(void *ptr, int value, size_t count); void *memset(void *ptr, int value, size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_MEMSET_H #endif // LLVM_LIBC_SRC_STRING_MEMSET_H

libc/src/string/stpcpy.h

//===-- Implementation header for stpcpy ------------------------*- C++ -*-===// //===-- Implementation header for stpcpy ------------------------*- 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_STRING_STPCPY_H #ifndef LLVM_LIBC_SRC_STRING_STPCPY_H
#define LLVM_LIBC_SRC_STRING_STPCPY_H #define LLVM_LIBC_SRC_STRING_STPCPY_H
namespace __llvm_libc { namespace __llvm_libc {
char *stpcpy(char *__restrict dest, const char *__restrict src); char *stpcpy(char *__restrict dest, const char *__restrict src) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STPCPY_H #endif // LLVM_LIBC_SRC_STRING_STPCPY_H

libc/src/string/stpncpy.h

//===-- Implementation header for stpncpy -----------------------*- C++ -*-===// //===-- Implementation header for stpncpy -----------------------*- 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_STRING_STPNCPY_H #ifndef LLVM_LIBC_SRC_STRING_STPNCPY_H
#define LLVM_LIBC_SRC_STRING_STPNCPY_H #define LLVM_LIBC_SRC_STRING_STPNCPY_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
char *stpncpy(char *__restrict dest, const char *__restrict src, size_t n); char *stpncpy(char *__restrict dest, const char *__restrict src,
size_t n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STPNCPY_H #endif // LLVM_LIBC_SRC_STRING_STPNCPY_H

libc/src/string/strcat.h

//===-- Implementation header for strcat ------------------------*- C++ -*-===// //===-- Implementation header for strcat ------------------------*- 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_STRING_STRCAT_H #ifndef LLVM_LIBC_SRC_STRING_STRCAT_H
#define LLVM_LIBC_SRC_STRING_STRCAT_H #define LLVM_LIBC_SRC_STRING_STRCAT_H
#include <string.h> #include <string.h>
namespace __llvm_libc { namespace __llvm_libc {
char *strcat(char *__restrict dest, const char *__restrict src); char *strcat(char *__restrict dest, const char *__restrict src) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRCAT_H #endif // LLVM_LIBC_SRC_STRING_STRCAT_H

libc/src/string/strchr.h

//===-- Implementation header for strchr ------------------------*- C++ -*-===// //===-- Implementation header for strchr ------------------------*- 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_STRING_STRCHR_H #ifndef LLVM_LIBC_SRC_STRING_STRCHR_H
#define LLVM_LIBC_SRC_STRING_STRCHR_H #define LLVM_LIBC_SRC_STRING_STRCHR_H
namespace __llvm_libc { namespace __llvm_libc {
char *strchr(const char *src, int c); char *strchr(const char *src, int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRCHR_H #endif // LLVM_LIBC_SRC_STRING_STRCHR_H

libc/src/string/strcmp.h

//===-- Implementation header for strcmp ------------------------*- C++ -*-===// //===-- Implementation header for strcmp ------------------------*- 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_STRING_STRCMP_H #ifndef LLVM_LIBC_SRC_STRING_STRCMP_H
#define LLVM_LIBC_SRC_STRING_STRCMP_H #define LLVM_LIBC_SRC_STRING_STRCMP_H
namespace __llvm_libc { namespace __llvm_libc {
int strcmp(const char *left, const char *right); int strcmp(const char *left, const char *right) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRCMP_H #endif // LLVM_LIBC_SRC_STRING_STRCMP_H

libc/src/string/strcoll.h

//===-- Implementation header for strcoll -----------------------*- C++ -*-===// //===-- Implementation header for strcoll -----------------------*- 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_STRING_STRCOLL_H #ifndef LLVM_LIBC_SRC_STRING_STRCOLL_H
#define LLVM_LIBC_SRC_STRING_STRCOLL_H #define LLVM_LIBC_SRC_STRING_STRCOLL_H
namespace __llvm_libc { namespace __llvm_libc {
int strcoll(const char *left, const char *right); int strcoll(const char *left, const char *right) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRCOLL_H #endif // LLVM_LIBC_SRC_STRING_STRCOLL_H

libc/src/string/strcpy.h

//===-- Implementation header for strcpy ------------------------*- C++ -*-===// //===-- Implementation header for strcpy ------------------------*- 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_STRING_STRCPY_H #ifndef LLVM_LIBC_SRC_STRING_STRCPY_H
#define LLVM_LIBC_SRC_STRING_STRCPY_H #define LLVM_LIBC_SRC_STRING_STRCPY_H
#include <string.h> #include <string.h>
namespace __llvm_libc { namespace __llvm_libc {
char *strcpy(char *__restrict dest, const char *__restrict src); char *strcpy(char *__restrict dest, const char *__restrict src) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRCPY_H #endif // LLVM_LIBC_SRC_STRING_STRCPY_H

libc/src/string/strcspn.h

//===-- Implementation header for strcspn -----------------------*- C++ -*-===// //===-- Implementation header for strcspn -----------------------*- 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_STRING_STRCSPN_H #ifndef LLVM_LIBC_SRC_STRING_STRCSPN_H
#define LLVM_LIBC_SRC_STRING_STRCSPN_H #define LLVM_LIBC_SRC_STRING_STRCSPN_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t strcspn(const char *src, const char *segment); size_t strcspn(const char *src, const char *segment) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRCSPN_H #endif // LLVM_LIBC_SRC_STRING_STRCSPN_H

libc/src/string/strdup.h

//===-- Implementation header for strdup ------------------------*- C++ -*-===// //===-- Implementation header for strdup ------------------------*- 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_STRING_STRDUP_H #ifndef LLVM_LIBC_SRC_STRING_STRDUP_H
#define LLVM_LIBC_SRC_STRING_STRDUP_H #define LLVM_LIBC_SRC_STRING_STRDUP_H
#include <string.h> #include <string.h>
namespace __llvm_libc { namespace __llvm_libc {
char *strdup(const char *src); char *strdup(const char *src) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRDUP_H #endif // LLVM_LIBC_SRC_STRING_STRDUP_H

libc/src/string/strerror.h

//===-- Implementation header for strerror ----------------------*- C++ -*-===// //===-- Implementation header for strerror ----------------------*- 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_STRING_STRERROR_H #ifndef LLVM_LIBC_SRC_STRING_STRERROR_H
#define LLVM_LIBC_SRC_STRING_STRERROR_H #define LLVM_LIBC_SRC_STRING_STRERROR_H
namespace __llvm_libc { namespace __llvm_libc {
char *strerror(int err_num); char *strerror(int err_num) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRERROR_H #endif // LLVM_LIBC_SRC_STRING_STRERROR_H

libc/src/string/strerror_r.h

//===-- Implementation header for strerror_r --------------------*- C++ -*-===// //===-- Implementation header for strerror_r --------------------*- 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_STRING_STRERROR_R_H #ifndef LLVM_LIBC_SRC_STRING_STRERROR_R_H
#define LLVM_LIBC_SRC_STRING_STRERROR_R_H #define LLVM_LIBC_SRC_STRING_STRERROR_R_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
char *strerror_r(int err_num, char *buf, size_t buflen); char *strerror_r(int err_num, char *buf, size_t buflen) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRERROR_R_H #endif // LLVM_LIBC_SRC_STRING_STRERROR_R_H

libc/src/string/strlcat.h

//===-- Implementation header for strlcat -----------------------*- C++ -*-===// //===-- Implementation header for strlcat -----------------------*- 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_STRING_STRLCAT_H #ifndef LLVM_LIBC_SRC_STRING_STRLCAT_H
#define LLVM_LIBC_SRC_STRING_STRLCAT_H #define LLVM_LIBC_SRC_STRING_STRLCAT_H
#include <string.h> #include <string.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t strlcat(char *__restrict dst, const char *__restrict src, size_t size); size_t strlcat(char *__restrict dst, const char *__restrict src,
size_t size) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRLCAT_H #endif // LLVM_LIBC_SRC_STRING_STRLCAT_H

libc/src/string/strlcpy.h

//===-- Implementation header for strlcpy -----------------------*- C++ -*-===// //===-- Implementation header for strlcpy -----------------------*- 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_STRING_STRLCPY_H #ifndef LLVM_LIBC_SRC_STRING_STRLCPY_H
#define LLVM_LIBC_SRC_STRING_STRLCPY_H #define LLVM_LIBC_SRC_STRING_STRLCPY_H
#include <string.h> #include <string.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t strlcpy(char *__restrict dst, const char *__restrict src, size_t size); size_t strlcpy(char *__restrict dst, const char *__restrict src,
size_t size) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRLCPY_H #endif // LLVM_LIBC_SRC_STRING_STRLCPY_H

libc/src/string/strlen.h

//===-- Implementation header for strlen ------------------------*- C++ -*-===// //===-- Implementation header for strlen ------------------------*- 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_STRING_STRLEN_H #ifndef LLVM_LIBC_SRC_STRING_STRLEN_H
#define LLVM_LIBC_SRC_STRING_STRLEN_H #define LLVM_LIBC_SRC_STRING_STRLEN_H
#include <string.h> #include <string.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t strlen(const char *src); size_t strlen(const char *src) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRLEN_H #endif // LLVM_LIBC_SRC_STRING_STRLEN_H

libc/src/string/strncat.h

//===-- Implementation header for strncat -----------------------*- C++ -*-===// //===-- Implementation header for strncat -----------------------*- 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_STRING_STRNCAT_H #ifndef LLVM_LIBC_SRC_STRING_STRNCAT_H
#define LLVM_LIBC_SRC_STRING_STRNCAT_H #define LLVM_LIBC_SRC_STRING_STRNCAT_H
#include <string.h> #include <string.h>
namespace __llvm_libc { namespace __llvm_libc {
char *strncat(char *__restrict dest, const char *__restrict src, size_t count); char *strncat(char *__restrict dest, const char *__restrict src,
size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRNCAT_H #endif // LLVM_LIBC_SRC_STRING_STRNCAT_H

libc/src/string/strncmp.h

//===-- Implementation header for strncmp -----------------------*- C++ -*-===// //===-- Implementation header for strncmp -----------------------*- 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_STRING_STRNCMP_H #ifndef LLVM_LIBC_SRC_STRING_STRNCMP_H
#define LLVM_LIBC_SRC_STRING_STRNCMP_H #define LLVM_LIBC_SRC_STRING_STRNCMP_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
int strncmp(const char *left, const char *right, size_t n); int strncmp(const char *left, const char *right, size_t n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRNCMP_H #endif // LLVM_LIBC_SRC_STRING_STRNCMP_H

libc/src/string/strncpy.h

//===-- Implementation header for strncpy -----------------------*- C++ -*-===// //===-- Implementation header for strncpy -----------------------*- 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_STRING_STRNCPY_H #ifndef LLVM_LIBC_SRC_STRING_STRNCPY_H
#define LLVM_LIBC_SRC_STRING_STRNCPY_H #define LLVM_LIBC_SRC_STRING_STRNCPY_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
char *strncpy(char *__restrict dest, const char *__restrict src, size_t n); char *strncpy(char *__restrict dest, const char *__restrict src,
size_t n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRNCPY_H #endif // LLVM_LIBC_SRC_STRING_STRNCPY_H

libc/src/string/strndup.h

//===-- Implementation header for strndup -----------------------*- C++-*-===// //===-- Implementation header for strndup -----------------------*- 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_STRING_STRNDUP_H #ifndef LLVM_LIBC_SRC_STRING_STRNDUP_H
#define LLVM_LIBC_SRC_STRING_STRNDUP_H #define LLVM_LIBC_SRC_STRING_STRNDUP_H
#include <string.h> #include <string.h>
namespace __llvm_libc { namespace __llvm_libc {
char *strndup(const char *src, size_t size); char *strndup(const char *src, size_t size) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRNDUP_H #endif // LLVM_LIBC_SRC_STRING_STRNDUP_H

libc/src/string/strnlen.h

//===-- Implementation header for strnlen ------------------------*- C++-*-===// //===-- Implementation header for strnlen ------------------------*- 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_STRING_STRNLEN_H #ifndef LLVM_LIBC_SRC_STRING_STRNLEN_H
#define LLVM_LIBC_SRC_STRING_STRNLEN_H #define LLVM_LIBC_SRC_STRING_STRNLEN_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t strnlen(const char *src, size_t n); size_t strnlen(const char *src, size_t n) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRNLEN_H #endif // LLVM_LIBC_SRC_STRING_STRNLEN_H

libc/src/string/strpbrk.h

//===-- Implementation header for strpbrk -----------------------*- C++ -*-===// //===-- Implementation header for strpbrk -----------------------*- 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_STRING_STRPBRK_H #ifndef LLVM_LIBC_SRC_STRING_STRPBRK_H
#define LLVM_LIBC_SRC_STRING_STRPBRK_H #define LLVM_LIBC_SRC_STRING_STRPBRK_H
namespace __llvm_libc { namespace __llvm_libc {
char *strpbrk(const char *src, const char *breakset); char *strpbrk(const char *src, const char *breakset) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRPBRK_H #endif // LLVM_LIBC_SRC_STRING_STRPBRK_H

libc/src/string/strrchr.h

//===-- Implementation header for strrchr -----------------------*- C++ -*-===// //===-- Implementation header for strrchr -----------------------*- 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_STRING_STRRCHR_H #ifndef LLVM_LIBC_SRC_STRING_STRRCHR_H
#define LLVM_LIBC_SRC_STRING_STRRCHR_H #define LLVM_LIBC_SRC_STRING_STRRCHR_H
namespace __llvm_libc { namespace __llvm_libc {
char *strrchr(const char *src, int c); char *strrchr(const char *src, int c) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRRCHR_H #endif // LLVM_LIBC_SRC_STRING_STRRCHR_H

libc/src/string/strsignal.h

//===-- Implementation header for strsignal ----------------------*- C++ //===-- Implementation header for strsignal ----------------------*- 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_STRING_STRSIGNAL_H #ifndef LLVM_LIBC_SRC_STRING_STRSIGNAL_H
#define LLVM_LIBC_SRC_STRING_STRSIGNAL_H #define LLVM_LIBC_SRC_STRING_STRSIGNAL_H
namespace __llvm_libc { namespace __llvm_libc {
char *strsignal(int sig_num); char *strsignal(int sig_num) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRSIGNAL_H #endif // LLVM_LIBC_SRC_STRING_STRSIGNAL_H

libc/src/string/strspn.h

//===-- Implementation header for strspn ------------------------*- C++ -*-===// //===-- Implementation header for strspn ------------------------*- 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_STRING_STRSPN_H #ifndef LLVM_LIBC_SRC_STRING_STRSPN_H
#define LLVM_LIBC_SRC_STRING_STRSPN_H #define LLVM_LIBC_SRC_STRING_STRSPN_H
#include <stddef.h> #include <stddef.h>
namespace __llvm_libc { namespace __llvm_libc {
size_t strspn(const char *src, const char *segment); size_t strspn(const char *src, const char *segment) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRSPN_H #endif // LLVM_LIBC_SRC_STRING_STRSPN_H

libc/src/string/strstr.h

//===-- Implementation header for strstr ------------------------*- C++ -*-===// //===-- Implementation header for strstr ------------------------*- 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_STRING_STRSTR_H #ifndef LLVM_LIBC_SRC_STRING_STRSTR_H
#define LLVM_LIBC_SRC_STRING_STRSTR_H #define LLVM_LIBC_SRC_STRING_STRSTR_H
namespace __llvm_libc { namespace __llvm_libc {
char *strstr(const char *haystack, const char *needle); char *strstr(const char *haystack, const char *needle) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRSTR_H #endif // LLVM_LIBC_SRC_STRING_STRSTR_H

libc/src/string/strtok.h

//===-- Implementation header for strtok ------------------------*- C++ -*-===// //===-- Implementation header for strtok ------------------------*- 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_STRING_STRTOK_H #ifndef LLVM_LIBC_SRC_STRING_STRTOK_H
#define LLVM_LIBC_SRC_STRING_STRTOK_H #define LLVM_LIBC_SRC_STRING_STRTOK_H
namespace __llvm_libc { namespace __llvm_libc {
char *strtok(char *__restrict src, const char *__restrict delimiter_string); char *strtok(char *__restrict src,
const char *__restrict delimiter_string) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRTOK_H #endif // LLVM_LIBC_SRC_STRING_STRTOK_H

libc/src/string/strtok_r.h

//===-- Implementation header for strtok_r ----------------------*- C++ -*-===// //===-- Implementation header for strtok_r ----------------------*- 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_STRING_STRTOK_R_H #ifndef LLVM_LIBC_SRC_STRING_STRTOK_R_H
#define LLVM_LIBC_SRC_STRING_STRTOK_R_H #define LLVM_LIBC_SRC_STRING_STRTOK_R_H
namespace __llvm_libc { namespace __llvm_libc {
char *strtok_r(char *__restrict src, const char *__restrict delimiter_string, char *strtok_r(char *__restrict src, const char *__restrict delimiter_string,
char **__restrict saveptr); char **__restrict saveptr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_STRING_STRTOK_R_H #endif // LLVM_LIBC_SRC_STRING_STRTOK_R_H

libc/src/sys/mman/madvise.h

//===-- Implementation header for madvise function --------------*- C++ -*-===// //===-- Implementation header for madvise function --------------*- 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_SYS_MMAN_MADVISE_H #ifndef LLVM_LIBC_SRC_SYS_MMAN_MADVISE_H
#define LLVM_LIBC_SRC_SYS_MMAN_MADVISE_H #define LLVM_LIBC_SRC_SYS_MMAN_MADVISE_H
#include <sys/mman.h> // For size_t and off_t #include <sys/mman.h> // For size_t and off_t
namespace __llvm_libc { namespace __llvm_libc {
int madvise(void *addr, size_t size, int advice); int madvise(void *addr, size_t size, int advice) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_MMAN_MADVISE_H #endif // LLVM_LIBC_SRC_SYS_MMAN_MADVISE_H

libc/src/sys/mman/mmap.h

//===-- Implementation header for mmap function -----------------*- C++ -*-===// //===-- Implementation header for mmap function -----------------*- 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_SYS_MMAN_MMAP_H #ifndef LLVM_LIBC_SRC_SYS_MMAN_MMAP_H
#define LLVM_LIBC_SRC_SYS_MMAN_MMAP_H #define LLVM_LIBC_SRC_SYS_MMAN_MMAP_H
#include <sys/mman.h> // For size_t and off_t #include <sys/mman.h> // For size_t and off_t
namespace __llvm_libc { namespace __llvm_libc {
void *mmap(void *addr, size_t size, int prot, int flags, int fd, off_t offset); void *mmap(void *addr, size_t size, int prot, int flags, int fd,
off_t offset) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_MMAN_MMAP_H #endif // LLVM_LIBC_SRC_SYS_MMAN_MMAP_H

libc/src/sys/mman/mprotect.h

//===-- Implementation header for mprotect function -------------*- C++ -*-===// //===-- Implementation header for mprotect function -------------*- 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_SYS_MMAN_MPROTECT_H #ifndef LLVM_LIBC_SRC_SYS_MMAN_MPROTECT_H
#define LLVM_LIBC_SRC_SYS_MMAN_MPROTECT_H #define LLVM_LIBC_SRC_SYS_MMAN_MPROTECT_H
#include <sys/mman.h> // For size_t and off_t #include <sys/mman.h> // For size_t and off_t
namespace __llvm_libc { namespace __llvm_libc {
int mprotect(void *addr, size_t size, int prot); int mprotect(void *addr, size_t size, int prot) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_MMAN_MPROTECT_H #endif // LLVM_LIBC_SRC_SYS_MMAN_MPROTECT_H

libc/src/sys/mman/munmap.h

//===-- Implementation header for mumap function ----------------*- C++ -*-===// //===-- Implementation header for mumap function ----------------*- 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_SYS_MMAN_MUNMAP_H #ifndef LLVM_LIBC_SRC_SYS_MMAN_MUNMAP_H
#define LLVM_LIBC_SRC_SYS_MMAN_MUNMAP_H #define LLVM_LIBC_SRC_SYS_MMAN_MUNMAP_H
#include <sys/mman.h> // For size_t. #include <sys/mman.h> // For size_t.
namespace __llvm_libc { namespace __llvm_libc {
int munmap(void *addr, size_t size); int munmap(void *addr, size_t size) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_MMAN_MUNMAP_H #endif // LLVM_LIBC_SRC_SYS_MMAN_MUNMAP_H

libc/src/sys/mman/posix_madvise.h

//===-- Implementation header for posix_madvise function --------*- C++ -*-===// //===-- Implementation header for posix_madvise function --------*- 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_SYS_MMAN_POSIX_MADVISE_H #ifndef LLVM_LIBC_SRC_SYS_MMAN_POSIX_MADVISE_H
#define LLVM_LIBC_SRC_SYS_MMAN_POSIX_MADVISE_H #define LLVM_LIBC_SRC_SYS_MMAN_POSIX_MADVISE_H
#include <sys/mman.h> // For size_t and off_t #include <sys/mman.h> // For size_t and off_t
namespace __llvm_libc { namespace __llvm_libc {
int posix_madvise(void *addr, size_t size, int advice); int posix_madvise(void *addr, size_t size, int advice) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_MMAN_POSIX_MADVISE_H #endif // LLVM_LIBC_SRC_SYS_MMAN_POSIX_MADVISE_H

libc/src/sys/random/getrandom.h

//===-- Implementation header for getrandom ----------------------*- C++-*-===// //===-- Implementation header for getrandom ----------------------*- 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_SYS_RANDOM_GETRANDOM_H #ifndef LLVM_LIBC_SRC_SYS_RANDOM_GETRANDOM_H
#define LLVM_LIBC_SRC_SYS_RANDOM_GETRANDOM_H #define LLVM_LIBC_SRC_SYS_RANDOM_GETRANDOM_H
#include <sys/random.h> #include <sys/random.h>
namespace __llvm_libc { namespace __llvm_libc {
ssize_t getrandom(void *buf, size_t buflen, unsigned int flags); ssize_t getrandom(void *buf, size_t buflen, unsigned int flags) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_RANDOM_GETRANDOM_H #endif // LLVM_LIBC_SRC_SYS_RANDOM_GETRANDOM_H

libc/src/sys/resource/getrlimit.h

//===-- Implementation header for getrlimit ---------------------*- C++ -*-===// //===-- Implementation header for getrlimit ---------------------*- 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_SYS_STAT_GETRLIMIT_H #ifndef LLVM_LIBC_SRC_SYS_STAT_GETRLIMIT_H
#define LLVM_LIBC_SRC_SYS_STAT_GETRLIMIT_H #define LLVM_LIBC_SRC_SYS_STAT_GETRLIMIT_H
#include <sys/resource.h> #include <sys/resource.h>
namespace __llvm_libc { namespace __llvm_libc {
int getrlimit(int resource, struct rlimit *lim); int getrlimit(int resource, struct rlimit *lim) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_GETRLIMIT_H #endif // LLVM_LIBC_SRC_SYS_STAT_GETRLIMIT_H

libc/src/sys/resource/setrlimit.h

//===-- Implementation header for setrlimit ---------------------*- C++ -*-===// //===-- Implementation header for setrlimit ---------------------*- 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_SYS_STAT_SETRLIMIT_H #ifndef LLVM_LIBC_SRC_SYS_STAT_SETRLIMIT_H
#define LLVM_LIBC_SRC_SYS_STAT_SETRLIMIT_H #define LLVM_LIBC_SRC_SYS_STAT_SETRLIMIT_H
#include <sys/resource.h> #include <sys/resource.h>
namespace __llvm_libc { namespace __llvm_libc {
int setrlimit(int resource, const struct rlimit *lim); int setrlimit(int resource, const struct rlimit *lim) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_SETRLIMIT_H #endif // LLVM_LIBC_SRC_SYS_STAT_SETRLIMIT_H

libc/src/sys/select/select.h

//===-- Implementation header for select ------------------------*- C++ -*-===// //===-- Implementation header for select ------------------------*- 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_SYS_SELECT_SELECT_H #ifndef LLVM_LIBC_SRC_SYS_SELECT_SELECT_H
#define LLVM_LIBC_SRC_SYS_SELECT_SELECT_H #define LLVM_LIBC_SRC_SYS_SELECT_SELECT_H
#include <sys/select.h> #include <sys/select.h>
namespace __llvm_libc { namespace __llvm_libc {
int select(int nfds, fd_set *__restrict read_set, fd_set *__restrict write_set, int select(int nfds, fd_set *__restrict read_set, fd_set *__restrict write_set,
fd_set *__restrict error_set, struct timeval *__restrict timeout); fd_set *__restrict error_set,
struct timeval *__restrict timeout) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_SELECT_SELECT_H #endif // LLVM_LIBC_SRC_SYS_SELECT_SELECT_H

libc/src/sys/sendfile/sendfile.h

//===-- Implementation header for sendfile ----------------------*- C++ -*-===// //===-- Implementation header for sendfile ----------------------*- 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_SYS_STAT_SENDFILE_H #ifndef LLVM_LIBC_SRC_SYS_STAT_SENDFILE_H
#define LLVM_LIBC_SRC_SYS_STAT_SENDFILE_H #define LLVM_LIBC_SRC_SYS_STAT_SENDFILE_H
#include <sys/sendfile.h> #include <sys/sendfile.h>
namespace __llvm_libc { namespace __llvm_libc {
ssize_t sendfile(int, int, off_t *, size_t); ssize_t sendfile(int, int, off_t *, size_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_SENDFILE_H #endif // LLVM_LIBC_SRC_SYS_STAT_SENDFILE_H

libc/src/sys/stat/chmod.h

//===-- Implementation header for chmod -------------------------*- C++ -*-===// //===-- Implementation header for chmod -------------------------*- 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_SYS_STAT_CHMOD_H #ifndef LLVM_LIBC_SRC_SYS_STAT_CHMOD_H
#define LLVM_LIBC_SRC_SYS_STAT_CHMOD_H #define LLVM_LIBC_SRC_SYS_STAT_CHMOD_H
#include <sys/stat.h> #include <sys/stat.h>
namespace __llvm_libc { namespace __llvm_libc {
int chmod(const char *path, mode_t mode); int chmod(const char *path, mode_t mode) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_CHMOD_H #endif // LLVM_LIBC_SRC_SYS_STAT_CHMOD_H

libc/src/sys/stat/fchmod.h

//===-- Implementation header for fchmod ------------------------*- C++ -*-===// //===-- Implementation header for fchmod ------------------------*- 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_SYS_STAT_FCHMOD_H #ifndef LLVM_LIBC_SRC_SYS_STAT_FCHMOD_H
#define LLVM_LIBC_SRC_SYS_STAT_FCHMOD_H #define LLVM_LIBC_SRC_SYS_STAT_FCHMOD_H
#include <sys/stat.h> #include <sys/stat.h>
namespace __llvm_libc { namespace __llvm_libc {
int fchmod(int fd, mode_t mode); int fchmod(int fd, mode_t mode) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_FCHMOD_H #endif // LLVM_LIBC_SRC_SYS_STAT_FCHMOD_H

libc/src/sys/stat/fchmodat.h

//===-- Implementation header for fchmodat ----------------------*- C++ -*-===// //===-- Implementation header for fchmodat ----------------------*- 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_SYS_STAT_FCHMODAT_H #ifndef LLVM_LIBC_SRC_SYS_STAT_FCHMODAT_H
#define LLVM_LIBC_SRC_SYS_STAT_FCHMODAT_H #define LLVM_LIBC_SRC_SYS_STAT_FCHMODAT_H
#include <sys/stat.h> #include <sys/stat.h>
namespace __llvm_libc { namespace __llvm_libc {
int fchmodat(int dirfd, const char *path, mode_t mode, int flags); int fchmodat(int dirfd, const char *path, mode_t mode, int flags) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_FCHMODAT_H #endif // LLVM_LIBC_SRC_SYS_STAT_FCHMODAT_H

libc/src/sys/stat/fstat.h

//===-- Implementation header for fstat -------------------------*- C++ -*-===// //===-- Implementation header for fstat -------------------------*- 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_SYS_STAT_FSTAT_H #ifndef LLVM_LIBC_SRC_SYS_STAT_FSTAT_H
#define LLVM_LIBC_SRC_SYS_STAT_FSTAT_H #define LLVM_LIBC_SRC_SYS_STAT_FSTAT_H
#include <sys/stat.h> #include <sys/stat.h>
namespace __llvm_libc { namespace __llvm_libc {
int fstat(int fd, struct stat *statbuf); int fstat(int fd, struct stat *statbuf) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_FSTAT_H #endif // LLVM_LIBC_SRC_SYS_STAT_FSTAT_H

libc/src/sys/stat/lstat.h

//===-- Implementation header for lstat -------------------------*- C++ -*-===// //===-- Implementation header for lstat -------------------------*- 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_SYS_STAT_LSTAT_H #ifndef LLVM_LIBC_SRC_SYS_STAT_LSTAT_H
#define LLVM_LIBC_SRC_SYS_STAT_LSTAT_H #define LLVM_LIBC_SRC_SYS_STAT_LSTAT_H
#include <sys/stat.h> #include <sys/stat.h>
namespace __llvm_libc { namespace __llvm_libc {
int lstat(const char *__restrict path, struct stat *__restrict statbuf); int lstat(const char *__restrict path,
struct stat *__restrict statbuf) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_LSTAT_H #endif // LLVM_LIBC_SRC_SYS_STAT_LSTAT_H

libc/src/sys/stat/mkdir.h

//===-- Implementation header for mkdir -------------------------*- C++ -*-===// //===-- Implementation header for mkdir -------------------------*- 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_SYS_STAT_MKDIR_H #ifndef LLVM_LIBC_SRC_SYS_STAT_MKDIR_H
#define LLVM_LIBC_SRC_SYS_STAT_MKDIR_H #define LLVM_LIBC_SRC_SYS_STAT_MKDIR_H
#include <sys/stat.h> #include <sys/stat.h>
namespace __llvm_libc { namespace __llvm_libc {
int mkdir(const char *path, mode_t mode); int mkdir(const char *path, mode_t mode) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_MKDIR_H #endif // LLVM_LIBC_SRC_SYS_STAT_MKDIR_H

libc/src/sys/stat/mkdirat.h

//===-- Implementation header for mkdirat -----------------------*- C++ -*-===// //===-- Implementation header for mkdirat -----------------------*- 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_SYS_STAT_MKDIRAT_H #ifndef LLVM_LIBC_SRC_SYS_STAT_MKDIRAT_H
#define LLVM_LIBC_SRC_SYS_STAT_MKDIRAT_H #define LLVM_LIBC_SRC_SYS_STAT_MKDIRAT_H
#include <sys/stat.h> #include <sys/stat.h>
namespace __llvm_libc { namespace __llvm_libc {
int mkdirat(int dfd, const char *path, mode_t mode); int mkdirat(int dfd, const char *path, mode_t mode) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_MKDIRAT_H #endif // LLVM_LIBC_SRC_SYS_STAT_MKDIRAT_H

libc/src/sys/stat/stat.h

//===-- Implementation header for stat --------------------------*- C++ -*-===// //===-- Implementation header for stat --------------------------*- 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_SYS_STAT_STAT_H #ifndef LLVM_LIBC_SRC_SYS_STAT_STAT_H
#define LLVM_LIBC_SRC_SYS_STAT_STAT_H #define LLVM_LIBC_SRC_SYS_STAT_STAT_H
#include <sys/stat.h> #include <sys/stat.h>
namespace __llvm_libc { namespace __llvm_libc {
int stat(const char *__restrict path, struct stat *__restrict statbuf); int stat(const char *__restrict path, struct stat *__restrict statbuf) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_STAT_STAT_H #endif // LLVM_LIBC_SRC_SYS_STAT_STAT_H

libc/src/sys/utsname/uname.h

//===-- Implementation header for uname -------------------------*- C++ -*-===// //===-- Implementation header for uname -------------------------*- 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_SYS_UTSNAME_UNAME_H #ifndef LLVM_LIBC_SRC_SYS_UTSNAME_UNAME_H
#define LLVM_LIBC_SRC_SYS_UTSNAME_UNAME_H #define LLVM_LIBC_SRC_SYS_UTSNAME_UNAME_H
#include <sys/utsname.h> #include <sys/utsname.h>
namespace __llvm_libc { namespace __llvm_libc {
int uname(struct utsname *name); int uname(struct utsname *name) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_UTSNAME_UNAME_H #endif // LLVM_LIBC_SRC_SYS_UTSNAME_UNAME_H

libc/src/sys/wait/wait.h

//===-- Implementation header for wait --------------------------*- C++ -*-===// //===-- Implementation header for wait --------------------------*- 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_SYS_WAIT_WAIT_H #ifndef LLVM_LIBC_SRC_SYS_WAIT_WAIT_H
#define LLVM_LIBC_SRC_SYS_WAIT_WAIT_H #define LLVM_LIBC_SRC_SYS_WAIT_WAIT_H
#include <sys/wait.h> #include <sys/wait.h>
namespace __llvm_libc { namespace __llvm_libc {
pid_t wait(int *waitstatus); pid_t wait(int *waitstatus) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_WAIT_WAIT_H #endif // LLVM_LIBC_SRC_SYS_WAIT_WAIT_H

libc/src/sys/wait/wait4.h

//===-- Implementation header for wait4 -------------------------*- C++ -*-===// //===-- Implementation header for wait4 -------------------------*- 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_SYS_WAIT_WAIT4_H #ifndef LLVM_LIBC_SRC_SYS_WAIT_WAIT4_H
#define LLVM_LIBC_SRC_SYS_WAIT_WAIT4_H #define LLVM_LIBC_SRC_SYS_WAIT_WAIT4_H
#include <sys/wait.h> #include <sys/wait.h>
namespace __llvm_libc { namespace __llvm_libc {
pid_t wait4(pid_t pid, int *waitstatus, int options, struct rusage *usage); pid_t wait4(pid_t pid, int *waitstatus, int options,
struct rusage *usage) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_WAIT_WAIT4_H #endif // LLVM_LIBC_SRC_SYS_WAIT_WAIT4_H

libc/src/sys/wait/waitpid.h

//===-- Implementation header for waitpid -----------------------*- C++ -*-===// //===-- Implementation header for waitpid -----------------------*- 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_SYS_WAIT_WAITPID_H #ifndef LLVM_LIBC_SRC_SYS_WAIT_WAITPID_H
#define LLVM_LIBC_SRC_SYS_WAIT_WAITPID_H #define LLVM_LIBC_SRC_SYS_WAIT_WAITPID_H
#include <sys/wait.h> #include <sys/wait.h>
namespace __llvm_libc { namespace __llvm_libc {
pid_t waitpid(pid_t pid, int *waitstatus, int options); pid_t waitpid(pid_t pid, int *waitstatus, int options) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_SYS_WAIT_WAITPID_H #endif // LLVM_LIBC_SRC_SYS_WAIT_WAITPID_H

libc/src/termios/cfgetispeed.h

//===-- Implementation header for cfgetispeed -------------------*- C++ -*-===// //===-- Implementation header for cfgetispeed -------------------*- 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_UNISTD_CFGETISPEED_H #ifndef LLVM_LIBC_SRC_UNISTD_CFGETISPEED_H
#define LLVM_LIBC_SRC_UNISTD_CFGETISPEED_H #define LLVM_LIBC_SRC_UNISTD_CFGETISPEED_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
speed_t cfgetispeed(const struct termios *t); speed_t cfgetispeed(const struct termios *t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_CFGETISPEED_H #endif // LLVM_LIBC_SRC_UNISTD_CFGETISPEED_H

libc/src/termios/cfgetospeed.h

//===-- Implementation header for cfgetospeed -------------------*- C++ -*-===// //===-- Implementation header for cfgetospeed -------------------*- 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_UNISTD_CFGETOSPEED_H #ifndef LLVM_LIBC_SRC_UNISTD_CFGETOSPEED_H
#define LLVM_LIBC_SRC_UNISTD_CFGETOSPEED_H #define LLVM_LIBC_SRC_UNISTD_CFGETOSPEED_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
speed_t cfgetospeed(const struct termios *t); speed_t cfgetospeed(const struct termios *t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_CFGETOSPEED_H #endif // LLVM_LIBC_SRC_UNISTD_CFGETOSPEED_H

libc/src/termios/cfsetispeed.h

//===-- Implementation header for cfsetispeed -------------------*- C++ -*-===// //===-- Implementation header for cfsetispeed -------------------*- 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_UNISTD_CFSETISPEED_H #ifndef LLVM_LIBC_SRC_UNISTD_CFSETISPEED_H
#define LLVM_LIBC_SRC_UNISTD_CFSETISPEED_H #define LLVM_LIBC_SRC_UNISTD_CFSETISPEED_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
int cfsetispeed(struct termios *t, speed_t speed); int cfsetispeed(struct termios *t, speed_t speed) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_CFSETISPEED_H #endif // LLVM_LIBC_SRC_UNISTD_CFSETISPEED_H

libc/src/termios/cfsetospeed.h

//===-- Implementation header for cfsetospeed -------------------*- C++ -*-===// //===-- Implementation header for cfsetospeed -------------------*- 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_UNISTD_CFSETOSPEED_H #ifndef LLVM_LIBC_SRC_UNISTD_CFSETOSPEED_H
#define LLVM_LIBC_SRC_UNISTD_CFSETOSPEED_H #define LLVM_LIBC_SRC_UNISTD_CFSETOSPEED_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
int cfsetospeed(struct termios *t, speed_t speed); int cfsetospeed(struct termios *t, speed_t speed) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_CFSETOSPEED_H #endif // LLVM_LIBC_SRC_UNISTD_CFSETOSPEED_H

libc/src/termios/tcdrain.h

//===-- Implementation header for tcdrain -----------------------*- C++ -*-===// //===-- Implementation header for tcdrain -----------------------*- 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_UNISTD_TCDRAIN_H #ifndef LLVM_LIBC_SRC_UNISTD_TCDRAIN_H
#define LLVM_LIBC_SRC_UNISTD_TCDRAIN_H #define LLVM_LIBC_SRC_UNISTD_TCDRAIN_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
int tcdrain(int fd); int tcdrain(int fd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_TCDRAIN_H #endif // LLVM_LIBC_SRC_UNISTD_TCDRAIN_H

libc/src/termios/tcflow.h

//===-- Implementation header for tcflow ------------------------*- C++ -*-===// //===-- Implementation header for tcflow ------------------------*- 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_UNISTD_TCFLOW_H #ifndef LLVM_LIBC_SRC_UNISTD_TCFLOW_H
#define LLVM_LIBC_SRC_UNISTD_TCFLOW_H #define LLVM_LIBC_SRC_UNISTD_TCFLOW_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
int tcflow(int fd, int action); int tcflow(int fd, int action) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_TCFLOW_H #endif // LLVM_LIBC_SRC_UNISTD_TCFLOW_H

libc/src/termios/tcflush.h

//===-- Implementation header for tcflush -----------------------*- C++ -*-===// //===-- Implementation header for tcflush -----------------------*- 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_UNISTD_TCFLUSH_H #ifndef LLVM_LIBC_SRC_UNISTD_TCFLUSH_H
#define LLVM_LIBC_SRC_UNISTD_TCFLUSH_H #define LLVM_LIBC_SRC_UNISTD_TCFLUSH_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
int tcflush(int fd, int queue_selector); int tcflush(int fd, int queue_selector) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_TCFLUSH_H #endif // LLVM_LIBC_SRC_UNISTD_TCFLUSH_H

libc/src/termios/tcgetattr.h

//===-- Implementation header for tcgetattr ---------------------*- C++ -*-===// //===-- Implementation header for tcgetattr ---------------------*- 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_TERMIOS_TCGETATTR_H #ifndef LLVM_LIBC_SRC_TERMIOS_TCGETATTR_H
#define LLVM_LIBC_SRC_TERMIOS_TCGETATTR_H #define LLVM_LIBC_SRC_TERMIOS_TCGETATTR_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
int tcgetattr(int fd, struct termios *t); int tcgetattr(int fd, struct termios *t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TERMIOS_TCGETATTR_H #endif // LLVM_LIBC_SRC_TERMIOS_TCGETATTR_H

libc/src/termios/tcgetsid.h

//===-- Implementation header for tcgetsid ----------------------*- C++ -*-===// //===-- Implementation header for tcgetsid ----------------------*- 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_TERMIOS_TCGETSID_H #ifndef LLVM_LIBC_SRC_TERMIOS_TCGETSID_H
#define LLVM_LIBC_SRC_TERMIOS_TCGETSID_H #define LLVM_LIBC_SRC_TERMIOS_TCGETSID_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
pid_t tcgetsid(int fd); pid_t tcgetsid(int fd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TERMIOS_TCGETSID_H #endif // LLVM_LIBC_SRC_TERMIOS_TCGETSID_H

libc/src/termios/tcsendbreak.h

//===-- Implementation header for tcsendbreak -------------------*- C++ -*-===// //===-- Implementation header for tcsendbreak -------------------*- 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_UNISTD_TCSENDBREAK_H #ifndef LLVM_LIBC_SRC_UNISTD_TCSENDBREAK_H
#define LLVM_LIBC_SRC_UNISTD_TCSENDBREAK_H #define LLVM_LIBC_SRC_UNISTD_TCSENDBREAK_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
int tcsendbreak(int fd, int duration); int tcsendbreak(int fd, int duration) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_TCSENDBREAK_H #endif // LLVM_LIBC_SRC_UNISTD_TCSENDBREAK_H

libc/src/termios/tcsetattr.h

//===-- Implementation header for tcsetattr ---------------------*- C++ -*-===// //===-- Implementation header for tcsetattr ---------------------*- 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_TERMIOS_TCSETATTR_H #ifndef LLVM_LIBC_SRC_TERMIOS_TCSETATTR_H
#define LLVM_LIBC_SRC_TERMIOS_TCSETATTR_H #define LLVM_LIBC_SRC_TERMIOS_TCSETATTR_H
#include <termios.h> #include <termios.h>
namespace __llvm_libc { namespace __llvm_libc {
int tcsetattr(int fd, int actions, const struct termios *t); int tcsetattr(int fd, int actions, const struct termios *t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TERMIOS_TCSETATTR_H #endif // LLVM_LIBC_SRC_TERMIOS_TCSETATTR_H

libc/src/threads/call_once.h

//===-- Implementation header for call_once function ------------*- C++ -*-===// //===-- Implementation header for call_once function ------------*- 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_THREADS_CALL_ONCE_H #ifndef LLVM_LIBC_SRC_THREADS_CALL_ONCE_H
#define LLVM_LIBC_SRC_THREADS_CALL_ONCE_H #define LLVM_LIBC_SRC_THREADS_CALL_ONCE_H
#include <threads.h> #include <threads.h>
namespace __llvm_libc { namespace __llvm_libc {
void call_once(once_flag *flag, __call_once_func_t func); void call_once(once_flag *flag, __call_once_func_t func) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_CALL_ONCE_H #endif // LLVM_LIBC_SRC_THREADS_CALL_ONCE_H

libc/src/threads/cnd_broadcast.h

//===-- Implementation header for cnd_broadcast function --------*- C++ -*-===// //===-- Implementation header for cnd_broadcast function --------*- 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_THREADS_CND_BROADCAST_H #ifndef LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H
#define LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H #define LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int cnd_broadcast(cnd_t *cond); int cnd_broadcast(cnd_t *cond) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H #endif // LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H

libc/src/threads/cnd_destroy.h

//===-- Implementation header for cnd_destroy function ----------*- C++ -*-===// //===-- Implementation header for cnd_destroy function ----------*- 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_THREADS_CND_DESTROY_H #ifndef LLVM_LIBC_SRC_THREADS_CND_DESTROY_H
#define LLVM_LIBC_SRC_THREADS_CND_DESTROY_H #define LLVM_LIBC_SRC_THREADS_CND_DESTROY_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
void cnd_destroy(cnd_t *cond); void cnd_destroy(cnd_t *cond) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_CND_DESTROY_H #endif // LLVM_LIBC_SRC_THREADS_CND_DESTROY_H

libc/src/threads/cnd_init.h

//===-- Implementation header for cnd_init function -------------*- C++ -*-===// //===-- Implementation header for cnd_init function -------------*- 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_THREADS_CND_INIT_H #ifndef LLVM_LIBC_SRC_THREADS_CND_INIT_H
#define LLVM_LIBC_SRC_THREADS_CND_INIT_H #define LLVM_LIBC_SRC_THREADS_CND_INIT_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int cnd_init(cnd_t *cond); int cnd_init(cnd_t *cond) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_CND_INIT_H #endif // LLVM_LIBC_SRC_THREADS_CND_INIT_H

libc/src/threads/cnd_signal.h

//===-- Implementation header for cnd_signal function -----------*- C++ -*-===// //===-- Implementation header for cnd_signal function -----------*- 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_THREADS_CND_SIGNAL_H #ifndef LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H
#define LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H #define LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int cnd_signal(cnd_t *cond); int cnd_signal(cnd_t *cond) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H #endif // LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H

libc/src/threads/cnd_wait.h

//===-- Implementation header for cnd_wait function -------------*- C++ -*-===// //===-- Implementation header for cnd_wait function -------------*- 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_THREADS_CND_WAIT_H #ifndef LLVM_LIBC_SRC_THREADS_CND_WAIT_H
#define LLVM_LIBC_SRC_THREADS_CND_WAIT_H #define LLVM_LIBC_SRC_THREADS_CND_WAIT_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int cnd_wait(cnd_t *cond, mtx_t *mutex); int cnd_wait(cnd_t *cond, mtx_t *mutex) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_CND_WAIT_H #endif // LLVM_LIBC_SRC_THREADS_CND_WAIT_H

libc/src/threads/mtx_destroy.h

//===-- Implementation header for mtx_destroy function ----------*- C++ -*-===// //===-- Implementation header for mtx_destroy function ----------*- 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_THREADS_MTX_DESTROY_H #ifndef LLVM_LIBC_SRC_THREADS_MTX_DESTROY_H
#define LLVM_LIBC_SRC_THREADS_MTX_DESTROY_H #define LLVM_LIBC_SRC_THREADS_MTX_DESTROY_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
void mtx_destroy(mtx_t *mutex); void mtx_destroy(mtx_t *mutex) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_MTX_DESTROY_H #endif // LLVM_LIBC_SRC_THREADS_MTX_DESTROY_H

libc/src/threads/mtx_init.h

//===-- Implementation header for mtx_init function -------------*- C++ -*-===// //===-- Implementation header for mtx_init function -------------*- 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_THREADS_MTX_INIT_H #ifndef LLVM_LIBC_SRC_THREADS_MTX_INIT_H
#define LLVM_LIBC_SRC_THREADS_MTX_INIT_H #define LLVM_LIBC_SRC_THREADS_MTX_INIT_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int mtx_init(mtx_t *mutex, int type); int mtx_init(mtx_t *mutex, int type) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_MTX_INIT_H #endif // LLVM_LIBC_SRC_THREADS_MTX_INIT_H

libc/src/threads/mtx_lock.h

//===-- Implementation header for mtx_lock function -------------*- C++ -*-===// //===-- Implementation header for mtx_lock function -------------*- 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_THREADS_MTX_LOCK_H #ifndef LLVM_LIBC_SRC_THREADS_MTX_LOCK_H
#define LLVM_LIBC_SRC_THREADS_MTX_LOCK_H #define LLVM_LIBC_SRC_THREADS_MTX_LOCK_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int mtx_lock(mtx_t *mutex); int mtx_lock(mtx_t *mutex) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_MTX_LOCK_H #endif // LLVM_LIBC_SRC_THREADS_MTX_LOCK_H

libc/src/threads/mtx_unlock.h

//===-- Implementation header for mtx_unlock function -----------*- C++ -*-===// //===-- Implementation header for mtx_unlock function -----------*- 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_THREADS_MTX_UNLOCK_H #ifndef LLVM_LIBC_SRC_THREADS_MTX_UNLOCK_H
#define LLVM_LIBC_SRC_THREADS_MTX_UNLOCK_H #define LLVM_LIBC_SRC_THREADS_MTX_UNLOCK_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int mtx_unlock(mtx_t *mutex); int mtx_unlock(mtx_t *mutex) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_MTX_UNLOCK_H #endif // LLVM_LIBC_SRC_THREADS_MTX_UNLOCK_H

libc/src/threads/thrd_create.h

//===-- Implementation header for thrd_create function ----------*- C++ -*-===// //===-- Implementation header for thrd_create function ----------*- 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_THREADS_THRD_CREATE_H #ifndef LLVM_LIBC_SRC_THREADS_THRD_CREATE_H
#define LLVM_LIBC_SRC_THREADS_THRD_CREATE_H #define LLVM_LIBC_SRC_THREADS_THRD_CREATE_H
#include <threads.h> #include <threads.h>
namespace __llvm_libc { namespace __llvm_libc {
int thrd_create(thrd_t *thread, thrd_start_t func, void *arg); int thrd_create(thrd_t *thread, thrd_start_t func, void *arg) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_THRD_CREATE_H #endif // LLVM_LIBC_SRC_THREADS_THRD_CREATE_H

libc/src/threads/thrd_current.h

//===-- Implementation header for thrd_current function ---------*- C++ -*-===// //===-- Implementation header for thrd_current function ---------*- 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_THREADS_THRD_CURRENT_H #ifndef LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H
#define LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H #define LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
thrd_t thrd_current(); thrd_t thrd_current() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H #endif // LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H

libc/src/threads/thrd_detach.h

//===-- Implementation header for thrd_detach function ----------*- C++ -*-===// //===-- Implementation header for thrd_detach function ----------*- 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_THREADS_THRD_DETACH_H #ifndef LLVM_LIBC_SRC_THREADS_THRD_DETACH_H
#define LLVM_LIBC_SRC_THREADS_THRD_DETACH_H #define LLVM_LIBC_SRC_THREADS_THRD_DETACH_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int thrd_detach(thrd_t thread); int thrd_detach(thrd_t thread) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_THRD_DETACH_H #endif // LLVM_LIBC_SRC_THREADS_THRD_DETACH_H

libc/src/threads/thrd_equal.h

//===-- Implementation header for thrd_equal function -----------*- C++ -*-===// //===-- Implementation header for thrd_equal function -----------*- 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_THREADS_THRD_EQUAL_H #ifndef LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H
#define LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H #define LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int thrd_equal(thrd_t lhs, thrd_t rhs); int thrd_equal(thrd_t lhs, thrd_t rhs) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H #endif // LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H

libc/src/threads/thrd_exit.h

//===-- Implementation header for thrd_exit function ------------*- C++ -*-===// //===-- Implementation header for thrd_exit function ------------*- 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_THREADS_THRD_EXIT_H #ifndef LLVM_LIBC_SRC_THREADS_THRD_EXIT_H
#define LLVM_LIBC_SRC_THREADS_THRD_EXIT_H #define LLVM_LIBC_SRC_THREADS_THRD_EXIT_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
void thrd_exit(int retval); void thrd_exit(int retval) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_THRD_EXIT_H #endif // LLVM_LIBC_SRC_THREADS_THRD_EXIT_H

libc/src/threads/thrd_join.h

//===-- Implementation header for thrd_join function ------------*- C++ -*-===// //===-- Implementation header for thrd_join function ------------*- 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_THREADS_THRD_JOIN_H #ifndef LLVM_LIBC_SRC_THREADS_THRD_JOIN_H
#define LLVM_LIBC_SRC_THREADS_THRD_JOIN_H #define LLVM_LIBC_SRC_THREADS_THRD_JOIN_H
#include "include/threads.h" #include "include/threads.h"
namespace __llvm_libc { namespace __llvm_libc {
int thrd_join(thrd_t thread, int *retval); int thrd_join(thrd_t thread, int *retval) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_THRD_JOIN_H #endif // LLVM_LIBC_SRC_THREADS_THRD_JOIN_H

libc/src/threads/tss_create.h

//===-- Implementation header for tss_create --------------------*- C++ -*-===// //===-- Implementation header for tss_create --------------------*- 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_THREADS_TSS_CREATE_H #ifndef LLVM_LIBC_SRC_THREADS_TSS_CREATE_H
#define LLVM_LIBC_SRC_THREADS_TSS_CREATE_H #define LLVM_LIBC_SRC_THREADS_TSS_CREATE_H
#include <threads.h> #include <threads.h>
namespace __llvm_libc { namespace __llvm_libc {
int tss_create(tss_t *key, tss_dtor_t dtor); int tss_create(tss_t *key, tss_dtor_t dtor) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_TSS_CREATE_H #endif // LLVM_LIBC_SRC_THREADS_TSS_CREATE_H

libc/src/threads/tss_delete.h

//===-- Implementation header for tss_delete --------------------*- C++ -*-===// //===-- Implementation header for tss_delete --------------------*- 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_THREADS_TSS_DELETE_H #ifndef LLVM_LIBC_SRC_THREADS_TSS_DELETE_H
#define LLVM_LIBC_SRC_THREADS_TSS_DELETE_H #define LLVM_LIBC_SRC_THREADS_TSS_DELETE_H
#include <threads.h> #include <threads.h>
namespace __llvm_libc { namespace __llvm_libc {
void tss_delete(tss_t key); void tss_delete(tss_t key) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_TSS_DELETE_H #endif // LLVM_LIBC_SRC_THREADS_TSS_DELETE_H

libc/src/threads/tss_get.h

//===-- Implementation header for tss_get function --------------*- C++ -*-===// //===-- Implementation header for tss_get function --------------*- 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_THREADS_TSS_GET_H #ifndef LLVM_LIBC_SRC_THREADS_TSS_GET_H
#define LLVM_LIBC_SRC_THREADS_TSS_GET_H #define LLVM_LIBC_SRC_THREADS_TSS_GET_H
#include <pthread.h> #include <pthread.h>
namespace __llvm_libc { namespace __llvm_libc {
void *tss_get(pthread_key_t); void *tss_get(pthread_key_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_TSS_GET_H #endif // LLVM_LIBC_SRC_THREADS_TSS_GET_H

libc/src/threads/tss_set.h

//===-- Implementation header for tss_set function --------------*- C++ -*-===// //===-- Implementation header for tss_set function --------------*- 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_THREADS_TSS_SET_H #ifndef LLVM_LIBC_SRC_THREADS_TSS_SET_H
#define LLVM_LIBC_SRC_THREADS_TSS_SET_H #define LLVM_LIBC_SRC_THREADS_TSS_SET_H
#include <threads.h> #include <threads.h>
namespace __llvm_libc { namespace __llvm_libc {
int tss_set(tss_t, void *); int tss_set(tss_t, void *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_THREADS_TSS_SET_H #endif // LLVM_LIBC_SRC_THREADS_TSS_SET_H

libc/src/time/asctime.h

//===-- Implementation header of asctime ------------------------*- C++ -*-===// //===-- Implementation header of asctime ------------------------*- 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_TIME_ASCTIME_H #ifndef LLVM_LIBC_SRC_TIME_ASCTIME_H
#define LLVM_LIBC_SRC_TIME_ASCTIME_H #define LLVM_LIBC_SRC_TIME_ASCTIME_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
char *asctime(const struct tm *timeptr); char *asctime(const struct tm *timeptr) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_ASCTIME_H #endif // LLVM_LIBC_SRC_TIME_ASCTIME_H
#include "include/time.h" #include "include/time.h"

libc/src/time/asctime_r.h

//===-- Implementation header of asctime_r ----------------------*- C++ -*-===// //===-- Implementation header of asctime_r ----------------------*- 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_TIME_ASCTIME_R_H #ifndef LLVM_LIBC_SRC_TIME_ASCTIME_R_H
#define LLVM_LIBC_SRC_TIME_ASCTIME_R_H #define LLVM_LIBC_SRC_TIME_ASCTIME_R_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
char *asctime_r(const struct tm *timeptr, char *buffer); char *asctime_r(const struct tm *timeptr, char *buffer) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_ASCTIME_R_H #endif // LLVM_LIBC_SRC_TIME_ASCTIME_R_H
#include "include/time.h" #include "include/time.h"

libc/src/time/clock.h

//===-- Implementation header of clock --------------------------*- C++ -*-===// //===-- Implementation header of clock --------------------------*- 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_TIME_CLOCK_H #ifndef LLVM_LIBC_SRC_TIME_CLOCK_H
#define LLVM_LIBC_SRC_TIME_CLOCK_H #define LLVM_LIBC_SRC_TIME_CLOCK_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
clock_t clock(); clock_t clock() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_CLOCK_H #endif // LLVM_LIBC_SRC_TIME_CLOCK_H

libc/src/time/clock_gettime.h

//===-- Implementation header for clock_gettime function --------*- C++ -*-===// //===-- Implementation header for clock_gettime function --------*- 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_TIME_CLOCK_GETTIME_H #ifndef LLVM_LIBC_SRC_TIME_CLOCK_GETTIME_H
#define LLVM_LIBC_SRC_TIME_CLOCK_GETTIME_H #define LLVM_LIBC_SRC_TIME_CLOCK_GETTIME_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
int clock_gettime(clockid_t clockid, struct timespec *tp); int clock_gettime(clockid_t clockid, struct timespec *tp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_CLOCK_GETTIME_H #endif // LLVM_LIBC_SRC_TIME_CLOCK_GETTIME_H

libc/src/time/difftime.h

//===-- Implementation header of difftime -----------------------*- C++ -*-===// //===-- Implementation header of difftime -----------------------*- 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_TIME_DIFFTIME_H #ifndef LLVM_LIBC_SRC_TIME_DIFFTIME_H
#define LLVM_LIBC_SRC_TIME_DIFFTIME_H #define LLVM_LIBC_SRC_TIME_DIFFTIME_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
double difftime(time_t end, time_t beginning); double difftime(time_t end, time_t beginning) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_DIFFTIME_H #endif // LLVM_LIBC_SRC_TIME_DIFFTIME_H
#include "include/time.h" #include "include/time.h"

libc/src/time/gettimeofday.h

//===-- Implementation header of gettimeofday -------------------*- C++ -*-===// //===-- Implementation header of gettimeofday -------------------*- 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_TIME_GETTIMEOFDAY_H #ifndef LLVM_LIBC_SRC_TIME_GETTIMEOFDAY_H
#define LLVM_LIBC_SRC_TIME_GETTIMEOFDAY_H #define LLVM_LIBC_SRC_TIME_GETTIMEOFDAY_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
int gettimeofday(struct timeval *tv, void *tz); int gettimeofday(struct timeval *tv, void *tz) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_GETTIMEOFDAY_H #endif // LLVM_LIBC_SRC_TIME_GETTIMEOFDAY_H
#include "include/time.h" #include "include/time.h"

libc/src/time/gmtime.h

//===-- Implementation header of gmtime -------------------------*- C++ -*-===// //===-- Implementation header of gmtime -------------------------*- 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_TIME_GMTIME_H #ifndef LLVM_LIBC_SRC_TIME_GMTIME_H
#define LLVM_LIBC_SRC_TIME_GMTIME_H #define LLVM_LIBC_SRC_TIME_GMTIME_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
struct tm *gmtime(const time_t *timer); struct tm *gmtime(const time_t *timer) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_GMTIME_H #endif // LLVM_LIBC_SRC_TIME_GMTIME_H
#include "include/time.h" #include "include/time.h"

libc/src/time/gmtime_r.h

//===-- Implementation header of gmtime_r -----------------------*- C++ -*-===// //===-- Implementation header of gmtime_r -----------------------*- 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_TIME_GMTIME_R_H #ifndef LLVM_LIBC_SRC_TIME_GMTIME_R_H
#define LLVM_LIBC_SRC_TIME_GMTIME_R_H #define LLVM_LIBC_SRC_TIME_GMTIME_R_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
struct tm *gmtime_r(const time_t *timer, struct tm *result); struct tm *gmtime_r(const time_t *timer, struct tm *result) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_GMTIME_R_H #endif // LLVM_LIBC_SRC_TIME_GMTIME_R_H
#include "include/time.h" #include "include/time.h"

libc/src/time/mktime.h

//===-- Implementation header of mktime -------------------------*- C++ -*-===// //===-- Implementation header of mktime -------------------------*- 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_TIME_MKTIME_H #ifndef LLVM_LIBC_SRC_TIME_MKTIME_H
#define LLVM_LIBC_SRC_TIME_MKTIME_H #define LLVM_LIBC_SRC_TIME_MKTIME_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
time_t mktime(struct tm *t1); time_t mktime(struct tm *t1) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_MKTIME_H #endif // LLVM_LIBC_SRC_TIME_MKTIME_H
#include "include/time.h" #include "include/time.h"

libc/src/time/nanosleep.h

//===-- Implementation header of nanosleep -------------------------*- C++ //===-- Implementation header of nanosleep -------------------------*- 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_TIME_NANOSLEEP_H #ifndef LLVM_LIBC_SRC_TIME_NANOSLEEP_H
#define LLVM_LIBC_SRC_TIME_NANOSLEEP_H #define LLVM_LIBC_SRC_TIME_NANOSLEEP_H
#include <time.h> #include <time.h>
namespace __llvm_libc { namespace __llvm_libc {
int nanosleep(const struct timespec *req, struct timespec *rem); int nanosleep(const struct timespec *req, struct timespec *rem) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_NANOSLEEP_H #endif // LLVM_LIBC_SRC_TIME_NANOSLEEP_H
#include "include/time.h" #include "include/time.h"

libc/src/time/time_func.h

Show All 9 Lines
#define LLVM_LIBC_SRC_TIME_TIME_FUNC_H #define LLVM_LIBC_SRC_TIME_TIME_FUNC_H
#include <time.h> #include <time.h>
// Note this header file is named time_func.h to avoid conflicts with the // Note this header file is named time_func.h to avoid conflicts with the
// public header file time.h. // public header file time.h.
namespace __llvm_libc { namespace __llvm_libc {
time_t time(time_t *tp); time_t time(time_t *tp) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_TIME_TIME_FUNC_H #endif // LLVM_LIBC_SRC_TIME_TIME_FUNC_H

libc/src/unistd/access.h

//===-- Implementation header for access ------------------------*- C++ -*-===// //===-- Implementation header for access ------------------------*- 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_UNISTD_ACCESS_H #ifndef LLVM_LIBC_SRC_UNISTD_ACCESS_H
#define LLVM_LIBC_SRC_UNISTD_ACCESS_H #define LLVM_LIBC_SRC_UNISTD_ACCESS_H
namespace __llvm_libc { namespace __llvm_libc {
int access(const char *path, int mode); int access(const char *path, int mode) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_ACCESS_H #endif // LLVM_LIBC_SRC_UNISTD_ACCESS_H

libc/src/unistd/chdir.h

//===-- Implementation header for chdir -------------------------*- C++ -*-===// //===-- Implementation header for chdir -------------------------*- 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_UNISTD_CHDIR_H #ifndef LLVM_LIBC_SRC_UNISTD_CHDIR_H
#define LLVM_LIBC_SRC_UNISTD_CHDIR_H #define LLVM_LIBC_SRC_UNISTD_CHDIR_H
namespace __llvm_libc { namespace __llvm_libc {
int chdir(const char *path); int chdir(const char *path) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_CHDIR_H #endif // LLVM_LIBC_SRC_UNISTD_CHDIR_H

libc/src/unistd/close.h

//===-- Implementation header for close -------------------------*- C++ -*-===// //===-- Implementation header for close -------------------------*- 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_UNISTD_CLOSE_H #ifndef LLVM_LIBC_SRC_UNISTD_CLOSE_H
#define LLVM_LIBC_SRC_UNISTD_CLOSE_H #define LLVM_LIBC_SRC_UNISTD_CLOSE_H
namespace __llvm_libc { namespace __llvm_libc {
int close(int fd); int close(int fd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_CLOSE_H #endif // LLVM_LIBC_SRC_UNISTD_CLOSE_H

libc/src/unistd/dup.h

//===-- Implementation header for dup ---------------------------*- C++ -*-===// //===-- Implementation header for dup ---------------------------*- 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_UNISTD_DUP_H #ifndef LLVM_LIBC_SRC_UNISTD_DUP_H
#define LLVM_LIBC_SRC_UNISTD_DUP_H #define LLVM_LIBC_SRC_UNISTD_DUP_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int dup(int fd); int dup(int fd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_DUP_H #endif // LLVM_LIBC_SRC_UNISTD_DUP_H

libc/src/unistd/dup2.h

//===-- Implementation header for dup2 --------------------------*- C++ -*-===// //===-- Implementation header for dup2 --------------------------*- 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_UNISTD_DUP2_H #ifndef LLVM_LIBC_SRC_UNISTD_DUP2_H
#define LLVM_LIBC_SRC_UNISTD_DUP2_H #define LLVM_LIBC_SRC_UNISTD_DUP2_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int dup2(int oldfd, int newfd); int dup2(int oldfd, int newfd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_DUP2_H #endif // LLVM_LIBC_SRC_UNISTD_DUP2_H

libc/src/unistd/dup3.h

//===-- Implementation header for dup3 --------------------------*- C++ -*-===// //===-- Implementation header for dup3 --------------------------*- 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_UNISTD_DUP3_H #ifndef LLVM_LIBC_SRC_UNISTD_DUP3_H
#define LLVM_LIBC_SRC_UNISTD_DUP3_H #define LLVM_LIBC_SRC_UNISTD_DUP3_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int dup3(int oldfd, int newfd, int flags); int dup3(int oldfd, int newfd, int flags) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_DUP3_H #endif // LLVM_LIBC_SRC_UNISTD_DUP3_H

libc/src/unistd/execv.h

//===-- Implementation header for execv -------------------------*- C++ -*-===// //===-- Implementation header for execv -------------------------*- 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_UNISTD_EXECV_H #ifndef LLVM_LIBC_SRC_UNISTD_EXECV_H
#define LLVM_LIBC_SRC_UNISTD_EXECV_H #define LLVM_LIBC_SRC_UNISTD_EXECV_H
namespace __llvm_libc { namespace __llvm_libc {
int execv(const char *path, char *const argv[]); int execv(const char *path, char *const argv[]) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_EXECV_H #endif // LLVM_LIBC_SRC_UNISTD_EXECV_H

libc/src/unistd/execve.h

//===-- Implementation header for execve ------------------------*- C++ -*-===// //===-- Implementation header for execve ------------------------*- 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_UNISTD_EXECVE_H #ifndef LLVM_LIBC_SRC_UNISTD_EXECVE_H
#define LLVM_LIBC_SRC_UNISTD_EXECVE_H #define LLVM_LIBC_SRC_UNISTD_EXECVE_H
namespace __llvm_libc { namespace __llvm_libc {
int execve(const char *path, char *const argv[], char *const envp[]); int execve(const char *path, char *const argv[], char *const envp[]) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_EXECVE_H #endif // LLVM_LIBC_SRC_UNISTD_EXECVE_H

libc/src/unistd/fchdir.h

//===-- Implementation header for fchdir ------------------------*- C++ -*-===// //===-- Implementation header for fchdir ------------------------*- 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_UNISTD_FCHDIR_H #ifndef LLVM_LIBC_SRC_UNISTD_FCHDIR_H
#define LLVM_LIBC_SRC_UNISTD_FCHDIR_H #define LLVM_LIBC_SRC_UNISTD_FCHDIR_H
namespace __llvm_libc { namespace __llvm_libc {
int fchdir(int fd); int fchdir(int fd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_FCHDIR_H #endif // LLVM_LIBC_SRC_UNISTD_FCHDIR_H

libc/src/unistd/fork.h

//===-- Implementation header for fork --------------------------*- C++ -*-===// //===-- Implementation header for fork --------------------------*- 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_UNISTD_FORK_H #ifndef LLVM_LIBC_SRC_UNISTD_FORK_H
#define LLVM_LIBC_SRC_UNISTD_FORK_H #define LLVM_LIBC_SRC_UNISTD_FORK_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
pid_t fork(); pid_t fork() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_FORK_H #endif // LLVM_LIBC_SRC_UNISTD_FORK_H

libc/src/unistd/fsync.h

//===-- Implementation header for fsync -------------------------*- C++ -*-===// //===-- Implementation header for fsync -------------------------*- 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_UNISTD_FSYNC_H #ifndef LLVM_LIBC_SRC_UNISTD_FSYNC_H
#define LLVM_LIBC_SRC_UNISTD_FSYNC_H #define LLVM_LIBC_SRC_UNISTD_FSYNC_H
namespace __llvm_libc { namespace __llvm_libc {
int fsync(int fd); int fsync(int fd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_FSYNC_H #endif // LLVM_LIBC_SRC_UNISTD_FSYNC_H

libc/src/unistd/ftruncate.h

//===-- Implementation header for ftruncate ---------------------*- C++ -*-===// //===-- Implementation header for ftruncate ---------------------*- 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_UNISTD_FTRUNCATE_H #ifndef LLVM_LIBC_SRC_UNISTD_FTRUNCATE_H
#define LLVM_LIBC_SRC_UNISTD_FTRUNCATE_H #define LLVM_LIBC_SRC_UNISTD_FTRUNCATE_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int ftruncate(int, off_t); int ftruncate(int, off_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_FTRUNCATE_H #endif // LLVM_LIBC_SRC_UNISTD_FTRUNCATE_H

libc/src/unistd/getcwd.h

//===-- Implementation header for getcwd ------------------------*- C++ -*-===// //===-- Implementation header for getcwd ------------------------*- 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_UNISTD_GETCWD_H #ifndef LLVM_LIBC_SRC_UNISTD_GETCWD_H
#define LLVM_LIBC_SRC_UNISTD_GETCWD_H #define LLVM_LIBC_SRC_UNISTD_GETCWD_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
char *getcwd(char *buf, size_t size); char *getcwd(char *buf, size_t size) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_GETCWD_H #endif // LLVM_LIBC_SRC_UNISTD_GETCWD_H

libc/src/unistd/geteuid.h

//===-- Implementation header for geteuid -----------------------*- C++ -*-===// //===-- Implementation header for geteuid -----------------------*- 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_UNISTD_GETEUID_H #ifndef LLVM_LIBC_SRC_UNISTD_GETEUID_H
#define LLVM_LIBC_SRC_UNISTD_GETEUID_H #define LLVM_LIBC_SRC_UNISTD_GETEUID_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
uid_t geteuid(); uid_t geteuid() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_GETEUID_H #endif // LLVM_LIBC_SRC_UNISTD_GETEUID_H

libc/src/unistd/getopt.h

Show All 9 Lines
#define LLVM_LIBC_SRC_UNISTD_GETOPT_H #define LLVM_LIBC_SRC_UNISTD_GETOPT_H
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
namespace impl { namespace impl {
void set_getopt_state(char **, int *, int *, unsigned *, int, FILE *); void set_getopt_state(char **, int *, int *, unsigned *, int, FILE *) noexcept;
} }
int getopt(int argc, char *const argv[], const char *optstring); int getopt(int argc, char *const argv[], const char *optstring) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_GETOPT_H #endif // LLVM_LIBC_SRC_UNISTD_GETOPT_H

libc/src/unistd/getopt.cpp

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
static GetoptContext ctx{ static GetoptContext ctx{
&impl::optarg, &impl::optind, &impl::optarg, &impl::optind,
&impl::optopt, &optpos, &impl::optopt, &optpos,
impl::opterr, reinterpret_cast<FILE *>(__llvm_libc::stderr)}; impl::opterr, reinterpret_cast<FILE *>(__llvm_libc::stderr)};
#ifndef LLVM_LIBC_PUBLIC_PACKAGING #ifndef LLVM_LIBC_PUBLIC_PACKAGING
// This is used exclusively in tests. // This is used exclusively in tests.
void set_getopt_state(char **optarg, int *optind, int *optopt, unsigned *optpos, void set_getopt_state(char **optarg, int *optind, int *optopt, unsigned *optpos,
int opterr, FILE *errstream) { int opterr, FILE *errstream) noexcept {
ctx = {optarg, optind, optopt, optpos, opterr, errstream}; ctx = {optarg, optind, optopt, optpos, opterr, errstream};
} }
#endif #endif
} // namespace impl } // namespace impl
LLVM_LIBC_FUNCTION(int, getopt, LLVM_LIBC_FUNCTION(int, getopt,
(int argc, char *const argv[], const char *optstring)) { (int argc, char *const argv[], const char *optstring)) {
return getopt_r(argc, argv, optstring, impl::ctx); return getopt_r(argc, argv, optstring, impl::ctx);
} }
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/unistd/getpid.h

//===-- Implementation header for getpid ------------------------*- C++ -*-===// //===-- Implementation header for getpid ------------------------*- 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_UNISTD_GETPID_H #ifndef LLVM_LIBC_SRC_UNISTD_GETPID_H
#define LLVM_LIBC_SRC_UNISTD_GETPID_H #define LLVM_LIBC_SRC_UNISTD_GETPID_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
pid_t getpid(); pid_t getpid() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_GETPID_H #endif // LLVM_LIBC_SRC_UNISTD_GETPID_H

libc/src/unistd/getppid.h

//===-- Implementation header for getppid -----------------------*- C++ -*-===// //===-- Implementation header for getppid -----------------------*- 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_UNISTD_GETPPID_H #ifndef LLVM_LIBC_SRC_UNISTD_GETPPID_H
#define LLVM_LIBC_SRC_UNISTD_GETPPID_H #define LLVM_LIBC_SRC_UNISTD_GETPPID_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
pid_t getppid(); pid_t getppid() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_GETPPID_H #endif // LLVM_LIBC_SRC_UNISTD_GETPPID_H

libc/src/unistd/getuid.h

//===-- Implementation header for getuid ------------------------*- C++ -*-===// //===-- Implementation header for getuid ------------------------*- 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_UNISTD_GETUID_H #ifndef LLVM_LIBC_SRC_UNISTD_GETUID_H
#define LLVM_LIBC_SRC_UNISTD_GETUID_H #define LLVM_LIBC_SRC_UNISTD_GETUID_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
uid_t getuid(); uid_t getuid() noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_GETUID_H #endif // LLVM_LIBC_SRC_UNISTD_GETUID_H

libc/src/unistd/isatty.h

//===-- Implementation header for isatty ------------------------*- C++ -*-===// //===-- Implementation header for isatty ------------------------*- 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_UNISTD_ISATTY_H #ifndef LLVM_LIBC_SRC_UNISTD_ISATTY_H
#define LLVM_LIBC_SRC_UNISTD_ISATTY_H #define LLVM_LIBC_SRC_UNISTD_ISATTY_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int isatty(int fd); int isatty(int fd) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_ISATTY_H #endif // LLVM_LIBC_SRC_UNISTD_ISATTY_H

libc/src/unistd/link.h

//===-- Implementation header for link --------------------------*- C++ -*-===// //===-- Implementation header for link --------------------------*- 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_UNISTD_LINK_H #ifndef LLVM_LIBC_SRC_UNISTD_LINK_H
#define LLVM_LIBC_SRC_UNISTD_LINK_H #define LLVM_LIBC_SRC_UNISTD_LINK_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int link(const char *, const char *); int link(const char *, const char *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_LINK_H #endif // LLVM_LIBC_SRC_UNISTD_LINK_H

libc/src/unistd/linkat.h

//===-- Implementation header for linkat ------------------------*- C++ -*-===// //===-- Implementation header for linkat ------------------------*- 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_UNISTD_LINKAT_H #ifndef LLVM_LIBC_SRC_UNISTD_LINKAT_H
#define LLVM_LIBC_SRC_UNISTD_LINKAT_H #define LLVM_LIBC_SRC_UNISTD_LINKAT_H
namespace __llvm_libc { namespace __llvm_libc {
int linkat(int, const char *, int, const char *, int); int linkat(int, const char *, int, const char *, int) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_LINKAT_H #endif // LLVM_LIBC_SRC_UNISTD_LINKAT_H

libc/src/unistd/lseek.h

//===-- Implementation header for lseek -------------------------*- C++ -*-===// //===-- Implementation header for lseek -------------------------*- 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_UNISTD_LSEEK_H #ifndef LLVM_LIBC_SRC_UNISTD_LSEEK_H
#define LLVM_LIBC_SRC_UNISTD_LSEEK_H #define LLVM_LIBC_SRC_UNISTD_LSEEK_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
off_t lseek(int fd, off_t offset, int whence); off_t lseek(int fd, off_t offset, int whence) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_LSEEK_H #endif // LLVM_LIBC_SRC_UNISTD_LSEEK_H

libc/src/unistd/pread.h

//===-- Implementation header for pread -------------------------*- C++ -*-===// //===-- Implementation header for pread -------------------------*- 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_UNISTD_PREAD_H #ifndef LLVM_LIBC_SRC_UNISTD_PREAD_H
#define LLVM_LIBC_SRC_UNISTD_PREAD_H #define LLVM_LIBC_SRC_UNISTD_PREAD_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
ssize_t pread(int fd, void *buf, size_t count, off_t offset); ssize_t pread(int fd, void *buf, size_t count, off_t offset) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_PREAD_H #endif // LLVM_LIBC_SRC_UNISTD_PREAD_H

libc/src/unistd/pwrite.h

//===-- Implementation header for pwrite ------------------------*- C++ -*-===// //===-- Implementation header for pwrite ------------------------*- 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_UNISTD_PWRITE_H #ifndef LLVM_LIBC_SRC_UNISTD_PWRITE_H
#define LLVM_LIBC_SRC_UNISTD_PWRITE_H #define LLVM_LIBC_SRC_UNISTD_PWRITE_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset); ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_PWRITE_H #endif // LLVM_LIBC_SRC_UNISTD_PWRITE_H

libc/src/unistd/read.h

//===-- Implementation header for read --------------------------*- C++ -*-===// //===-- Implementation header for read --------------------------*- 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_UNISTD_READ_H #ifndef LLVM_LIBC_SRC_UNISTD_READ_H
#define LLVM_LIBC_SRC_UNISTD_READ_H #define LLVM_LIBC_SRC_UNISTD_READ_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
ssize_t read(int fd, void *buf, size_t count); ssize_t read(int fd, void *buf, size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_READ_H #endif // LLVM_LIBC_SRC_UNISTD_READ_H

libc/src/unistd/readlink.h

//===-- Implementation header for readlink ----------------------*- C++ -*-===// //===-- Implementation header for readlink ----------------------*- 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_UNISTD_READLINK_H #ifndef LLVM_LIBC_SRC_UNISTD_READLINK_H
#define LLVM_LIBC_SRC_UNISTD_READLINK_H #define LLVM_LIBC_SRC_UNISTD_READLINK_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
ssize_t readlink(const char *__restrict, char *__restrict, size_t); ssize_t readlink(const char *__restrict, char *__restrict, size_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_READLINK_H #endif // LLVM_LIBC_SRC_UNISTD_READLINK_H

libc/src/unistd/readlinkat.h

//===-- Implementation header for readlinkat --------------------*- C++ -*-===// //===-- Implementation header for readlinkat --------------------*- 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_UNISTD_READLINKAT_H #ifndef LLVM_LIBC_SRC_UNISTD_READLINKAT_H
#define LLVM_LIBC_SRC_UNISTD_READLINKAT_H #define LLVM_LIBC_SRC_UNISTD_READLINKAT_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
ssize_t readlinkat(int, const char *__restrict, char *__restrict, size_t); ssize_t readlinkat(int, const char *__restrict, char *__restrict,
size_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_READLINKAT_H #endif // LLVM_LIBC_SRC_UNISTD_READLINKAT_H

libc/src/unistd/rmdir.h

//===-- Implementation header for rmdir -------------------------*- C++ -*-===// //===-- Implementation header for rmdir -------------------------*- 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_UNISTD_RMDIR_H #ifndef LLVM_LIBC_SRC_UNISTD_RMDIR_H
#define LLVM_LIBC_SRC_UNISTD_RMDIR_H #define LLVM_LIBC_SRC_UNISTD_RMDIR_H
namespace __llvm_libc { namespace __llvm_libc {
int rmdir(const char *path); int rmdir(const char *path) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_RMDIR_H #endif // LLVM_LIBC_SRC_UNISTD_RMDIR_H

libc/src/unistd/symlink.h

//===-- Implementation header for symlink -----------------------*- C++ -*-===// //===-- Implementation header for symlink -----------------------*- 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_UNISTD_SYMLINK_H #ifndef LLVM_LIBC_SRC_UNISTD_SYMLINK_H
#define LLVM_LIBC_SRC_UNISTD_SYMLINK_H #define LLVM_LIBC_SRC_UNISTD_SYMLINK_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int symlink(const char *, const char *); int symlink(const char *, const char *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_SYMLINK_H #endif // LLVM_LIBC_SRC_UNISTD_SYMLINK_H

libc/src/unistd/symlinkat.h

//===-- Implementation header for symlinkat ---------------------*- C++ -*-===// //===-- Implementation header for symlinkat ---------------------*- 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_UNISTD_SYMLINKAT_H #ifndef LLVM_LIBC_SRC_UNISTD_SYMLINKAT_H
#define LLVM_LIBC_SRC_UNISTD_SYMLINKAT_H #define LLVM_LIBC_SRC_UNISTD_SYMLINKAT_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int symlinkat(const char *, int, const char *); int symlinkat(const char *, int, const char *) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_SYMLINKAT_H #endif // LLVM_LIBC_SRC_UNISTD_SYMLINKAT_H

libc/src/unistd/syscall.h

Show All 9 Lines
#define LLVM_LIBC_SRC_UNISTD_SYSCALL_H #define LLVM_LIBC_SRC_UNISTD_SYSCALL_H
#include <stdarg.h> #include <stdarg.h>
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
long __llvm_libc_syscall(long number, long arg1, long arg2, long arg3, long __llvm_libc_syscall(long number, long arg1, long arg2, long arg3,
long arg4, long arg5, long arg6); long arg4, long arg5, long arg6) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_SYSCALL_H #endif // LLVM_LIBC_SRC_UNISTD_SYSCALL_H

libc/src/unistd/sysconf.h

//===-- Implementation header for sysconf -----------------------*- C++ -*-===// //===-- Implementation header for sysconf -----------------------*- 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_UNISTD_SYSCONF_H #ifndef LLVM_LIBC_SRC_UNISTD_SYSCONF_H
#define LLVM_LIBC_SRC_UNISTD_SYSCONF_H #define LLVM_LIBC_SRC_UNISTD_SYSCONF_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
long sysconf(int name); long sysconf(int name) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_SYSCONF_H #endif // LLVM_LIBC_SRC_UNISTD_SYSCONF_H

libc/src/unistd/truncate.h

//===-- Implementation header for truncate ----------------------*- C++ -*-===// //===-- Implementation header for truncate ----------------------*- 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_UNISTD_TRUNCATE_H #ifndef LLVM_LIBC_SRC_UNISTD_TRUNCATE_H
#define LLVM_LIBC_SRC_UNISTD_TRUNCATE_H #define LLVM_LIBC_SRC_UNISTD_TRUNCATE_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
int truncate(const char *, off_t); int truncate(const char *, off_t) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_TRUNCATE_H #endif // LLVM_LIBC_SRC_UNISTD_TRUNCATE_H

libc/src/unistd/unlink.h

//===-- Implementation header for unlink ------------------------*- C++ -*-===// //===-- Implementation header for unlink ------------------------*- 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_UNISTD_UNLINK_H #ifndef LLVM_LIBC_SRC_UNISTD_UNLINK_H
#define LLVM_LIBC_SRC_UNISTD_UNLINK_H #define LLVM_LIBC_SRC_UNISTD_UNLINK_H
namespace __llvm_libc { namespace __llvm_libc {
int unlink(const char *path); int unlink(const char *path) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_UNLINK_H #endif // LLVM_LIBC_SRC_UNISTD_UNLINK_H

libc/src/unistd/unlinkat.h

//===-- Implementation header for unlinkat ----------------------*- C++ -*-===// //===-- Implementation header for unlinkat ----------------------*- 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_UNISTD_UNLINKAT_H #ifndef LLVM_LIBC_SRC_UNISTD_UNLINKAT_H
#define LLVM_LIBC_SRC_UNISTD_UNLINKAT_H #define LLVM_LIBC_SRC_UNISTD_UNLINKAT_H
namespace __llvm_libc { namespace __llvm_libc {
int unlinkat(int dfd, const char *path, int flags); int unlinkat(int dfd, const char *path, int flags) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_UNLINKAT_H #endif // LLVM_LIBC_SRC_UNISTD_UNLINKAT_H

libc/src/unistd/write.h

//===-- Implementation header for write -------------------------*- C++ -*-===// //===-- Implementation header for write -------------------------*- 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_UNISTD_WRITE_H #ifndef LLVM_LIBC_SRC_UNISTD_WRITE_H
#define LLVM_LIBC_SRC_UNISTD_WRITE_H #define LLVM_LIBC_SRC_UNISTD_WRITE_H
#include <unistd.h> #include <unistd.h>
namespace __llvm_libc { namespace __llvm_libc {
ssize_t write(int fd, const void *buf, size_t count); ssize_t write(int fd, const void *buf, size_t count) noexcept;
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_UNISTD_WRITE_H #endif // LLVM_LIBC_SRC_UNISTD_WRITE_H