Support higher-resolution time stamps.

Fixes: debbugs:9000

34 files changed, 962 insertions, 953 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index a5e10fe9473..65424205f34 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,172 @@
+2012-06-22  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Support higher-resolution time stamps (Bug#9000).
+        The time stamps are only nanosecond-resolution at the C level,
+        since that's the best that any real-world system supports now.
+        But they are picosecond-resolution at the Lisp level, as that's
+        easy, and leaves room for future OS improvements.
+
+        * Makefile.in (LIB_CLOCK_GETTIME): New macro.
+        (LIBES): Use it.
+
+        * alloc.c (Fgarbage_collect): Port to higher-res time stamps.
+        Don't get current time unless it's needed.
+
+        * atimer.c: Include <sys/time.h> unconditionally, since gnulib
+        now provides it if it's absent.
+        (start_atimer): Port to higher-res time stamps.
+        Check for time stamp overflow.  Don't get current time more
+        often than is needed.
+
+        * buffer.h (struct buffer): Buffer modtime now has high resolution.
+        Include systime.h, not time.h.
+        (NONEXISTENT_MODTIME_NSECS, UNKNOWN_MODTIME_NSECS): New macros.
+
+        * dired.c: Include stat-time.h.
+        (Ffile-attributes): File times now have higher resolution.
+
+        * dispextern.h [HAVE_WINDOW_SYSTEM]: Include systime.h.
+        (struct image): Timestamp now has higher resolution.
+
+        * dispnew.c (PERIODIC_PREEMPTION_CHECKING): Remove, as Emacs always
+        has at least microseconds now.  All uses removed.
+        (update_frame, update_single_window, update_window, update_frame_1)
+        (Fsleep_for, sit_for): Port to higher-resolution time stamps.
+
+        * editfns.c (time_overflow): Now extern.
+        (Fcurrent_time, Fget_internal_run_time, make_time, lisp_time_argument)
+        (float-time, Fformat_time_string, Fcurrent_time_string)
+        (Fcurrent_time_zone): Accept and generate higher-resolution
+        time stamps.
+        (make_time_tail, make_lisp_time, dissassemble_lisp_time)
+        (decode_time_components, lisp_seconds_argument): New functions.
+        (make_time): Now static.
+        (lisp_time_argument): Now returns EMACS_TIME.  New arg ppsec.
+        Report an error if the time is invalid, rather than having the caller
+        do that.
+
+        * fileio.c: Include <stat-time.h>
+        (Fcopy_file): Copy higher-resolution time stamps.
+        Prefer to set the time stamp via a file descriptor if that works.
+        (Fset_file_times, Finsert_file_contents, Fwrite_region)
+        (Fverify_visited_file_modtime, Fclear_visited_file_modtime)
+        (Fvisited_file_modtime, Fset_visited_file_modtime):
+        Support higher-resolution time stamps.
+
+        * fns.c (Frandom): Use nanoseconds, not microseconds, for seed.
+
+        * gtkutil.c (xg_maybe_add_timer): Port to higher-res time stamps.
+
+        * image.c (prepare_image_for_display, clear_image_cache)
+        (lookup_image): Port to higer-resolution time stamps.
+
+        * keyboard.c (start_polling, bind_polling_period):
+        Check for time stamp overflow.
+        (read_char, kbd_buffer_get_event, timer_start_idle)
+        (timer_stop_idle, timer_resume_idle, timer_check_2, timer_check)
+        (Fcurrent_idle_time, init_keyboard, set_waiting_for_input):
+        Port to higher-resolution time stamps.  Do not assume time_t is signed.
+        (decode_timer): New function.  Timers are now vectors of length 9,
+        not 8, to accommodate the picosecond component.
+        (timer_check_2): Use it.
+
+        * nsterm.m (select_timeout, timeval_subtract): Remove.
+        (ns_timeout): Use Emacs's facilities for time stamp arithmetic,
+        as they're a bit more accurate and handle overflow better.
+        (ns_select): Change prototype to be compatible with pselect.
+        (ns_select, ns_term_shutdown): Port to ns-resolution time stamps.
+        * nsterm.h (ns_select): Adjust prototype.
+
+        * msdos.c (EMACS_TIME_ZERO_OR_NEG_P): Remove, as it assumes
+        us-resolution time stamps.
+        (sys_select): Use the new EMACS_TIME_SIGN macro instead.
+
+        * lread.c (read_filtered_event): Port to ns-resolution time stamps.
+
+        * lisp.h (time_overflow): New decl.
+        (wait_reading_process_output): First arg is now intmax_t, not int,
+        to accommodate larger waits.
+
+        * process.h (struct Lisp_Process.read_output_delay):
+        Now counts nanoseconds, not microseconds.
+        * process.c (ADAPTIVE_READ_BUFFERING): Don't worry about
+        EMACS_HAS_USECS.
+        (READ_OUTPUT_DELAY_INCREMENT, Faccept_process_output)
+        (wait_reading_process_output):
+        Port to ns-resolution time stamps.
+        (Faccept_process_output, wait_reading_process_output):
+        Check for time stamp overflow.  Do not assume time_t is signed.
+        (select_wrapper): Remove; we now use pselect.
+        (Fprocess_attributes): Now generates ns-resolution time stamps.
+
+        * sysdep.c: Include utimens.h.  Don't include utime.h
+        or worry about struct utimbuf; gnulib does that for us now.
+        (gettimeofday): Remove; gnulib provides a substitute.
+        (make_timeval): New function.
+        (set_file_times): Now sets ns-resolution time stamps.
+        New arg FD; all uses changed.
+        (time_from_jiffies, ltime_from_jiffies, get_up_time)
+        (system_process_attributes):
+        Now returns ns-resolution time stamp.  All uses changed.
+        Check for time stamp overflow.
+
+        * sysselect.h: Don't depend on HAVE_SYS_SELECT_H; gnulib
+        provides a substitute now.
+
+        * systime.h: Include timespec.h rather than sys/time.h and time.h,
+        since it guarantees struct timespec.
+        (EMACS_TIME): Now struct timespec, so that we can support
+        ns-resolution time stamps.
+        (EMACS_TIME_RESOLUTION, LOG10_EMACS_TIME_RESOLUTION): New macros.
+        (EMACS_HAS_USECS): Remove; Emacs always has sub-second time stamps now.
+        (EMACS_USECS): Remove.
+        (EMACS_SET_USECS): The underlying time stamp now has ns resolution,
+        so multiply the arg by 1000 before storing it.
+        (EMACS_NSECS, EMACS_SECS_ADDR, EMACS_SET_NSECS, EMACS_SET_SECS_NSECS):
+        New macros.
+        (EMACS_GET_TIME, EMACS_ADD_TIME, EMACS_SUB_TIME):
+        Port to ns-resolution time stamps.
+        (EMACS_TIME_NEG_P): Remove; replaced by....
+        (EMACS_TIME_SIGN): New macro.
+        (EMACS_SET_INVALID_TIME, EMACS_TIME_VALID_P)
+        (EMACS_TIME_FROM_DOUBLE, EMACS_TIME_TO_DOUBLE): New macros.
+        (set_file_times, make_time, lisp_time_argument): Adjust signature.
+        (make_timeval, make_lisp_time, decode_time_components): New decls.
+        (EMACS_TIME_CMP): Remove; no longer used.  Plus, it was buggy, in
+        that it mishandled time_t overflow.  You can't compare by subtracting!
+        (EMACS_TIME_EQ, EMACS_TIME_NE, EMACS_TIME_GT, EMACS_TIME_GE)
+        (EMACS_TIME_LT, EMACS_TIME_LE): Rewrite in terms of timespec_cmp.
+
+        * term.c: Include <sys/time.h>.
+        (timeval_to_Time): New function, for proper overflow wraparound.
+        (term_mouse_position, term_mouse_click): Use it.
+
+        * undo.c (record_first_change): Support higher-resolution time stamps
+        in the undo buffer.
+        (Fprimitive_undo): Use them when restoring time stamps.
+
+        * w32.c (ltime, U64_TO_LISP_TIME, process_times, emacs_gnutls_pull)
+        (w32_get_internal_run_time):
+        Port to higher-resolution Emacs time stamps.
+        (ltime): Now accepts single 64-bit integer, as that's more convenient
+        for callers.
+
+        * xdisp.c (start_hourglass): Port to ns-resolution time stamps.
+
+        * xgselect.c, xgselect.h (xg_select): Add sigmask argument,
+        for compatibility with pselect.  Support ns-resolution time stamps.
+
+        * xmenu.c (x_menu_wait_for_event): Support ns-resolution time stamps.
+
+        * xselect.c (wait_for_property_change, x_get_foreign_selection):
+        Check for time stamp overflow, and support ns-resolution time stamps.
+
+        * xterm.c: Don't include sys/time.h; gnulib does that for us now.
+        Don't worry about whether HAVE_TIMEVAL and HAVE_SELECT are set.
+        (timeval_subtract): Remove; no longer needed.
+        (XTflash, XTring_bell, x_wait_for_event):
+        Port to ns-resolution time stamps.  Don't assume time_t is signed.
+
 2012-06-22  Chong Yidong  <cyd@gnu.org>
 
         * xdisp.c (x_consider_frame_title): Revert last change.
diff --git a/src/Makefile.in b/src/Makefile.in
index 47c7d5cfbc2..40cfe94c707 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -153,6 +153,8 @@ LIBOTF_LIBS = @LIBOTF_LIBS@
 M17N_FLT_CFLAGS = @M17N_FLT_CFLAGS@
 M17N_FLT_LIBS = @M17N_FLT_LIBS@
 
+LIB_CLOCK_GETTIME=@LIB_CLOCK_GETTIME@
+
 DBUS_CFLAGS = @DBUS_CFLAGS@
 DBUS_LIBS = @DBUS_LIBS@
 ## dbusbind.o if HAVE_DBUS, else empty.
@@ -384,7 +386,7 @@ otherobj= $(TERMCAP_OBJ) $(PRE_ALLOC_OBJ) $(GMALLOC_OBJ) $(RALLOC_OBJ) \
 ## duplicated symbols.  If the standard libraries were compiled
 ## with GCC, we might need LIB_GCC again after them.
 LIBES = $(LIBS) $(LIBX_BASE) $(LIBX_OTHER) $(LIBSOUND) \
-   $(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(DBUS_LIBS) \
+   $(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(LIB_CLOCK_GETTIME) $(DBUS_LIBS) \
    $(LIBXML2_LIBS) $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \
    $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
diff --git a/src/alloc.c b/src/alloc.c
index aba76386dd6..490632f282f 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -5669,12 +5669,14 @@ See Info node `(elisp)Garbage Collection'.  */)
     }
 
   /* Accumulate statistics.  */
-  EMACS_GET_TIME (t2);
-  EMACS_SUB_TIME (t3, t2, t1);
   if (FLOATP (Vgc_elapsed))
-    Vgc_elapsed = make_float (XFLOAT_DATA (Vgc_elapsed) +
-                              EMACS_SECS (t3) +
-                              EMACS_USECS (t3) * 1.0e-6);
+    {
+      EMACS_GET_TIME (t2);
+      EMACS_SUB_TIME (t3, t2, t1);
+      Vgc_elapsed = make_float (XFLOAT_DATA (Vgc_elapsed)
+                                + EMACS_TIME_TO_DOUBLE (t3));
+    }
+
   gcs_done++;
 
   return Flist (sizeof total / sizeof *total, total);
diff --git a/src/atimer.c b/src/atimer.c
index 48f22fe0e3e..e72bc305753 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -26,10 +26,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "blockinput.h"
 #include "atimer.h"
 #include <unistd.h>
-
-#ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
-#endif
 
 /* Free-list of atimer structures.  */
 
@@ -94,7 +91,8 @@ start_atimer (enum atimer_type type, EMACS_TIME timestamp, atimer_callback fn,
   /* Round TIME up to the next full second if we don't have
      itimers.  */
 #ifndef HAVE_SETITIMER
-  if (EMACS_USECS (timestamp) != 0)
+  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);
@@ -294,18 +292,21 @@ set_alarm (void)
 
       /* Determine s/us till the next timer is ripe.  */
       EMACS_GET_TIME (now);
-      EMACS_SUB_TIME (timestamp, atimers->expiration, now);
 
-#ifdef HAVE_SETITIMER
       /* 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);
+
+
+#ifdef HAVE_SETITIMER
 
       memset (&it, 0, sizeof it);
-      it.it_value = timestamp;
+      it.it_value = make_timeval (timestamp);
       setitimer (ITIMER_REAL, &it, 0);
 #else /* not HAVE_SETITIMER */
       alarm (max (EMACS_SECS (timestamp), 1));
@@ -341,11 +342,10 @@ run_timers (void)
 {
   EMACS_TIME now;
 
-  EMACS_GET_TIME (now);
-
   while (atimers
          && (pending_atimers = interrupt_input_blocked) == 0
-         && EMACS_TIME_LE (atimers->expiration, now))
+         && (EMACS_GET_TIME (now),
+             EMACS_TIME_LE (atimers->expiration, now)))
     {
       struct atimer *t;
 
@@ -363,8 +363,6 @@ run_timers (void)
           t->next = free_atimers;
           free_atimers = t;
         }
-
-      EMACS_GET_TIME (now);
     }
 
   if (! atimers)
diff --git a/src/buffer.c b/src/buffer.c
index e501c9b73cc..89a4e26fb73 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -709,7 +709,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;
-  b->modtime = 0;
+  EMACS_SET_SECS_NSECS (b->modtime, 0, UNKNOWN_MODTIME_NSECS);
   b->modtime_size = -1;
   XSETFASTINT (BVAR (b, save_length), 0);
   b->last_window_start = 1;
@@ -5834,9 +5834,9 @@ An entry (TEXT . POSITION) represents the deletion of the string TEXT
 from (abs POSITION).  If POSITION is positive, point was at the front
 of the text being deleted; if negative, point was at the end.
 
-An entry (t HIGH . LOW) indicates that the buffer previously had
-\"unmodified\" status.  HIGH and LOW are the high and low 16-bit portions
-of the visited file's modification time, as of that time.  If the
+An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
+unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
+and is the visited file's modification time, as of that time.  If the
 modification time of the most recent save is different, this entry is
 obsolete.
 
diff --git a/src/buffer.h b/src/buffer.h
index 8e0604e90c2..97b45e15387 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -19,6 +19,7 @@ You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <sys/types.h> /* for off_t, time_t */
+#include "systime.h" /* for EMACS_TIME */
 
 /* Accessing the parameters of the current buffer.  */
 
@@ -529,10 +530,13 @@ struct buffer
   char local_flags[MAX_PER_BUFFER_VARS];
 
   /* Set to the modtime of the visited file when read or written.
-     -1 means visited file was nonexistent.
-     0 means visited file modtime unknown; in no case complain
-     about any mismatch on next save attempt.  */
-  time_t modtime;
+     EMACS_NSECS (modtime) == NONEXISTENT_MODTIME_NSECS means
+     visited file was nonexistent.  EMACS_NSECS (modtime) ==
+     UNKNOWN_MODTIME_NSECS means visited file modtime unknown;
+     in no case complain about any mismatch on next save attempt.  */
+#define NONEXISTENT_MODTIME_NSECS (-1)
+#define UNKNOWN_MODTIME_NSECS (-2)
+  EMACS_TIME modtime;
   /* Size of the file when modtime was set.  This is used to detect the
      case where the file grew while we were reading it, so the modtime
      is still the same (since it's rounded up to seconds) but we're actually
diff --git a/src/dired.c b/src/dired.c
index 1ce236d5674..b319072aa33 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -62,6 +62,7 @@ extern struct direct *readdir (DIR *);
 #endif /* HAVE_DIRENT_H */
 
 #include <filemode.h>
+#include <stat-time.h>
 
 #ifdef MSDOS
 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
@@ -893,8 +894,8 @@ Elements of the attribute list are:
  2. File uid as a string or a number.  If a string value cannot be
   looked up, a numeric value, either an integer or a float, is returned.
  3. File gid, likewise.
- 4. Last access time, as a list of two integers.
-  First integer has high-order 16 bits of time, second has low 16 bits.
+ 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
+  same style as (current-time).
   (See a note below about access time on FAT-based filesystems.)
  5. Last modification time, likewise.  This is the time of the last
   change to the file's contents.
@@ -979,9 +980,9 @@ so last access time will always be midnight of that day.  */)
   else
     values[3] = make_fixnum_or_float (s.st_gid);
 
-  values[4] = make_time (s.st_atime);
-  values[5] = make_time (s.st_mtime);
-  values[6] = make_time (s.st_ctime);
+  values[4] = make_lisp_time (get_stat_atime (&s));
+  values[5] = make_lisp_time (get_stat_mtime (&s));
+  values[6] = make_lisp_time (get_stat_ctime (&s));
 
   /* If the file size is a 4-byte type, assume that files of sizes in
      the 2-4 GiB range wrap around to negative values, as this is a
diff --git a/src/dispextern.h b/src/dispextern.h
index fc7bec97f7a..63c23b8962f 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -68,6 +68,10 @@ typedef Pixmap XImagePtr;
 typedef XImagePtr XImagePtr_or_DC;
 #endif
 
+#ifdef HAVE_WINDOW_SYSTEM
+# include "systime.h"
+#endif
+
 #ifndef HAVE_WINDOW_SYSTEM
 typedef int Cursor;
 #define No_Cursor (0)
@@ -2780,7 +2784,7 @@ struct image
 {
   /* The time in seconds at which the image was last displayed.  Set
      in prepare_image_for_display.  */
-  time_t timestamp;
+  EMACS_TIME timestamp;
 
   /* Pixmaps of the image.  */
   Pixmap pixmap, mask;
diff --git a/src/dispnew.c b/src/dispnew.c
index ad675f6e098..5582607ff6a 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -137,24 +137,11 @@ static void adjust_frame_glyphs_for_window_redisplay (struct frame *);
 static void adjust_frame_glyphs_for_frame_redisplay (struct frame *);
 
 
-/* Define PERIODIC_PREEMPTION_CHECKING to 1, if micro-second timers
-   are supported, so we can check for input during redisplay at
-   regular intervals.  */
-#ifdef EMACS_HAS_USECS
-#define PERIODIC_PREEMPTION_CHECKING 1
-#else
-#define PERIODIC_PREEMPTION_CHECKING 0
-#endif
-
-#if PERIODIC_PREEMPTION_CHECKING
-
 /* Redisplay preemption timers.  */
 
 static EMACS_TIME preemption_period;
 static EMACS_TIME preemption_next_check;
 
-#endif
-
 /* Nonzero upon entry to redisplay means do not assume anything about
    current contents of actual terminal frame; clear and redraw it.  */
 
@@ -3221,14 +3208,12 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
 
   if (redisplay_dont_pause)
     force_p = 1;
-#if PERIODIC_PREEMPTION_CHECKING
   else if (NILP (Vredisplay_preemption_period))
     force_p = 1;
   else if (!force_p && NUMBERP (Vredisplay_preemption_period))
     {
       EMACS_TIME tm;
       double p = XFLOATINT (Vredisplay_preemption_period);
-      int sec, usec;
 
       if (detect_input_pending_ignore_squeezables ())
         {
@@ -3236,14 +3221,10 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
           goto do_pause;
         }
 
-      sec = (int) p;
-      usec = (p - sec) * 1000000;
-
       EMACS_GET_TIME (tm);
-      EMACS_SET_SECS_USECS (preemption_period, sec, usec);
+      preemption_period = EMACS_TIME_FROM_DOUBLE (p);
       EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
     }
-#endif
 
   if (FRAME_WINDOW_P (f))
     {
@@ -3327,9 +3308,7 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
 #endif
     }
 
-#if PERIODIC_PREEMPTION_CHECKING
  do_pause:
-#endif
   /* Reset flags indicating that a window should be updated.  */
   set_window_update_flags (root_window, 0);
 
@@ -3382,23 +3361,17 @@ update_single_window (struct window *w, int force_p)
 
       if (redisplay_dont_pause)
         force_p = 1;
-#if PERIODIC_PREEMPTION_CHECKING
       else if (NILP (Vredisplay_preemption_period))
         force_p = 1;
       else if (!force_p && NUMBERP (Vredisplay_preemption_period))
         {
           EMACS_TIME tm;
           double p = XFLOATINT (Vredisplay_preemption_period);
-          int sec, usec;
-
-          sec = (int) p;
-          usec = (p - sec) * 1000000;
 
           EMACS_GET_TIME (tm);
-          EMACS_SET_SECS_USECS (preemption_period, sec, usec);
+          preemption_period = EMACS_TIME_FROM_DOUBLE (p);
           EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
         }
-#endif
 
       /* Update W.  */
       update_begin (f);
@@ -3644,10 +3617,9 @@ update_window (struct window *w, int force_p)
 #if PERIODIC_PREEMPTION_CHECKING
             if (!force_p)
               {
-                EMACS_TIME tm, dif;
+                EMACS_TIME tm;
                 EMACS_GET_TIME (tm);
-                EMACS_SUB_TIME (dif, preemption_next_check, tm);
-                if (EMACS_TIME_NEG_P (dif))
+                if (EMACS_TIME_LT (preemption_next_check, tm))
                   {
                     EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
                     if (detect_input_pending_ignore_squeezables ())
@@ -4750,10 +4722,9 @@ update_frame_1 (struct frame *f, int force_p, int inhibit_id_p)
 #if PERIODIC_PREEMPTION_CHECKING
           if (!force_p)
             {
-              EMACS_TIME tm, dif;
+              EMACS_TIME tm;
               EMACS_GET_TIME (tm);
-              EMACS_SUB_TIME (dif, preemption_next_check, tm);
-              if (EMACS_TIME_NEG_P (dif))
+              if (EMACS_TIME_LT (preemption_next_check, tm))
                 {
                   EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
                   if (detect_input_pending_ignore_squeezables ())
@@ -5967,48 +5938,14 @@ bitch_at_user (void)
                           Sleeping, Waiting
  ***********************************************************************/
 
-/* Convert a positive value DURATION to a seconds count *PSEC plus a
-   microseconds count *PUSEC, rounding up.  On overflow return the
-   maximal value.  */
-void
-duration_to_sec_usec (double duration, int *psec, int *pusec)
-{
-  int MILLION = 1000000;
-  int sec = INT_MAX, usec = MILLION - 1;
-
-  if (duration < INT_MAX + 1.0)
-    {
-      int s = duration;
-      double usdouble = (duration - s) * MILLION;
-      int usfloor = usdouble;
-      int usceil = usfloor + (usfloor < usdouble);
-
-      if (usceil < MILLION)
-        {
-          sec = s;
-          usec = usceil;
-        }
-      else if (sec < INT_MAX)
-        {
-          sec = s + 1;
-          usec = 0;
-        }
-    }
-
-  *psec = sec;
-  *pusec = usec;
-}
-
 DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 2, 0,
        doc: /* Pause, without updating display, for SECONDS seconds.
 SECONDS may be a floating-point value, meaning that you can wait for a
 fraction of a second.  Optional second arg MILLISECONDS specifies an
-additional wait period, in milliseconds; this may be useful if your
-Emacs was built without floating point support.
+additional wait period, in milliseconds; this is for backwards compatibility.
 \(Not all operating systems support waiting for a fraction of a second.)  */)
   (Lisp_Object seconds, Lisp_Object milliseconds)
 {
-  int sec, usec;
   double duration = extract_float (seconds);
 
   if (!NILP (milliseconds))
@@ -6017,17 +5954,12 @@ Emacs was built without floating point support.
       duration += XINT (milliseconds) / 1000.0;
     }
 
-  if (! (0 < duration))
-    return Qnil;
-
-  duration_to_sec_usec (duration, &sec, &usec);
-
-#ifndef EMACS_HAS_USECS
-  if (sec == 0 && usec != 0)
-    error ("Millisecond `sleep-for' not supported on %s", SYSTEM_TYPE);
-#endif
-
-  wait_reading_process_output (sec, usec, 0, 0, Qnil, NULL, 0);
+  if (0 < duration)
+    {
+      EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (duration);
+      wait_reading_process_output (min (EMACS_SECS (t), INTMAX_MAX),
+                                   EMACS_NSECS (t), 0, 0, Qnil, NULL, 0);
+    }
 
   return Qnil;
 }
@@ -6046,7 +5978,8 @@ Emacs was built without floating point support.
 Lisp_Object
 sit_for (Lisp_Object timeout, int reading, int do_display)
 {
-  int sec, usec;
+  intmax_t sec;
+  int nsec;
 
   swallow_events (do_display);
 
@@ -6057,26 +5990,39 @@ sit_for (Lisp_Object timeout, int reading, int do_display)
   if (do_display >= 2)
     redisplay_preserve_echo_area (2);
 
-  if (EQ (timeout, Qt))
+  if (INTEGERP (timeout))
     {
-      sec = 0;
-      usec = 0;
+      sec = XINT (timeout);
+      if (! (0 < sec))
+        return Qt;
+      nsec = 0;
     }
-  else
+  else if (FLOATP (timeout))
     {
-      double duration = extract_float (timeout);
-
-      if (! (0 < duration))
+      double seconds = XFLOAT_DATA (timeout);
+      if (! (0 < seconds))
         return Qt;
-
-      duration_to_sec_usec (duration, &sec, &usec);
+      else
+        {
+          EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (seconds);
+          sec = min (EMACS_SECS (t), INTMAX_MAX);
+          nsec = EMACS_NSECS (t);
+        }
+    }
+  else if (EQ (timeout, Qt))
+    {
+      sec = 0;
+      nsec = 0;
     }
+  else
+    wrong_type_argument (Qnumberp, timeout);
+
 
 #ifdef SIGIO
   gobble_input (0);
 #endif
 
-  wait_reading_process_output (sec, usec, reading ? -1 : 1, do_display,
+  wait_reading_process_output (sec, nsec, reading ? -1 : 1, do_display,
                                Qnil, NULL, 0);
 
   return detect_input_pending () ? Qnil : Qt;
diff --git a/src/editfns.c b/src/editfns.c
index 1fb20b07e70..63e77004f8b 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -73,9 +73,8 @@ extern char **environ;
 extern Lisp_Object w32_get_internal_run_time (void);
 #endif
 
-static void time_overflow (void) NO_RETURN;
-static Lisp_Object format_time_string (char const *, ptrdiff_t, Lisp_Object,
-                                       int, time_t *, struct tm *);
+static Lisp_Object format_time_string (char const *, ptrdiff_t, EMACS_TIME,
+                                       int, struct tm *);
 static int tm_diff (struct tm *, struct tm *);
 static void update_buffer_properties (ptrdiff_t, ptrdiff_t);
 
@@ -1378,14 +1377,13 @@ DEFUN ("emacs-pid", Femacs_pid, Semacs_pid, 0, 0, 0,
 #endif
 
 /* Report that a time value is out of range for Emacs.  */
-static void
+void
 time_overflow (void)
 {
   error ("Specified time is not representable");
 }
 
-/* Return the upper part of the time T (everything but the bottom 16 bits),
-   making sure that it is representable.  */
+/* Return the upper part of the time T (everything but the bottom 16 bits).  */
 static EMACS_INT
 hi_time (time_t t)
 {
@@ -1413,40 +1411,33 @@ lo_time (time_t t)
 
 DEFUN ("current-time", Fcurrent_time, Scurrent_time, 0, 0, 0,
        doc: /* Return the current time, as the number of seconds since 1970-01-01 00:00:00.
-The time is returned as a list of three integers.  The first has the
-most significant 16 bits of the seconds, while the second has the
-least significant 16 bits.  The third integer gives the microsecond
-count.
-
-The microsecond count is zero on systems that do not provide
-resolution finer than a second.  */)
+The time is returned as a list of integers (HIGH LOW USEC PSEC).
+HIGH has the most significant bits of the seconds, while LOW has the
+least significant 16 bits.  USEC and PSEC are the microsecond and
+picosecond counts.  */)
   (void)
 {
   EMACS_TIME t;
 
   EMACS_GET_TIME (t);
-  return list3 (make_number (hi_time (EMACS_SECS (t))),
-                make_number (lo_time (EMACS_SECS (t))),
-                make_number (EMACS_USECS (t)));
+  return make_lisp_time (t);
 }
 
 DEFUN ("get-internal-run-time", Fget_internal_run_time, Sget_internal_run_time,
        0, 0, 0,
        doc: /* Return the current run time used by Emacs.
-The time is returned as a list of three integers.  The first has the
-most significant 16 bits of the seconds, while the second has the
-least significant 16 bits.  The third integer gives the microsecond
-count.
+The time is returned as a list (HIGH LOW USEC PSEC), using the same
+style as (current-time).
 
 On systems that can't determine the run time, `get-internal-run-time'
-does the same thing as `current-time'.  The microsecond count is zero
-on systems that do not provide resolution finer than a second.  */)
+does the same thing as `current-time'.  */)
   (void)
 {
 #ifdef HAVE_GETRUSAGE
   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?  */
@@ -1460,10 +1451,8 @@ on systems that do not provide resolution finer than a second.  */)
       usecs -= 1000000;
       secs++;
     }
-
-  return list3 (make_number (hi_time (secs)),
-                make_number (lo_time (secs)),
-                make_number (usecs));
+  EMACS_SET_SECS_USECS (t, secs, usecs);
+  return make_lisp_time (t);
 #else /* ! HAVE_GETRUSAGE  */
 #ifdef WINDOWSNT
   return w32_get_internal_run_time ();
@@ -1474,80 +1463,151 @@ on systems that do not provide resolution finer than a second.  */)
 }
 
 
-/* Make a Lisp list that represents the time T.  */
-Lisp_Object
+/* Make a Lisp list that represents the time T with fraction TAIL.  */
+static Lisp_Object
+make_time_tail (time_t t, Lisp_Object tail)
+{
+  return Fcons (make_number (hi_time (t)),
+                Fcons (make_number (lo_time (t)), tail));
+}
+
+/* Make a Lisp list that represents the system time T.  */
+static Lisp_Object
 make_time (time_t t)
 {
-  return list2 (make_number (hi_time (t)),
-                make_number (lo_time (t)));
+  return make_time_tail (t, Qnil);
+}
+
+/* Make a Lisp list that represents the Emacs time T.  T may be an
+   invalid time, with a slightly negative tv_nsec value such as
+   UNKNOWN_MODTIME_NSECS; in that case, the Lisp list contains a
+   correspondingly negative picosecond count.  */
+Lisp_Object
+make_lisp_time (EMACS_TIME t)
+{
+  int ns = EMACS_NSECS (t);
+  return make_time_tail (EMACS_SECS (t),
+                         list2 (make_number (ns / 1000),
+                                make_number (ns % 1000 * 1000)));
 }
 
 /* Decode a Lisp list SPECIFIED_TIME that represents a time.
-   If SPECIFIED_TIME is nil, use the current time.
-   Set *RESULT to seconds since the Epoch.
-   If USEC is not null, set *USEC to the microseconds component.
+   Set *PHIGH, *PLOW, *PUSEC, *PPSEC to its parts; do not check their values.
    Return nonzero if successful.  */
+static int
+disassemble_lisp_time (Lisp_Object specified_time, Lisp_Object *phigh,
+                       Lisp_Object *plow, Lisp_Object *pusec,
+                       Lisp_Object *ppsec)
+{
+  if (CONSP (specified_time))
+    {
+      Lisp_Object low = XCDR (specified_time);
+      Lisp_Object usec = make_number (0);
+      Lisp_Object psec = make_number (0);
+      if (CONSP (low))
+        {
+          Lisp_Object low_tail = XCDR (low);
+          low = XCAR (low);
+          if (CONSP (low_tail))
+            {
+              usec = XCAR (low_tail);
+              low_tail = XCDR (low_tail);
+              if (CONSP (low_tail))
+                psec = XCAR (low_tail);
+            }
+          else if (!NILP (low_tail))
+            usec = low_tail;
+        }
+
+      *phigh = XCAR (specified_time);
+      *plow = low;
+      *pusec = usec;
+      *ppsec = psec;
+      return 1;
+    }
+
+  return 0;
+}
+
+/* From the time components HIGH, LOW, USEC and PSEC taken from a Lisp
+   list, generate the corresponding EMACS_TIME value *RESULT, and
+   if RESULT_PSEC is not null store into *RESULT_PSEC the
+   (nonnegative) difference in picoseconds between the input time and
+   the returned time.  Return nonzero if successful.  */
 int
-lisp_time_argument (Lisp_Object specified_time, time_t *result, int *usec)
+decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec,
+                        Lisp_Object psec, EMACS_TIME *result, int *result_psec)
 {
+  EMACS_INT hi, lo, us, ps;
+  time_t sec;
+  if (! (INTEGERP (high) && INTEGERP (low)
+         && INTEGERP (usec) && INTEGERP (psec)))
+    return 0;
+  hi = XINT (high);
+  lo = XINT (low);
+  us = XINT (usec);
+  ps = XINT (psec);
+
+  /* Normalize out-of-range lower-order components by carrying
+     each overflow into the next higher-order component.  */
+  us += ps / 1000000 - (ps % 1000000 < 0);
+  lo += us / 1000000 - (us % 1000000 < 0);
+  hi += lo >> 16;
+  ps = ps % 1000000 + 1000000 * (ps % 1000000 < 0);
+  us = us % 1000000 + 1000000 * (us % 1000000 < 0);
+  lo &= (1 << 16) - 1;
+
+  /* Check for overflow in the highest-order component.  */
+  if (! ((TYPE_SIGNED (time_t) ? TIME_T_MIN >> 16 <= hi : 0 <= hi)
+         && hi <= TIME_T_MAX >> 16))
+    return 0;
+
+  sec = hi;
+  EMACS_SET_SECS_NSECS (*result, (sec << 16) + lo, us * 1000 + ps / 1000);
+  if (result_psec)
+    *result_psec = ps % 1000;
+  return 1;
+}
+
+/* Decode a Lisp list SPECIFIED_TIME that represents a time.
+   If SPECIFIED_TIME is nil, use the current time.
+   Round the time down to the nearest EMACS_TIME value, and
+   if PPSEC is not null store into *PPSEC the (nonnegative) difference in
+   picoseconds between the input time and the returned time.
+   Return seconds since the Epoch.
+   Signal an error if unsuccessful.  */
+EMACS_TIME
+lisp_time_argument (Lisp_Object specified_time, int *ppsec)
+{
+  EMACS_TIME t;
   if (NILP (specified_time))
+    EMACS_GET_TIME (t);
+  else
     {
-      if (usec)
-        {
-          EMACS_TIME t;
-
-          EMACS_GET_TIME (t);
-          *usec = EMACS_USECS (t);
-          *result = EMACS_SECS (t);
-          return 1;
-        }
-      else
-        return time (result) != -1;
+      Lisp_Object high, low, usec, psec;
+      if (! (disassemble_lisp_time (specified_time, &high, &low, &usec, &psec)
+             && decode_time_components (high, low, usec, psec, &t, ppsec)))
+        error ("Invalid time specification");
     }
+  return t;
+}
+
+/* Like lisp_time_argument, except decode only the seconds part,
+   and do not check the subseconds part, and always round down.  */
+static time_t
+lisp_seconds_argument (Lisp_Object specified_time)
+{
+  if (NILP (specified_time))
+    return time (NULL);
   else
     {
-      Lisp_Object high, low;
-      EMACS_INT hi;
-      high = Fcar (specified_time);
-      CHECK_NUMBER (high);
-      low = Fcdr (specified_time);
-      if (CONSP (low))
-        {
-          if (usec)
-            {
-              Lisp_Object usec_l = Fcdr (low);
-              if (CONSP (usec_l))
-                usec_l = Fcar (usec_l);
-              if (NILP (usec_l))
-                *usec = 0;
-              else
-                {
-                  CHECK_NUMBER (usec_l);
-                  if (! (0 <= XINT (usec_l) && XINT (usec_l) < 1000000))
-                    return 0;
-                  *usec = XINT (usec_l);
-                }
-            }
-          low = Fcar (low);
-        }
-      else if (usec)
-        *usec = 0;
-      CHECK_NUMBER (low);
-      hi = XINT (high);
-
-      /* Check for overflow, helping the compiler for common cases
-         where no runtime check is needed, and taking care not to
-         convert negative numbers to unsigned before comparing them.  */
-      if (! ((TYPE_SIGNED (time_t)
-              ? (TIME_T_MIN >> 16 <= MOST_NEGATIVE_FIXNUM
-                 || TIME_T_MIN >> 16 <= hi)
-              : 0 <= hi)
-             && (MOST_POSITIVE_FIXNUM <= TIME_T_MAX >> 16
-                 || hi <= TIME_T_MAX >> 16)))
-        return 0;
-
-      *result = (hi << 16) + (XINT (low) & 0xffff);
-      return 1;
+      Lisp_Object high, low, usec, psec;
+      EMACS_TIME t;
+      if (! (disassemble_lisp_time (specified_time, &high, &low, &usec, &psec)
+             && decode_time_components (high, low, make_number (0),
+                                        make_number (0), &t, 0)))
+        error ("Invalid time specification");
+      return EMACS_SECS (t);
     }
 }
 
@@ -1555,22 +1615,22 @@ DEFUN ("float-time", Ffloat_time, Sfloat_time, 0, 1, 0,
        doc: /* Return the current time, as a float number of seconds since the epoch.
 If SPECIFIED-TIME is given, it is the time to convert to float
 instead of the current time.  The argument should have the form
-(HIGH LOW) or (HIGH LOW USEC). Thus, you can use times obtained from
-`current-time' and from `file-attributes'.  SPECIFIED-TIME can also
-have the form (HIGH . LOW), but this is considered obsolete.
+(HIGH LOW) or (HIGH LOW USEC) or (HIGH LOW USEC PSEC).  Thus,
+you can use times from `current-time' and from `file-attributes'.
+SPECIFIED-TIME can also have the form (HIGH . LOW), but this is
+considered obsolete.
 
 WARNING: Since the result is floating point, it may not be exact.
 If precise time stamps are required, use either `current-time',
 or (if you need time as a string) `format-time-string'.  */)
   (Lisp_Object specified_time)
 {
-  time_t sec;
-  int usec;
-
-  if (! lisp_time_argument (specified_time, &sec, &usec))
-    error ("Invalid time specification");
-
-  return make_float ((sec * 1e6 + usec) / 1e6);
+  int psec;
+  EMACS_TIME t = lisp_time_argument (specified_time, &psec);
+  double ps = (1000 * 1000 * 1000 <= INTMAX_MAX / 1000
+               ? EMACS_NSECS (t) * (intmax_t) 1000 + psec
+               : EMACS_NSECS (t) * 1e3 + psec);
+  return make_float (EMACS_SECS (t) + ps / 1e12);
 }
 
 /* Write information into buffer S of size MAXSIZE, according to the
@@ -1625,7 +1685,7 @@ emacs_nmemftime (char *s, size_t maxsize, const char *format,
 
 DEFUN ("format-time-string", Fformat_time_string, Sformat_time_string, 1, 3, 0,
        doc: /* Use FORMAT-STRING to format the time TIME, or now if omitted.
-TIME is specified as (HIGH LOW . IGNORED), as returned by
+TIME is specified as (HIGH LOW USEC PSEC), as returned by
 `current-time' or `file-attributes'.  The obsolete form (HIGH . LOW)
 is also still accepted.
 The third, optional, argument UNIVERSAL, if non-nil, means describe TIME
@@ -1679,41 +1739,36 @@ For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".
 usage: (format-time-string FORMAT-STRING &optional TIME UNIVERSAL)  */)
   (Lisp_Object format_string, Lisp_Object timeval, Lisp_Object universal)
 {
-  time_t t;
+  EMACS_TIME t = lisp_time_argument (timeval, 0);
   struct tm tm;
 
   CHECK_STRING (format_string);
   format_string = code_convert_string_norecord (format_string,
                                                 Vlocale_coding_system, 1);
   return format_time_string (SSDATA (format_string), SBYTES (format_string),
-                             timeval, ! NILP (universal), &t, &tm);
+                             t, ! NILP (universal), &tm);
 }
 
 static Lisp_Object
 format_time_string (char const *format, ptrdiff_t formatlen,
-                    Lisp_Object timeval, int ut, time_t *tval, struct tm *tmp)
+                    EMACS_TIME t, int ut, struct tm *tmp)
 {
   char buffer[4000];
   char *buf = buffer;
   ptrdiff_t size = sizeof buffer;
   size_t len;
   Lisp_Object bufstring;
-  int usec;
-  int ns;
+  int ns = EMACS_NSECS (t);
   struct tm *tm;
   USE_SAFE_ALLOCA;
 
-  if (! lisp_time_argument (timeval, tval, &usec))
-    error ("Invalid time specification");
-  ns = usec * 1000;
-
   while (1)
     {
       BLOCK_INPUT;
 
       synchronize_system_time_locale ();
 
-      tm = ut ? gmtime (tval) : localtime (tval);
+      tm = ut ? gmtime (EMACS_SECS_ADDR (t)) : localtime (EMACS_SECS_ADDR (t));
       if (! tm)
         {
           UNBLOCK_INPUT;
@@ -1758,17 +1813,13 @@ east of Greenwich.  (Note that Common Lisp has different meanings for
 DOW and ZONE.)  */)
   (Lisp_Object specified_time)
 {
-  time_t time_spec;
+  time_t time_spec = lisp_seconds_argument (specified_time);
   struct tm save_tm;
   struct tm *decoded_time;
   Lisp_Object list_args[9];
 
-  if (! lisp_time_argument (specified_time, &time_spec, NULL))
-    error ("Invalid time specification");
-
   BLOCK_INPUT;
   decoded_time = localtime (&time_spec);
-  /* Make a copy, in case a signal handler modifies TZ or the struct.  */
   if (decoded_time)
     save_tm = *decoded_time;
   UNBLOCK_INPUT;
@@ -1919,14 +1970,11 @@ Thus, you can use times obtained from `current-time' and from
 but this is considered obsolete.  */)
   (Lisp_Object specified_time)
 {
-  time_t value;
+  time_t value = lisp_seconds_argument (specified_time);
   struct tm *tm;
   char buf[sizeof "Mon Apr 30 12:49:17 " + INT_STRLEN_BOUND (int) + 1];
   int len IF_LINT (= 0);
 
-  if (! lisp_time_argument (specified_time, &value, NULL))
-    error ("Invalid time specification");
-
   /* Convert to a string in ctime format, except without the trailing
      newline, and without the 4-digit year limit.  Don't use asctime
      or ctime, as they might dump core if the year is outside the
@@ -1994,17 +2042,17 @@ in this case, `current-time-zone' returns a list containing nil for
 the data it can't find.  */)
   (Lisp_Object specified_time)
 {
-  time_t value;
+  EMACS_TIME value;
   int offset;
   struct tm *t;
   struct tm localtm;
   Lisp_Object zone_offset, zone_name;
 
   zone_offset = Qnil;
-  zone_name = format_time_string ("%Z", sizeof "%Z" - 1, specified_time,
-                                  0, &value, &localtm);
+  EMACS_SET_SECS_NSECS (value, lisp_seconds_argument (specified_time), 0);
+  zone_name = format_time_string ("%Z", sizeof "%Z" - 1, value, 0, &localtm);
   BLOCK_INPUT;
-  t = gmtime (&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 8b69ed5eae4..824a92148cb 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -76,6 +76,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 #include "systime.h"
+#include <stat-time.h>
 
 #ifdef HPUX
 #include <netio.h>
@@ -1931,7 +1932,7 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
       /* Ensure file is writable while its modified time is set.  */
       attributes = GetFileAttributes (filename);
       SetFileAttributes (filename, attributes & ~FILE_ATTRIBUTE_READONLY);
-      if (set_file_times (filename, now, now))
+      if (set_file_times (-1, filename, now, now))
         {
           /* Restore original attributes.  */
           SetFileAttributes (filename, attributes);
@@ -2054,24 +2055,21 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
     }
 #endif
 
-  /* Closing the output clobbers the file times on some systems.  */
-  if (emacs_close (ofd) < 0)
-    report_file_error ("I/O error", Fcons (newname, Qnil));
-
   if (input_file_statable_p)
     {
       if (!NILP (keep_time))
         {
-          EMACS_TIME atime, mtime;
-          EMACS_SET_SECS_USECS (atime, st.st_atime, 0);
-          EMACS_SET_SECS_USECS (mtime, st.st_mtime, 0);
-          if (set_file_times (SSDATA (encoded_newname),
-                              atime, mtime))
+          EMACS_TIME atime = get_stat_atime (&st);
+          EMACS_TIME mtime = get_stat_mtime (&st);
+          if (set_file_times (ofd, SSDATA (encoded_newname), atime, mtime))
             xsignal2 (Qfile_date_error,
                       build_string ("Cannot set file date"), newname);
         }
     }
 
+  if (emacs_close (ofd) < 0)
+    report_file_error ("I/O error", Fcons (newname, Qnil));
+
   emacs_close (ifd);
 
 #ifdef MSDOS
@@ -3034,11 +3032,7 @@ Use the current time if TIMESTAMP is nil.  TIMESTAMP is in the format of
 {
   Lisp_Object absname, encoded_absname;
   Lisp_Object handler;
-  time_t sec;
-  int usec;
-
-  if (! lisp_time_argument (timestamp, &sec, &usec))
-    error ("Invalid time specification");
+  EMACS_TIME t = lisp_time_argument (timestamp, 0);
 
   absname = Fexpand_file_name (filename, BVAR (current_buffer, directory));
 
@@ -3051,12 +3045,7 @@ Use the current time if TIMESTAMP is nil.  TIMESTAMP is in the format of
   encoded_absname = ENCODE_FILE (absname);
 
   {
-    EMACS_TIME t;
-
-    EMACS_SET_SECS (t, sec);
-    EMACS_SET_USECS (t, usec);
-
-    if (set_file_times (SSDATA (encoded_absname), t, t))
+    if (set_file_times (-1, SSDATA (encoded_absname), t, t))
       {
 #ifdef DOS_NT
         struct stat st;
@@ -4205,7 +4194,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
 
       if (NILP (handler))
         {
-          current_buffer->modtime = st.st_mtime;
+          current_buffer->modtime = get_stat_mtime (&st);
           current_buffer->modtime_size = st.st_size;
           BVAR (current_buffer, filename) = orig_filename;
         }
@@ -4365,7 +4354,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
     }
 
   if (!NILP (visit)
-      && current_buffer->modtime == -1)
+      && EMACS_NSECS (current_buffer->modtime) == NONEXISTENT_MODTIME_NSECS)
     {
       /* If visiting nonexistent file, return nil.  */
       errno = save_errno;
@@ -4803,7 +4792,7 @@ This calls `write-region-annotate-functions' at the start, and
      next attempt to save.  */
   if (visiting)
     {
-      current_buffer->modtime = st.st_mtime;
+      current_buffer->modtime = get_stat_mtime (&st);
       current_buffer->modtime_size = st.st_size;
     }
 
@@ -5080,6 +5069,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;
 
   if (NILP (buf))
     b = current_buffer;
@@ -5090,7 +5080,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
     }
 
   if (!STRINGP (BVAR (b, filename))) return Qt;
-  if (b->modtime == 0) return Qt;
+  if (EMACS_NSECS (b->modtime) == UNKNOWN_MODTIME_NSECS) return Qt;
 
   /* If the file name has special constructs in it,
      call the corresponding file handler.  */
@@ -5101,20 +5091,25 @@ See Info node `(elisp)Modification Time' for more details.  */)
 
   filename = ENCODE_FILE (BVAR (b, filename));
 
-  if (stat (SSDATA (filename), &st) < 0)
+  if (stat (SSDATA (filename), &st) == 0)
+    mtime = get_stat_mtime (&st);
+  else
     {
       /* If the file doesn't exist now and didn't exist before,
          we say that it isn't modified, provided the error is a tame one.  */
-      if (errno == ENOENT || errno == EACCES || errno == ENOTDIR)
-        st.st_mtime = -1;
-      else
-        st.st_mtime = 0;
+      int ns = (errno == ENOENT || errno == EACCES || errno == ENOTDIR
+                ? NONEXISTENT_MODTIME_NSECS
+                : UNKNOWN_MODTIME_NSECS);
+      EMACS_SET_SECS_NSECS (mtime, 0, ns);
     }
-  if ((st.st_mtime == b->modtime
-       /* If both are positive, accept them if they are off by one second.  */
-       || (st.st_mtime > 0 && b->modtime > 0
-           && (st.st_mtime - 1 == b->modtime
-               || st.st_mtime == b->modtime - 1)))
+  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))))
       && (st.st_size == b->modtime_size
           || b->modtime_size < 0))
     return Qt;
@@ -5127,7 +5122,7 @@ DEFUN ("clear-visited-file-modtime", Fclear_visited_file_modtime,
 Next attempt to save will certainly not complain of a discrepancy.  */)
   (void)
 {
-  current_buffer->modtime = 0;
+  EMACS_SET_SECS_NSECS (current_buffer->modtime, 0, UNKNOWN_MODTIME_NSECS);
   current_buffer->modtime_size = -1;
   return Qnil;
 }
@@ -5135,16 +5130,16 @@ Next attempt to save will certainly not complain of a discrepancy.  */)
 DEFUN ("visited-file-modtime", Fvisited_file_modtime,
        Svisited_file_modtime, 0, 0, 0,
        doc: /* Return the current buffer's recorded visited file modification time.
-The value is a list of the form (HIGH LOW), like the time values that
+The value is a list of the form (HIGH LOW USEC PSEC), like the time values that
 `file-attributes' returns.  If the current buffer has no recorded file
 modification time, this function returns 0.  If the visited file
 doesn't exist, HIGH will be -1.
 See Info node `(elisp)Modification Time' for more details.  */)
   (void)
 {
-  if (! current_buffer->modtime)
+  if (EMACS_NSECS (current_buffer->modtime) < 0)
     return make_number (0);
-  return make_time (current_buffer->modtime);
+  return make_lisp_time (current_buffer->modtime);
 }
 
 DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime,
@@ -5154,12 +5149,12 @@ Useful if the buffer was not read from the file normally
 or if the file itself has been changed for some known benign reason.
 An argument specifies the modification time value to use
 \(instead of that of the visited file), in the form of a list
-\(HIGH . LOW) or (HIGH LOW).  */)
+\(HIGH LOW USEC PSEC) as returned by `current-time'.  */)
   (Lisp_Object time_list)
 {
   if (!NILP (time_list))
     {
-      CONS_TO_INTEGER (time_list, time_t, current_buffer->modtime);
+      current_buffer->modtime = lisp_time_argument (time_list, 0);
       current_buffer->modtime_size = -1;
     }
   else
@@ -5181,7 +5176,7 @@ An argument specifies the modification time value to use
 
       if (stat (SSDATA (filename), &st) >= 0)
         {
-          current_buffer->modtime = st.st_mtime;
+          current_buffer->modtime = get_stat_mtime (&st);
           current_buffer->modtime_size = st.st_size;
         }
     }
diff --git a/src/fns.c b/src/fns.c
index 676e53ccbd8..515cd28328b 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -80,7 +80,7 @@ Other values of LIMIT are ignored.  */)
     {
       EMACS_TIME t;
       EMACS_GET_TIME (t);
-      seed_random (getpid () ^ EMACS_SECS (t) ^ EMACS_USECS (t));
+      seed_random (getpid () ^ EMACS_SECS (t) ^ EMACS_NSECS (t));
     }
 
   if (NATNUMP (limit) && XFASTINT (limit) != 0)
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 4cf421b6616..51c56e49540 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1612,16 +1612,16 @@ xg_maybe_add_timer (gpointer data)
 {
   struct xg_dialog_data *dd = (struct xg_dialog_data *) data;
   EMACS_TIME next_time = timer_check ();
-  long secs = EMACS_SECS (next_time);
-  long usecs = EMACS_USECS (next_time);
 
   dd->timerid = 0;
 
-  if (secs >= 0 && usecs >= 0 && secs < ((guint)-1)/1000)
+  if (EMACS_TIME_VALID_P (next_time))
     {
-      dd->timerid = g_timeout_add (secs * 1000 + usecs/1000,
-                                   xg_maybe_add_timer,
-                                   dd);
+      time_t s = EMACS_SECS (next_time);
+      int per_ms = EMACS_TIME_RESOLUTION / 1000;
+      int ms = (EMACS_NSECS (next_time) + per_ms - 1) / per_ms;
+      if (s <= ((guint) -1 - ms) / 1000)
+        dd->timerid = g_timeout_add (s * 1000 + ms, xg_maybe_add_timer, dd);
     }
   return FALSE;
 }
diff --git a/src/image.c b/src/image.c
index 103f0a7feb6..47b14a333e9 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1062,11 +1062,8 @@ check_image_size (struct frame *f, int width, int height)
 void
 prepare_image_for_display (struct frame *f, struct image *img)
 {
-  EMACS_TIME t;
-
   /* We're about to display IMG, so set its timestamp to `now'.  */
-  EMACS_GET_TIME (t);
-  img->timestamp = EMACS_SECS (t);
+  EMACS_GET_TIME (img->timestamp);
 
   /* If IMG doesn't have a pixmap yet, load it now, using the image
      type dependent loader function.  */
@@ -1514,8 +1511,8 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
       else if (INTEGERP (Vimage_cache_eviction_delay))
         {
           /* Free cache based on timestamp.  */
-          EMACS_TIME t;
-          double old, delay;
+          EMACS_TIME old, t;
+          double delay;
           ptrdiff_t nimages = 0;
 
           for (i = 0; i < c->used; ++i)
@@ -1530,12 +1527,12 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
           delay = max (delay, 1);
 
           EMACS_GET_TIME (t);
-          old = EMACS_SECS (t) - delay;
+          EMACS_SUB_TIME (old, t, EMACS_TIME_FROM_DOUBLE (delay));
 
           for (i = 0; i < c->used; ++i)
             {
               struct image *img = c->images[i];
-              if (img && img->timestamp < old)
+              if (img && EMACS_TIME_LT (img->timestamp, old))
                 {
                   free_image (f, img);
                   ++nfreed;
@@ -1708,7 +1705,6 @@ lookup_image (struct frame *f, Lisp_Object spec)
 {
   struct image *img;
   EMACS_UINT hash;
-  EMACS_TIME now;
 
   /* F must be a window-system frame, and SPEC must be a valid image
      specification.  */
@@ -1802,8 +1798,7 @@ lookup_image (struct frame *f, Lisp_Object spec)
     }
 
   /* We're using IMG, so set its timestamp to `now'.  */
-  EMACS_GET_TIME (now);
-  img->timestamp = EMACS_SECS (now);
+  EMACS_GET_TIME (img->timestamp);
 
   /* Value is the image id.  */
   return img->id;
diff --git a/src/keyboard.c b/src/keyboard.c
index 3e197ab4938..9b80c5c7019 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -2020,12 +2020,13 @@ start_polling (void)
       if (poll_timer == NULL
           || EMACS_SECS (poll_timer->interval) != polling_period)
         {
+          time_t period = max (1, min (polling_period, TYPE_MAXIMUM (time_t)));
           EMACS_TIME interval;
 
           if (poll_timer)
             cancel_atimer (poll_timer);
 
-          EMACS_SET_SECS_USECS (interval, polling_period, 0);
+          EMACS_SET_SECS_USECS (interval, period, 0);
           poll_timer = start_atimer (ATIMER_CONTINUOUS, interval,
                                      poll_for_input, NULL);
         }
@@ -2093,7 +2094,7 @@ void
 bind_polling_period (int n)
 {
 #ifdef POLL_FOR_INPUT
-  int new = polling_period;
+  EMACS_INT new = polling_period;
 
   if (n > new)
     new = n;
@@ -2223,7 +2224,7 @@ show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
 /* Input of single characters from keyboard */
 
 static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, int *used_mouse_menu,
-                                         struct timeval *end_time);
+                                         EMACS_TIME *end_time);
 static void record_char (Lisp_Object c);
 
 static Lisp_Object help_form_saved_window_configs;
@@ -2275,7 +2276,7 @@ do { if (polling_stopped_here) start_polling ();	\
 Lisp_Object
 read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
            Lisp_Object prev_event,
-           int *used_mouse_menu, struct timeval *end_time)
+           int *used_mouse_menu, EMACS_TIME *end_time)
 {
   volatile Lisp_Object c;
   ptrdiff_t jmpcount;
@@ -3783,7 +3784,7 @@ clear_event (struct input_event *event)
 static Lisp_Object
 kbd_buffer_get_event (KBOARD **kbp,
                       int *used_mouse_menu,
-                      struct timeval *end_time)
+                      EMACS_TIME *end_time)
 {
   Lisp_Object obj;
 
@@ -3857,8 +3858,9 @@ kbd_buffer_get_event (KBOARD **kbp,
           else
             {
               EMACS_SUB_TIME (duration, *end_time, duration);
-              wait_reading_process_output (EMACS_SECS (duration),
-                                           EMACS_USECS (duration),
+              wait_reading_process_output (min (EMACS_SECS (duration),
+                                                INTMAX_MAX),
+                                           EMACS_NSECS (duration),
                                            -1, 1, Qnil, NULL, 0);
             }
         }
@@ -4253,7 +4255,7 @@ timer_start_idle (void)
   Lisp_Object timers;
 
   /* If we are already in the idle state, do nothing.  */
-  if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
+  if (EMACS_TIME_VALID_P (timer_idleness_start_time))
     return;
 
   EMACS_GET_TIME (timer_idleness_start_time);
@@ -4267,7 +4269,7 @@ timer_start_idle (void)
 
       timer = XCAR (timers);
 
-      if (!VECTORP (timer) || ASIZE (timer) != 8)
+      if (!VECTORP (timer) || ASIZE (timer) != 9)
         continue;
       ASET (timer, 0, Qnil);
     }
@@ -4278,7 +4280,7 @@ timer_start_idle (void)
 static void
 timer_stop_idle (void)
 {
-  EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
+  EMACS_SET_INVALID_TIME (timer_idleness_start_time);
 }
 
 /* Resume idle timer from last idle start time.  */
@@ -4286,7 +4288,7 @@ timer_stop_idle (void)
 static void
 timer_resume_idle (void)
 {
-  if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
+  if (EMACS_TIME_VALID_P (timer_idleness_start_time))
     return;
 
   timer_idleness_start_time = timer_last_idleness_start_time;
@@ -4300,6 +4302,24 @@ struct input_event last_timer_event EXTERNALLY_VISIBLE;
    ...).  Each element has the form (FUN . ARGS).  */
 Lisp_Object pending_funcalls;
 
+/* If TIMER is a valid timer, return nonzero and place its value into
+   *RESULT.  Otherwise return zero.  */
+static int
+decode_timer (Lisp_Object timer, EMACS_TIME *result)
+{
+  Lisp_Object *vector;
+
+  if (! (VECTORP (timer) && ASIZE (timer) == 9))
+    return 0;
+  vector = XVECTOR (timer)->contents;
+  if (! NILP (vector[0]))
+    return 0;
+
+  return decode_time_components (vector[1], vector[2], vector[3], vector[4],
+                                 result, 0);
+}
+
+
 /* Check whether a timer has fired.  To prevent larger problems we simply
    disregard elements that are not proper timers.  Do not make a circular
    timer list for the time being.
@@ -4317,17 +4337,16 @@ timer_check_2 (void)
 {
   EMACS_TIME nexttime;
   EMACS_TIME now;
-  EMACS_TIME idleness_now IF_LINT (= {0});
+  EMACS_TIME idleness_now;
   Lisp_Object timers, idle_timers, chosen_timer;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
-  EMACS_SET_SECS (nexttime, -1);
-  EMACS_SET_USECS (nexttime, -1);
+  EMACS_SET_INVALID_TIME (nexttime);
 
   /* Always consider the ordinary timers.  */
   timers = Vtimer_list;
   /* Consider the idle timers only if Emacs is idle.  */
-  if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
+  if (EMACS_TIME_VALID_P (timer_idleness_start_time))
     idle_timers = Vtimer_idle_list;
   else
     idle_timers = Qnil;
@@ -4345,8 +4364,10 @@ timer_check_2 (void)
   if (CONSP (timers) || CONSP (idle_timers))
     {
       EMACS_GET_TIME (now);
-      if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
+      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);
     }
 
   while (CONSP (timers) || CONSP (idle_timers))
@@ -4355,113 +4376,84 @@ 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 IF_LINT (= {0});
-      EMACS_TIME idle_timer_difference IF_LINT (= {0});
+      EMACS_TIME timer_difference, idle_timer_difference;
+      int ripe, timer_ripe = 0, idle_timer_ripe = 0;
 
-      /* Skip past invalid timers and timers already handled.  */
+      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
+         this timer becomes ripe (negative if it's already ripe).
+         Skip past invalid timers and timers already handled.  */
       if (CONSP (timers))
         {
           timer = XCAR (timers);
-          if (!VECTORP (timer) || ASIZE (timer) != 8)
+          if (! decode_timer (timer, &timer_time))
             {
               timers = XCDR (timers);
               continue;
             }
-          vector = XVECTOR (timer)->contents;
 
-          if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
-              || !INTEGERP (vector[3])
-              || ! NILP (vector[0]))
-            {
-              timers = XCDR (timers);
-              continue;
-            }
+          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);
         }
+
+      /* Likewise for IDLE_TIMER and IDLE_TIMER_DIFFERENCE
+         based on the next idle timer.  */
       if (CONSP (idle_timers))
         {
-          timer = XCAR (idle_timers);
-          if (!VECTORP (timer) || ASIZE (timer) != 8)
-            {
-              idle_timers = XCDR (idle_timers);
-              continue;
-            }
-          vector = XVECTOR (timer)->contents;
-
-          if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
-              || !INTEGERP (vector[3])
-              || ! NILP (vector[0]))
+          idle_timer = XCAR (idle_timers);
+          if (! decode_timer (idle_timer, &idle_timer_time))
             {
               idle_timers = XCDR (idle_timers);
               continue;
             }
-        }
-
-      /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
-         based on the next ordinary timer.
-         TIMER_DIFFERENCE is the distance in time from NOW to when
-         this timer becomes ripe (negative if it's already ripe).  */
-      if (CONSP (timers))
-        {
-          timer = XCAR (timers);
-          vector = XVECTOR (timer)->contents;
-          EMACS_SET_SECS (timer_time,
-                          (XINT (vector[1]) << 16) | (XINT (vector[2])));
-          EMACS_SET_USECS (timer_time, XINT (vector[3]));
-          EMACS_SUB_TIME (timer_difference, timer_time, now);
-        }
 
-      /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
-         based on the next idle timer.  */
-      if (CONSP (idle_timers))
-        {
-          idle_timer = XCAR (idle_timers);
-          vector = XVECTOR (idle_timer)->contents;
-          EMACS_SET_SECS (idle_timer_time,
-                          (XINT (vector[1]) << 16) | (XINT (vector[2])));
-          EMACS_SET_USECS (idle_timer_time, XINT (vector[3]));
-          EMACS_SUB_TIME (idle_timer_difference, idle_timer_time, idleness_now);
+          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);
         }
 
       /* Decide which timer is the next timer,
-         and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
+         and set CHOSEN_TIMER, DIFFERENCE, and RIPE accordingly.
          Also step down the list where we found that timer.  */
 
-      if (CONSP (timers) && CONSP (idle_timers))
-        {
-          EMACS_TIME temp;
-          EMACS_SUB_TIME (temp, timer_difference, idle_timer_difference);
-          if (EMACS_TIME_NEG_P (temp))
-            {
-              chosen_timer = timer;
-              timers = XCDR (timers);
-              difference = timer_difference;
-            }
-          else
-            {
-              chosen_timer = idle_timer;
-              idle_timers = XCDR (idle_timers);
-              difference = idle_timer_difference;
-            }
-        }
-      else if (CONSP (timers))
+      if (EMACS_TIME_VALID_P (timer_difference)
+          && (! EMACS_TIME_VALID_P (idle_timer_difference)
+              || idle_timer_ripe < timer_ripe
+              || (idle_timer_ripe == timer_ripe
+                  && (timer_ripe
+                      ? EMACS_TIME_LT (idle_timer_difference,
+                                       timer_difference)
+                      : EMACS_TIME_LT (timer_difference,
+                                       idle_timer_difference)))))
         {
           chosen_timer = timer;
           timers = XCDR (timers);
           difference = timer_difference;
+          ripe = timer_ripe;
         }
       else
         {
           chosen_timer = idle_timer;
           idle_timers = XCDR (idle_timers);
           difference = idle_timer_difference;
+          ripe = idle_timer_ripe;
         }
-      vector = XVECTOR (chosen_timer)->contents;
 
       /* If timer is ripe, run it if it hasn't been run.  */
-      if (EMACS_TIME_NEG_P (difference)
-          || (EMACS_SECS (difference) == 0
-              && EMACS_USECS (difference) == 0))
+      if (ripe)
         {
+          vector = XVECTOR (chosen_timer)->contents;
           if (NILP (vector[0]))
             {
               ptrdiff_t count = SPECPDL_INDEX ();
@@ -4508,7 +4500,7 @@ timer_check_2 (void)
    timer list for the time being.
 
    Returns the time to wait until the next timer fires.
-   If no timer is active, return -1.
+   If no timer is active, return an invalid value.
 
    As long as any timer is ripe, we run it.  */
 
@@ -4521,33 +4513,29 @@ timer_check (void)
     {
       nexttime = timer_check_2 ();
     }
-  while (EMACS_SECS (nexttime) == 0 && EMACS_USECS (nexttime) == 0);
+  while (EMACS_SECS (nexttime) == 0 && EMACS_NSECS (nexttime) == 0);
 
   return nexttime;
 }
 
 DEFUN ("current-idle-time", Fcurrent_idle_time, Scurrent_idle_time, 0, 0, 0,
        doc: /* Return the current length of Emacs idleness, or nil.
-The value when Emacs is idle is a list of three integers.  The first has
-the most significant 16 bits of the seconds, while the second has the least
-significant 16 bits.  The third integer gives the microsecond count.
+The value when Emacs is idle is a list of four integers (HIGH LOW USEC PSEC)
+in the same style as (current-time).
 
 The value when Emacs is not idle is nil.
 
-The microsecond count is zero on systems that do not provide
-resolution finer than a second.  */)
+NSEC is a multiple of the system clock resolution.  */)
   (void)
 {
-  if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
+  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 list3 (make_number ((EMACS_SECS (idleness_now) >> 16) & 0xffff),
-                    make_number ((EMACS_SECS (idleness_now) >> 0)  & 0xffff),
-                    make_number (EMACS_USECS (idleness_now)));
+      return make_lisp_time (idleness_now);
     }
 
   return Qnil;
@@ -10735,7 +10723,7 @@ stuff_buffered_input (Lisp_Object stuffstring)
 }
 
 void
-set_waiting_for_input (struct timeval *time_to_clear)
+set_waiting_for_input (EMACS_TIME *time_to_clear)
 {
   input_available_clear_time = time_to_clear;
 
@@ -11358,7 +11346,7 @@ init_keyboard (void)
   quit_char = Ctl ('g');
   Vunread_command_events = Qnil;
   unread_command_char = -1;
-  EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
+  EMACS_SET_INVALID_TIME (timer_idleness_start_time);
   total_keys = 0;
   recent_keys_index = 0;
   kbd_fetch_ptr = kbd_buffer;
diff --git a/src/lisp.h b/src/lisp.h
index a88bf10c8bc..dd8cdd348b2 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2954,6 +2954,7 @@ EXFUN (Fnarrow_to_region, 2);
 EXFUN (Fwiden, 0);
 EXFUN (Fuser_login_name, 1);
 EXFUN (Fsystem_name, 0);
+extern void time_overflow (void) NO_RETURN;
 EXFUN (Fcurrent_time, 0);
 EXFUN (Fget_internal_run_time, 0);
 extern Lisp_Object make_buffer_string (ptrdiff_t, ptrdiff_t, int);
@@ -3244,7 +3245,7 @@ EXFUN (Fkill_process, 2);
 EXFUN (Fwaiting_for_user_input_p, 0);
 extern Lisp_Object Qprocessp;
 extern void kill_buffer_processes (Lisp_Object);
-extern int wait_reading_process_output (int, int, int, int,
+extern int wait_reading_process_output (intmax_t, int, int, int,
                                         Lisp_Object,
                                         struct Lisp_Process *,
                                         int);
diff --git a/src/lread.c b/src/lread.c
index 96868c2da89..fee97044a73 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -601,17 +601,9 @@ read_filtered_event (int no_switch_frame, int ascii_required,
   /* Compute timeout.  */
   if (NUMBERP (seconds))
     {
-      EMACS_TIME wait_time;
-      int sec, usec;
       double duration = extract_float (seconds);
-
-      if (0 < duration)
-        duration_to_sec_usec (duration, &sec, &usec);
-      else
-        sec = usec = 0;
-
+      EMACS_TIME wait_time = EMACS_TIME_FROM_DOUBLE (duration);
       EMACS_GET_TIME (end_time);
-      EMACS_SET_SECS_USECS (wait_time, sec, usec);
       EMACS_ADD_TIME (end_time, end_time, wait_time);
     }
 
diff --git a/src/msdos.c b/src/msdos.c
index c9bee400020..66911098ce0 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -4070,13 +4070,6 @@ sigprocmask (int how, const sigset_t *new_set, sigset_t *old_set)
 #ifndef HAVE_SELECT
 #include "sysselect.h"
 
-#ifndef EMACS_TIME_ZERO_OR_NEG_P
-#define EMACS_TIME_ZERO_OR_NEG_P(time)  \
-  ((long)(time).tv_sec < 0              \
-   || ((time).tv_sec == 0               \
-       && (long)(time).tv_usec <= 0))
-#endif
-
 /* This yields the rest of the current time slice to the task manager.
    It should be called by any code which knows that it has nothing
    useful to do except idle.
@@ -4145,12 +4138,12 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
 
           /* When seconds wrap around, we assume that no more than
              1 minute passed since last `gettime'.  */
-          if (EMACS_TIME_NEG_P (cldiff))
+          if (EMACS_TIME_SIGN (cldiff) < 0)
             EMACS_SET_SECS (cldiff, EMACS_SECS (cldiff) + 60);
           EMACS_SUB_TIME (*timeout, *timeout, cldiff);
 
           /* Stop when timeout value crosses zero.  */
-          if (EMACS_TIME_ZERO_OR_NEG_P (*timeout))
+          if (EMACS_TIME_SIGN (*timeout) <= 0)
             return 0;
           cllast = clnow;
           dos_yield_time_slice ();
diff --git a/src/nsterm.h b/src/nsterm.h
index bc535b47d97..9158b78e7ba 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -824,7 +824,8 @@ extern int x_display_pixel_width (struct ns_display_info *);
 
 /* This in nsterm.m */
 extern int ns_select (int nfds, fd_set *readfds, fd_set *writefds,
-                      fd_set *exceptfds, struct timeval *timeout);
+                      fd_set *exceptfds, EMACS_TIME *timeout,
+                      sigset_t *sigmask);
 extern unsigned long ns_get_rgb_color (struct frame *f,
                                        float r, float g, float b, float a);
 extern NSPoint last_mouse_motion_position;
diff --git a/src/nsterm.m b/src/nsterm.m
index dd4969a1e2e..bf14e5c83b1 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -183,7 +183,6 @@ static NSTimer *timed_entry = 0;
 static NSTimer *fd_entry = nil;
 static NSTimer *scroll_repeat_entry = nil;
 static fd_set select_readfds, t_readfds;
-static struct timeval select_timeout;
 static int select_nfds;
 static NSAutoreleasePool *outerpool;
 static struct input_event *emacs_event = NULL;
@@ -381,67 +380,30 @@ ns_init_paths (void)
     }
 }
 
-
-static int
-timeval_subtract (struct timeval *result, struct timeval x, struct timeval y)
-/* --------------------------------------------------------------------------
-   Subtract the `struct timeval' values X and Y, storing the result in RESULT.
-   Return 1 if the difference is negative, otherwise 0.
-   -------------------------------------------------------------------------- */
-{
-  /* Perform the carry for the later subtraction by updating y.
-     This is safer because on some systems
-     the tv_sec member is unsigned.  */
-  if (x.tv_usec < y.tv_usec)
-    {
-      int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
-      y.tv_usec -= 1000000 * nsec;
-      y.tv_sec += nsec;
-    }
-  if (x.tv_usec - y.tv_usec > 1000000)
-    {
-      int nsec = (y.tv_usec - x.tv_usec) / 1000000;
-      y.tv_usec += 1000000 * nsec;
-      y.tv_sec -= nsec;
-    }
-
-  /* Compute the time remaining to wait.  tv_usec is certainly positive.  */
-  result->tv_sec = x.tv_sec - y.tv_sec;
-  result->tv_usec = x.tv_usec - y.tv_usec;
-
-  /* Return indication of whether the result should be considered negative.  */
-  return x.tv_sec < y.tv_sec;
-}
-
 static void
 ns_timeout (int usecs)
 /* --------------------------------------------------------------------------
      Blocking timer utility used by ns_ring_bell
    -------------------------------------------------------------------------- */
 {
-  struct timeval wakeup;
+  EMACS_TIME wakeup, delay;
 
   EMACS_GET_TIME (wakeup);
-
-  /* Compute time to wait until, propagating carry from usecs.  */
-  wakeup.tv_usec += usecs;
-  wakeup.tv_sec += (wakeup.tv_usec / 1000000);
-  wakeup.tv_usec %= 1000000;
+  EMACS_SET_SECS_USECS (delay, 0, usecs);
+  EMACS_ADD_TIME (wakeup, wakeup, delay);
 
   /* Keep waiting until past the time wakeup.  */
   while (1)
     {
-      struct timeval timeout;
+      EMACS_TIME timeout;
 
       EMACS_GET_TIME (timeout);
-
-      /* In effect, timeout = wakeup - timeout.
-         Break if result would be negative.  */
-      if (timeval_subtract (&timeout, wakeup, timeout))
+      if (EMACS_TIME_LE (wakeup, timeout))
         break;
+      EMACS_SUB_TIME (timeout, wakeup, timeout);
 
       /* Try to wait that long--but we might wake up sooner.  */
-      select (0, NULL, NULL, NULL, &timeout);
+      pselect (0, NULL, NULL, NULL, &timeout, NULL);
     }
 }
 
@@ -3537,7 +3499,7 @@ ns_read_socket (struct terminal *terminal, int expected,
 
 int
 ns_select (int nfds, fd_set *readfds, fd_set *writefds,
-           fd_set *exceptfds, struct timeval *timeout)
+           fd_set *exceptfds, EMACS_TIME *timeout, sigset_t *sigmask)
 /* --------------------------------------------------------------------------
      Replacement for select, checking for events
    -------------------------------------------------------------------------- */
@@ -3545,12 +3507,14 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
   int result;
   double time;
   NSEvent *ev;
+  struct timespec select_timeout;
+
 /*  NSTRACE (ns_select); */
 
   if (NSApp == nil || inNsSelect == 1 /* || ([NSApp isActive] == NO &&
                       [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:nil
  inMode:NSDefaultRunLoopMode dequeue:NO] == nil) */)
-    return select (nfds, readfds, writefds, exceptfds, timeout);
+    return pselect (nfds, readfds, writefds, exceptfds, timeout, sigmask);
 
   /* Save file descriptor set, which gets overwritten in calls to select ()
      Note, this is called from process.c, and only readfds is ever set */
@@ -3563,8 +3527,9 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
     select_nfds = 0;
 
     /* Try an initial select for pending data on input files */
-  select_timeout.tv_sec = select_timeout.tv_usec = 0;
-  result = select (nfds, readfds, writefds, exceptfds, &select_timeout);
+  select_timeout.tv_sec = select_timeout.tv_nsec = 0;
+  result = pselect (nfds, readfds, writefds, exceptfds,
+                    &select_timeout, sigmask);
   if (result)
     return result;
 
@@ -3573,7 +3538,7 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
 
     /* set a timeout and run the main AppKit event loop while continuing
        to monitor the files */
-  time = ((double) timeout->tv_sec) + ((double) timeout->tv_usec)/1000000.0;
+  time = EMACS_TIME_TO_DOUBLE (*timeout);
   timed_entry = [[NSTimer scheduledTimerWithTimeInterval: time
                                            target: NSApp
                                          selector: @selector (timeout_handler:)
@@ -3581,7 +3546,7 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
                                           repeats: YES] /* for safe removal */
                                                          retain];
 
-  /* set a periodic task to try the select () again */
+  /* set a periodic task to try the pselect () again */
   fd_entry = [[NSTimer scheduledTimerWithTimeInterval: 0.1
                                                target: NSApp
                                              selector: @selector (fd_handler:)
@@ -3623,7 +3588,7 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
         }
       else
         {
-          /* Received back from select () in fd_handler; copy the results */
+          /* Received back from pselect () in fd_handler; copy the results */
           if (readfds)
             memcpy (readfds, &select_readfds, sizeof (fd_set));
           return t;
@@ -4603,6 +4568,7 @@ ns_term_shutdown (int sig)
    -------------------------------------------------------------------------- */
 {
   int result;
+  struct timespec select_timeout;
   /* NSTRACE (fd_handler); */
 
   if (select_nfds == 0)
@@ -4610,9 +4576,8 @@ ns_term_shutdown (int sig)
 
   memcpy (&t_readfds, &select_readfds, sizeof (fd_set));
 
-  select_timeout.tv_sec = select_timeout.tv_usec = 0;
-  result = select (select_nfds, &t_readfds, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
-                  &select_timeout);
+  select_timeout.tv_sec = select_timeout.tv_nsec = 0;
+  result = pselect (select_nfds, &t_readfds, NULL, NULL, &select_timeout, NULL);
   if (result)
     {
       memcpy (&select_readfds, &t_readfds, sizeof (fd_set));
diff --git a/src/process.c b/src/process.c
index cb89cae99fe..0ee0e499d6e 100644
--- a/src/process.c
+++ b/src/process.c
@@ -228,13 +228,11 @@ static EMACS_INT update_tick;
 #endif
 
 #if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING)
-#ifdef EMACS_HAS_USECS
 #define ADAPTIVE_READ_BUFFERING
 #endif
-#endif
 
 #ifdef ADAPTIVE_READ_BUFFERING
-#define READ_OUTPUT_DELAY_INCREMENT 10000
+#define READ_OUTPUT_DELAY_INCREMENT (EMACS_TIME_RESOLUTION / 100)
 #define READ_OUTPUT_DELAY_MAX       (READ_OUTPUT_DELAY_INCREMENT * 5)
 #define READ_OUTPUT_DELAY_MAX_MAX   (READ_OUTPUT_DELAY_INCREMENT * 7)
 
@@ -3291,7 +3289,7 @@ usage: (make-network-process &rest ARGS)  */)
         {
           /* Unlike most other syscalls connect() cannot be called
              again.  (That would return EALREADY.)  The proper way to
-             wait for completion is select(). */
+             wait for completion is pselect(). */
           int sc;
           socklen_t len;
           SELECT_TYPE fdset;
@@ -3299,8 +3297,7 @@ usage: (make-network-process &rest ARGS)  */)
           FD_ZERO (&fdset);
           FD_SET (s, &fdset);
           QUIT;
-          sc = select (s + 1, (SELECT_TYPE *)0, &fdset, (SELECT_TYPE *)0,
-                       (EMACS_TIME *)0);
+          sc = pselect (s + 1, NULL, &fdset, NULL, NULL, NULL);
           if (sc == -1)
             {
               if (errno == EINTR)
@@ -3961,7 +3958,8 @@ If JUST-THIS-ONE is an integer, don't run any timers either.
 Return non-nil if we received any output before the timeout expired.  */)
   (register Lisp_Object process, Lisp_Object seconds, Lisp_Object millisec, Lisp_Object just_this_one)
 {
-  int secs = -1, usecs = 0;
+  intmax_t secs;
+  int nsecs;
 
   if (! NILP (process))
     CHECK_PROCESS (process);
@@ -3980,17 +3978,36 @@ Return non-nil if we received any output before the timeout expired.  */)
         }
     }
 
+  secs = 0;
+  nsecs = -1;
+
   if (!NILP (seconds))
     {
-      double duration = extract_float (seconds);
-      if (0 < duration)
-        duration_to_sec_usec (duration, &secs, &usecs);
+      if (INTEGERP (seconds))
+        {
+          if (0 < XINT (seconds))
+            {
+              secs = XINT (seconds);
+              nsecs = 0;
+            }
+        }
+      else if (FLOATP (seconds))
+        {
+          if (0 < XFLOAT_DATA (seconds))
+            {
+              EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds));
+              secs = min (EMACS_SECS (t), INTMAX_MAX);
+              nsecs = EMACS_NSECS (t);
+            }
+        }
+      else
+        wrong_type_argument (Qnumberp, seconds);
     }
