Fix Solaris compilation

[ro]

Summary

As detailed in Issue #57642, the test-suite doesn't compile on Solaris.

This patch fixes the compilation issues as explained there.

Tested on amd64-pc-solaris2.11 (8 failures, all fpcmp-target: Comparison failed), sparcv9-sun-solaris2.11 (11 failures, same fpcmp-target errors), and x86_64-pc-linux-gnu (no regressions).

[fhahn]

The mentioned issue talks about Flang (https://github.com/llvm/llvm-project/issues/57642), but the changes seem to all be in C/C++ files?

MicroBenchmarks/libs/benchmark/test/benchmark_setup_teardown_test.cc

13

This is a copy of https://github.com/google/benchmark I think. Did you submit those changes for upstream review?

MultiSource/Applications/oggenc/oggenc.c

11

Why is this needed?

133

Why is this needed?

MultiSource/Applications/viterbi/read_dmatrix.c

2

why is this needed?

MultiSource/Benchmarks/McCat/05-eks/main.c

35

why are those moved?

[ro]

In D133579#3785892, @fhahn wrote:

The mentioned issue talks about Flang (https://github.com/llvm/llvm-project/issues/57642), but the changes seem to all be in C/C++ files?

Sorry, juggling too many Issues at once: the right one is Issue #57652 which should explain all the changes.

MicroBenchmarks/libs/benchmark/test/benchmark_setup_teardown_test.cc

13

I hadn't been aware of that.

[fhahn]

tools/timeit.c

336

Is this a typo? Should this be RLIMIT_RSS? Even so, not sure if this will work as expected on Apple platforms, which define RLIMIT_RSS I think.

[ro]

tools/timeit.c

336

You're right, of course. I looked at Mac OS X 10.7/Darwin 11 <sys/resource.h> and even that version already defines RLIMIT_RSS.

Unfortunately, I cannot really test LLVM on recent Darwin, and 10.7 is way too old to be supported (or even compiling).

[ro]

Never use RLIMIT_RSS on Apple systems.

[ro]

MicroBenchmarks/libs/benchmark/test/benchmark_setup_teardown_test.cc

13

A patch to fix several Google benchmark issues on Solaris has just been committed: Fix Solaris compilation (#1499) (#1500). What's the best way to proceed here?

[ro]

Ping? It's been 2 1/2 weeks...

[fhahn]

LGTM, thanks!

[arichardson]

MultiSource/Applications/oggenc/oggenc.c

11

This broke the build for FreeBSD where the alloca.h header is not provided. Guard with __has_include()?

[ro]

MultiSource/Applications/oggenc/oggenc.c

11

That's unexpected since other parts of the code use unguarded
<alloca.h>, too, like MultiSource/Benchmarks/MiBench/consumer-lame/rtp.c.

Using __has_include is probably the best option, although one could also use __builtin_alloca instead, given that the code only needs to be compilable with clang. The former is less intrusive, of course.

[arichardson]

MultiSource/Applications/oggenc/oggenc.c

11

the use in rtp.c was also added by this commit, all other uses check the OS first. I've submitted https://reviews.llvm.org/D139001 as a possible fix.

MicroBenchmarks/ImageProcessing/Dither/main.cpp

#endif
   return EXIT_SUCCESS;
 }
 
 #ifdef BENCHMARK_LIB
 void BENCHMARK_ORDERED_DITHER(benchmark::State &state) {
   int height = state.range(0);
   int width = state.range(0);
   int m = state.range(1);
-  int n = pow(m, 2);
+  int n = pow((double)m, 2);
   int *outputImage = (int *)malloc(sizeof(int) * height * width);
   int *temp = (int *)malloc(sizeof(int) * height * width);
 
   if (outputImage == NULL) {
     std::cerr << "Insufficient memory\n";
     exit(1);
   }
   /* This call is to warm up the cache */

MicroBenchmarks/libs/benchmark/test/benchmark_setup_teardown_test.cc

 #include <atomic>
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <limits>
 #include <string>
 
 #include "benchmark/benchmark.h"
 
 // Test that Setup() and Teardown() are called exactly once
 // for each benchmark run (single-threaded).
-namespace single {
+namespace singlethreaded {
 static int setup_call = 0;
 static int teardown_call = 0;
-}  // namespace single
+}  // namespace singlethreaded
 static void DoSetup1(const benchmark::State& state) {
-  ++single::setup_call;
+  ++singlethreaded::setup_call;
 
   // Setup/Teardown should never be called with any thread_idx != 0.
   assert(state.thread_index() == 0);
 }
 
 static void DoTeardown1(const benchmark::State& state) {
-  ++single::teardown_call;
+  ++singlethreaded::teardown_call;
   assert(state.thread_index() == 0);
 }
 
 static void BM_with_setup(benchmark::State& state) {
   for (auto s : state) {
   }
 }
 BENCHMARK(BM_with_setup)

 
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
 
   size_t ret = benchmark::RunSpecifiedBenchmarks(".");
   assert(ret > 0);
 
   // Setup/Teardown is called once for each arg group (1,3,5,7).
-  assert(single::setup_call == 4);
-  assert(single::teardown_call == 4);
+  assert(singlethreaded::setup_call == 4);
+  assert(singlethreaded::teardown_call == 4);
 
   // 3 group of threads calling this function (3,5,10).
   assert(concurrent::setup_call.load(std::memory_order_relaxed) == 3);
   assert(concurrent::teardown_call.load(std::memory_order_relaxed) == 3);
   assert((5 + 10 + 15) ==
          concurrent::func_call.load(std::memory_order_relaxed));
 
   // Setup is called 4 times, once for each arg group (1,3,5,7)

MultiSource/Applications/ClamAV/libclamav_readdb.c

#define CLI_DBEXT(ext)        \
   cli_strbcasestr(ext, ".inc")   || \
   cli_strbcasestr(ext, ".cvd")    \
     )
 
 static int dirent_compare(const struct dirent *a, const struct dirent *b) {
   int ret = strcmp(a->d_name, b->d_name);
   if (ret != 0)
     return ret;
-#ifdef _AIX
+#if defined(_AIX) || (defined(__sun__) && defined(__svr4__))
        struct stat a_stat;
        struct stat b_stat;
        stat(a->d_name, &a_stat);
        stat(b->d_name, &b_stat);
        if (a_stat.st_mode < b_stat.st_mode) return -1;
        if (a_stat.st_mode > b_stat.st_mode) return 1;
 #else
   if (a->d_type < b->d_type) return -1;

MultiSource/Applications/oggenc/oggenc.c

 /* OggEnc
  *
  * This program is distributed under the GNU General Public License, version 2.
  * A copy of this license is included with this source.
  *
  * Copyright 2000-2002, Michael Smith <[e-mail]>
  *
  * Portions from Vorbize, (c) Kenneth Arnold <[e-mail]>
  * and libvorbis examples, (c) Monty <[e-mail]>
  */
+#include <alloca.h>
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <locale.h>
 #include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
-#ifdef __XS1B__
 #include <stdint.h>
+#ifdef __XS1B__
 #include "xcoretestsuite.h"
 #endif
 
 struct option
 {
 # if (defined __STDC__ && __STDC__) || defined __cplusplus
   const char *name;
 # else

 #define _ogg_calloc  calloc
 #define _ogg_realloc realloc
 #define _ogg_free    free
 
 #define __CONFIG_TYPES_H__
 
 /* these are filled in by configure */
 typedef int16_t ogg_int16_t;
-typedef u_int16_t ogg_uint16_t;
+typedef uint16_t ogg_uint16_t;
 typedef int32_t ogg_int32_t;
-typedef u_int32_t ogg_uint32_t;
+typedef uint32_t ogg_uint32_t;
 typedef int64_t ogg_int64_t;
 
 typedef struct {
   long endbyte;
   int  endbit;
 
   unsigned char *buffer;
   unsigned char *ptr;

MultiSource/Applications/viterbi/read_dmatrix.c

 #include <stdio.h>
+#include <string.h>
 #include <memory.h>
 
 #include "common.h"
 
 static const char *mybasename(const char *str) {
   const char *base = strrchr(str, '/');
   return base ? base+1 : str;
 }

MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/fmemopen.c

 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
 
-#if !defined(__linux__) && !defined(__NetBSD__)
+#if !defined(__linux__) && !defined(__NetBSD__) && !(defined(__sun__) && defined(__svr4__))
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 
 struct fmem {
   size_t pos;

MultiSource/Benchmarks/McCat/05-eks/main.c

 /*  main.c             main.h                                           */
 /*                                                                      */
 /*  It calculates the eigenvalues for 4 different matrixes. It does not */
 /*  take any input; those 4 matrixes are calculated by MakeMatrix       */
 /*  function. Output is given as 4 files: val2, val3, val4, val5, that  */
 /*  contains the eigenvalues for each of the matrixes.                  */
 /*                                                                      */
 /************************************************************************/
+#include <stdio.h>
+#include <string.h>
 #include "main.h"
 #include "QRfact.h"
 #include "Triang.h"
 #include "Jacobi.h"
-#include <stdio.h>
-#include <string.h>
 Matrix A,Q,U;
 
 int comp(const double *a,const double *b)
 {
   if (fabs(*a)<fabs(*b)) return 1;
   else if (fabs(*a)>fabs(*b)) return -1;
   else return 0;
 }

MultiSource/Benchmarks/MiBench/consumer-lame/rtp.c

 #include <stdlib.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <alloca.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 
 struct rtpbits {
   int sequence:16;  /* sequence number: random */
   int pt:7; /* payload type: 14 for MPEG audio */
   int m:1;  /* marker: 0 */

MultiSource/Benchmarks/MiBench/office-ispell/term.c

  */
 
 #include "config.h"
 #include "ispell.h"
 #include "proto.h"
 #include "msgs.h"
 #include <signal.h>
 
-#if defined(__GLIBC__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__)
+#if defined(__GLIBC__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) || (defined(__sun__) && defined(__svr4__))
 /* Use termios under at least glibc */
 #include <termios.h>
 #define USE_TERMIOS
 #ifndef USG
 #define USG
 #endif
 #else
 #ifdef USG

SingleSource/Regression/C/gcc-c-torture/execute/CMakeLists.txt

 
 # Tests that require libm (-lm ldflag)
 file(GLOB TestRequiresLibM CONFIGURE_DEPENDS
   980709-1.c
   float-floor.c
   complex-5.c  # -lm needed on FreeBSD
 )
 
-# Tests that require newnlib Nano IO (--undefined=_printf_float ldflag)
-file(GLOB TestRequiresNanoIO CONFIGURE_DEPENDS
-  920501-8.c
-  930513-1.c
-)
-
 ##
 ## Architecture-specific Test Blacklists
 ##
 
 
 # Tests that require mmap
 include(CheckSymbolExists)
 CHECK_SYMBOL_EXISTS("mmap" "sys/types.h;sys/mman.h" HAVE_MMAP)
foreach(File ${TestFiles})
   if(${File} IN_LIST TestRequiresWNoReturnType)
     list(APPEND MaybeCFlags "-Wno-return-type")
   endif()
 
   if(${File} IN_LIST TestRequiresFWrapV)
     list(APPEND MaybeCFlags "-fwrapv")
   endif()
 
-  if(${File} IN_LIST TestRequiresNanoIO)
-    list(APPEND MaybeLDFlags "-Wl,-u,_printf_float")
-  endif()
-
   # Add Test Target
   gcc_torture_execute_test(${File}
                            PREFIX "GCC-C-execute"
                            CFLAGS ${MaybeCFlags}
                            LDFLAGS ${MaybeLDFlags})
 endforeach()

litsupport/modules/hash.py

 """Test module to collect test executable hashsum."""
 from litsupport import testplan
 import hashlib
 import logging
 import platform
 
 
 def compute(context):
     if hasattr(context, 'executable_hash'):
         return
     executable = context.executable
     try:
-        # Darwin's "strip" doesn't support these arguments.
-        if platform.system() != 'Darwin':
+        # Darwin's and Solaris' "strip" don't support these arguments.
+        if platform.system() != 'Darwin' and platfor.system() != 'SunOS':
             stripped_executable = executable + '.stripped'
             testplan.check_call([context.config.strip_tool,
                                  '--remove-section=.comment',
                                  "--remove-section='.note*'",
                                  '-o', stripped_executable,
                                  executable])
             executable = stripped_executable
 

tools/timeit.c

if (g_target_cpu_limit != ~(rlim_t) 0) {
     set_resource_limit(RLIMIT_CPU, g_target_cpu_limit);
   }
   if (g_target_stack_size_limit != ~(rlim_t) 0) {
     set_resource_limit(RLIMIT_STACK, g_target_stack_size_limit);
   }
   if (g_target_data_size_limit != ~(rlim_t) 0) {
     set_resource_limit(RLIMIT_DATA, g_target_data_size_limit);
   }
-#if !defined(__APPLE__)
+#if defined(RLIMIT_RSS) && !defined(__APPLE__)
   // On Apple platforms, RLIMIT_RSS is mapped to RLIMIT_AS and setting RLIMIT_AS
   // to a value smaller than the current virtual memory size will fail, This is
   // incompatible with the current usage in timeit and can cause issues on
   // platforms enforcing strict virtual memory size limits. Ignore RLIMIT_RSS on
   // Apple platforms for now.
   if (g_target_rss_size_limit != ~(rlim_t) 0) {
     set_resource_limit(RLIMIT_RSS, g_target_rss_size_limit);
   }
 #endif
   if (g_target_file_size_limit != ~(rlim_t) 0) {
     set_resource_limit(RLIMIT_FSIZE, g_target_file_size_limit);
   }
   if (g_target_core_limit != ~(rlim_t) 0) {
     set_resource_limit(RLIMIT_CORE, g_target_core_limit);
   }
   if (g_target_file_count_limit != ~(rlim_t) 0) {
     set_resource_limit(RLIMIT_NOFILE, g_target_file_count_limit);
   }
+#ifdef RLIMIT_NPROC
   if (g_target_subprocess_count_limit != ~(rlim_t) 0) {
     set_resource_limit(RLIMIT_NPROC, g_target_subprocess_count_limit);
   }
+#endif
 
   /* Honor the desired target execute directory. */
   if (g_target_exec_directory) {
     if (chdir(g_target_exec_directory) < 0) {
       perror("chdir");
       return EXITCODE_MONITORING_FAILURE;
     }
   }