22 files changed, 268 insertions, 264 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index d7ae52ac01e..de56d4160a7 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,32 @@
 2012-07-10  Paul Eggert  <eggert@cs.ucla.edu>
 
+        EMACS_TIME simplification (Bug#11875).
+        This replaces macros (which typically do not work in GDB)
+        with functions, typedefs and enums, making the code easier to debug.
+        The functional style also makes code easier to read and maintain.
+        * systime.h: Include <sys/time.h> on all hosts, not just if
+        WINDOWSNT, since 'struct timeval' is needed in general.
+        (EMACS_TIME): Now a typedef, not a macro.
+        (EMACS_TIME_RESOLUTION, LOG10_EMACS_TIME_RESOLUTION): Now constants,
+        not macros.
+        (EMACS_SECS, EMACS_NSECS, EMACS_TIME_SIGN, EMACS_TIME_VALID_P)
+        (EMACS_TIME_FROM_DOUBLE, EMACS_TIME_TO_DOUBLE, EMACS_TIME_EQ)
+        (EMACS_TIME_NE, EMACS_TIME_GT, EMACS_TIME_GE, EMACS_TIME_LT)
+        (EMACS_TIME_LE): Now functions, not macros.
+        (EMACS_SET_SECS, EMACS_SET_NSECS, EMACS_SET_SECS_NSECS)
+        (EMACS_SET_USECS, EMACS_SET_SECS_USECS): Remove these macros,
+        which are not functions.  All uses rewritten to use:
+        (make_emacs_time): New function.
+        (EMACS_SECS_ADDR, EMACS_SET_INVALID_TIME, EMACS_GET_TIME)
+        (EMACS_ADD_TIME, EMACS_SUB_TIME): Remove these macros, which are
+        not functions.  All uses rewritten to use the following, respectively:
+        (emacs_secs_addr, invalid_emacs_time, get_emacs_time)
+        (add_emacs_time, sub_emacs_time): New functions.
+        * atimer.c: Don't include <sys/time.h>, as "systime.h" does this.
+        * fileio.c (Fcopy_file):
+        * xterm.c (XTflash): Get the current time closer to when it's used.
+        * makefile.w32-in ($(BLD)/atimer.$(O)): Update dependencies.
+
         * bytecode.c (targets): Suppress -Woverride-init warnings.
 
         Simplify by avoiding confusing use of strncpy etc.
diff --git a/src/alloc.c b/src/alloc.c
index 52d683a1b67..89f2c5dbed1 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -5393,7 +5393,7 @@ See Info node `(elisp)Garbage Collection'.  */)
   int message_p;
   Lisp_Object total[8];
   ptrdiff_t count = SPECPDL_INDEX ();
-  EMACS_TIME t1, t2, t3;
+  EMACS_TIME t1;
 
   if (abort_on_gc)
     abort ();
@@ -5442,7 +5442,7 @@ See Info node `(elisp)Garbage Collection'.  */)
       }
   }
 
-  EMACS_GET_TIME (t1);
+  t1 = current_emacs_time ();
 
   /* In case user calls debug_print during GC,
      don't let that cause a recursive GC.  */
