Avoid NanoSleep overflow

NanoSleep with a very large argument could cause it to fail on 32 bits.
It doesn't appear to me that this was ever exposed to client code.
So this was probably not an observable bug.

Remove redundant uses of "constexpr inline" instead of adding another
one.

Bug: 161006928
Test: Treehugger
Change-Id: I2ad3b92d01c764915ab2aac17cc72ac5c6907ed4

7 files changed, 19 insertions, 19 deletions

diff --git a/compiler/utils/arm/managed_register_arm.h b/compiler/utils/arm/managed_register_arm.h
index e42572dc32..6d942fa774 100644
--- a/compiler/utils/arm/managed_register_arm.h
+++ b/compiler/utils/arm/managed_register_arm.h
@@ -264,7 +264,7 @@ std::ostream& operator<<(std::ostream& os, const ArmManagedRegister& reg);
 
 }  // namespace arm
 
-constexpr inline arm::ArmManagedRegister ManagedRegister::AsArm() const {
+constexpr arm::ArmManagedRegister ManagedRegister::AsArm() const {
   arm::ArmManagedRegister reg(id_);
   CHECK(reg.IsNoRegister() || reg.IsValidManagedRegister());
   return reg;
diff --git a/compiler/utils/arm64/managed_register_arm64.h b/compiler/utils/arm64/managed_register_arm64.h
index 0513890aa8..8a06f631a1 100644
--- a/compiler/utils/arm64/managed_register_arm64.h
+++ b/compiler/utils/arm64/managed_register_arm64.h
@@ -215,7 +215,7 @@ std::ostream& operator<<(std::ostream& os, const Arm64ManagedRegister& reg);
 
 }  // namespace arm64
 
-constexpr inline arm64::Arm64ManagedRegister ManagedRegister::AsArm64() const {
+constexpr arm64::Arm64ManagedRegister ManagedRegister::AsArm64() const {
   arm64::Arm64ManagedRegister reg(id_);
   CHECK(reg.IsNoRegister() || reg.IsValidManagedRegister());
   return reg;
diff --git a/compiler/utils/x86/managed_register_x86.h b/compiler/utils/x86/managed_register_x86.h
index 8810bfa2f1..27555bfd32 100644
--- a/compiler/utils/x86/managed_register_x86.h
+++ b/compiler/utils/x86/managed_register_x86.h
@@ -214,7 +214,7 @@ std::ostream& operator<<(std::ostream& os, const X86ManagedRegister& reg);
 
 }  // namespace x86
 
-constexpr inline x86::X86ManagedRegister ManagedRegister::AsX86() const {
+constexpr x86::X86ManagedRegister ManagedRegister::AsX86() const {
   x86::X86ManagedRegister reg(id_);
   CHECK(reg.IsNoRegister() || reg.IsValidManagedRegister());
   return reg;
diff --git a/compiler/utils/x86_64/managed_register_x86_64.h b/compiler/utils/x86_64/managed_register_x86_64.h
index 6760882965..62c0e373a7 100644
--- a/compiler/utils/x86_64/managed_register_x86_64.h
+++ b/compiler/utils/x86_64/managed_register_x86_64.h
@@ -200,7 +200,7 @@ std::ostream& operator<<(std::ostream& os, const X86_64ManagedRegister& reg);
 
 }  // namespace x86_64
 
-constexpr inline x86_64::X86_64ManagedRegister ManagedRegister::AsX86_64() const {
+constexpr x86_64::X86_64ManagedRegister ManagedRegister::AsX86_64() const {
   x86_64::X86_64ManagedRegister reg(id_);
   CHECK(reg.IsNoRegister() || reg.IsValidManagedRegister());
   return reg;
diff --git a/libartbase/base/time_utils.cc b/libartbase/base/time_utils.cc
index d38d885f5d..037d7b59a3 100644
--- a/libartbase/base/time_utils.cc
+++ b/libartbase/base/time_utils.cc
@@ -216,7 +216,7 @@ uint64_t ProcessCpuNanoTime() {
 
 void NanoSleep(uint64_t ns) {
   timespec tm;
-  tm.tv_sec = ns / MsToNs(1000);
+  tm.tv_sec = SaturatedTimeT(ns / MsToNs(1000));
   tm.tv_nsec = ns - static_cast<uint64_t>(tm.tv_sec) * MsToNs(1000);
   nanosleep(&tm, nullptr);
 }
diff --git a/libartbase/base/time_utils.h b/libartbase/base/time_utils.h
index 69c867cfaf..cb0ab13ef9 100644
--- a/libartbase/base/time_utils.h
+++ b/libartbase/base/time_utils.h
@@ -69,24 +69,33 @@ uint64_t ThreadCpuNanoTime();
 uint64_t ProcessCpuNanoTime();
 
 // Converts the given number of nanoseconds to milliseconds.
-static constexpr inline uint64_t NsToMs(uint64_t ns) {
+static constexpr uint64_t NsToMs(uint64_t ns) {
   return ns / 1000 / 1000;
 }
 
 // Converts the given number of milliseconds to nanoseconds
-static constexpr inline uint64_t MsToNs(uint64_t ms) {
+static constexpr uint64_t MsToNs(uint64_t ms) {
   return ms * 1000 * 1000;
 }
 
 // Converts the given number of milliseconds to microseconds
-static constexpr inline uint64_t MsToUs(uint64_t ms) {
+static constexpr uint64_t MsToUs(uint64_t ms) {
   return ms * 1000;
 }
 
-static constexpr inline uint64_t UsToNs(uint64_t us) {
+static constexpr uint64_t UsToNs(uint64_t us) {
   return us * 1000;
 }
 
+static constexpr time_t SaturatedTimeT(int64_t secs) {
+  if (sizeof(time_t) < sizeof(int64_t)) {
+    return static_cast<time_t>(std::min(secs,
+                                        static_cast<int64_t>(std::numeric_limits<time_t>::max())));
+  } else {
+    return secs;
+  }
+}
+
 #if defined(__APPLE__)
 #ifndef CLOCK_REALTIME
 // No clocks to specify on OS/X < 10.12, fake value to pass to routines that require a clock.
diff --git a/runtime/thread.cc b/runtime/thread.cc
index d1c87932da..55a7c28e15 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -46,12 +46,12 @@
 #include "base/atomic.h"
 #include "base/bit_utils.h"
 #include "base/casts.h"
-#include "arch/context.h"
 #include "base/file_utils.h"
 #include "base/memory_tool.h"
 #include "base/mutex.h"
 #include "base/stl_util.h"
 #include "base/systrace.h"
+#include "base/time_utils.h"
 #include "base/timing_logger.h"
 #include "base/to_str.h"
 #include "base/utils.h"
@@ -295,15 +295,6 @@ enum {
   kNoPermitWaiterWaiting = 2
 };
 
-static inline time_t SaturatedTimeT(int64_t secs) {
-  if (sizeof(time_t) < sizeof(int64_t)) {
-    return static_cast<time_t>(std::min(secs,
-                                        static_cast<int64_t>(std::numeric_limits<time_t>::max())));
-  } else {
-    return secs;
-  }
-}
-
 void Thread::Park(bool is_absolute, int64_t time) {
   DCHECK(this == Thread::Current());
 #if ART_USE_FUTEXES