Build LLVM with -Wstrict-prototypes enabled

[arphaman]

Summary

Clang 5 supports -Wstrict-prototypes. We should use it to catch any C declarations that declare a non-prototype function.

[arphaman]

Ping

[dexonsmith]

LGTM.

compiler-rt/trunk/lib/profile/GCDAProfiling.c

 static uint64_t cur_pos = 0;
 static uint64_t file_size = 0;
 static int new_file = 0;
 static int fd = -1;
 
 /*
  * A list of functions to write out the data.
  */
-typedef void (*writeout_fn)();
+typedef void (*writeout_fn)(void);
 
 struct writeout_fn_node {
   writeout_fn fn;
   struct writeout_fn_node *next;
 };
 
 static struct writeout_fn_node *writeout_fn_head = NULL;
 static struct writeout_fn_node *writeout_fn_tail = NULL;
 
 /*
  *  A list of flush functions that our __gcov_flush() function should call.
  */
-typedef void (*flush_fn)();
+typedef void (*flush_fn)(void);
 
 struct flush_fn_node {
   flush_fn fn;
   struct flush_fn_node *next;
 };
 
 static struct flush_fn_node *flush_fn_head = NULL;
 static struct flush_fn_node *flush_fn_tail = NULL;

compiler-rt/trunk/lib/profile/InstrProfiling.h

 int __llvm_profile_write_buffer(char *Buffer);
 
 const __llvm_profile_data *__llvm_profile_begin_data(void);
 const __llvm_profile_data *__llvm_profile_end_data(void);
 const char *__llvm_profile_begin_names(void);
 const char *__llvm_profile_end_names(void);
 uint64_t *__llvm_profile_begin_counters(void);
 uint64_t *__llvm_profile_end_counters(void);
-ValueProfNode *__llvm_profile_begin_vnodes();
-ValueProfNode *__llvm_profile_end_vnodes();
+ValueProfNode *__llvm_profile_begin_vnodes(void);
+ValueProfNode *__llvm_profile_end_vnodes(void);
 
 /*!
  * \brief Clear profile counters to zero.
  *
  */
 void __llvm_profile_reset_counters(void);
 
 /*!

 /*!
  * \brief Return path prefix (excluding the base filename) of the profile data.
  * This is useful for users using \c -fprofile-generate=./path_prefix who do
  * not care about the default raw profile name. It is also useful to collect
  * more than more profile data files dumped in the same directory (Online
  * merge mode is turned on for instrumented programs with shared libs).
  * Side-effect: this API call will invoke malloc with dynamic memory allocation.
  */
-const char *__llvm_profile_get_path_prefix();
+const char *__llvm_profile_get_path_prefix(void);
 
 /*! \brief Get the magic token for the file format. */
 uint64_t __llvm_profile_get_magic(void);
 
 /*! \brief Get the version of the file format. */
 uint64_t __llvm_profile_get_version(void);
 
 /*! \brief Get the number of entries in the profile data section. */

compiler-rt/trunk/lib/profile/InstrProfilingFile.c

typedef struct lprofFilename {
   unsigned MergePoolSize;
   ProfileNameSpecifier PNS;
 } lprofFilename;
 
 COMPILER_RT_WEAK lprofFilename lprofCurFilename = {0, 0, 0, {0}, {0},
                                                    0, 0, 0, PNS_unknown};
 
 int getpid(void);