-  else if (!NILP (process))
-    secs = 0;
+  else if (! NILP (process))
+    nsecs = 0;
 
   return
-    (wait_reading_process_output (secs, usecs, 0, 0,
+    (wait_reading_process_output (secs, nsecs, 0, 0,
                                   Qnil,
                                   !NILP (process) ? XPROCESS (process) : NULL,
                                   NILP (just_this_one) ? 0 :
@@ -4231,34 +4248,19 @@ wait_reading_process_output_1 (void)
 {
 }
 
-/* Use a wrapper around select to work around a bug in gdb 5.3.
-   Normally, the wrapper is optimized away by inlining.
-
-   If emacs is stopped inside select, the gdb backtrace doesn't
-   show the function which called select, so it is practically
-   impossible to step through wait_reading_process_output.  */
-
-#ifndef select
-static inline int
-select_wrapper (int n, fd_set *rfd, fd_set *wfd, fd_set *xfd, struct timeval *tmo)
-{
-  return select (n, rfd, wfd, xfd, tmo);
-}
-#define select select_wrapper
-#endif
-
 /* Read and dispose of subprocess output while waiting for timeout to
    elapse and/or keyboard input to be available.
 
    TIME_LIMIT is:
-     timeout in seconds, or
-     zero for no limit, or
-     -1 means gobble data immediately available but don't wait for any.
+     timeout in seconds
+     If negative, gobble data immediately available but don't wait for any.
 
-   MICROSECS is:
-     an additional duration to wait, measured in microseconds.
-     If this is nonzero and time_limit is 0, then the timeout
-     consists of MICROSECS only.
+   NSECS is:
+     an additional duration to wait, measured in nanoseconds
+     If TIME_LIMIT is zero, then:
+       If NSECS == 0, there is no limit.
+       If NSECS > 0, the timeout consists of NSEC only.
+       If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
 
    READ_KBD is a lisp value:
      0 to ignore keyboard input, or
@@ -4285,7 +4287,7 @@ select_wrapper (int n, fd_set *rfd, fd_set *wfd, fd_set *xfd, struct timeval *tm
    Otherwise, return true if we received input from any process.  */
 
 int
-wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
+wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                              int do_display,
                              Lisp_Object wait_for_cell,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
@@ -4305,7 +4307,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
   FD_ZERO (&Available);
   FD_ZERO (&Writeok);
 
-  if (time_limit == 0 && microsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
+  if (time_limit == 0 && nsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
       && !(CONSP (wait_proc->status) && EQ (XCAR (wait_proc->status), Qexit)))
     message ("Blocking call to accept-process-output with quit inhibited!!");
 
@@ -4317,12 +4319,20 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                          make_number (waiting_for_user_input_p));
   waiting_for_user_input_p = read_kbd;
 
+  if (time_limit < 0)
+    {
+      time_limit = 0;
+      nsecs = -1;
+    }
+  else if (TYPE_MAXIMUM (time_t) < time_limit)
+    time_limit = TYPE_MAXIMUM (time_t);
+
   /* Since we may need to wait several times,
      compute the absolute time to return at.  */
-  if (time_limit || microsecs)
+  if (time_limit || nsecs) /* FIXME neither should be negative, no? */
     {
       EMACS_GET_TIME (end_time);
-      EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
+      EMACS_SET_SECS_NSECS (timeout, time_limit, nsecs);
       EMACS_ADD_TIME (end_time, end_time, timeout);
     }
 
@@ -4346,7 +4356,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 
       /* Compute time from now till when time limit is up */
       /* Exit if already run out */
-      if (time_limit == -1)
+      if (nsecs < 0)
         {
           /* -1 specified for timeout means
              gobble output available now
@@ -4354,12 +4364,12 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 
           EMACS_SET_SECS_USECS (timeout, 0, 0);
         }
-      else if (time_limit || microsecs)
+      else if (time_limit || nsecs)
         {
           EMACS_GET_TIME (timeout);
-          EMACS_SUB_TIME (timeout, end_time, timeout);
-          if (EMACS_TIME_NEG_P (timeout))
+          if (EMACS_TIME_LE (end_time, timeout))
             break;
+          EMACS_SUB_TIME (timeout, end_time, timeout);
         }
       else
         {
@@ -4405,21 +4415,22 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               && requeued_events_pending_p ())
             break;
 
-          if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
+          /* If time_limit is negative, we are not going to wait at all.  */
+          if (0 <= nsecs)
             {
-              EMACS_TIME difference;
-              EMACS_SUB_TIME (difference, timer_delay, timeout);
-              if (EMACS_TIME_NEG_P (difference))
+              if (EMACS_TIME_VALID_P (timer_delay))
                 {
-                  timeout = timer_delay;
-                  timeout_reduced_for_timers = 1;
+                  if (EMACS_TIME_LT (timer_delay, timeout))
+                    {
+                      timeout = timer_delay;
+                      timeout_reduced_for_timers = 1;
+                    }
+                }
+              else
+                {
+                  /* This is so a breakpoint can be put here.  */
+                  wait_reading_process_output_1 ();
                 }
-            }
-          /* If time_limit is -1, we are not going to wait at all.  */
-          else if (time_limit != -1)
-            {
-              /* This is so a breakpoint can be put here.  */
-              wait_reading_process_output_1 ();
             }
         }
 
@@ -4448,14 +4459,14 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
           Ctemp = write_mask;
 
           EMACS_SET_SECS_USECS (timeout, 0, 0);
-          if ((select (max (max_process_desc, max_input_desc) + 1,
-                       &Atemp,
+          if ((pselect (max (max_process_desc, max_input_desc) + 1,
+                        &Atemp,
 #ifdef NON_BLOCKING_CONNECT
-                       (num_pending_connects > 0 ? &Ctemp : (SELECT_TYPE *)0),
+                        (num_pending_connects > 0 ? &Ctemp : NULL),
 #else
-                       (SELECT_TYPE *)0,
+                        NULL,
 #endif
-                       (SELECT_TYPE *)0, &timeout)
+                        NULL, &timeout, NULL)
                <= 0))
             {
               /* It's okay for us to do this and then continue with
@@ -4578,9 +4589,9 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
              Vprocess_adaptive_read_buffering is nil.  */
           if (process_output_skip && check_delay > 0)
             {
-              int usecs = EMACS_USECS (timeout);
-              if (EMACS_SECS (timeout) > 0 || usecs > READ_OUTPUT_DELAY_MAX)
-                usecs = READ_OUTPUT_DELAY_MAX;
+              int nsecs = EMACS_NSECS (timeout);
+              if (EMACS_SECS (timeout) > 0 || nsecs > READ_OUTPUT_DELAY_MAX)
+                nsecs = READ_OUTPUT_DELAY_MAX;
               for (channel = 0; check_delay > 0 && channel <= max_process_desc; channel++)
                 {
                   proc = chan_process[channel];
@@ -4595,11 +4606,11 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                         continue;
                       FD_CLR (channel, &Available);
                       XPROCESS (proc)->read_output_skip = 0;
-                      if (XPROCESS (proc)->read_output_delay < usecs)
-                        usecs = XPROCESS (proc)->read_output_delay;
+                      if (XPROCESS (proc)->read_output_delay < nsecs)
+                        nsecs = XPROCESS (proc)->read_output_delay;
                     }
                 }
-              EMACS_SET_SECS_USECS (timeout, 0, usecs);
+              EMACS_SET_SECS_NSECS (timeout, 0, nsecs);
               process_output_skip = 0;
             }
 #endif
@@ -4608,12 +4619,12 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 #elif defined (HAVE_NS)
           nfds = ns_select
 #else
-          nfds = select
+          nfds = pselect
 #endif
             (max (max_process_desc, max_input_desc) + 1,
              &Available,
              (check_write ? &Writeok : (SELECT_TYPE *)0),
-             (SELECT_TYPE *)0, &timeout);
+             NULL, &timeout, NULL);
 
 #ifdef HAVE_GNUTLS
           /* GnuTLS buffers data internally.  In lowat mode it leaves
@@ -4671,7 +4682,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       /*  If we woke up due to SIGWINCH, actually change size now.  */
       do_pending_window_change (0);
 
-      if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
+      if ((time_limit || nsecs) && nfds == 0 && ! timeout_reduced_for_timers)
         /* We wanted the full specified time, so return now.  */
         break;
       if (nfds < 0)
@@ -4823,7 +4834,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               if (wait_channel == channel)
                 {
                   wait_channel = -1;
-                  time_limit = -1;
+                  nsecs = -1;
                   got_some_input = 1;
                 }
               proc = chan_process[channel];
@@ -5680,11 +5691,8 @@ send_process (volatile Lisp_Object proc, const char *volatile buf,
 
                       /* Put what we should have written in wait_queue.  */
                       write_queue_push (p, cur_object, cur_buf, cur_len, 1);
-#ifdef EMACS_HAS_USECS
-                      wait_reading_process_output (0, 20000, 0, 0, Qnil, NULL, 0);
-#else
-                      wait_reading_process_output (1, 0, 0, 0, Qnil, NULL, 0);
-#endif
+                      wait_reading_process_output (0, 20 * 1000 * 1000,
+                                                   0, 0, Qnil, NULL, 0);
                       /* Reread queue, to see what is left.  */
                       break;
                     }
@@ -6825,9 +6833,15 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
    Wait for timeout to elapse and/or keyboard input to be available.
 
    time_limit is:
-     timeout in seconds, or
-     zero for no limit, or
-     -1 means gobble data immediately available but don't wait for any.
+     timeout in seconds
+     If negative, gobble data immediately available but don't wait for any.
+
+   nsec is:
+     an additional duration to wait, measured in nanoseconds
+     If TIME_LIMIT is zero, then:
+       If NSEC == 0, there is no limit.
+       If NSEC > 0, the timeout consists of NSEC only.
+       If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
 
    read_kbd is a Lisp_Object:
      0 to ignore keyboard input, or
@@ -6844,7 +6858,7 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
    Return true if we received input from any process.  */
 
 int
-wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
+wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                              int do_display,
                              Lisp_Object wait_for_cell,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
@@ -6854,11 +6868,19 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
   SELECT_TYPE waitchannels;
   int xerrno;
 
+  if (time_limit < 0)
+    {
+      time_limit = 0;
+      nsecs = -1;
+    }
+  else if (TYPE_MAXIMUM (time_t) < time_limit)
+    time_limit = TYPE_MAXIMUM (time_t);
+
   /* What does time_limit really mean?  */
-  if (time_limit || microsecs)
+  if (time_limit || nsecs) /* FIXME: what if negative? */
     {
       EMACS_GET_TIME (end_time);
-      EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
+      EMACS_SET_SECS_NSECS (timeout, time_limit, nsecs);
       EMACS_ADD_TIME (end_time, end_time, timeout);
     }
 
@@ -6884,7 +6906,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 
       /* Compute time from now till when time limit is up */
       /* Exit if already run out */
-      if (time_limit == -1)
+      if (nsecs < 0)
         {
           /* -1 specified for timeout means
              gobble output available now
@@ -6892,12 +6914,12 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 
           EMACS_SET_SECS_USECS (timeout, 0, 0);
         }
-      else if (time_limit || microsecs)
+      else if (time_limit || nsecs)
         {
           EMACS_GET_TIME (timeout);
-          EMACS_SUB_TIME (timeout, end_time, timeout);
-          if (EMACS_TIME_NEG_P (timeout))
+          if (EMACS_TIME_LE (end_time, timeout))
             break;
+          EMACS_SUB_TIME (timeout, end_time, timeout);
         }
       else
         {
@@ -6930,11 +6952,9 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               && requeued_events_pending_p ())
             break;
 
-          if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
+          if (EMACS_TIME_VALID_P (timer_delay) && 0 <= nsecs)
             {
-              EMACS_TIME difference;
-              EMACS_SUB_TIME (difference, timer_delay, timeout);
-              if (EMACS_TIME_NEG_P (difference))
+              if (EMACS_TIME_LT (timer_delay, timeout))
                 {
                   timeout = timer_delay;
                   timeout_reduced_for_timers = 1;
@@ -6970,8 +6990,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
           FD_ZERO (&waitchannels);
         }
       else
-        nfds = select (1, &waitchannels, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
-                       &timeout);
+        nfds = pselect (1, &waitchannels, NULL, NULL, &timeout, NULL);
 
       xerrno = errno;
 
@@ -6981,7 +7000,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       /*  If we woke up due to SIGWINCH, actually change size now.  */
       do_pending_window_change (0);
 
-      if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
+      if ((time_limit || nsecs) && nfds == 0 && ! timeout_reduced_for_timers)
         /* We waited the full specified time, so return now.  */
         break;
 
@@ -7284,19 +7303,20 @@ integer or floating point values.
  majflt  -- number of major page faults (number)
  cminflt -- cumulative number of minor page faults (number)
  cmajflt -- cumulative number of major page faults (number)
- utime   -- user time used by the process, in the (HIGH LOW USEC) format
- stime   -- system time used by the process, in the (HIGH LOW USEC) format
- time    -- sum of utime and stime, in the (HIGH LOW USEC) format
- cutime  -- user time used by the process and its children, (HIGH LOW USEC)
- cstime  -- system time used by the process and its children, (HIGH LOW USEC)
- ctime   -- sum of cutime and cstime, in the (HIGH LOW USEC) format
+ utime   -- user time used by the process, in (current-time) format,
+              which is a list of integers (HIGH LOW USEC PSEC)
+ stime   -- system time used by the process (current-time)
+ time    -- sum of utime and stime (current-time)
+ cutime  -- user time used by the process and its children (current-time)
+ cstime  -- system time used by the process and its children (current-time)
+ ctime   -- sum of cutime and cstime (current-time)
  pri     -- priority of the process (number)
  nice    -- nice value of the process (number)
  thcount -- process thread count (number)
- start   -- time the process started, in the (HIGH LOW USEC) format
+ start   -- time the process started (current-time)
  vsize   -- virtual memory size of the process in KB's (number)
  rss     -- resident set size of the process in KB's (number)
- etime   -- elapsed time the process is running, in (HIGH LOW USEC) format
+ etime   -- elapsed time the process is running, in (HIGH LOW USEC PSEC) format
  pcpu    -- percents of CPU time used by the process (floating-point number)
  pmem    -- percents of total physical memory used by process's resident set
               (floating-point number)
diff --git a/src/process.h b/src/process.h
index ae4b6b61c94..649056a99ff 100644
--- a/src/process.h
+++ b/src/process.h
@@ -106,8 +106,8 @@ struct Lisp_Process
        On some systems, e.g. GNU/Linux, Emacs is seen as
        an interactive app also when reading process output, meaning
        that process output can be read in as little as 1 byte at a
-       time.  Value is micro-seconds to delay reading output from
-       this process.  Range is 0 .. 50000.  */
+       time.  Value is nanoseconds to delay reading output from
+       this process.  Range is 0 .. 50 * 1000 * 1000.  */
     int read_output_delay;
     /* Should we delay reading output from this process.
        Initialized from `Vprocess_adaptive_read_buffering'.
diff --git a/src/sysdep.c b/src/sysdep.c
index 3356582de0c..8d1c3d0ca3c 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -32,6 +32,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <allocator.h>
 #include <careadlinkat.h>
 #include <ignore-value.h>
+#include <utimens.h>
 
 #include "lisp.h"
 #include "sysselect.h"
@@ -109,20 +110,6 @@ extern char *getwd (char *);
 
 #include "syssignal.h"
 #include "systime.h"
-#ifdef HAVE_UTIME_H
-#include <utime.h>
-#endif
-
-#ifndef HAVE_UTIMES
-#ifndef HAVE_STRUCT_UTIMBUF
-/* We want to use utime rather than utimes, but we couldn't find the
-   structure declaration.  We'll use the traditional one.  */
-struct utimbuf {
-  long actime;
-  long modtime;
-};
-#endif
-#endif
 
 static int emacs_get_tty (int, struct emacs_tty *);
 static int emacs_set_tty (int, struct emacs_tty *, int);
@@ -2067,30 +2054,6 @@ perror (void)
 #endif /* HPUX and not HAVE_PERROR */
 
 /*
- *      Gettimeofday.  Simulate as much as possible.  Only accurate
- *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
- *      Only needed when subprocesses are defined.
- */
-
-#ifndef HAVE_GETTIMEOFDAY
-#ifdef HAVE_TIMEVAL
-
-int
-gettimeofday (struct timeval *tp, struct timezone *tzp)
-{
-  extern long time (long);
-
-  tp->tv_sec = time ((long *)0);
-  tp->tv_usec = 0;
-  if (tzp != 0)
-    tzp->tz_minuteswest = -1;
-  return 0;
-}
-
-#endif
-#endif /* !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL */
-
-/*
  *      This function will go away as soon as all the stubs fixed. (fnf)
  */
 
@@ -2126,20 +2089,43 @@ closedir (DIR *dirp /* stream from opendir */)
 #endif /* HAVE_DIRENT_H */
 
 
+/* Return a struct timeval that is roughly equivalent to T.
+   Use the least timeval not less than T.
+   Return an extremal value if the result would overflow.  */
+struct timeval
+make_timeval (EMACS_TIME t)
+{
+  struct timeval tv;
+  tv.tv_sec = t.tv_sec;
+  tv.tv_usec = t.tv_nsec / 1000;
+
+  if (t.tv_nsec % 1000 != 0)
+    {
+      if (tv.tv_usec < 999999)
+        tv.tv_usec++;
+      else if (tv.tv_sec < TYPE_MAXIMUM (time_t))
+        {
+          tv.tv_sec++;
+          tv.tv_usec = 0;
+        }
+    }
+
+  return tv;
+}
+
+/* Set the access and modification time stamps of FD (a.k.a. FILE) to be
+   ATIME and MTIME, respectively.
+   FD must be either negative -- in which case it is ignored --
+   or a file descriptor that is open on FILE.
+   If FD is nonnegative, then FILE can be NULL.  */
 int
-set_file_times (const char *filename, EMACS_TIME atime, EMACS_TIME mtime)
-{
-#ifdef HAVE_UTIMES
-  struct timeval tv[2];
-  tv[0] = atime;
-  tv[1] = mtime;
-  return utimes (filename, tv);
-#else /* not HAVE_UTIMES */
-  struct utimbuf utb;
-  utb.actime = EMACS_SECS (atime);
-  utb.modtime = EMACS_SECS (mtime);
-  return utime (filename, &utb);
-#endif /* not HAVE_UTIMES */
+set_file_times (int fd, const char *filename,
+                EMACS_TIME atime, EMACS_TIME mtime)
+{
+  struct timespec timespec[2];
+  timespec[0] = atime;
+  timespec[1] = mtime;
+  return fdutimens (fd, filename, timespec);
 }
 
 /* mkdir and rmdir functions, for systems which don't have them.  */
@@ -2595,60 +2581,82 @@ list_system_processes (void)
 #endif /* !defined (WINDOWSNT) */
 
 #ifdef GNU_LINUX
-static void
-time_from_jiffies (unsigned long long tval, long hz,
-                   time_t *sec, unsigned *usec)
-{
-  unsigned long long ullsec;
-
-  *sec = tval / hz;
-  ullsec = *sec;
-  tval -= ullsec * hz;
-  /* Careful: if HZ > 1 million, then integer division by it yields zero.  */
-  if (hz <= 1000000)
-    *usec = tval * 1000000 / hz;
+static EMACS_TIME
+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 ();
+  if (LONG_MAX - 1 <= ULLONG_MAX / EMACS_TIME_RESOLUTION
+      || frac <= ULLONG_MAX / EMACS_TIME_RESOLUTION)
+    ns = frac * EMACS_TIME_RESOLUTION / hz;
   else
-    *usec = tval / (hz / 1000000);
+    {
+      /* This is reachable only in the unlikely case that HZ * HZ
+         exceeds ULLONG_MAX.  It calculates an approximation that is
+         guaranteed to be in range.  */
+      long hz_per_ns = (hz / EMACS_TIME_RESOLUTION
+                        + (hz % EMACS_TIME_RESOLUTION != 0));
+      ns = frac / hz_per_ns;
+    }
+
+  EMACS_SET_SECS_NSECS (t, s, ns);
+  return t;
 }
 
 static Lisp_Object
 ltime_from_jiffies (unsigned long long tval, long hz)
 {
-  time_t sec;
-  unsigned usec;
-
-  time_from_jiffies (tval, hz, &sec, &usec);
-
-  return list3 (make_number ((sec >> 16) & 0xffff),
-                make_number (sec & 0xffff),
-                make_number (usec));
+  EMACS_TIME t = time_from_jiffies (tval, hz);
+  return make_lisp_time (t);
 }
 
-static void
-get_up_time (time_t *sec, unsigned *usec)
+static EMACS_TIME
+get_up_time (void)
 {
   FILE *fup;
+  EMACS_TIME up;
 
-  *sec = *usec = 0;
+  EMACS_SET_SECS_NSECS (up, 0, 0);
 
   BLOCK_INPUT;
   fup = fopen ("/proc/uptime", "r");
 
   if (fup)
     {
-      double uptime, idletime;
+      unsigned long long upsec, upfrac, idlesec, idlefrac;
+      int upfrac_start, upfrac_end, idlefrac_start, idlefrac_end;
 
-      /* The numbers in /proc/uptime use C-locale decimal point, but
-         we already set ourselves to the C locale (see `fixup_locale'
-         in emacs.c).  */
-      if (2 <= fscanf (fup, "%lf %lf", &uptime, &idletime))
+      if (fscanf (fup, "%llu.%n%llu%n %llu.%n%llu%n",
+                  &upsec, &upfrac_start, &upfrac, &upfrac_end,
+                  &idlesec, &idlefrac_start, &idlefrac, &idlefrac_end)
+          == 4)
         {
-          *sec = uptime;
-          *usec = (uptime - *sec) * 1000000;
+          if (TYPE_MAXIMUM (time_t) < upsec)
+            {
+              upsec = TYPE_MAXIMUM (time_t);
+              upfrac = EMACS_TIME_RESOLUTION - 1;
+            }
+          else
+            {
+              int upfraclen = upfrac_end - upfrac_start;
+              for (; upfraclen < LOG10_EMACS_TIME_RESOLUTION; upfraclen++)
+                upfrac *= 10;
+              for (; LOG10_EMACS_TIME_RESOLUTION < upfraclen; upfraclen--)
+                upfrac /= 10;
+              upfrac = min (upfrac, EMACS_TIME_RESOLUTION - 1);
+            }
+          EMACS_SET_SECS_NSECS (up, upsec, upfrac);
         }
       fclose (fup);
     }
   UNBLOCK_INPUT;
+
+  return up;
 }
 
 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
@@ -2748,9 +2756,7 @@ system_process_attributes (Lisp_Object pid)
   unsigned long long u_time, s_time, cutime, cstime, start;
   long priority, niceness, rss;
   unsigned long minflt, majflt, cminflt, cmajflt, vsize;
-  time_t sec;
-  unsigned usec;
-  EMACS_TIME tnow, tstart, tboot, telapsed;
+  EMACS_TIME tnow, tstart, tboot, telapsed, us_time;
   double pcpu, pmem;
   Lisp_Object attrs = Qnil;
   Lisp_Object cmd_str, decoded_cmd, tem;
@@ -2873,35 +2879,18 @@ system_process_attributes (Lisp_Object pid)
           attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
           attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs);
           EMACS_GET_TIME (tnow);
-          get_up_time (&sec, &usec);
-          EMACS_SET_SECS (telapsed, sec);
-          EMACS_SET_USECS (telapsed, usec);
+          telapsed = get_up_time ();
           EMACS_SUB_TIME (tboot, tnow, telapsed);
-          time_from_jiffies (start, clocks_per_sec, &sec, &usec);
-          EMACS_SET_SECS (tstart, sec);
-          EMACS_SET_USECS (tstart, usec);
+          tstart = time_from_jiffies (start, clocks_per_sec);
           EMACS_ADD_TIME (tstart, tboot, tstart);
-          attrs = Fcons (Fcons (Qstart,
-                                list3 (make_number
-                                       ((EMACS_SECS (tstart) >> 16) & 0xffff),
-                                       make_number
-                                       (EMACS_SECS (tstart) & 0xffff),
-                                       make_number
-                                       (EMACS_USECS (tstart)))),
-                         attrs);
+          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);
-          attrs = Fcons (Fcons (Qetime,
-                                list3 (make_number
-                                       ((EMACS_SECS (telapsed) >> 16) & 0xffff),
-                                       make_number
-                                       (EMACS_SECS (telapsed) & 0xffff),
-                                       make_number
-                                       (EMACS_USECS (telapsed)))),
-                         attrs);
-          time_from_jiffies (u_time + s_time, clocks_per_sec, &sec, &usec);
-          pcpu = (sec + usec / 1000000.0) / (EMACS_SECS (telapsed) + EMACS_USECS (telapsed) / 1000000.0);
+          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)
+                  / EMACS_TIME_TO_DOUBLE (telapsed));
           if (pcpu > 1.0)
             pcpu = 1.0;
           attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs);
@@ -3082,27 +3071,13 @@ system_process_attributes (Lisp_Object pid)
                 Qcstime
                 Are they available? */
 
-          attrs = Fcons (Fcons (Qtime,
-                                list3 (make_number (pinfo.pr_time.tv_sec >> 16),
-                                       make_number (pinfo.pr_time.tv_sec & 0xffff),
-                                       make_number (pinfo.pr_time.tv_nsec))),
-                         attrs);
-
-          attrs = Fcons (Fcons (Qctime,
-                                list3 (make_number (pinfo.pr_ctime.tv_sec >> 16),
-                                       make_number (pinfo.pr_ctime.tv_sec & 0xffff),
-                                       make_number (pinfo.pr_ctime.tv_nsec))),
-                         attrs);
-
+          attrs = Fcons (Fcons (Qtime, make_lisp_time (pinfo.pr_time)), attrs);
+          attrs = Fcons (Fcons (Qctime, make_lisp_time (pinfo.pr_ctime)), attrs);
           attrs = Fcons (Fcons (Qpri, make_number (pinfo.pr_lwp.pr_pri)), attrs);
           attrs = Fcons (Fcons (Qnice, make_number (pinfo.pr_lwp.pr_nice)), attrs);
           attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (pinfo.pr_nlwp)), attrs);
 
