--- old/src/share/vm/utilities/ticks.inline.hpp	2019-01-28 17:45:03.000000000 +0800
+++ new/src/share/vm/utilities/ticks.inline.hpp	2019-01-28 17:45:03.000000000 +0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -27,71 +27,165 @@
 
 #include "utilities/ticks.hpp"
 
-inline Tickspan operator+(Tickspan lhs, const Tickspan& rhs) {
-  lhs += rhs;
-  return lhs;
+template <typename InstantType>
+inline TimeInterval<InstantType>& TimeInterval<InstantType>::operator+=(const TimeInterval<InstantType>& rhs) {
+  _interval += rhs._interval;
+  return *this;
 }
 
-inline bool operator==(const Tickspan& lhs, const Tickspan& rhs) {
+template <typename InstantType>
+inline TimeInterval<InstantType>& TimeInterval<InstantType>::operator-=(const TimeInterval<InstantType>& rhs) {
+  _interval -= rhs._interval;
+  return *this;
+}
+
+template <typename InstantType>
+inline bool operator==(const TimeInterval<InstantType>& lhs, const TimeInterval<InstantType>& rhs) {
+  return lhs.value() == rhs.value();
+}
+
+template <typename InstantType>
+inline bool operator!=(const TimeInterval<InstantType>& lhs, const TimeInterval<InstantType>& rhs) {
+  return !operator==(lhs, rhs);
+}
+
+template <typename InstantType>
+inline bool operator<(const TimeInterval<InstantType>& lhs, const TimeInterval<InstantType>& rhs) {
+  return lhs.value() < rhs.value();
+}
+
+template <typename InstantType>
+inline bool operator>(const TimeInterval<InstantType>& lhs, const TimeInterval<InstantType>& rhs) {
+  return operator<(rhs, lhs);
+}
+
+template <typename InstantType>
+inline bool operator<=(const TimeInterval<InstantType>& lhs, const TimeInterval<InstantType>& rhs) {
+  return !operator>(lhs, rhs);
+}
+
+template <typename InstantType>
+inline bool operator>=(const TimeInterval<InstantType>& lhs, const TimeInterval<InstantType>& rhs) {
+  return !operator<(lhs, rhs);
+}
+
+template <typename InstantType>
+inline TimeInterval<InstantType> operator-(const InstantType& end, const InstantType& start) {
+  return TimeInterval<InstantType>(end, start);
+}
+
+inline TimeInstant& TimeInstant::operator+=(const TimeInterval<TimeInstant>& rhs) {
+  _instant += rhs.value();
+  return *this;
+}
+
+inline TimeInstant& TimeInstant::operator-=(const TimeInterval<TimeInstant>& rhs) {
+  _instant -= rhs.value();
+  return *this;
+}
+
+inline bool operator==(const TimeInstant& lhs, const TimeInstant& rhs) {
   return lhs.value() == rhs.value();
 }
 
-inline bool operator!=(const Tickspan& lhs, const Tickspan& rhs) {
-  return !operator==(lhs,rhs);
+inline bool operator!=(const TimeInstant& lhs, const TimeInstant& rhs) {
+  return !operator==(lhs, rhs);
 }
 
-inline bool operator<(const Tickspan& lhs, const Tickspan& rhs) {
+inline bool operator<(const TimeInstant& lhs, const TimeInstant& rhs) {
   return lhs.value() < rhs.value();
 }
 
-inline bool operator>(const Tickspan& lhs, const Tickspan& rhs) {
-  return operator<(rhs,lhs);
+inline bool operator>(const TimeInstant& lhs, const TimeInstant& rhs) {
+  return operator<(rhs, lhs);
+}
+
+inline bool operator<=(const TimeInstant& lhs, const TimeInstant& rhs) {
+  return !operator>(lhs, rhs);
 }
 
-inline bool operator<=(const Tickspan& lhs, const Tickspan& rhs) {
-  return !operator>(lhs,rhs);
+inline bool operator>=(const TimeInstant& lhs, const TimeInstant& rhs) {
+  return !operator<(lhs, rhs);
 }
 
-inline bool operator>=(const Tickspan& lhs, const Tickspan& rhs) {
-  return !operator<(lhs,rhs);
+inline TimeInstant operator+(const TimeInstant& lhs, const TimeInterval<TimeInstant>& span) {
+  TimeInstant t(lhs);
+  t += span;
+  return t;
 }
 
-inline Ticks operator+(Ticks lhs, const Tickspan& span) {
-  lhs += span;
-  return lhs;
+inline TimeInstant operator-(const TimeInstant& lhs, const TimeInterval<TimeInstant>& span) {
+  TimeInstant t(lhs);
+  t -= span;
+  return t;
 }
 
-inline Ticks operator-(Ticks lhs, const Tickspan& span) {
-  lhs -= span;
-  return lhs;
+// TraceElapsedInterval
+
+inline bool operator==(const TraceElapsedInterval& lhs, const TraceElapsedInterval& rhs) {
+  return lhs.value() == rhs.value();
+}
+
+inline bool operator!=(const TraceElapsedInterval& lhs, const TraceElapsedInterval& rhs) {
+  return !operator==(lhs, rhs);
+}
+
+inline bool operator<(const TraceElapsedInterval& lhs, const TraceElapsedInterval& rhs) {
+  return lhs.value() < rhs.value();
+}
+
+inline bool operator>(const TraceElapsedInterval& lhs, const TraceElapsedInterval& rhs) {
+  return operator<(rhs, lhs);
+}
+
+inline bool operator<=(const TraceElapsedInterval& lhs, const TraceElapsedInterval& rhs) {
+  return !operator>(lhs, rhs);
+}
+
+inline bool operator>=(const TraceElapsedInterval& lhs, const TraceElapsedInterval& rhs) {
+  return !operator<(lhs, rhs);
+}
+
+inline TraceElapsedInterval operator-(const TraceElapsedCounter& end, const TraceElapsedCounter& start) {
+  return TraceElapsedInterval(end, start);
+}
+
+// TraceElapsedCounter
+
+inline TraceElapsedCounter operator+(const TraceElapsedCounter& lhs, const TraceElapsedInterval& span) {
+  TraceElapsedCounter t(lhs);
+  t += span;
+  return t;
 }
 
-inline Tickspan operator-(const Ticks& end, const Ticks& start) {
-  return Tickspan(end, start);
+inline TraceElapsedCounter operator-(const TraceElapsedCounter& lhs, const TraceElapsedInterval& span) {
+  TraceElapsedCounter t(lhs);
+  t -= span;
+  return t;
 }
 
-inline bool operator==(const Ticks& lhs, const Ticks& rhs) {
+inline bool operator==(const TraceElapsedCounter& lhs, const TraceElapsedCounter& rhs) {
   return lhs.value() == rhs.value();
 }
 
-inline bool operator!=(const Ticks& lhs, const Ticks& rhs) {
-  return !operator==(lhs,rhs);
+inline bool operator!=(const TraceElapsedCounter& lhs, const TraceElapsedCounter& rhs) {
+  return !operator==(lhs, rhs);
 }
 
-inline bool operator<(const Ticks& lhs, const Ticks& rhs) {
+inline bool operator<(const TraceElapsedCounter& lhs, const TraceElapsedCounter& rhs) {
   return lhs.value() < rhs.value();
 }
 
-inline bool operator>(const Ticks& lhs, const Ticks& rhs) {
-  return operator<(rhs,lhs);
+inline bool operator>(const TraceElapsedCounter& lhs, const TraceElapsedCounter& rhs) {
+  return operator<(rhs, lhs);
 }
 
-inline bool operator<=(const Ticks& lhs, const Ticks& rhs) {
-  return !operator>(lhs,rhs);
+inline bool operator<=(const TraceElapsedCounter& lhs, const TraceElapsedCounter& rhs) {
+  return !operator>(lhs, rhs);
 }
 
-inline bool operator>=(const Ticks& lhs, const Ticks& rhs) {
-  return !operator<(lhs,rhs);
+inline bool operator>=(const TraceElapsedCounter& lhs, const TraceElapsedCounter& rhs) {
+  return !operator<(lhs, rhs);
 }
 
 #endif // SHARE_VM_UTILITIES_TICKS_INLINE_HPP