@@ -5696,8 +5696,8 @@ See Info node `(elisp)Garbage Collection'.  */)
   /* Accumulate statistics.  */
   if (FLOATP (Vgc_elapsed))
     {
-      EMACS_GET_TIME (t2);
-      EMACS_SUB_TIME (t3, t2, t1);
+      EMACS_TIME t2 = current_emacs_time ();
+      EMACS_TIME t3 = sub_emacs_time (t2, t1);
       Vgc_elapsed = make_float (XFLOAT_DATA (Vgc_elapsed)
                                 + EMACS_TIME_TO_DOUBLE (t3));
     }
diff --git a/src/atimer.c b/src/atimer.c
index 39ac3e826bb..d67e1375f9a 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -26,7 +26,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "blockinput.h"
 #include "atimer.h"
 #include <unistd.h>
-#include <sys/time.h>
 
 /* Free-list of atimer structures.  */
 
@@ -93,10 +92,7 @@ start_atimer (enum atimer_type type, EMACS_TIME timestamp, atimer_callback fn,
 #ifndef HAVE_SETITIMER
   if (EMACS_NSECS (timestamp) != 0
       && EMACS_SECS (timestamp) < TYPE_MAXIMUM (time_t))
-    {
-      EMACS_SET_USECS (timestamp, 0);
-      EMACS_SET_SECS (timestamp, EMACS_SECS (timestamp) + 1);
-    }
+    timestamp = make_emacs_time (EMACS_SECS (timestamp) + 1, 0);
 #endif /* not HAVE_SETITIMER */
 
   /* Get an atimer structure from the free-list, or allocate
@@ -125,13 +121,11 @@ start_atimer (enum atimer_type type, EMACS_TIME timestamp, atimer_callback fn,
       break;
 
     case ATIMER_RELATIVE:
-      EMACS_GET_TIME (t->expiration);
-      EMACS_ADD_TIME (t->expiration, t->expiration, timestamp);
+      t->expiration = add_emacs_time (current_emacs_time (), timestamp);
       break;
 
     case ATIMER_CONTINUOUS:
-      EMACS_GET_TIME (t->expiration);
-      EMACS_ADD_TIME (t->expiration, t->expiration, timestamp);
+      t->expiration = add_emacs_time (current_emacs_time (), timestamp);
       t->interval = timestamp;
       break;
     }
@@ -285,31 +279,25 @@ set_alarm (void)
 {
   if (atimers)
     {
-      EMACS_TIME now, timestamp;
 #ifdef HAVE_SETITIMER
       struct itimerval it;
 #endif
 
       /* Determine s/us till the next timer is ripe.  */
-      EMACS_GET_TIME (now);
+      EMACS_TIME now = current_emacs_time ();
 
       /* Don't set the interval to 0; this disables the timer.  */
-      if (EMACS_TIME_LE (atimers->expiration, now))
-        {
-          EMACS_SET_SECS (timestamp, 0);
-          EMACS_SET_USECS (timestamp, 1000);
-        }
-      else
-        EMACS_SUB_TIME (timestamp, atimers->expiration, now);
-
+      EMACS_TIME interval = (EMACS_TIME_LE (atimers->expiration, now)
+                             ? make_emacs_time (0, 1000 * 1000)
+                             : sub_emacs_time (atimers->expiration, now));
 
 #ifdef HAVE_SETITIMER
 
       memset (&it, 0, sizeof it);
-      it.it_value = make_timeval (timestamp);
+      it.it_value = make_timeval (interval);
       setitimer (ITIMER_REAL, &it, 0);
 #else /* not HAVE_SETITIMER */
-      alarm (max (EMACS_SECS (timestamp), 1));
+      alarm (max (EMACS_SECS (interval), 1));
 #endif /* not HAVE_SETITIMER */
     }
 }
@@ -344,7 +332,7 @@ run_timers (void)
 
   while (atimers
          && (pending_atimers = interrupt_input_blocked) == 0
-         && (EMACS_GET_TIME (now),
+         && (now = current_emacs_time (),
              EMACS_TIME_LE (atimers->expiration, now)))
     {
       struct atimer *t;
@@ -355,7 +343,7 @@ run_timers (void)
 
       if (t->type == ATIMER_CONTINUOUS)
         {
-          EMACS_ADD_TIME (t->expiration, now, t->interval);
+          t->expiration = add_emacs_time (now, t->interval);
           schedule_atimer (t);
         }
       else
diff --git a/src/buffer.c b/src/buffer.c
index f06a2a5ea0c..b8c81a10d54 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -705,7 +705,7 @@ reset_buffer (register struct buffer *b)
   BVAR (b, filename) = Qnil;
   BVAR (b, file_truename) = Qnil;
   BVAR (b, directory) = (current_buffer) ? BVAR (current_buffer, directory) : Qnil;
-  EMACS_SET_SECS_NSECS (b->modtime, 0, UNKNOWN_MODTIME_NSECS);
+  b->modtime = make_emacs_time (0, UNKNOWN_MODTIME_NSECS);
   b->modtime_size = -1;
   XSETFASTINT (BVAR (b, save_length), 0);
   b->last_window_start = 1;
diff --git a/src/dispnew.c b/src/dispnew.c
index 0d34147e035..c149baec507 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -3191,7 +3191,6 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
     force_p = 1;
   else if (!force_p && NUMBERP (Vredisplay_preemption_period))
     {
-      EMACS_TIME tm;
       double p = XFLOATINT (Vredisplay_preemption_period);
 
       if (detect_input_pending_ignore_squeezables ())
@@ -3200,9 +3199,9 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
           goto do_pause;
         }
 
-      EMACS_GET_TIME (tm);
       preemption_period = EMACS_TIME_FROM_DOUBLE (p);
-      EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
+      preemption_next_check = add_emacs_time (current_emacs_time (),
+                                              preemption_period);
     }
 
   if (FRAME_WINDOW_P (f))
@@ -3344,12 +3343,10 @@ update_single_window (struct window *w, int force_p)
         force_p = 1;
       else if (!force_p && NUMBERP (Vredisplay_preemption_period))
         {
-          EMACS_TIME tm;
           double p = XFLOATINT (Vredisplay_preemption_period);
-
-          EMACS_GET_TIME (tm);
           preemption_period = EMACS_TIME_FROM_DOUBLE (p);
-          EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
+          preemption_next_check = add_emacs_time (current_emacs_time (),
+                                                  preemption_period);
         }
 
       /* Update W.  */
@@ -3596,11 +3593,11 @@ update_window (struct window *w, int force_p)
 #if PERIODIC_PREEMPTION_CHECKING
             if (!force_p)
               {
-                EMACS_TIME tm;
-                EMACS_GET_TIME (tm);
+                EMACS_TIME tm = current_emacs_time ();
                 if (EMACS_TIME_LT (preemption_next_check, tm))
                   {
-                    EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
+                    preemption_next_check = add_emacs_time (tm,
+                                                            preemption_period);
                     if (detect_input_pending_ignore_squeezables ())
                       break;
                   }
@@ -4701,11 +4698,10 @@ update_frame_1 (struct frame *f, int force_p, int inhibit_id_p)
 #if PERIODIC_PREEMPTION_CHECKING
           if (!force_p)
             {
-              EMACS_TIME tm;
-              EMACS_GET_TIME (tm);
+              EMACS_TIME tm = current_emacs_time ();
               if (EMACS_TIME_LT (preemption_next_check, tm))
                 {
-                  EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
+                  preemption_next_check = add_emacs_time (tm, preemption_period);
                   if (detect_input_pending_ignore_squeezables ())
                     break;
                 }
diff --git a/src/editfns.c b/src/editfns.c
index e48097ab3a6..32d11faa216 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1408,10 +1408,7 @@ least significant 16 bits.  USEC and PSEC are the microsecond and
 picosecond counts.  */)
   (void)
 {
-  EMACS_TIME t;
-
-  EMACS_GET_TIME (t);
-  return make_lisp_time (t);
+  return make_lisp_time (current_emacs_time ());
 }
 
 DEFUN ("get-internal-run-time", Fget_internal_run_time, Sget_internal_run_time,
@@ -1428,7 +1425,6 @@ does the same thing as `current-time'.  */)
   struct rusage usage;
   time_t secs;
   int usecs;
-  EMACS_TIME t;
 
   if (getrusage (RUSAGE_SELF, &usage) < 0)
     /* This shouldn't happen.  What action is appropriate?  */
@@ -1442,8 +1438,7 @@ does the same thing as `current-time'.  */)
       usecs -= 1000000;
       secs++;
     }
-  EMACS_SET_SECS_USECS (t, secs, usecs);
-  return make_lisp_time (t);
+  return make_lisp_time (make_emacs_time (secs, usecs * 1000));
 #else /* ! HAVE_GETRUSAGE  */
 #ifdef WINDOWSNT
   return w32_get_internal_run_time ();
@@ -1560,8 +1555,7 @@ decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec,
           /* Return the greatest representable time that is not greater
              than the requested time.  */
           time_t sec = hi;
-          EMACS_SET_SECS_NSECS (*result, (sec << 16) + lo,
-                                us * 1000 + ps / 1000);
+          *result = make_emacs_time ((sec << 16) + lo, us * 1000 + ps / 1000);
         }
       else
         {
@@ -1587,7 +1581,7 @@ lisp_time_argument (Lisp_Object specified_time)
 {
   EMACS_TIME t;
   if (NILP (specified_time))
-    EMACS_GET_TIME (t);
+    t = current_emacs_time ();
   else
     {
       Lisp_Object high, low, usec, psec;
@@ -1635,8 +1629,7 @@ or (if you need time as a string) `format-time-string'.  */)
   double t;
   if (NILP (specified_time))
     {
-      EMACS_TIME now;
-      EMACS_GET_TIME (now);
+      EMACS_TIME now = current_emacs_time ();
       t = EMACS_SECS (now) + EMACS_NSECS (now) / 1e9;
     }
   else