-          attrs = Fcons (Fcons (Qstart,
-                                list3 (make_number (pinfo.pr_start.tv_sec >> 16),
-                                       make_number (pinfo.pr_start.tv_sec & 0xffff),
-                                       make_number (pinfo.pr_start.tv_nsec))),
-                         attrs);
+          attrs = Fcons (Fcons (Qstart, make_lisp_time (pinfo.pr_start)), attrs);
           attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (pinfo.pr_size)), attrs);
           attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (pinfo.pr_rssize)), attrs);
 
diff --git a/src/sysselect.h b/src/sysselect.h
index f9b9fc00b35..e1e5839cfe4 100644
--- a/src/sysselect.h
+++ b/src/sysselect.h
@@ -16,7 +16,6 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
-#ifdef HAVE_SYS_SELECT_H
 #if defined (DARWIN_OS)
 #undef init_process
 #endif
@@ -24,7 +23,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #if defined (DARWIN_OS)
 #define init_process emacs_init_process
 #endif
-#endif
 
 /* The w32 build defines select stuff in w32.h, which is included
    where w32 needs it, but not where sysselect.h is included.  The w32
@@ -52,4 +50,3 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #if !defined (HAVE_SELECT)
 #define select sys_select
 #endif
-
diff --git a/src/systime.h b/src/systime.h
index 9e7a1173a20..dd0d77c827d 100644
--- a/src/systime.h
+++ b/src/systime.h
@@ -19,16 +19,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef EMACS_SYSTIME_H
 #define EMACS_SYSTIME_H
 
-#ifdef TIME_WITH_SYS_TIME
-#include <sys/time.h>
-#include <time.h>
-#else
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#else
-#include <time.h>
-#endif
-#endif
+#include <timespec.h>
 
 #ifdef emacs
 # ifdef HAVE_X_WINDOWS
@@ -48,91 +39,64 @@ typedef unsigned long Time;
 #endif
 #endif
 
-/* EMACS_TIME is the type to use to represent temporal intervals -
-   struct timeval on some systems, int on others.  It can be passed as
-   the timeout argument to the select  system call.
+/* The type to use to represent temporal intervals.  It can be passed
+   as the timeout argument to the pselect system call.  */
+#define EMACS_TIME struct timespec
 
