Enforce the use of the tmv_t wrapper functions by converting tmv_t from an int64_t to a struct containing an int64_t.
Inspection of the disassembly shows that this change has essentially no impact on the resulting object code, at least for x86_64 with compiler optimisations enabled. Signed-off-by: Michael Brown <mbr...@fensystems.co.uk> --- tmv.h | 53 +++++++++++++++++++++++++++++++++++------------------ 1 file changed, 35 insertions(+), 18 deletions(-) diff --git a/tmv.h b/tmv.h index 001963f..edfa577 100644 --- a/tmv.h +++ b/tmv.h @@ -53,90 +53,107 @@ struct hw_timestamp { * the fractional nanosecond parts of the correction fields, if and * when people start asking for them. */ -typedef int64_t tmv_t; +typedef struct { + int64_t ns; +} tmv_t; static inline tmv_t tmv_add(tmv_t a, tmv_t b) { - return a + b; + tmv_t t; + t.ns = a.ns + b.ns; + return t; } static inline tmv_t tmv_div(tmv_t a, int divisor) { - return a / divisor; + tmv_t t; + t.ns = a.ns / divisor; + return t; } static inline int tmv_cmp(tmv_t a, tmv_t b) { - return a == b ? 0 : a > b ? +1 : -1; + return a.ns == b.ns ? 0 : a.ns > b.ns ? +1 : -1; } static inline int tmv_sign(tmv_t x) { - return x == 0 ? 0 : x > 0 ? +1 : -1; + return x.ns == 0 ? 0 : x.ns > 0 ? +1 : -1; } static inline int tmv_is_zero(tmv_t x) { - return x == ((tmv_t) 0) ? 1 : 0; + return x.ns == 0 ? 1 : 0; } static inline tmv_t tmv_sub(tmv_t a, tmv_t b) { - return a - b; + tmv_t t; + t.ns = a.ns - b.ns; + return t; } static inline tmv_t tmv_zero(void) { - return (tmv_t) 0; + tmv_t t = { 0 }; + return t; } static inline tmv_t correction_to_tmv(Integer64 c) { - return c >> 16; + tmv_t t; + t.ns = (c >> 16); + return t; } static inline double tmv_dbl(tmv_t x) { - return (double) x; + return (double) x.ns; } static inline tmv_t dbl_tmv(double x) { - return (tmv_t) x; + tmv_t t; + t.ns = x; + return t; } static inline int64_t tmv_to_nanoseconds(tmv_t x) { - return x; + return x.ns; } static inline void tmv_to_Timestamp(tmv_t x, struct Timestamp *ts) { - uint64_t seconds = x / NS_PER_SEC; + uint64_t seconds = x.ns / NS_PER_SEC; ts->seconds_lsb = seconds; ts->seconds_msb = (seconds >> 32); - ts->nanoseconds = (x % NS_PER_SEC); + ts->nanoseconds = (x.ns % NS_PER_SEC); } static inline TimeInterval tmv_to_TimeInterval(tmv_t x) { - return x << 16; + return x.ns << 16; } static inline tmv_t timespec_to_tmv(struct timespec ts) { - return ts.tv_sec * NS_PER_SEC + ts.tv_nsec; + tmv_t t; + t.ns = ts.tv_sec * NS_PER_SEC + ts.tv_nsec; + return t; } static inline tmv_t timestamp_to_tmv(struct timestamp ts) { - return ts.sec * NS_PER_SEC + ts.nsec; + tmv_t t; + t.ns = ts.sec * NS_PER_SEC + ts.nsec; + return t; } static inline tmv_t hwts_to_tmv(const struct hw_timestamp *hwts) { tmv_t t = timespec_to_tmv(hwts->ts); - t += hwts->latency; + t.ns += hwts->latency; return t; } -- 2.9.5 ------------------------------------------------------------------------------ Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot _______________________________________________ Linuxptp-devel mailing list Linuxptp-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/linuxptp-devel