@@ -1780,11 +1773,12 @@ format_time_string (char const *format, ptrdiff_t formatlen,
 
   while (1)
     {
+      time_t *taddr = emacs_secs_addr (&t);
       BLOCK_INPUT;
 
       synchronize_system_time_locale ();
 
-      tm = ut ? gmtime (EMACS_SECS_ADDR (t)) : localtime (EMACS_SECS_ADDR (t));
+      tm = ut ? gmtime (taddr) : localtime (taddr);
       if (! tm)
         {
           UNBLOCK_INPUT;
@@ -2065,10 +2059,10 @@ the data it can't find.  */)
   Lisp_Object zone_offset, zone_name;
 
   zone_offset = Qnil;
-  EMACS_SET_SECS_NSECS (value, lisp_seconds_argument (specified_time), 0);
+  value = make_emacs_time (lisp_seconds_argument (specified_time), 0);
   zone_name = format_time_string ("%Z", sizeof "%Z" - 1, value, 0, &localtm);
   BLOCK_INPUT;
-  t = gmtime (EMACS_SECS_ADDR (value));
+  t = gmtime (emacs_secs_addr (&value));
   if (t)
     offset = tm_diff (&localtm, t);
   UNBLOCK_INPUT;
diff --git a/src/fileio.c b/src/fileio.c
index eccb1fbb559..2b55b6f6bd1 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -1927,12 +1927,12 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
       DWORD attributes;
       char * filename;
 
-      EMACS_GET_TIME (now);
       filename = SDATA (encoded_newname);
 
       /* Ensure file is writable while its modified time is set.  */
       attributes = GetFileAttributes (filename);
       SetFileAttributes (filename, attributes & ~FILE_ATTRIBUTE_READONLY);
+      now = current_emacs_time ();
       if (set_file_times (-1, filename, now, now))
         {
           /* Restore original attributes.  */
@@ -3219,12 +3219,10 @@ emacs_lseek (int fd, EMACS_INT offset, int whence)
 static EMACS_TIME
 time_error_value (int errnum)
 {
-  EMACS_TIME t;
   int ns = (errnum == ENOENT || errnum == EACCES || errnum == ENOTDIR
             ? NONEXISTENT_MODTIME_NSECS
             : UNKNOWN_MODTIME_NSECS);
-  EMACS_SET_SECS_NSECS (t, 0, ns);
-  return t;
+  return make_emacs_time (0, ns);
 }
 
 DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,
@@ -5084,7 +5082,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
   struct stat st;
   Lisp_Object handler;
   Lisp_Object filename;
-  EMACS_TIME mtime, diff, one_second;
+  EMACS_TIME mtime, diff;
 
   if (NILP (buf))
     b = current_buffer;
@@ -5112,11 +5110,10 @@ See Info node `(elisp)Modification Time' for more details.  */)
   if ((EMACS_TIME_EQ (mtime, b->modtime)
        /* If both exist, accept them if they are off by one second.  */
        || (EMACS_TIME_VALID_P (mtime) && EMACS_TIME_VALID_P (b->modtime)
-           && ((EMACS_TIME_LT (mtime, b->modtime)
-                ? EMACS_SUB_TIME (diff, b->modtime, mtime)
-                : EMACS_SUB_TIME (diff, mtime, b->modtime)),
-               EMACS_SET_SECS_NSECS (one_second, 1, 0),
-               EMACS_TIME_LE (diff, one_second))))
+           && ((diff = (EMACS_TIME_LT (mtime, b->modtime)
+                        ? sub_emacs_time (b->modtime, mtime)
+                        : sub_emacs_time (mtime, b->modtime))),
+               EMACS_TIME_LE (diff, make_emacs_time (1, 0)))))
       && (st.st_size == b->modtime_size
           || b->modtime_size < 0))
     return Qt;
@@ -5129,7 +5126,7 @@ DEFUN ("clear-visited-file-modtime", Fclear_visited_file_modtime,
 Next attempt to save will certainly not complain of a discrepancy.  */)
   (void)
 {
-  EMACS_SET_SECS_NSECS (current_buffer->modtime, 0, UNKNOWN_MODTIME_NSECS);
+  current_buffer->modtime = make_emacs_time (0, UNKNOWN_MODTIME_NSECS);
   current_buffer->modtime_size = -1;
   return Qnil;
 }
@@ -5428,9 +5425,8 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
                 || NILP (Ffind_file_name_handler (BVAR (b, auto_save_file_name),
                                                   Qwrite_region))))
           {
-            EMACS_TIME before_time, after_time;
-
-            EMACS_GET_TIME (before_time);
+            EMACS_TIME before_time = current_emacs_time ();
+            EMACS_TIME after_time;
 
             /* If we had a failure, don't try again for 20 minutes.  */
             if (b->auto_save_failure_time > 0
@@ -5467,7 +5463,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
             XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
             set_buffer_internal (old);
 
-            EMACS_GET_TIME (after_time);
+            after_time = current_emacs_time ();
 
             /* If auto-save took more than 60 seconds,
                assume it was an NFS failure that got a timeout.  */
diff --git a/src/fns.c b/src/fns.c
index c30c85f7b45..a42a1530906 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -78,8 +78,7 @@ Other values of LIMIT are ignored.  */)
 
   if (EQ (limit, Qt))
     {
-      EMACS_TIME t;
-      EMACS_GET_TIME (t);
+      EMACS_TIME t = current_emacs_time ();
       seed_random (getpid () ^ EMACS_SECS (t) ^ EMACS_NSECS (t));
     }
 
diff --git a/src/image.c b/src/image.c
index b4ad329bacb..88d2f36cda9 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1061,7 +1061,7 @@ void
 prepare_image_for_display (struct frame *f, struct image *img)
 {
   /* We're about to display IMG, so set its timestamp to `now'.  */
-  EMACS_GET_TIME (img->timestamp);
+  img->timestamp = current_emacs_time ();
 
   /* If IMG doesn't have a pixmap yet, load it now, using the image
      type dependent loader function.  */
@@ -1520,8 +1520,8 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
             delay = 1600 * delay / nimages / nimages;
           delay = max (delay, 1);
 
-          EMACS_GET_TIME (t);
-          EMACS_SUB_TIME (old, t, EMACS_TIME_FROM_DOUBLE (delay));
+          t = current_emacs_time ();
+          old = sub_emacs_time (t, EMACS_TIME_FROM_DOUBLE (delay));
 
           for (i = 0; i < c->used; ++i)
             {
@@ -1792,7 +1792,7 @@ lookup_image (struct frame *f, Lisp_Object spec)
     }
 
   /* We're using IMG, so set its timestamp to `now'.  */
-  EMACS_GET_TIME (img->timestamp);
+  img->timestamp = current_emacs_time ();
 
   /* Value is the image id.  */
   return img->id;
diff --git a/src/keyboard.c b/src/keyboard.c
index b34d3c470a5..1ef4ac84d0c 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -2017,12 +2017,11 @@ start_polling (void)
           || EMACS_SECS (poll_timer->interval) != polling_period)
         {
           time_t period = max (1, min (polling_period, TYPE_MAXIMUM (time_t)));
-          EMACS_TIME interval;
+          EMACS_TIME interval = make_emacs_time (period, 0);
 
           if (poll_timer)
             cancel_atimer (poll_timer);
 
-          EMACS_SET_SECS_USECS (interval, period, 0);
           poll_timer = start_atimer (ATIMER_CONTINUOUS, interval,
                                      poll_for_input, NULL);
         }
@@ -2786,13 +2785,8 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
     {
       KBOARD *kb IF_LINT (= NULL);
 
-      if (end_time)
-        {
-          EMACS_TIME now;
-          EMACS_GET_TIME (now);
-          if (EMACS_TIME_GE (now, *end_time))
-            goto exit;
-        }
+      if (end_time && EMACS_TIME_LE (*end_time, current_emacs_time ()))
+        goto exit;
 
       /* Actually read a character, waiting if necessary.  */
       save_getcjmp (save_jump);
@@ -3847,13 +3841,12 @@ kbd_buffer_get_event (KBOARD **kbp,
 #endif
       if (end_time)
         {
-          EMACS_TIME duration;
-          EMACS_GET_TIME (duration);
-          if (EMACS_TIME_GE (duration, *end_time))
+          EMACS_TIME now = current_emacs_time ();
+          if (EMACS_TIME_LE (*end_time, now))
             return Qnil;        /* Finished waiting.  */
           else
             {
-              EMACS_SUB_TIME (duration, *end_time, duration);
+              EMACS_TIME duration = sub_emacs_time (*end_time, now);
               wait_reading_process_output (min (EMACS_SECS (duration),
                                                 WAIT_READING_MAX),
                                            EMACS_NSECS (duration),
@@ -4256,8 +4249,7 @@ timer_start_idle (void)
   if (EMACS_TIME_VALID_P (timer_idleness_start_time))
     return;
 
-  EMACS_GET_TIME (timer_idleness_start_time);
-
+  timer_idleness_start_time = current_emacs_time ();
   timer_last_idleness_start_time = timer_idleness_start_time;
 
   /* Mark all idle-time timers as once again candidates for running.  */
@@ -4278,7 +4270,7 @@ timer_start_idle (void)
 static void
 timer_stop_idle (void)
 {
-  EMACS_SET_INVALID_TIME (timer_idleness_start_time);
+  timer_idleness_start_time = invalid_emacs_time ();
 }
 
 /* Resume idle timer from last idle start time.  */
@@ -4339,7 +4331,7 @@ timer_check_2 (void)
   Lisp_Object timers, idle_timers, chosen_timer;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
-  EMACS_SET_INVALID_TIME (nexttime);
+  nexttime = invalid_emacs_time ();
 
   /* Always consider the ordinary timers.  */
   timers = Vtimer_list;
@@ -4361,11 +4353,10 @@ timer_check_2 (void)
 
   if (CONSP (timers) || CONSP (idle_timers))
     {
-      EMACS_GET_TIME (now);
-      if (EMACS_TIME_VALID_P (timer_idleness_start_time))
-        EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time);
-      else
-        EMACS_SET_SECS_NSECS (idleness_now, 0, 0);
+      now = current_emacs_time ();
+      idleness_now = (EMACS_TIME_VALID_P (timer_idleness_start_time)
+                      ? sub_emacs_time (now, timer_idleness_start_time)
+                      : make_emacs_time (0, 0));
     }
 
   while (CONSP (timers) || CONSP (idle_timers))
@@ -4374,12 +4365,10 @@ timer_check_2 (void)
       Lisp_Object timer = Qnil, idle_timer = Qnil;
       EMACS_TIME timer_time, idle_timer_time;
       EMACS_TIME difference;
-      EMACS_TIME timer_difference, idle_timer_difference;
+      EMACS_TIME timer_difference = invalid_emacs_time ();
+      EMACS_TIME idle_timer_difference = invalid_emacs_time ();
       int ripe, timer_ripe = 0, idle_timer_ripe = 0;
 
-      EMACS_SET_INVALID_TIME (timer_difference);
-      EMACS_SET_INVALID_TIME (idle_timer_difference);
-
       /* Set TIMER and TIMER_DIFFERENCE
          based on the next ordinary timer.
          TIMER_DIFFERENCE is the distance in time from NOW to when
@@ -4395,10 +4384,9 @@ timer_check_2 (void)
             }
 
           timer_ripe = EMACS_TIME_LE (timer_time, now);
-          if (timer_ripe)
-            EMACS_SUB_TIME (timer_difference, now, timer_time);
-          else
-            EMACS_SUB_TIME (timer_difference, timer_time, now);
+          timer_difference = (timer_ripe
+                              ? sub_emacs_time (now, timer_time)
+                              : sub_emacs_time (timer_time, now));
         }
 
       /* Likewise for IDLE_TIMER and IDLE_TIMER_DIFFERENCE
@@ -4413,12 +4401,10 @@ timer_check_2 (void)
             }
 
           idle_timer_ripe = EMACS_TIME_LE (idle_timer_time, idleness_now);
-          if (idle_timer_ripe)
-            EMACS_SUB_TIME (idle_timer_difference,
-                            idleness_now, idle_timer_time);
-          else
-            EMACS_SUB_TIME (idle_timer_difference,
-                            idle_timer_time, idleness_now);
+          idle_timer_difference =
+            (idle_timer_ripe
+             ? sub_emacs_time (idleness_now, idle_timer_time)
+             : sub_emacs_time (idle_timer_time, idleness_now));
         }
 
       /* Decide which timer is the next timer,
@@ -4474,8 +4460,7 @@ timer_check_2 (void)
                  return 0 to indicate that.  */
             }
 
-          EMACS_SET_SECS (nexttime, 0);
-          EMACS_SET_USECS (nexttime, 0);
+          nexttime = make_emacs_time (0, 0);
         }
       else
         /* When we encounter a timer that is still waiting,
@@ -4527,14 +4512,8 @@ NSEC is a multiple of the system clock resolution.  */)
   (void)
 {
   if (EMACS_TIME_VALID_P (timer_idleness_start_time))
-    {
-      EMACS_TIME now, idleness_now;
-
-      EMACS_GET_TIME (now);
-      EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time);
-
-      return make_lisp_time (idleness_now);
-    }
+    return make_lisp_time (sub_emacs_time (current_emacs_time (),
+                                           timer_idleness_start_time));
 
   return Qnil;
 }
@@ -7224,7 +7203,7 @@ input_available_signal (int signo)
 #endif
 
   if (input_available_clear_time)
-    EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
+    *input_available_clear_time = make_emacs_time (0, 0);
 
 #ifndef SYNC_INPUT
   handle_async_input ();
@@ -7327,7 +7306,7 @@ handle_user_signal (int sig)
             /* Tell wait_reading_process_output that it needs to wake
                up and look around.  */
             if (input_available_clear_time)
-              EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
+              *input_available_clear_time = make_emacs_time (0, 0);
           }
         break;
       }
@@ -11344,7 +11323,7 @@ init_keyboard (void)
   quit_char = Ctl ('g');
   Vunread_command_events = Qnil;
   unread_command_char = -1;
-  EMACS_SET_INVALID_TIME (timer_idleness_start_time);
+  timer_idleness_start_time = invalid_emacs_time ();
   total_keys = 0;
   recent_keys_index = 0;
   kbd_fetch_ptr = kbd_buffer;
diff --git a/src/lread.c b/src/lread.c
index 640414b3e91..c0e4a173eeb 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -604,8 +604,7 @@ read_filtered_event (int no_switch_frame, int ascii_required,
     {
       double duration = extract_float (seconds);
       EMACS_TIME wait_time = EMACS_TIME_FROM_DOUBLE (duration);
-      EMACS_GET_TIME (end_time);
-      EMACS_ADD_TIME (end_time, end_time, wait_time);
+      end_time = add_emacs_time (current_emacs_time (), wait_time);
     }
 
 /* Read until we get an acceptable event.  */
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 5459224eb10..0106616f3c9 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -490,7 +490,6 @@ $(BLD)/alloc.$(O) : \
 $(BLD)/atimer.$(O) : \
         $(SRC)/atimer.c \
         $(SRC)/syssignal.h \
-        $(NT_INC)/sys/time.h \
         $(NT_INC)/unistd.h \
         $(ATIMER_H) \
         $(BLOCKINPUT_H) \
diff --git a/src/msdos.c b/src/msdos.c
index e19e4ef8f3a..d75277e3866 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -4138,14 +4138,14 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
       EMACS_TIME clnow, cllast, cldiff;
 
       gettime (&t);
-      EMACS_SET_SECS_NSECS (cllast, t.tv_sec, t.tv_nsec);
+      cllast = make_emacs_time (t.tv_sec, t.tv_nsec);
 
       while (!check_input || !detect_input_pending ())
         {
           gettime (&t);
-          EMACS_SET_SECS_NSECS (clnow, t.tv_sec, t.tv_nsec);
-          EMACS_SUB_TIME (cldiff, clnow, cllast);
-          EMACS_SUB_TIME (*timeout, *timeout, cldiff);
+          clnow = make_emacs_time (t.tv_sec, t.tv_nsec);
+          cldiff = sub_emacs_time (clnow, cllast);
+          *timeout = sub_emacs_time (*timeout, cldiff);
 
           /* Stop when timeout value crosses zero.  */
           if (EMACS_TIME_SIGN (*timeout) <= 0)
diff --git a/src/nsterm.m b/src/nsterm.m
index 0745efc35bd..686b748c14e 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -410,21 +410,16 @@ ns_timeout (int usecs)
      Blocking timer utility used by ns_ring_bell
    -------------------------------------------------------------------------- */
 {
-  EMACS_TIME wakeup, delay;
-
-  EMACS_GET_TIME (wakeup);
-  EMACS_SET_SECS_USECS (delay, 0, usecs);
-  EMACS_ADD_TIME (wakeup, wakeup, delay);
+  EMACS_TIME wakeup = add_emacs_time (current_emacs_time (),
+                                      make_emacs_time (0, usecs * 1000));
 
   /* Keep waiting until past the time wakeup.  */
   while (1)
     {
-      EMACS_TIME timeout;
-
-      EMACS_GET_TIME (timeout);
-      if (EMACS_TIME_LE (wakeup, timeout))
+      EMACS_TIME now = current_emacs_time ();
+      if (EMACS_TIME_LE (wakeup, now))
         break;
-      EMACS_SUB_TIME (timeout, wakeup, timeout);
+      timeout = sub_emacs_time (wakeup, now);
 
       /* Try to wait that long--but we might wake up sooner.  */
       pselect (0, NULL, NULL, NULL, &timeout, NULL);
diff --git a/src/process.c b/src/process.c
index 79100eb7a2c..98a47eca7ae 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1851,10 +1851,9 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
          So have an interrupt jar it loose.  */
       {
         struct atimer *timer;
-        EMACS_TIME offset;
+        EMACS_TIME offset = make_emacs_time (1, 0);
 
         stop_polling ();
-        EMACS_SET_SECS_USECS (offset, 1, 0);
         timer = start_atimer (ATIMER_RELATIVE, offset, create_process_1, 0);
 
         if (forkin >= 0)
@@ -4311,9 +4310,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
      compute the absolute time to return at.  */
   if (time_limit || 0 < nsecs)
     {
-      EMACS_GET_TIME (end_time);
-      EMACS_SET_SECS_NSECS (timeout, time_limit, nsecs);
-      EMACS_ADD_TIME (end_time, end_time, timeout);
+      timeout = make_emacs_time (time_limit, nsecs);
+      end_time = add_emacs_time (current_emacs_time (), timeout);
     }
 
   while (1)
@@ -4342,18 +4340,18 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
              gobble output available now
              but don't wait at all. */
 
-          EMACS_SET_SECS_USECS (timeout, 0, 0);
+          timeout = make_emacs_time (0, 0);
         }
       else if (time_limit || 0 < nsecs)
         {
-          EMACS_GET_TIME (timeout);
-          if (EMACS_TIME_LE (end_time, timeout))
+          EMACS_TIME now = current_emacs_time ();
+          if (EMACS_TIME_LE (end_time, now))
             break;
-          EMACS_SUB_TIME (timeout, end_time, timeout);
+          timeout = sub_emacs_time (end_time, now);
         }
       else
         {
-          EMACS_SET_SECS_USECS (timeout, 100000, 0);
+          timeout = make_emacs_time (100000, 0);
         }
 
       /* Normally we run timers here.
@@ -4438,7 +4436,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
             Atemp = input_wait_mask;
           Ctemp = write_mask;
 
-          EMACS_SET_SECS_USECS (timeout, 0, 0);
+          timeout = make_emacs_time (0, 0);
           if ((pselect (max (max_process_desc, max_input_desc) + 1,
                         &Atemp,
 #ifdef NON_BLOCKING_CONNECT
@@ -4590,7 +4588,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                         nsecs = XPROCESS (proc)->read_output_delay;
                     }
                 }
-              EMACS_SET_SECS_NSECS (timeout, 0, nsecs);
+              timeout = make_emacs_time (0, nsecs);
               process_output_skip = 0;
             }
 #endif
@@ -6426,7 +6424,7 @@ sigchld_handler (int signo)
           /* Tell wait_reading_process_output that it needs to wake up and
              look around.  */
           if (input_available_clear_time)
-            EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
+            *input_available_clear_time = make_emacs_time (0, 0);
         }
 
       /* There was no asynchronous process found for that pid: we have
@@ -6444,7 +6442,7 @@ sigchld_handler (int signo)
           /* Tell wait_reading_process_output that it needs to wake up and
              look around.  */
           if (input_available_clear_time)
-            EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
+            *input_available_clear_time = make_emacs_time (0, 0);
         }
 
     sigchld_end_of_loop:
@@ -6857,9 +6855,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
   /* What does time_limit really mean?  */
   if (time_limit || 0 < nsecs)
     {
-      EMACS_GET_TIME (end_time);
-      EMACS_SET_SECS_NSECS (timeout, time_limit, nsecs);
-      EMACS_ADD_TIME (end_time, end_time, timeout);
+      timeout = make_emacs_time (time_limit, nsecs);
+      end_time = add_emacs_time (current_emacs_time (), timeout);
     }
 
   /* Turn off periodic alarms (in case they are in use)
@@ -6892,18 +6889,18 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
              gobble output available now
              but don't wait at all. */
 
-          EMACS_SET_SECS_USECS (timeout, 0, 0);
+          timeout = make_emacs_time (0, 0);
         }
       else if (time_limit || 0 < nsecs)
         {
-          EMACS_GET_TIME (timeout);
-          if (EMACS_TIME_LE (end_time, timeout))
+          EMACS_TIME now = current_emacs_time ();
+          if (EMACS_TIME_LE (end_time, now))
             break;
-          EMACS_SUB_TIME (timeout, end_time, timeout);
+          timeout = sub_emacs_time (end_time, now);
         }
       else
         {
-          EMACS_SET_SECS_USECS (timeout, 100000, 0);
+          timeout = make_emacs_time (100000, 0);
         }
 
       /* If our caller will not immediately handle keyboard events,
diff --git a/src/sysdep.c b/src/sysdep.c
index ed926760414..37dc75529d0 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -2586,7 +2586,6 @@ time_from_jiffies (unsigned long long tval, long hz)
   unsigned long long s = tval / hz;
   unsigned long long frac = tval % hz;
   int ns;
-  EMACS_TIME t;
 
   if (TYPE_MAXIMUM (time_t) < s)
     time_overflow ();
@@ -2603,8 +2602,7 @@ time_from_jiffies (unsigned long long tval, long hz)
       ns = frac / hz_per_ns;
     }
 
-  EMACS_SET_SECS_NSECS (t, s, ns);
-  return t;
+  return make_emacs_time (s, ns);
 }
 
 static Lisp_Object
@@ -2618,9 +2616,7 @@ static EMACS_TIME
 get_up_time (void)
 {
   FILE *fup;
-  EMACS_TIME up;
-
-  EMACS_SET_SECS_NSECS (up, 0, 0);
+  EMACS_TIME up = make_emacs_time (0, 0);
 
   BLOCK_INPUT;
   fup = fopen ("/proc/uptime", "r");
@@ -2649,7 +2645,7 @@ get_up_time (void)
                 upfrac /= 10;
               upfrac = min (upfrac, EMACS_TIME_RESOLUTION - 1);
             }
-          EMACS_SET_SECS_NSECS (up, upsec, upfrac);
+          up = make_emacs_time (upsec, upfrac);
         }
       fclose (fup);
     }
@@ -2874,15 +2870,15 @@ system_process_attributes (Lisp_Object pid)
           attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs);
           attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
           attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs);
-          EMACS_GET_TIME (tnow);
+          tnow = current_emacs_time ();
           telapsed = get_up_time ();
-          EMACS_SUB_TIME (tboot, tnow, telapsed);
+          tboot = sub_emacs_time (tnow, telapsed);
           tstart = time_from_jiffies (start, clocks_per_sec);
-          EMACS_ADD_TIME (tstart, tboot, tstart);
+          tstart = add_emacs_time (tboot, tstart);
           attrs = Fcons (Fcons (Qstart, make_lisp_time (tstart)), attrs);
           attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize/1024)), attrs);
           attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4*rss)), attrs);
-          EMACS_SUB_TIME (telapsed, tnow, tstart);
+          telapsed = sub_emacs_time (tnow, tstart);
           attrs = Fcons (Fcons (Qetime, make_lisp_time (telapsed)), attrs);
           us_time = time_from_jiffies (u_time + s_time, clocks_per_sec);
           pcpu = (EMACS_TIME_TO_DOUBLE (us_time)
@@ -3101,9 +3097,7 @@ system_process_attributes (Lisp_Object pid)
 static EMACS_TIME
 timeval_to_EMACS_TIME (struct timeval t)
 {
-  EMACS_TIME e;
-  EMACS_SET_SECS_NSECS (e, t.tv_sec, t.tv_usec * 1000);
-  return e;
+  return make_emacs_time (t.tv_sec, t.tv_usec * 1000);
 }
 
 static Lisp_Object
@@ -3211,9 +3205,8 @@ system_process_attributes (Lisp_Object pid)
                  attrs);
   attrs = Fcons (Fcons (Qstime, make_lisp_timeval (proc.ki_rusage.ru_stime)),
                  attrs);
-  EMACS_ADD_TIME (t,
-                  timeval_to_EMACS_TIME (proc.ki_rusage.ru_utime),
-                  timeval_to_EMACS_TIME (proc.ki_rusage.ru_stime));
+  t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage.ru_utime),
+                      timeval_to_EMACS_TIME (proc.ki_rusage.ru_stime));
   attrs = Fcons (Fcons (Qtime, make_lisp_time (t)), attrs);
 
   attrs = Fcons (Fcons (Qcutime,
@@ -3222,9 +3215,8 @@ system_process_attributes (Lisp_Object pid)
   attrs = Fcons (Fcons (Qcstime,
                         make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
                  attrs);
-  EMACS_ADD_TIME (t,
-                  timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_utime),
-                  timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_stime));
+  t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_utime),
+                      timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_stime));
   attrs = Fcons (Fcons (Qctime, make_lisp_time (t)), attrs);
 
   attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (proc.ki_numthreads)),
@@ -3236,8 +3228,8 @@ system_process_attributes (Lisp_Object pid)
   attrs = Fcons (Fcons (Qrss,   make_number (proc.ki_rssize * pagesize >> 10)),
                  attrs);
 
-  EMACS_GET_TIME (now);
-  EMACS_SUB_TIME (t, now, timeval_to_EMACS_TIME (proc.ki_start));
+  now = current_emacs_time ();
+  t = sub_emacs_time (now, timeval_to_EMACS_TIME (proc.ki_start));
   attrs = Fcons (Fcons (Qetime, make_lisp_time (t)), attrs);
 
   len = sizeof fscale;
diff --git a/src/systime.h b/src/systime.h
index a03630cf936..24e9a6f4507 100644
--- a/src/systime.h
+++ b/src/systime.h
@@ -39,65 +39,92 @@ typedef unsigned long Time;
 #endif
 #endif
 
-#ifdef WINDOWSNT
 #include <sys/time.h>   /* for 'struct timeval' */
-#endif
 
-/* The type to use to represent temporal intervals.  It can be passed
+/* The type to use to represent temporal intervals.  Its address can be passed
    as the timeout argument to the pselect system call.  */
-#define EMACS_TIME struct timespec
+typedef struct timespec EMACS_TIME;
 
 /* Resolution of EMACS_TIME time stamps (in units per second), and log
    base 10 of the resolution.  The log must be a positive integer.  */
-#define EMACS_TIME_RESOLUTION           1000000000
-#define LOG10_EMACS_TIME_RESOLUTION     9
-
-/* EMACS_SECS (TIME) is an rvalue for the seconds component of TIME.
-   EMACS_SECS_ADDR (time) is the address of the seconds component.
-   EMACS_SET_SECS (TIME, SECONDS) sets that to SECONDS.
-
-   EMACS_NSECS (TIME) is an rvalue for the nanoseconds component of TIME.
-   EMACS_SET_NSECS (TIME, NANOSECONDS) sets that to NANOSECONDS.
-
-   EMACS_SET_SECS_NSECS (TIME, SECS, NSECS) sets both components of TIME.  */
-#define EMACS_SECS(time)                    ((time).tv_sec  + 0)
-#define EMACS_NSECS(time)                   ((time).tv_nsec + 0)
-#define EMACS_SECS_ADDR(time)               (&(time).tv_sec)
-#define EMACS_SET_SECS(time, seconds)       ((time).tv_sec  = (seconds))
-#define EMACS_SET_NSECS(time, ns)           ((time).tv_nsec = (ns))
-#define EMACS_SET_SECS_NSECS(time, s, ns)                               \
-  ((void) (EMACS_SET_SECS (time, s), EMACS_SET_NSECS (time, ns)))
-
-/* Convenience macros for older code that counts microseconds.  */
-#define EMACS_SET_USECS(time, us)  ((void) EMACS_SET_NSECS (time, (us) * 1000))
-#define EMACS_SET_SECS_USECS(time, secs, usecs)                 \
-  (EMACS_SET_SECS (time, secs), EMACS_SET_USECS (time, usecs))
-
-/* Set TIME to an invalid time stamp.  */
-#define EMACS_SET_INVALID_TIME(time)        EMACS_SET_SECS_NSECS(time, 0, -1)
-
-/* Set TIME to the current system time.  */
-#define EMACS_GET_TIME(time)                gettime (&(time))
-
-/* Put into DEST the result of adding SRC1 to SRC2, or of subtracting
-   SRC2 from SRC1.  On overflow, store an extremal value: ergo, if
-   time_t is unsigned, return 0 if the true answer would be negative.  */
-#define EMACS_ADD_TIME(dest, src1, src2) ((dest) = timespec_add (src1, src2))
-#define EMACS_SUB_TIME(dest, src1, src2) ((dest) = timespec_sub (src1, src2))
+enum { EMACS_TIME_RESOLUTION = 1000000000 };
+enum { LOG10_EMACS_TIME_RESOLUTION = 9 };
+
+/* EMACS_SECS (TIME) is the seconds component of TIME.
+   EMACS_NSECS (TIME) is the nanoseconds component of TIME.
+   emacs_secs_addr (PTIME) is the address of *PTIME's seconds component.  */
+static inline time_t EMACS_SECS (EMACS_TIME t) { return t.tv_sec; }
+static inline int EMACS_NSECS (EMACS_TIME t) { return t.tv_nsec; }
+static inline time_t *emacs_secs_addr (EMACS_TIME *t) { return &t->tv_sec; }
+
+/* Return an Emacs time with seconds S and nanoseconds NS.  */
+static inline EMACS_TIME
+make_emacs_time (time_t s, int ns)
+{
+  EMACS_TIME r = { s, ns };
+  return r;
+}
+
+/* Return an invalid Emacs time.  */
+static inline EMACS_TIME
+invalid_emacs_time (void)
+{
+  EMACS_TIME r = { 0, -1 };
+  return r;
+}
+
+/* Return current system time.  */
+static inline EMACS_TIME
+current_emacs_time (void)
+{
+  EMACS_TIME r;
+  gettime (&r);
+  return r;
+}
+
+/* Return the result of adding A to B, or of subtracting B from A.
+   On overflow, store an extremal value: ergo, if time_t is unsigned,
+   return 0 if the true answer would be negative.  */
+static inline EMACS_TIME
+add_emacs_time (EMACS_TIME a, EMACS_TIME b)
+{
+  return timespec_add (a, b);
+}
+static inline EMACS_TIME
+sub_emacs_time (EMACS_TIME a, EMACS_TIME b)
+{
+  return timespec_sub (a, b);
+}
 
 /* Return the sign of the valid time stamp TIME, either -1, 0, or 1.  */
-#define EMACS_TIME_SIGN(time)           timespec_sign (time)
+static inline int
+EMACS_TIME_SIGN (EMACS_TIME t)
+{
+  return timespec_sign (t);
+}
 
 /* Return 1 if TIME is a valid time stamp.  */
-#define EMACS_TIME_VALID_P(time)        (0 <= (time).tv_nsec)
+static inline int
+EMACS_TIME_VALID_P (EMACS_TIME t)
+{
+  return 0 <= t.tv_nsec;
+}
 
 /* Convert the double D to the greatest EMACS_TIME not greater than D.
    On overflow, return an extremal value.  Return the minimum
    EMACS_TIME if D is not a number.  */
-#define EMACS_TIME_FROM_DOUBLE(d)       dtotimespec (d)
+static inline EMACS_TIME
+EMACS_TIME_FROM_DOUBLE (double d)
+{
+  return dtotimespec (d);
+}
 
 /* Convert the Emacs time T to an approximate double value D.  */
-#define EMACS_TIME_TO_DOUBLE(t)         timespectod (t)
+static inline double
+EMACS_TIME_TO_DOUBLE (EMACS_TIME t)
+{
+  return timespectod (t);
+}
 
 /* defined in sysdep.c */
 extern int set_file_times (int, const char *, EMACS_TIME, EMACS_TIME);
@@ -118,12 +145,35 @@ extern EMACS_TIME lisp_time_argument (Lisp_Object);
 #endif
 
 /* Compare times T1 and T2 for equality, inequality etc.  */
-
-#define EMACS_TIME_EQ(T1, T2) (timespec_cmp (T1, T2) == 0)
-#define EMACS_TIME_NE(T1, T2) (timespec_cmp (T1, T2) != 0)
-#define EMACS_TIME_GT(T1, T2) (timespec_cmp (T1, T2) > 0)
-#define EMACS_TIME_GE(T1, T2) (timespec_cmp (T1, T2) >= 0)
-#define EMACS_TIME_LT(T1, T2) (timespec_cmp (T1, T2) < 0)
-#define EMACS_TIME_LE(T1, T2) (timespec_cmp (T1, T2) <= 0)
+static inline int
+EMACS_TIME_EQ (EMACS_TIME t1, EMACS_TIME t2)
+{
+  return timespec_cmp (t1, t2) == 0;
+}
+static inline int
+EMACS_TIME_NE (EMACS_TIME t1, EMACS_TIME t2)
+{
+  return timespec_cmp (t1, t2) != 0;
+}
+static inline int
+EMACS_TIME_GT (EMACS_TIME t1, EMACS_TIME t2)
+{
+  return timespec_cmp (t1, t2) > 0;
+}
+static inline int
+EMACS_TIME_GE (EMACS_TIME t1, EMACS_TIME t2)
+{
+  return timespec_cmp (t1, t2) >= 0;
+}
+static inline int
+EMACS_TIME_LT (EMACS_TIME t1, EMACS_TIME t2)
+{
+  return timespec_cmp (t1, t2) < 0;
+}
+static inline int
+EMACS_TIME_LE (EMACS_TIME t1, EMACS_TIME t2)
+{
+  return timespec_cmp (t1, t2) <= 0;
+}
 
 #endif /* EMACS_SYSTIME_H */
diff --git a/src/undo.c b/src/undo.c
index bada46563a0..c90e7b62405 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -517,9 +517,9 @@ Return what remains of the list.  */)
                       && CONSP (XCDR (XCDR (XCDR (cdr))))
                       && INTEGERP (XCAR (XCDR (XCDR (XCDR (cdr)))))
                       && XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) < 0)