-   EMACS_SECS (TIME) is an rvalue for the seconds component of 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_HAS_USECS is defined if EMACS_TIME has a usecs component.
-   EMACS_USECS (TIME) is an rvalue for the microseconds component of TIME.
-        This returns zero if EMACS_TIME doesn't have a microseconds component.
-   EMACS_SET_USECS (TIME, MICROSECONDS) sets that to MICROSECONDS.
-        This does nothing if EMACS_TIME doesn't have a microseconds component.
+   EMACS_NSECS (TIME) is an rvalue for the nanoseconds component of TIME.
+   EMACS_SET_NSECS (TIME, NANOSECONDS) sets that to NANOSECONDS.
 
-   EMACS_SET_SECS_USECS (TIME, SECS, USECS) sets both components of TIME.
+   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)))
 
-   EMACS_GET_TIME (TIME) stores the current system time in TIME, which
-        should be an lvalue.
+/* 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))
 
-   EMACS_ADD_TIME (DEST, SRC1, SRC2) adds SRC1 to SRC2 and stores the
-        result in DEST.  SRC should not be negative.
+/* Set TIME to an invalid time stamp.  */
+#define EMACS_SET_INVALID_TIME(time)        EMACS_SET_SECS_NSECS(time, 0, -1)
 
-   EMACS_SUB_TIME (DEST, SRC1, SRC2) subtracts SRC2 from SRC1 and
-        stores the result in DEST.  SRC should not be negative.
-   EMACS_TIME_NEG_P (TIME) is true if TIME is negative.
+/* 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.  */
+#define EMACS_ADD_TIME(dest, src1, src2) ((dest) = timespec_add (src1, src2))
+#define EMACS_SUB_TIME(dest, src1, src2) ((dest) = timespec_sub (src1, src2))
 
