[libc][NFC] Add a few compiler warning flags.

[sivachandra]

Summary

A bunch of cleanup to supress the new warnings is also done.

[abrachet]

Thanks this will reduce some churn for me in the future :)

[sivachandra]

Rebase

libc/cmake/modules/LLVMLibCObjectRules.cmake

function(_get_common_compile_options output_var flags)
   if(${round} LESS 0)
     list(FIND flags "${ROUND_OPT_FLAG}__ONLY" round)
   endif()
   if((${round} GREATER -1) AND (LIBC_CPU_FEATURES MATCHES "SSE4_2"))
     set(ADD_SSE4_2_FLAG TRUE)
   endif()
 
   set(compile_options ${LIBC_COMPILE_OPTIONS_DEFAULT} ${ARGN})
-  if(NOT ${LIBC_TARGET_OS} STREQUAL "windows")
-    set(compile_options ${compile_options} -fpie -ffreestanding -fno-builtin)
-  endif()
   if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
+    list(APPEND compile_options "-fpie")
+    list(APPEND compile_options "-ffreestanding")
+    list(APPEND compile_options "-fno-builtin")
     list(APPEND compile_options "-fno-exceptions")
     list(APPEND compile_options "-fno-unwind-tables")
     list(APPEND compile_options "-fno-asynchronous-unwind-tables")
     list(APPEND compile_options "-fno-rtti")
+    list(APPEND compile_options "-Wall")
+    list(APPEND compile_options "-Wextra")
+    list(APPEND compile_options "-Wimplicit-fallthrough")
+    list(APPEND compile_options "-Wwrite-strings")
+    list(APPEND compile_options "-Wextra-semi")
+    list(APPEND compile_options "-Wstrict-prototypes")
+    if(NOT CMAKE_COMPILER_IS_GNUCXX)
+      list(APPEND compile_options "-Wnewline-eof")
+      list(APPEND compile_options "-Wnonportable-system-include-path")
+      list(APPEND compile_options "-Wthread-safety")
+    endif()
     if(ADD_FMA_FLAG)
       list(APPEND compile_options "-mfma")
     endif()
     if(ADD_SSE4_2_FLAG)
       list(APPEND compile_options "-msse4.2")
     endif()
   elseif(MSVC)
     list(APPEND compile_options "/EHs-c-")

libc/src/__support/CPP/stringstream.h

public:
   // Write the |val| as string.
   template <typename T, enable_if_t<is_integral_v<T>, int> = 0>
   StringStream &operator<<(T val) {
     const auto int_to_str = integer_to_string(val);
     return operator<<(int_to_str.str());
   }
 
   template <typename T, enable_if_t<is_floating_point_v<T>, int> = 0>