-                    EMACS_SET_SECS_NSECS
-                      (mod_time, 0,
-                       XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) / 1000);
+                    mod_time =
+                      (make_emacs_time
+                       (0, XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) / 1000));
                   else
                     mod_time = lisp_time_argument (cdr);
 
diff --git a/src/w32.c b/src/w32.c
index 167dd467e10..e8c48a50a97 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -1969,7 +1969,7 @@ gettimeofday (struct timeval *tv, struct timezone *tz)
      changed.  We could fix that by using GetSystemTime and
      GetTimeZoneInformation, but that doesn't seem necessary, since
      Emacs always calls gettimeofday with the 2nd argument NULL (see
-     EMACS_GET_TIME).  */
+     current_emacs_time).  */
   if (tz)
     {
       tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich  */
diff --git a/src/xdisp.c b/src/xdisp.c
index 4c9f3fda0a8..6af0dd6e8a3 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -29308,14 +29308,14 @@ start_hourglass (void)
 
   if (INTEGERP (Vhourglass_delay)
       && XINT (Vhourglass_delay) > 0)
-    EMACS_SET_SECS_NSECS (delay,
-                          min (XINT (Vhourglass_delay), TYPE_MAXIMUM (time_t)),
-                          0);
+    delay = make_emacs_time (min (XINT (Vhourglass_delay),
+                                  TYPE_MAXIMUM (time_t)),
+                             0);
   else if (FLOATP (Vhourglass_delay)
            && XFLOAT_DATA (Vhourglass_delay) > 0)
     delay = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (Vhourglass_delay));
   else