-#ifdef HAVE_TIMEVAL
+/* Return the sign of the valid time stamp TIME, either -1, 0, or 1.  */
+#define EMACS_TIME_SIGN(time)           timespec_sign (time)
 
-#define EMACS_HAS_USECS
+/* Return 1 if TIME is a valid time stamp.  */
+#define EMACS_TIME_VALID_P(time)        (0 <= (time).tv_nsec)
 
-#define EMACS_TIME struct timeval
-#define EMACS_SECS(time)                    ((time).tv_sec  + 0)
-#define EMACS_USECS(time)                   ((time).tv_usec + 0)
-#define EMACS_SET_SECS(time, seconds)       ((time).tv_sec  = (seconds))
-#define EMACS_SET_USECS(time, microseconds) ((time).tv_usec = (microseconds))
-
-/* On SVR4, the compiler may complain if given this extra BSD arg.  */
-#ifdef GETTIMEOFDAY_ONE_ARGUMENT
-#define EMACS_GET_TIME(time) gettimeofday (&(time))
-#else /* not GETTIMEOFDAY_ONE_ARGUMENT */
-/* Presumably the second arg is ignored.  */
-#define EMACS_GET_TIME(time) gettimeofday (&(time), NULL)
-#endif /* not GETTIMEOFDAY_ONE_ARGUMENT */
-
-#define EMACS_ADD_TIME(dest, src1, src2)                \
-  do {                                                  \
-    (dest).tv_sec  = (src1).tv_sec  + (src2).tv_sec;    \
-    (dest).tv_usec = (src1).tv_usec + (src2).tv_usec;   \
-    if ((dest).tv_usec > 1000000)                       \
-      (dest).tv_usec -= 1000000, (dest).tv_sec++;       \
-  } while (0)
-
-#define EMACS_SUB_TIME(dest, src1, src2)                \
-  do {                                                  \
-    (dest).tv_sec  = (src1).tv_sec  - (src2).tv_sec;    \
-    (dest).tv_usec = (src1).tv_usec - (src2).tv_usec;   \
-    if ((dest).tv_usec < 0)                             \
-      (dest).tv_usec += 1000000, (dest).tv_sec--;       \
-  } while (0)
-
-#define EMACS_TIME_NEG_P(time)                                  \
-  ((long)(time).tv_sec < 0                                      \
-   || ((time).tv_sec == 0                                       \
-       && (long)(time).tv_usec < 0))
-
-#else /* ! defined (HAVE_TIMEVAL) */
-
-#define EMACS_TIME int
-#define EMACS_SECS(time)                    (time)
-#define EMACS_USECS(time)                   0
-#define EMACS_SET_SECS(time, seconds)       ((time) = (seconds))
-#define EMACS_SET_USECS(time, usecs)        0
-
-#define EMACS_GET_TIME(t) ((t) = time ((long *) 0))
-#define EMACS_ADD_TIME(dest, src1, src2) ((dest) = (src1) + (src2))
-#define EMACS_SUB_TIME(dest, src1, src2) ((dest) = (src1) - (src2))
-#define EMACS_TIME_NEG_P(t) ((t) < 0)
-
-#endif /* ! defined (HAVE_TIMEVAL) */
+/* 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)
 
-#define EMACS_SET_SECS_USECS(time, secs, usecs)                 \
-  (EMACS_SET_SECS (time, secs), EMACS_SET_USECS (time, usecs))
+/* Convert the Emacs time T to an approximate double value D.  */
+#define EMACS_TIME_TO_DOUBLE(t)         timespectod (t)
 