-  StringStream &operator<<(T val) {
+  StringStream &operator<<(T) {
     // If this specialization gets activated, then the static_assert will
     // trigger a compile error about missing floating point number support.
     static_assert(!is_floating_point_v<T>,
                   "Writing floating point numbers is not yet supported");
     return *this;
   }
 
   // Write a null-terminated string. The terminating null character is not

libc/src/__support/FPUtil/PolyEval.h

 // evaluated it as:  a_0 + x * (a_1 + x * ( ... (a_(n-1) + x * a_n) ... ) ) ).
 // We will use FMA instructions if available.
 // Example: to evaluate x^3 + 2*x^2 + 3*x + 4, call
 //   polyeval( x, 4.0, 3.0, 2.0, 1.0 )
 
 namespace __llvm_libc {
 namespace fputil {
 
-template <typename T> static inline T polyeval(T x, T a0) { return a0; }
+template <typename T> static inline T polyeval(T, T a0) { return a0; }
 
 template <typename T, typename... Ts>
 static inline T polyeval(T x, T a0, Ts... a) {
   return multiply_add(x, polyeval(x, a...), a0);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_POLYEVAL_H

libc/src/__support/str_to_float.h

 static inline uint64_t low64(const UInt128 &num) {
   return static_cast<uint64_t>(num & 0xffffffffffffffff);
 }
 
 static inline uint64_t high64(const UInt128 &num) {
   return static_cast<uint64_t>(num >> 64);
 }
 
-template <class T> inline void set_implicit_bit(fputil::FPBits<T> &result) {
-  return;
-}
+template <class T> inline void set_implicit_bit(fputil::FPBits<T> &) { return; }
 
 #if defined(SPECIAL_X86_LONG_DOUBLE)
 template <>
 inline void set_implicit_bit<long double>(fputil::FPBits<long double> &result) {
   result.set_implicit_bit(result.get_unbiased_exponent() != 0);
 }
 #endif
 

libc/src/pthread/pthread_attr_destroy.cpp

 //===-- Implementation of the pthread_attr_destroy ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "pthread_attr_destroy.h"
 
 #include "src/__support/common.h"
 
 #include <pthread.h>
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(int, pthread_attr_destroy, (pthread_attr_t * attr)) {
+LLVM_LIBC_FUNCTION(int, pthread_attr_destroy, (pthread_attr_t *)) {
   // There is nothing to cleanup.
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/pthread/pthread_create.cpp

 #include <pthread.h> // For pthread_* type definitions.
 
 namespace __llvm_libc {
 
 static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
               "Mismatch between pthread_t and internal Thread.");
 
 LLVM_LIBC_FUNCTION(int, pthread_create,
-                   (pthread_t *__restrict th,
-                    const pthread_attr_t *__restrict attr,
+                   (pthread_t *__restrict th, const pthread_attr_t *__restrict,
                     __pthread_start_t func, void *arg)) {
   auto *thread = reinterpret_cast<__llvm_libc::Thread *>(th);
+  // TODO: Use the attributes parameter to set up thread properties.
   int result = thread->run(func, arg, nullptr, 0);
   if (result != 0 && result != EPERM)
     return EAGAIN;
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/pthread/pthread_mutexattr_destroy.cpp

 #include "pthread_mutexattr.h"
 
 #include "src/__support/common.h"
 
 #include <errno.h>
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(int, pthread_mutexattr_destroy,
-                   (pthread_mutexattr_t * attr)) {
+LLVM_LIBC_FUNCTION(int, pthread_mutexattr_destroy, (pthread_mutexattr_t *)) {
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fopencookie.cpp

 
 int close_func(File *f) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.close == nullptr)
     return 0;
   return cookie_file->ops.close(cookie_file->cookie);
 }
 
-int flush_func(File *f) { return 0; }
+int flush_func(File *) { return 0; }
 
 } // anonymous namespace
 
 LLVM_LIBC_FUNCTION(::FILE *, fopencookie,
                    (void *cookie, const char *mode,
                     cookie_io_functions_t ops)) {
   auto modeflags = File::mode_flags(mode);
   void *buffer = malloc(File::DEFAULT_BUFFER_SIZE);

libc/src/string/memory_utils/elements.h

template <typename Element, size_t ElementCount> struct Repeated {
   }
 
   static void store(char *ptr, Storage<Repeated> value) {
     copy(ptr, reinterpret_cast<const char *>(&value));
   }
 };
 
 template <typename Element> struct Repeated<Element, 0> {
-  static void move(char *dst, const char *src) {}
+  static void move(char *, const char *) {}
 };
 
 // Chain the operation of several types.
 // For instance, to handle a 3 bytes operation, one can use:
 // Chained<UINT16, UINT8>::Operation();
 template <typename... Types> struct Chained;
 
 template <typename Head, typename... Tail> struct Chained<Head, Tail...> {
template <typename Head, typename... Tail> struct Chained<Head, Tail...> {
   static void splat_set(char *dst, const unsigned char value) {
     Chained<Tail...>::splat_set(dst + Head::SIZE, value);
     __llvm_libc::splat_set<Head>(dst, value);
   }
 };
 
 template <> struct Chained<> {
   static constexpr size_t SIZE = 0;
-  static void copy(char *__restrict dst, const char *__restrict src) {}
-  static void move(char *dst, const char *src) {}
-  static bool equals(const char *lhs, const char *rhs) { return true; }
-  static int three_way_compare(const char *lhs, const char *rhs) { return 0; }
-  static void splat_set(char *dst, const unsigned char value) {}
+  static void copy(char *__restrict, const char *__restrict) {}
+  static void move(char *, const char *) {}
+  static bool equals(const char *, const char *) { return true; }
+  static int three_way_compare(const char *, const char *) { return 0; }
+  static void splat_set(char *, const unsigned char) {}
 };
 
 // Overlap ElementA and ElementB so they span Size bytes.
 template <size_t Size, typename ElementA, typename ElementB = ElementA>
 struct Overlap {
   static constexpr size_t SIZE = Size;
   static_assert(ElementB::SIZE <= ElementA::SIZE, "ElementB too big");
   static_assert(ElementA::SIZE <= Size, "ElementA too big");

 enum class Arg { _1, _2, Dst = _1, Src = _2, Lhs = _1, Rhs = _2 };
 
 namespace internal {
 
 template <Arg arg> struct ArgSelector {};
 
 template <> struct ArgSelector<Arg::_1> {
   template <typename T1, typename T2>
-  static T1 *__restrict &Select(T1 *__restrict &p1ref, T2 *__restrict &p2ref) {
+  static T1 *__restrict &Select(T1 *__restrict &p1ref, T2 *__restrict &) {
     return p1ref;
   }
 };
 
 template <> struct ArgSelector<Arg::_2> {
   template <typename T1, typename T2>
-  static T2 *__restrict &Select(T1 *__restrict &p1ref, T2 *__restrict &p2ref) {
+  static T2 *__restrict &Select(T1 *__restrict &, T2 *__restrict &p2ref) {
     return p2ref;
   }
 };
 
 // Provides a specialized bump function that adjusts pointers and size so first
 // argument (resp. second argument) gets aligned to Alignment.
 // We make sure the compiler knows about the adjusted pointer alignment.
 // The 'additional_bumps' parameter allows to reach previous / next aligned

libc/src/threads/mtx_destroy.cpp

 //===-- Linux implementation of the mtx_destroy function ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/threads/mtx_destroy.h"
 #include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
 #include "src/__support/threads/mutex.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(void, mtx_destroy, (mtx_t * mutex)) {}
+LLVM_LIBC_FUNCTION(void, mtx_destroy, (mtx_t *)) {}
 
 } // namespace __llvm_libc

libc/test/src/time/asctime_test.cpp

TEST(LlvmLibcAsctime, Nullptr) {
   result = __llvm_libc::asctime(nullptr);
   ASSERT_EQ(EINVAL, llvmlibc_errno);
   ASSERT_STREQ(nullptr, result);
 }
 
 // Weekdays are in the range 0 to 6. Test passing invalid value in wday.
 TEST(LlvmLibcAsctime, InvalidWday) {
   struct tm tm_data;
-  char *result;
 
   // Test with wday = -1.
-  result = call_asctime(&tm_data,
-                        1970, // year
-                        1,    // month
-                        1,    // day
-                        0,    // hr
-                        0,    // min
-                        0,    // sec
-                        -1,   // wday
-                        0);   // yday
+  call_asctime(&tm_data,
   ASSERT_EQ(EINVAL, llvmlibc_errno);
 
   // Test with wday = 7.
-  result = call_asctime(&tm_data,
-                        1970, // year
-                        1,    // month
-                        1,    // day
-                        0,    // hr
-                        0,    // min
-                        0,    // sec
-                        7,    // wday
-                        0);   // yday
+  call_asctime(&tm_data,
   ASSERT_EQ(EINVAL, llvmlibc_errno);
 }
 
 // Months are from January to December. Test passing invalid value in month.
 TEST(LlvmLibcAsctime, InvalidMonth) {
   struct tm tm_data;
-  char *result;
 
   // Test with month = 0.
-  result = call_asctime(&tm_data,
-                        1970, // year
-                        0,    // month
-                        1,    // day
-                        0,    // hr
-                        0,    // min
-                        0,    // sec
-                        4,    // wday
-                        0);   // yday
+  call_asctime(&tm_data,
   ASSERT_EQ(EINVAL, llvmlibc_errno);
 
   // Test with month = 13.
-  result = call_asctime(&tm_data,
-                        1970, // year
-                        13,   // month
-                        1,    // day
-                        0,    // hr
-                        0,    // min
-                        0,    // sec
-                        4,    // wday
-                        0);   // yday
+  call_asctime(&tm_data,
   ASSERT_EQ(EINVAL, llvmlibc_errno);
 }
 
 TEST(LlvmLibcAsctime, ValidWeekdays) {
   struct tm tm_data;
   char *result;
   // 1970-01-01 00:00:00.
   result = call_asctime(&tm_data,