-    EMACS_SET_SECS_NSECS (delay, DEFAULT_HOURGLASS_DELAY, 0);
+    delay = make_emacs_time (DEFAULT_HOURGLASS_DELAY, 0);
 
   hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
                                    show_hourglass, NULL);
diff --git a/src/xgselect.c b/src/xgselect.c
index 3752056bd76..04ca00274e8 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -88,8 +88,8 @@ xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
 
   if (tmo_in_millisec >= 0)
     {
-      EMACS_SET_SECS_USECS (tmo, tmo_in_millisec/1000,
-                            1000 * (tmo_in_millisec % 1000));
+      tmo = make_emacs_time (tmo_in_millisec / 1000,
+                             1000 * 1000 * (tmo_in_millisec % 1000));
       if (!timeout || EMACS_TIME_LT (tmo, *timeout))
         tmop = &tmo;
     }
diff --git a/src/xterm.c b/src/xterm.c
index 3cf6b4c349a..b5c5ce33d6c 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -3168,26 +3168,22 @@ XTflash (struct frame *f)
       x_flush (f);
 
       {
-        EMACS_TIME wakeup, delay;
-
-        EMACS_GET_TIME (wakeup);
-        EMACS_SET_SECS_NSECS (delay, 0, 150 * 1000 * 1000);
-        EMACS_ADD_TIME (wakeup, wakeup, delay);
+        EMACS_TIME delay = make_emacs_time (0, 150 * 1000 * 1000);
+        EMACS_TIME wakeup = add_emacs_time (current_emacs_time (), delay);
 
         /* Keep waiting until past the time wakeup or any input gets
            available.  */
         while (! detect_input_pending ())
           {
-            EMACS_TIME current, timeout;
-
-            EMACS_GET_TIME (current);
+            EMACS_TIME current = current_emacs_time ();
+            EMACS_TIME timeout;
 
             /* Break if result would not be positive.  */
             if (EMACS_TIME_LE (wakeup, current))
               break;
 
             /* How long `select' should wait.  */
-            EMACS_SET_SECS_NSECS (timeout, 0, 10 * 1000 * 1000);
+            timeout = make_emacs_time (0, 10 * 1000 * 1000);
 
             /* Try to wait that long--but we might wake up sooner.  */
             pselect (0, NULL, NULL, NULL, &timeout, NULL);
@@ -8810,9 +8806,8 @@ x_wait_for_event (struct frame *f, int eventtype)
 
   /* Set timeout to 0.1 second.  Hopefully not noticeable.
      Maybe it should be configurable.  */
-  EMACS_SET_SECS_USECS (tmo, 0, 100000);
-  EMACS_GET_TIME (tmo_at);
-  EMACS_ADD_TIME (tmo_at, tmo_at, tmo);
+  tmo = make_emacs_time (0, 100 * 1000 * 1000);
+  tmo_at = add_emacs_time (current_emacs_time (), tmo);
 
   while (pending_event_wait.eventtype)
     {
@@ -8825,11 +8820,11 @@ x_wait_for_event (struct frame *f, int eventtype)
       FD_ZERO (&fds);
       FD_SET (fd, &fds);
 
-      EMACS_GET_TIME (time_now);
+      time_now = current_emacs_time ();
       if (EMACS_TIME_LT (tmo_at, time_now))
         break;
 
-      EMACS_SUB_TIME (tmo, tmo_at, time_now);
+      tmo = sub_emacs_time (tmo_at, time_now);
       if (pselect (fd + 1, &fds, NULL, NULL, &tmo, NULL) == 0)
         break; /* Timeout */
     }
@@ -10602,9 +10597,7 @@ x_activate_timeout_atimer (void)
   BLOCK_INPUT;
   if (!x_timeout_atimer_activated_flag)
     {
-      EMACS_TIME interval;
-
-      EMACS_SET_SECS_USECS (interval, 0, 100000);
+      EMACS_TIME interval = make_emacs_time (0, 100 * 1000 * 1000);
       start_atimer (ATIMER_RELATIVE, interval, x_process_timeouts, 0);
       x_timeout_atimer_activated_flag = 1;
     }