-extern int set_file_times (const char *, EMACS_TIME, EMACS_TIME);
+/* defined in sysdep.c */
+extern int set_file_times (int, const char *, EMACS_TIME, EMACS_TIME);
+extern struct timeval make_timeval (EMACS_TIME);
 
 /* defined in keyboard.c */
 extern void set_waiting_for_input (EMACS_TIME *);
@@ -141,29 +105,20 @@ extern void set_waiting_for_input (EMACS_TIME *);
    happen when this files is used outside the src directory).
    Use GCPRO1 to determine if lisp.h was included.  */
 #ifdef GCPRO1
-/* defined in editfns.c*/
-extern Lisp_Object make_time (time_t);
-extern int lisp_time_argument (Lisp_Object, time_t *, int *);
+/* defined in editfns.c */
+extern Lisp_Object make_lisp_time (EMACS_TIME);
+extern int decode_time_components (Lisp_Object, Lisp_Object, Lisp_Object,
+                                   Lisp_Object, EMACS_TIME *, int *);
+extern EMACS_TIME lisp_time_argument (Lisp_Object, int *);
 #endif
 
-/* Compare times T1 and T2.  Value is 0 if T1 and T2 are the same.
-   Value is < 0 if T1 is less than T2.  Value is > 0 otherwise.  (Cast
-   to long is for those platforms where time_t is an unsigned
-   type, and where otherwise T1 will always be grater than T2.)  */
-
-#define EMACS_TIME_CMP(T1, T2)                          \
-  ((long)EMACS_SECS (T1) - (long)EMACS_SECS (T2)        \
-   + (EMACS_SECS (T1) == EMACS_SECS (T2)                \
-      ? EMACS_USECS (T1) - EMACS_USECS (T2)             \
-      : 0))
-
 /* Compare times T1 and T2 for equality, inequality etc.  */
 
