[SystemZ][z/OS] Fix warnings from unsigned int to long in 32-bit mode

[zibi]

Summary

This patch fixes the warnings which shows up when libcxx library started to be compiled in 32-bit mode on z/OS.
More specifically, the assignment from unsigned int to time_t aka long was flags as follows:

libcxx/include/c++/v1/__support/ibm/nanosleep.h:31:11: warning: implicit conversion changes signedness: 'unsigned int' to 'time_t' (aka 'long') [-Wsign-conversion]
  __sec = sleep(static_cast<unsigned int>(__sec));
        ~ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
libcxx/include/c++/v1/__support/ibm/nanosleep.h:36:36: warning: implicit conversion changes signedness: 'unsigned int' to 'long' [-Wsign-conversion]
      __rem->tv_nsec = __micro_sec * 1000;
                     ~ ~~~~~~~~~~~~^~~~~~
libcxx/include/c++/v1/__support/ibm/nanosleep.h:47:36: warning: implicit conversion changes signedness: 'unsigned int' to 'long' [-Wsign-conversion]
      __rem->tv_nsec = __micro_sec * 1000;
                     ~ ~~~~~~~~~~~~^~~~~~
3 warnings generated.

Here is a small test case illustrating the issue:

typedef long    time_t ;
unsigned int sleep(unsigned int );
int main() {
  time_t sec = 0;
#ifdef FIX
  sec = static_cast<time_t>(sleep(static_cast<unsigned int>(sec)));
#else
  sec = sleep(static_cast<unsigned int>(sec));
#endif
}

clang++ -c -Wsign-conversion -m32 t.C

t.C:8:9: warning: implicit conversion changes signedness: 'unsigned int' to 'time_t' (aka 'long') [-Wsign-conversion]
  sec = sleep(static_cast<unsigned int>(sec));
      ~ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[zibi]

@ldionne Can you have a look at this patch?

This is a very small patch which was already reviewed downstream.
I would like to merge this in to eliminate many warnings we are getting on z/OS.

[• Quuxplusone]

FWIW, this seems fine to me because it's limited to __support/ibm/ code.
However,
(1) In portable code (which this is not), long would be problematic because its size varies. The ranges of numbers expected here are known, because they're time units (like, "one century in microseconds" fits comfortably in int64_t but not in int32_t). So probably int32_t or int64_t would be easier to reason about. (But again, this code is non-portable by design, and I assume you know the size of long on your specific platform, and I also assume it's 64 bits.)
(2) It's odd to be changing the variable types and adding casts. For example, __sec is a time_t variable, but is invariably(?) used as an unsigned int. __micro_sec is a long variable, but is invariably used as an unsigned int. Why aren't these variables just declared as unsigned int then?

[zibi]

Thank you Quuxplusone for your review and approval. Following is the rational of this patch.

This code was written for z/OS and as you indicated is not portable. The long was chosen to reduce number of cast statements. Currently we have 3 casts and with uint_32_t or int64_t we would have 5.

The root of the problem is the change of the signedness as the warning indicates and because long is a variant type on z/OS, 64-bit or 32-bit signed integer.

The type of time_t is long so as tv_nsec. The tv_sec is time_t. Therefore, they are all long.
However, both sleep() and usleep() take unsinged int` as parameter.

unsigned int sleep(unsigned int );
int usleep(useconds_t); // seconds_t is unsinged int

[zibi]

ping

[Mordante]

LGTM!

libcxx/include/__support/ibm/nanosleep.h

inline int nanosleep(const struct timespec* __req, struct timespec* __rem) {
   // The nanosleep() function is not available on z/OS. Therefore, we will call
   // sleep() to sleep for whole seconds and usleep() to sleep for any remaining
   // fraction of a second. Any remaining nanoseconds will round up to the next
   // microsecond.
   if (__req->tv_sec < 0 || __req->tv_nsec < 0 || __req->tv_nsec > 999999999) {
     errno = EINVAL;
     return -1;
   }
-  useconds_t __micro_sec =
-      static_cast<useconds_t>((__req->tv_nsec + 999) / 1000);
+  long __micro_sec = (__req->tv_nsec + 999) / 1000;
   time_t __sec = __req->tv_sec;
   if (__micro_sec > 999999) {
     ++__sec;
     __micro_sec -= 1000000;
   }
-  __sec = sleep(static_cast<unsigned int>(__sec));
+  __sec = static_cast<time_t>(sleep(static_cast<unsigned int>(__sec)));
   if (__sec) {
     if (__rem) {
       // Updating the remaining time to sleep in case of unsuccessful call to sleep().
       __rem->tv_sec = __sec;
       __rem->tv_nsec = __micro_sec * 1000;
     }
     errno = EINTR;
     return -1;
   }
   if (__micro_sec) {
-    int __rt = usleep(__micro_sec);
+    int __rt = usleep(static_cast<unsigned int>(__micro_sec));
     if (__rt != 0 && __rem) {
       // The usleep() does not provide the amount of remaining time upon its failure,
       // so the time slept will be ignored.
       __rem->tv_sec = 0;
       __rem->tv_nsec = __micro_sec * 1000;
       // The errno is already set.
       return -1;
     }
     return __rt;
   }
   return 0;
 }
 
 #endif // _LIBCPP_SUPPORT_IBM_NANOSLEEP_H