-static int getCurFilenameLength();
+static int getCurFilenameLength(void);
 static const char *getCurFilename(char *FilenameBuf);
 static unsigned doMerging() { return lprofCurFilename.MergePoolSize; }
 
 /* Return 1 if there is an error, otherwise return  0.  */
 static uint32_t fileWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
                            uint32_t NumIOVecs) {
   uint32_t I;
   FILE *File = (FILE *)This->WriterCtx;

compiler-rt/trunk/lib/profile/InstrProfilingInternal.h

int lprofWriteDataImpl(ProfDataWriter *Writer,
                        VPDataReaderType *VPDataReader, const char *NamesBegin,
                        const char *NamesEnd, int SkipNameDataWrite);
 
 /* Merge value profile data pointed to by SrcValueProfData into
  * in-memory profile counters pointed by to DstData.  */
 void lprofMergeValueProfData(struct ValueProfData *SrcValueProfData,
                              __llvm_profile_data *DstData);
 
-VPDataReaderType *lprofGetVPDataReader();
+VPDataReaderType *lprofGetVPDataReader(void);
 
 /* Internal interface used by test to reset the max number of 
  * tracked values per value site to be \p MaxVals.
  */
 void lprofSetMaxValsPerSite(uint32_t MaxVals);
-void lprofSetupValueProfiler();
+void lprofSetupValueProfiler(void);
 
 /* Return the profile header 'signature' value associated with the current
  * executable or shared library. The signature value can be used to for
  * a profile name that is unique to this load module so that it does not
  * collide with profiles from other binaries. It also allows shared libraries
  * to dump merged profile data into its own profile file. */
-uint64_t lprofGetLoadModuleSignature();
+uint64_t lprofGetLoadModuleSignature(void);
 
 /* 
  * Return non zero value if the profile data has already been
  * dumped to the file.
  */
-unsigned lprofProfileDumped();
-void lprofSetProfileDumped();
+unsigned lprofProfileDumped(void);
+void lprofSetProfileDumped(void);
 
 COMPILER_RT_VISIBILITY extern void (*FreeHook)(void *);
 COMPILER_RT_VISIBILITY extern uint8_t *DynamicBufferIOBuffer;
 COMPILER_RT_VISIBILITY extern uint32_t VPBufferSize;
 COMPILER_RT_VISIBILITY extern uint32_t VPMaxNumValsPerSite;
 /* Pointer to the start of static value counters to be allocted. */
 COMPILER_RT_VISIBILITY extern ValueProfNode *CurrentVNode;
 COMPILER_RT_VISIBILITY extern ValueProfNode *EndVNode;
 extern void (*VPMergeHook)(struct ValueProfData *, __llvm_profile_data *);
 
 #endif

compiler-rt/trunk/lib/profile/InstrProfilingUtil.h

 int lprofGetHostName(char *Name, int Len);
 
 unsigned lprofBoolCmpXchg(void **Ptr, void *OldV, void *NewV);
 void *lprofPtrFetchAdd(void **Mem, long ByteIncr);
 
 /* Temporarily suspend SIGKILL. Return value of 1 means a restore is needed.
  * Other return values mean no restore is needed.
  */
-int lprofSuspendSigKill();
+int lprofSuspendSigKill(void);
 
 /* Restore previously suspended SIGKILL. */
-void lprofRestoreSigKill();
+void lprofRestoreSigKill(void);
 
 #endif /* PROFILE_INSTRPROFILINGUTIL_H */

libunwind/trunk/src/config.h

#ifdef NDEBUG
   #define _LIBUNWIND_TRACING_UNWINDING (0)
   #define _LIBUNWIND_TRACING_DWARF (0)
   #define _LIBUNWIND_TRACE_UNWINDING(msg, ...)
   #define _LIBUNWIND_TRACE_DWARF(...)
 #else
   #ifdef __cplusplus
     extern "C" {
   #endif
-    extern  bool logAPIs();
-    extern  bool logUnwinding();
-    extern  bool logDWARF();
+    extern  bool logAPIs(void);
+    extern  bool logUnwinding(void);
+    extern  bool logDWARF(void);
   #ifdef __cplusplus
     }
   #endif
   #define _LIBUNWIND_DEBUG_LOG(msg, ...)  _LIBUNWIND_LOG(msg, __VA_ARGS__)
   #define _LIBUNWIND_TRACE_API(msg, ...)                                       \
     do {                                                                       \
       if (logAPIs())                                                           \
         _LIBUNWIND_LOG(msg, __VA_ARGS__);                                      \

libunwind/trunk/src/unwind_ext.h

 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // These platform specific functions to get and set the top context are
 // implemented elsewhere.
 
 extern struct _Unwind_FunctionContext *
-__Unwind_SjLj_GetTopOfFunctionStack();
+__Unwind_SjLj_GetTopOfFunctionStack(void);
 
 extern void
 __Unwind_SjLj_SetTopOfFunctionStack(struct _Unwind_FunctionContext *fc);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // __UNWIND_EXT__
 
 

llvm/trunk/cmake/modules/HandleLLVMOptions.cmake

CHECK_C_SOURCE_COMPILES("// \\\\\\n//\\nint main() {return 0;}"
                           C_WCOMMENT_ALLOWS_LINE_WRAP)
   set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
   if (NOT C_WCOMMENT_ALLOWS_LINE_WRAP)
     append("-Wno-comment" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
   endif()
 
   # Enable -Wstring-conversion to catch misuse of string literals.
   add_flag_if_supported("-Wstring-conversion" STRING_CONVERSION_FLAG)
+  # Enable -Wstrict-prototypes to catch incorrectly declared functions in C.
+  add_flag_if_supported("-Wstrict-prototypes" STRICT_PROTOTYPES_FLAG)
 endif (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL))
 
 if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT LLVM_ENABLE_WARNINGS)
   append("-w" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 endif()
 
 macro(append_common_sanitizer_flags)
   if (NOT MSVC)