-#define EMACS_TIME_EQ(T1, T2) (EMACS_TIME_CMP (T1, T2) == 0)
-#define EMACS_TIME_NE(T1, T2) (EMACS_TIME_CMP (T1, T2) != 0)
-#define EMACS_TIME_GT(T1, T2) (EMACS_TIME_CMP (T1, T2) > 0)
-#define EMACS_TIME_GE(T1, T2) (EMACS_TIME_CMP (T1, T2) >= 0)
-#define EMACS_TIME_LT(T1, T2) (EMACS_TIME_CMP (T1, T2) < 0)
-#define EMACS_TIME_LE(T1, T2) (EMACS_TIME_CMP (T1, T2) <= 0)
+#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)
 
 #endif /* EMACS_SYSTIME_H */
diff --git a/src/term.c b/src/term.c
index 5f807181199..1a2524fd297 100644
--- a/src/term.c
+++ b/src/term.c
@@ -24,6 +24,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <ctype.h>
 #include <errno.h>
 #include <sys/file.h>
+#include <sys/time.h>
 #include <unistd.h>
 #include <signal.h>
 #include <setjmp.h>
@@ -2611,6 +2612,18 @@ term_mouse_movement (FRAME_PTR frame, Gpm_Event *event)
   return 0;
 }
 
+/* Return the Time that corresponds to T.  Wrap around on overflow.  */
+static Time
+timeval_to_Time (struct timeval const *t)
+{
+  Time s_1000, ms;
+
+  s_1000 = t->tv_sec;
+  s_1000 *= 1000;
+  ms = t->tv_usec / 1000;
+  return s_1000 + ms;
+}
+
 /* Return the current position of the mouse.
 
    Set *f to the frame the mouse is in, or zero if the mouse is in no
@@ -2630,7 +2643,6 @@ term_mouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window,
                      Lisp_Object *y, Time *timeptr)
 {
   struct timeval now;
-  Time sec, usec;
 
   *fp = SELECTED_FRAME ();
   (*fp)->mouse_moved = 0;
@@ -2641,9 +2653,7 @@ term_mouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window,
   XSETINT (*x, last_mouse_x);
   XSETINT (*y, last_mouse_y);
   gettimeofday(&now, 0);
-  sec = now.tv_sec;
-  usec = now.tv_usec;
-  *timeptr = (sec * 1000) + (usec / 1000);
+  *timeptr = timeval_to_Time (&now);
 }
 
 /* Prepare a mouse-event in *RESULT for placement in the input queue.
@@ -2667,7 +2677,7 @@ term_mouse_click (struct input_event *result, Gpm_Event *event,
       }
     }
   gettimeofday(&now, 0);
-  result->timestamp = (now.tv_sec * 1000) + (now.tv_usec / 1000);
+  result->timestamp = timeval_to_Time (&now);
 
   if (event->type & GPM_UP)
     result->modifiers = up_modifier;
diff --git a/src/undo.c b/src/undo.c
index 1cb048690ba..ae9025c298e 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -226,7 +226,7 @@ record_first_change (void)
     base_buffer = base_buffer->base_buffer;
 
   BVAR (current_buffer, undo_list) =
-    Fcons (Fcons (Qt, INTEGER_TO_CONS (base_buffer->modtime)),
+    Fcons (Fcons (Qt, make_lisp_time (base_buffer->modtime)),
            BVAR (current_buffer, undo_list));
 }
 
@@ -505,10 +505,23 @@ Return what remains of the list.  */)
               cdr = XCDR (next);
               if (EQ (car, Qt))
                 {
-                  /* Element (t high . low) records previous modtime.  */
+                  /* Element (t . TIME) records previous modtime.
+                     Preserve any flag of NONEXISTENT_MODTIME_NSECS or
+                     UNKNOWN_MODTIME_NSECS.  */
                   struct buffer *base_buffer = current_buffer;
-                  time_t mod_time;
-                  CONS_TO_INTEGER (cdr, time_t, mod_time);
+                  EMACS_TIME mod_time;
+
+                  if (CONSP (cdr)
+                      && CONSP (XCDR (cdr))
+                      && CONSP (XCDR (XCDR (cdr)))
+                      && 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);
+                  else
+                    mod_time = lisp_time_argument (cdr, 0);
 
                   if (current_buffer->base_buffer)
                     base_buffer = current_buffer->base_buffer;
@@ -516,7 +529,7 @@ Return what remains of the list.  */)
                   /* If this records an obsolete save
                      (not matching the actual disk file)
                      then don't mark unmodified.  */
-                  if (mod_time != base_buffer->modtime)
+                  if (EMACS_TIME_NE (mod_time, base_buffer->modtime))
                     continue;
 #ifdef CLASH_DETECTION
                   Funlock_buffer ();
diff --git a/src/w32.c b/src/w32.c
index 248a91463e8..dbe7ec1764f 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -318,8 +318,10 @@ is_windows_9x (void)
   return s_b_ret;
 }
 
+static Lisp_Object ltime (ULONGLONG);
+
 /* Get total user and system times for get-internal-run-time.
-   Returns a list of three integers if the times are provided by the OS
+   Returns a list of integers if the times are provided by the OS
    (NT derivatives), otherwise it returns the result of current-time. */
 Lisp_Object
 w32_get_internal_run_time (void)
@@ -331,27 +333,13 @@ w32_get_internal_run_time (void)
       if ((*get_process_times_fn) (proc, &create, &exit, &kernel, &user))
         {
           LARGE_INTEGER user_int, kernel_int, total;
-          int microseconds;
+          int time_100ns;
           user_int.LowPart = user.dwLowDateTime;
           user_int.HighPart = user.dwHighDateTime;
           kernel_int.LowPart = kernel.dwLowDateTime;
           kernel_int.HighPart = kernel.dwHighDateTime;
           total.QuadPart = user_int.QuadPart + kernel_int.QuadPart;
-          /* FILETIME is 100 nanosecond increments, Emacs only wants
-             microsecond resolution.  */
-          total.QuadPart /= 10;
-          microseconds = total.QuadPart % 1000000;
-          total.QuadPart /= 1000000;
-
-          /* Sanity check to make sure we can represent the result.  */
-          if (total.HighPart == 0)
-            {
-              int secs = total.LowPart;
-
-              return list3 (make_number ((secs >> 16) & 0xffff),
-                            make_number (secs & 0xffff),
-                            make_number (microseconds));
-            }
+          return ltime (total.QuadPart);
         }
     }
 
@@ -4070,15 +4058,17 @@ restore_privilege (TOKEN_PRIVILEGES *priv)
   return ret_val;
 }
 
-static Lisp_Object
-ltime (long time_sec, long time_usec)
+ltime (ULONGLONG time_100ns)
 {
-  return list3 (make_number ((time_sec >> 16) & 0xffff),
+  ULONGLONG time_sec = time_100ns / 10000000;
+  int subsec = time_100ns % 10000000;
+  return list4 (make_number (time_sec >> 16),
                 make_number (time_sec & 0xffff),
-                make_number (time_usec));
+                make_number (subsec / 10),
+                make_number (subsec % 10 * 100000));
 }
 
-#define U64_TO_LISP_TIME(time) ltime ((time) / 1000000L, (time) % 1000000L)
+#define U64_TO_LISP_TIME(time) ltime (time)
 
 static int
 process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime,
@@ -4097,11 +4087,9 @@ process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime,
   GetSystemTimeAsFileTime (&ft_current);
 
   FILETIME_TO_U64 (tem1, ft_kernel);
-  tem1 /= 10L;
   *stime = U64_TO_LISP_TIME (tem1);
 
   FILETIME_TO_U64 (tem2, ft_user);
-  tem2 /= 10L;
   *utime = U64_TO_LISP_TIME (tem2);
 
   tem3 = tem1 + tem2;
@@ -4110,13 +4098,13 @@ process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime,
   FILETIME_TO_U64 (tem, ft_creation);
   /* Process no 4 (System) returns zero creation time.  */
   if (tem)
-    tem = (tem - utc_base) / 10L;
+    tem -= utc_base;
   *ctime = U64_TO_LISP_TIME (tem);
 
   if (tem)
     {
       FILETIME_TO_U64 (tem3, ft_current);
-      tem = (tem3 - utc_base) / 10L - tem;
+      tem = (tem3 - utc_base) - tem;
     }
   *etime = U64_TO_LISP_TIME (tem);
 
@@ -6275,7 +6263,7 @@ emacs_gnutls_pull (gnutls_transport_ptr_t p, void* buf, size_t sz)
 {
   int n, sc, err;
   SELECT_TYPE fdset;
-  EMACS_TIME timeout;
+  struct timeval timeout;
   struct Lisp_Process *process = (struct Lisp_Process *)p;
   int fd = process->infd;
 
@@ -6291,7 +6279,8 @@ emacs_gnutls_pull (gnutls_transport_ptr_t p, void* buf, size_t sz)
       if (err == EWOULDBLOCK)
         {
           /* Set a small timeout.  */
-          EMACS_SET_SECS_USECS (timeout, 1, 0);
+          timeout.tv_sec = 1;
+          timeout.tv_usec = 0;
           FD_ZERO (&fdset);
           FD_SET ((int)fd, &fdset);
 
diff --git a/src/xdisp.c b/src/xdisp.c
index a0739eb5522..0050d644931 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -29077,18 +29077,20 @@ start_hourglass (void)
 {
 #if defined (HAVE_WINDOW_SYSTEM)
   EMACS_TIME delay;
-  int secs = DEFAULT_HOURGLASS_DELAY, usecs = 0;
 
   cancel_hourglass ();
 
-  if (NUMBERP (Vhourglass_delay))
-    {
-      double duration = extract_float (Vhourglass_delay);
-      if (0 < duration)
-        duration_to_sec_usec (duration, &secs, &usecs);
-    }
+  if (INTEGERP (Vhourglass_delay)
+      && XINT (Vhourglass_delay) > 0)
+    EMACS_SET_SECS_NSECS (delay,
+                          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);
 
-  EMACS_SET_SECS_USECS (delay, secs, usecs);
   hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
                                    show_hourglass, NULL);
 #endif
diff --git a/src/xgselect.c b/src/xgselect.c
index 9d6a3ba774a..c7348d2c70a 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -34,18 +34,18 @@ static ptrdiff_t gfds_size;
 
 int
 xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
-           EMACS_TIME *timeout)
+           EMACS_TIME *timeout, sigset_t *sigmask)
 {
   SELECT_TYPE all_rfds, all_wfds;
   EMACS_TIME tmo, *tmop = timeout;
 
   GMainContext *context;
   int have_wfds = wfds != NULL;
-  int n_gfds = 0, our_tmo = 0, retval = 0, our_fds = 0, max_fds = fds_lim - 1;
+  int n_gfds = 0, retval = 0, our_fds = 0, max_fds = fds_lim - 1;
   int i, nfds, tmo_in_millisec;
 
   if (!x_in_use)
-    return select (fds_lim, rfds, wfds, efds, timeout);
+    return pselect (fds_lim, rfds, wfds, efds, tmop, sigmask);
 
   if (rfds) memcpy (&all_rfds, rfds, sizeof (all_rfds));
   else FD_ZERO (&all_rfds);
@@ -90,20 +90,13 @@ xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
     {
       EMACS_SET_SECS_USECS (tmo, tmo_in_millisec/1000,
                             1000 * (tmo_in_millisec % 1000));
-      if (!timeout) our_tmo = 1;
-      else
-        {
-          EMACS_TIME difference;
-
-          EMACS_SUB_TIME (difference, tmo, *timeout);
-          if (EMACS_TIME_NEG_P (difference)) our_tmo = 1;
-        }
-
-      if (our_tmo) tmop = &tmo;
+      if (!timeout || EMACS_TIME_LT (tmo, *timeout))
+        tmop = &tmo;
     }
 
   fds_lim = max_fds + 1;
-  nfds = select (fds_lim, &all_rfds, have_wfds ? &all_wfds : NULL, efds, tmop);
+  nfds = pselect (fds_lim, &all_rfds, have_wfds ? &all_wfds : NULL,
+                  efds, tmop, sigmask);
 
   if (nfds < 0)
     retval = nfds;
@@ -132,7 +125,7 @@ xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
         }
     }
 
-  if (our_fds > 0 || (nfds == 0 && our_tmo))
+  if (our_fds > 0 || (nfds == 0 && tmop == &tmo))
     {
 
       /* If Gtk+ is in use eventually gtk_main_iteration will be called,
diff --git a/src/xgselect.h b/src/xgselect.h
index 15d7cd5fdd3..8e5614ea972 100644
--- a/src/xgselect.h
+++ b/src/xgselect.h
@@ -28,9 +28,9 @@ extern int xg_select (int max_fds,
                       SELECT_TYPE *rfds,
                       SELECT_TYPE *wfds,
                       SELECT_TYPE *efds,
-                      EMACS_TIME *timeout);
+                      EMACS_TIME *timeout,
+                      sigset_t *sigmask);
 
 extern void xgselect_initialize (void);
 
 #endif /* XGSELECT_H */
-
diff --git a/src/xmenu.c b/src/xmenu.c
index 08b444f09f2..16279053e90 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -392,8 +392,6 @@ x_menu_wait_for_event (void *data)
          )
     {
       EMACS_TIME next_time = timer_check (), *ntp;
-      long secs = EMACS_SECS (next_time);
-      long usecs = EMACS_USECS (next_time);
       SELECT_TYPE read_fds;
       struct x_display_info *dpyinfo;
       int n = 0;
@@ -407,7 +405,7 @@ x_menu_wait_for_event (void *data)
           XFlush (dpyinfo->display);
         }
 
-      if (secs < 0 && usecs < 0)
+      if (! EMACS_TIME_VALID_P (next_time))
         ntp = 0;
       else
         ntp = &next_time;
@@ -417,9 +415,9 @@ x_menu_wait_for_event (void *data)
          over an arrow, a timeout scrolls it a bit.  Use xg_select so that
          timeout gets triggered.  */
 
-      xg_select (n + 1, &read_fds, (SELECT_TYPE *)0, (SELECT_TYPE *)0, ntp);
+      xg_select (n + 1, &read_fds, NULL, NULL, ntp);
 #else
-      select (n + 1, &read_fds, (SELECT_TYPE *)0, (SELECT_TYPE *)0, ntp);
+      pselect (n + 1, &read_fds, NULL, NULL, ntp, NULL);
 #endif
     }
 }
diff --git a/src/xselect.c b/src/xselect.c
index 49a491d4163..f21c57b44bb 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1139,7 +1139,6 @@ wait_for_property_change_unwind (Lisp_Object loc)
 static void
 wait_for_property_change (struct prop_location *location)
 {
-  int secs, usecs;
   ptrdiff_t count = SPECPDL_INDEX ();
 
   if (property_change_reply_object)
@@ -1156,10 +1155,11 @@ wait_for_property_change (struct prop_location *location)
      property_change_reply, because property_change_reply_object says so.  */
   if (! location->arrived)
     {
-      secs = x_selection_timeout / 1000;
-      usecs = (x_selection_timeout % 1000) * 1000;
-      TRACE2 ("  Waiting %d secs, %d usecs", secs, usecs);
-      wait_reading_process_output (secs, usecs, 0, 0,
+      EMACS_INT timeout = max (0, x_selection_timeout);
+      EMACS_INT secs = timeout / 1000;
+      int nsecs = (timeout % 1000) * 1000000;
+      TRACE2 ("  Waiting %"pI"d secs, %d nsecs", secs, nsecs);
+      wait_reading_process_output (secs, nsecs, 0, 0,
                                    property_change_reply, NULL, 0);
 
       if (NILP (XCAR (property_change_reply)))
@@ -1228,7 +1228,8 @@ x_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
   Atom type_atom = (CONSP (target_type)
                     ? symbol_to_x_atom (dpyinfo, XCAR (target_type))
                     : symbol_to_x_atom (dpyinfo, target_type));
-  int secs, usecs;
+  EMACS_INT timeout, secs;
+  int nsecs;
 
   if (!FRAME_LIVE_P (f))
     return Qnil;
@@ -1264,10 +1265,11 @@ x_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
   UNBLOCK_INPUT;
 
   /* This allows quits.  Also, don't wait forever.  */
-  secs = x_selection_timeout / 1000;
-  usecs = (x_selection_timeout % 1000) * 1000;
-  TRACE1 ("  Start waiting %d secs for SelectionNotify", secs);
-  wait_reading_process_output (secs, usecs, 0, 0,
+  timeout = max (0, x_selection_timeout);
+  secs = timeout / 1000;
+  nsecs = (timeout % 1000) * 1000000;
+  TRACE1 ("  Start waiting %"pI"d secs for SelectionNotify", secs);
+  wait_reading_process_output (secs, nsecs, 0, 0,
                                reading_selection_reply, NULL, 0);
   TRACE1 ("  Got event = %d", !NILP (XCAR (reading_selection_reply)));
 
diff --git a/src/xterm.c b/src/xterm.c
index fec661625f2..cb7aac2838c 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -85,10 +85,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <X11/Shell.h>
 #endif
 
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
 #include <unistd.h>
 
 #ifdef USE_GTK
@@ -3072,44 +3068,6 @@ x_clear_frame (struct frame *f)
 
 /* Invert the middle quarter of the frame for .15 sec.  */
 
-/* We use the select system call to do the waiting, so we have to make
-   sure it's available.  If it isn't, we just won't do visual bells.  */
-
-#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
-
-
-/* Subtract the `struct timeval' values X and Y, storing the result in
-   *RESULT.  Return 1 if the difference is negative, otherwise 0.  */
-
-static int
-timeval_subtract (struct timeval *result, struct timeval x, struct timeval y)
-{
-  /* Perform the carry for the later subtraction by updating y.  This
-     is safer because on some systems the tv_sec member is unsigned.  */
-  if (x.tv_usec < y.tv_usec)
-    {
-      int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
-      y.tv_usec -= 1000000 * nsec;
-      y.tv_sec += nsec;
-    }
-
-  if (x.tv_usec - y.tv_usec > 1000000)
-    {
-      int nsec = (y.tv_usec - x.tv_usec) / 1000000;
-      y.tv_usec += 1000000 * nsec;
-      y.tv_sec -= nsec;
-    }
-
-  /* Compute the time remaining to wait.  tv_usec is certainly
-     positive.  */
-  result->tv_sec = x.tv_sec - y.tv_sec;
-  result->tv_usec = x.tv_usec - y.tv_usec;
-
-  /* Return indication of whether the result should be considered
-     negative.  */
-  return x.tv_sec < y.tv_sec;
-}
-
 static void
 XTflash (struct frame *f)
 {
@@ -3210,34 +3168,29 @@ XTflash (struct frame *f)
       x_flush (f);
 
       {
-        struct timeval wakeup;
+        EMACS_TIME wakeup, delay;
 
         EMACS_GET_TIME (wakeup);
-
-        /* Compute time to wait until, propagating carry from usecs.  */
-        wakeup.tv_usec += 150000;
-        wakeup.tv_sec += (wakeup.tv_usec / 1000000);
-        wakeup.tv_usec %= 1000000;
+        EMACS_SET_SECS_NSECS (delay, 0, 150 * 1000 * 1000);
+        EMACS_ADD_TIME (wakeup, wakeup, delay);
 
         /* Keep waiting until past the time wakeup or any input gets
            available.  */
         while (! detect_input_pending ())
           {
-            struct timeval current;
-            struct timeval timeout;
+            EMACS_TIME current, timeout;
 
             EMACS_GET_TIME (current);
 
-            /* Break if result would be negative.  */
-            if (timeval_subtract (&current, wakeup, current))
+            /* Break if result would not be positive.  */
+            if (EMACS_TIME_LE (wakeup, current))
               break;
 
             /* How long `select' should wait.  */
-            timeout.tv_sec = 0;
-            timeout.tv_usec = 10000;
+            EMACS_SET_SECS_NSECS (timeout, 0, 10 * 1000 * 1000);
 
             /* Try to wait that long--but we might wake up sooner.  */
-            select (0, NULL, NULL, NULL, &timeout);
+            pselect (0, NULL, NULL, NULL, &timeout, NULL);
           }
       }
 
@@ -3278,8 +3231,6 @@ XTflash (struct frame *f)
   UNBLOCK_INPUT;
 }
 
-#endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
-
 
 static void
 XTtoggle_invisible_pointer (FRAME_PTR f, int invisible)
@@ -3306,11 +3257,9 @@ XTring_bell (struct frame *f)
 {
   if (FRAME_X_DISPLAY (f))
     {
-#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
       if (visible_bell)
         XTflash (f);
       else
-#endif
         {
           BLOCK_INPUT;
           XBell (FRAME_X_DISPLAY (f), 0);
@@ -8878,9 +8827,11 @@ x_wait_for_event (struct frame *f, int eventtype)
       FD_SET (fd, &fds);
 
       EMACS_GET_TIME (time_now);
-      EMACS_SUB_TIME (tmo, tmo_at, time_now);
+      if (EMACS_TIME_LT (tmo_at, time_now))
+        break;
 
-      if (EMACS_TIME_NEG_P (tmo) || select (fd+1, &fds, NULL, NULL, &tmo) == 0)
+      EMACS_SUB_TIME (tmo, tmo_at, time_now);
+      if (pselect (fd + 1, &fds, NULL, NULL, &tmo, NULL) == 0)
         break; /* Timeout */
     }
   pending_event_wait.f = 0;