auto upstream

13 files changed, 268 insertions, 220 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index 4688b0a4421..4215ffa312b 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -358,7 +358,6 @@ end
 
 define pwinx
   set $w = $arg0
-  xgetint $w->sequence_number
   if ($w->mini_p != Qnil)
     printf "Mini "
   end
diff --git a/src/ChangeLog b/src/ChangeLog
index 5c13e35306d..b4c3195973c 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,62 @@
+2013-02-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix timestamp bug when write-region appends nothing (Bug#13149).
+        * fileio.c (Fwrite_region): When neither O_EXCL nor O_TRUNC is used,
+        the file's time stamp doesn't change if Emacs happens to write nothing
+        to the file, and on a buggy file system this could cause Emacs to
+        incorrectly infer that the file system doesn't have the bug.
+        Avoid this problem by inhibiting the inference in this case.
+
+2013-02-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (struct window): Convert base_line_number, base_line_pos
+        and column_number_displayed members from Lisp_Object to ptrdiff_t.
+        Convert region_showing member from Lisp_Object to bitfield.
+        Remove sequence_number member.  Adjust comments.
+        * window.c (sequence_number): Remove.
+        (make_window): Initialize column_number_displayed.
+        * print.c (print_object): Follow the printed representation of
+        frames and print window pointer to distinguish between windows.
+        (adjust_window_count): Invalidate base_line_pos.  Adjust comment.
+        * xdisp.c (wset_base_line_number, wset_base_line_pos)
+        (wset_column_number_displayed, wset_region_showing): Remove.
+        (window_buffer_changed, mode_line_update_needed, redisplay_internal)
+        (try_scrolling, try_cursor_movement, redisplay_window)
+        (try_window_reusing_current_matrix, try_window_id, display_line)
+        (display_mode_lines, decode_mode_spec): Adjust users.
+        * .gdbinit (pwinx): Do not print sequence_number.
+
+2013-02-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use fdopendir, fstatat and readlinkat, for efficiency (Bug#13539).
+        * conf_post.h (GNULIB_SUPPORT_ONLY_AT_FDCWD): Remove.
+        * dired.c: Include <fcntl.h>.
+        (open_directory): New function, which uses open and fdopendir
+        rather than opendir.  DOS_NT platforms still use opendir, though.
+        (directory_files_internal, file_name_completion): Use it.
+        (file_attributes): New function, with most of the old Ffile_attributes.
+        (directory_files_internal, Ffile_attributes): Use it.
+        (file_attributes, file_name_completion_stat): First arg is now fd,
+        not dir name.  All uses changed.  Use fstatat rather than lstat +
+        stat.
+        (file_attributes): Use emacs_readlinkat rather than Ffile_symlink_p.
+        * fileio.c: Include <allocator.h>, <careadlinkat.h>.
+        (emacs_readlinkat): New function, with much of the old
+        Ffile_symlink_p, but with an fd argument for speed.
+        It uses readlinkat rather than careadlinkatcwd, so that it
+        need not assume the working directory.
+        (Ffile_symlink_p): Use it.
+        * filelock.c (current_lock_owner): Use emacs_readlinkat
+        rather than emacs_readlink.
+        * lisp.h (emacs_readlinkat): New decl.
+        (READLINK_BUFSIZE, emacs_readlink): Remove.
+        * sysdep.c: Do not include <allocator.h>, <careadlinkat.h>.
+        (emacs_norealloc_allocator, emacs_readlink): Remove.
+        This stuff is moved to fileio.c.
+        * w32.c (fstatat, readlinkat): New functions.
+        (careadlinkat): Don't check that fd == AT_FDCWD.
+        (careadlinkatcwd): Remove; no longer needed.
+
 2013-01-31  Glenn Morris  <rgm@gnu.org>
 
         * fileio.c (choose_write_coding_system): Make it callable from Lisp.
diff --git a/src/conf_post.h b/src/conf_post.h
index cd1e35bea7a..6c9747a436c 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -182,10 +182,6 @@ extern void _DebPrint (const char *fmt, ...);
 #endif
 #endif
 
-/* Tell gnulib to omit support for openat-related functions having a
-   first argument other than AT_FDCWD.  */
-#define GNULIB_SUPPORT_ONLY_AT_FDCWD
-
 #include <string.h>
 #include <stdlib.h>
 
diff --git a/src/dired.c b/src/dired.c
index a4c8621e9c0..ed0571fe9fe 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -30,6 +30,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <grp.h>
 
 #include <errno.h>
+#include <fcntl.h>
 #include <unistd.h>
 
 #include <dirent.h>
@@ -54,6 +55,7 @@ static Lisp_Object Qfile_attributes;
 static Lisp_Object Qfile_attributes_lessp;
 
 static ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
+static Lisp_Object file_attributes (int, char const *, Lisp_Object);
 
 /* Return the number of bytes in DP's name.  */
 static ptrdiff_t
@@ -66,6 +68,44 @@ dirent_namelen (struct dirent *dp)
 #endif
 }
 
+static DIR *
+open_directory (char const *name, int *fdp)
+{
+  DIR *d;
+  int fd, opendir_errno;
+
+  block_input ();
+
+#ifdef DOS_NT
+  /* Directories cannot be opened.  The emulation assumes that any
+     file descriptor other than AT_FDCWD corresponds to the most
+     recently opened directory.  This hack is good enough for Emacs.  */
+  fd = 0;
+  d = opendir (name);
+  opendir_errno = errno;
+#else
+  fd = emacs_open (name, O_RDONLY | O_DIRECTORY, 0);
+  if (fd < 0)
+    {
+      opendir_errno = errno;
+      d = 0;
+    }
+  else
+    {
+      d = fdopendir (fd);
+      opendir_errno = errno;
+      if (! d)
+        close (fd);
+    }
+#endif
+
+  unblock_input ();
+
+  *fdp = fd;
+  errno = opendir_errno;
+  return d;
+}
+
 #ifdef WINDOWSNT
 Lisp_Object
 directory_files_internal_w32_unwind (Lisp_Object arg)
@@ -96,6 +136,7 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
                           Lisp_Object id_format)
 {
   DIR *d;
+  int fd;
   ptrdiff_t directory_nbytes;
   Lisp_Object list, dirfilename, encoded_directory;
   struct re_pattern_buffer *bufp = NULL;
@@ -142,9 +183,7 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
   /* Now *bufp is the compiled form of MATCH; don't call anything
      which might compile a new regexp until we're done with the loop!  */
 
-  block_input ();
-  d = opendir (SSDATA (dirfilename));
-  unblock_input ();
+  d = open_directory (SSDATA (dirfilename), &fd);
   if (d == NULL)
     report_file_error ("Opening directory", Fcons (directory, Qnil));
 
@@ -259,20 +298,9 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
 
           if (attrs)
             {
-              /* Construct an expanded filename for the directory entry.
-                 Use the decoded names for input to Ffile_attributes.  */
-              Lisp_Object decoded_fullname, fileattrs;
-              struct gcpro gcpro1, gcpro2;
-
-              decoded_fullname = fileattrs = Qnil;
-              GCPRO2 (decoded_fullname, fileattrs);
-
-              /* Both Fexpand_file_name and Ffile_attributes can GC.  */
-              decoded_fullname = Fexpand_file_name (name, directory);
-              fileattrs = Ffile_attributes (decoded_fullname, id_format);
-
+              Lisp_Object fileattrs
+                = file_attributes (fd, dp->d_name, id_format);
               list = Fcons (Fcons (finalname, fileattrs), list);
-              UNGCPRO;
             }
           else
             list = Fcons (finalname, list);
@@ -413,8 +441,7 @@ These are all file names in directory DIRECTORY which begin with FILE.  */)
   return file_name_completion (file, directory, 1, Qnil);
 }
 
-static int file_name_completion_stat (Lisp_Object dirname, struct dirent *dp,
-                                      struct stat *st_addr);
+static int file_name_completion_stat (int, struct dirent *, struct stat *);
 static Lisp_Object Qdefault_directory;
 
 static Lisp_Object
@@ -422,6 +449,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
                       Lisp_Object predicate)
 {
   DIR *d;
+  int fd;
   ptrdiff_t bestmatchsize = 0;
   int matchcount = 0;
   /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
@@ -458,9 +486,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
 
   encoded_dir = ENCODE_FILE (dirname);
 
-  block_input ();
-  d = opendir (SSDATA (Fdirectory_file_name (encoded_dir)));
-  unblock_input ();
+  d = open_directory (SSDATA (Fdirectory_file_name (encoded_dir)), &fd);
   if (!d)
     report_file_error ("Opening directory", Fcons (dirname, Qnil));
 
@@ -495,7 +521,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
                         SCHARS (encoded_file)))
         continue;
 
-      if (file_name_completion_stat (encoded_dir, dp, &st) < 0)
+      if (file_name_completion_stat (fd, dp, &st) < 0)
         continue;
 
       directoryp = S_ISDIR (st.st_mode) != 0;
@@ -772,14 +798,9 @@ scmp (const char *s1, const char *s2, ptrdiff_t len)
 }
 
 static int
-file_name_completion_stat (Lisp_Object dirname, struct dirent *dp,
-                           struct stat *st_addr)
+file_name_completion_stat (int fd, struct dirent *dp, struct stat *st_addr)
 {
-  ptrdiff_t len = dirent_namelen (dp);
-  ptrdiff_t pos = SCHARS (dirname);
   int value;
-  USE_SAFE_ALLOCA;
-  char *fullname = SAFE_ALLOCA (len + pos + 2);
 
 #ifdef MSDOS
   /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
@@ -792,23 +813,15 @@ file_name_completion_stat (Lisp_Object dirname, struct dirent *dp,
   _djstat_flags = _STAT_INODE | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
 #endif /* MSDOS */
 
-  memcpy (fullname, SDATA (dirname), pos);
-  if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
-    fullname[pos++] = DIRECTORY_SEP;
-
-  memcpy (fullname + pos, dp->d_name, len);
-  fullname[pos + len] = 0;
-
   /* We want to return success if a link points to a nonexistent file,
      but we want to return the status for what the link points to,
      in case it is a directory.  */
-  value = lstat (fullname, st_addr);
+  value = fstatat (fd, dp->d_name, st_addr, AT_SYMLINK_NOFOLLOW);
   if (value == 0 && S_ISLNK (st_addr->st_mode))
-    stat (fullname, st_addr);
+    fstatat (fd, dp->d_name, st_addr, 0);
 #ifdef MSDOS
   _djstat_flags = save_djstat_flags;
 #endif /* MSDOS */
-  SAFE_FREE ();
   return value;
 }
 
@@ -886,18 +899,8 @@ On some FAT-based filesystems, only the date of last access is recorded,
 so last access time will always be midnight of that day.  */)
   (Lisp_Object filename, Lisp_Object id_format)
 {
-  Lisp_Object values[12];
   Lisp_Object encoded;
-  struct stat s;
-  int lstat_result;
-
-  /* An array to hold the mode string generated by filemodestring,
-     including its terminating space and null byte.  */
-  char modes[sizeof "-rwxr-xr-x "];
-
   Lisp_Object handler;
-  struct gcpro gcpro1;
-  char *uname = NULL, *gname = NULL;
 
   filename = Fexpand_file_name (filename, Qnil);
 
@@ -913,9 +916,22 @@ so last access time will always be midnight of that day.  */)
         return call3 (handler, Qfile_attributes, filename, id_format);
     }
 
-  GCPRO1 (filename);
   encoded = ENCODE_FILE (filename);
-  UNGCPRO;
+  return file_attributes (AT_FDCWD, SSDATA (encoded), id_format);
+}
+
+static Lisp_Object
+file_attributes (int fd, char const *name, Lisp_Object id_format)
+{
+  Lisp_Object values[12];
+  struct stat s;
+  int lstat_result;
+
+  /* An array to hold the mode string generated by filemodestring,
+     including its terminating space and null byte.  */
+  char modes[sizeof "-rwxr-xr-x "];
+
+  char *uname = NULL, *gname = NULL;
 
 #ifdef WINDOWSNT
   /* We usually don't request accurate owner and group info, because
@@ -925,7 +941,7 @@ so last access time will always be midnight of that day.  */)
   w32_stat_get_owner_group = 1;
 #endif
 
-  lstat_result = lstat (SSDATA (encoded), &s);
+  lstat_result = fstatat (fd, name, &s, AT_SYMLINK_NOFOLLOW);
 
 #ifdef WINDOWSNT
   w32_stat_get_owner_group = 0;
@@ -934,7 +950,7 @@ so last access time will always be midnight of that day.  */)
   if (lstat_result < 0)
     return Qnil;
 
-  values[0] = (S_ISLNK (s.st_mode) ? Ffile_symlink_p (filename)
+  values[0] = (S_ISLNK (s.st_mode) ? emacs_readlinkat (fd, name)
                : S_ISDIR (s.st_mode) ? Qt : Qnil);
   values[1] = make_number (s.st_nlink);
 
diff --git a/src/fileio.c b/src/fileio.c
index cd4bd4fa86e..fb6ecfedeb4 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -82,6 +82,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 #include "systime.h"
+#include <allocator.h>
+#include <careadlinkat.h>
 #include <stat-time.h>
 
 #ifdef HPUX
@@ -2759,6 +2761,29 @@ If there is no error, returns nil.  */)
   return Qnil;
 }
 
+/* Relative to directory FD, return the symbolic link value of FILENAME.
+   On failure, return nil.  */
+Lisp_Object
+emacs_readlinkat (int fd, char const *filename)
+{
+  static struct allocator const emacs_norealloc_allocator =
+    { xmalloc, NULL, xfree, memory_full };
+  Lisp_Object val;
+  char readlink_buf[1024];
+  char *buf = careadlinkat (fd, filename, readlink_buf, sizeof readlink_buf,
+                            &emacs_norealloc_allocator, readlinkat);
+  if (!buf)
+    return Qnil;
+
+  val = build_string (buf);
+  if (buf[0] == '/' && strchr (buf, ':'))
+    val = concat2 (build_string ("/:"), val);
+  if (buf != readlink_buf)
+    xfree (buf);
+  val = DECODE_FILE (val);
+  return val;
+}
+
 DEFUN ("file-symlink-p", Ffile_symlink_p, Sfile_symlink_p, 1, 1, 0,
        doc: /* Return non-nil if file FILENAME is the name of a symbolic link.
 The value is the link target, as a string.
@@ -2769,9 +2794,6 @@ points to a nonexistent file.  */)
   (Lisp_Object filename)
 {
   Lisp_Object handler;
-  char *buf;
-  Lisp_Object val;
-  char readlink_buf[READLINK_BUFSIZE];
 
   CHECK_STRING (filename);
   filename = Fexpand_file_name (filename, Qnil);
@@ -2784,17 +2806,7 @@ points to a nonexistent file.  */)
 
   filename = ENCODE_FILE (filename);
 
-  buf = emacs_readlink (SSDATA (filename), readlink_buf);
-  if (! buf)
-    return Qnil;
-
-  val = build_string (buf);
-  if (buf[0] == '/' && strchr (buf, ':'))
-    val = concat2 (build_string ("/:"), val);
-  if (buf != readlink_buf)
-    xfree (buf);
-  val = DECODE_FILE (val);
-  return val;
+  return emacs_readlinkat (AT_FDCWD, SSDATA (filename));
 }
 
 DEFUN ("file-directory-p", Ffile_directory_p, Sfile_directory_p, 1, 1, 0,
@@ -5024,7 +5036,11 @@ This calls `write-region-annotate-functions' at the start, and
               && st.st_dev == st1.st_dev && st.st_ino == st1.st_ino)
             {
               EMACS_TIME modtime1 = get_stat_mtime (&st1);
-              if (EMACS_TIME_EQ (modtime, modtime1)
+              /* If neither O_EXCL nor O_TRUNC is used, and Emacs happened to
+                 write nothing to the file, the file's time stamp won't change
+                 so it should not be used in this heuristic.  */
+              if ((open_flags & (O_EXCL | O_TRUNC)) != 0
+                  && EMACS_TIME_EQ (modtime, modtime1)
                   && st.st_size == st1.st_size)
                 {
                   timestamp_file_system = st.st_dev;
diff --git a/src/filelock.c b/src/filelock.c
index f21240f8340..228fe98e8c7 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -390,12 +390,14 @@ current_lock_owner (lock_info_type *owner, char *lfname)
   lock_info_type local_owner;
   intmax_t n;
   char *at, *dot, *colon;
-  char readlink_buf[READLINK_BUFSIZE];
-  char *lfinfo = emacs_readlink (lfname, readlink_buf);
+  Lisp_Object lfinfo_object = emacs_readlinkat (AT_FDCWD, lfname);
+  char *lfinfo;
+  struct gcpro gcpro1;
 
   /* If nonexistent lock file, all is well; otherwise, got strange error. */
-  if (!lfinfo)
+  if (NILP (lfinfo_object))
     return errno == ENOENT ? 0 : -1;
+  lfinfo = SSDATA (lfinfo_object);
 
   /* Even if the caller doesn't want the owner info, we still have to
      read it to determine return value.  */
@@ -407,12 +409,9 @@ current_lock_owner (lock_info_type *owner, char *lfname)
   at = strrchr (lfinfo, '@');
   dot = strrchr (lfinfo, '.');
   if (!at || !dot)
-    {
-      if (lfinfo != readlink_buf)
-        xfree (lfinfo);
-      return -1;
-    }
+    return -1;
   len = at - lfinfo;
+  GCPRO1 (lfinfo_object);
   owner->user = xmalloc (len + 1);
   memcpy (owner->user, lfinfo, len);
   owner->user[len] = 0;
@@ -445,8 +444,7 @@ current_lock_owner (lock_info_type *owner, char *lfname)
   owner->host[len] = 0;
 
   /* We're done looking at the link info.  */
-  if (lfinfo != readlink_buf)
-    xfree (lfinfo);
+  UNGCPRO;
 
   /* On current host?  */
   if (STRINGP (Fsystem_name ())
diff --git a/src/lisp.h b/src/lisp.h
index 7128c3d4b18..dd8d1f38db6 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3299,6 +3299,7 @@ extern Lisp_Object close_file_unwind (Lisp_Object);
 extern Lisp_Object restore_point_unwind (Lisp_Object);
 extern _Noreturn void report_file_error (const char *, Lisp_Object);
 extern bool internal_delete_file (Lisp_Object);
+extern Lisp_Object emacs_readlinkat (int, const char *);
 extern bool file_directory_p (const char *);
 extern bool file_accessible_directory_p (const char *);
 extern void init_fileio (void);
@@ -3571,8 +3572,6 @@ extern int emacs_open (const char *, int, int);
 extern int emacs_close (int);
 extern ptrdiff_t emacs_read (int, char *, ptrdiff_t);
 extern ptrdiff_t emacs_write (int, const char *, ptrdiff_t);
-enum { READLINK_BUFSIZE = 1024 };
-extern char *emacs_readlink (const char *, char [READLINK_BUFSIZE]);
 
 extern void unlock_all_files (void);
 extern void lock_file (Lisp_Object);
diff --git a/src/print.c b/src/print.c
index 8420f8075a5..f5f8450545d 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1775,7 +1775,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         {
           int len;
           strout ("#<window ", -1, -1, printcharfun);
-          len = sprintf (buf, "%d", XWINDOW (obj)->sequence_number);
+          len = sprintf (buf, "%p", XWINDOW (obj));
           strout (buf, len, len, printcharfun);
           if (!NILP (XWINDOW (obj)->buffer))
             {
diff --git a/src/sysdep.c b/src/sysdep.c
index 0e9a6826005..57ca8265a65 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -30,9 +30,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <limits.h>
 #include <unistd.h>
 
-#include <allocator.h>
 #include <c-ctype.h>
-#include <careadlinkat.h>
 #include <ignore-value.h>
 #include <utimens.h>
 
@@ -2247,22 +2245,6 @@ emacs_write (int fildes, const char *buf, ptrdiff_t nbyte)
 
   return (bytes_written);
 }
-
-static struct allocator const emacs_norealloc_allocator =
-  { xmalloc, NULL, xfree, memory_full };
-
-/* Get the symbolic link value of FILENAME.  Return a pointer to a
-   NUL-terminated string.  If readlink fails, return NULL and set
-   errno.  If the value fits in INITIAL_BUF, return INITIAL_BUF.
-   Otherwise, allocate memory and return a pointer to that memory.  If
-   memory allocation fails, diagnose and fail without returning.  If
-   successful, store the length of the symbolic link into *LINKLEN.  */
-char *
-emacs_readlink (char const *filename, char initial_buf[READLINK_BUFSIZE])
-{
-  return careadlinkat (AT_FDCWD, filename, initial_buf, READLINK_BUFSIZE,
-                       &emacs_norealloc_allocator, careadlinkatcwd);
-}
 
 /* Return a struct timeval that is roughly equivalent to T.
    Use the least timeval not less than T.
diff --git a/src/w32.c b/src/w32.c
index d0af53889e7..64f8a0335ac 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -4274,6 +4274,30 @@ lstat (const char * path, struct stat * buf)
   return stat_worker (path, buf, 0);
 }
 
+int
+fstatat (int fd, char const *name, struct stat *st, int flags)
+{
+  /* Rely on a hack: an open directory is modeled as file descriptor 0.
+     This is good enough for the current usage in Emacs, but is fragile.
+
+     FIXME: Add proper support for fdopendir, fstatatat, readlinkat.
+     Gnulib does this and can serve as a model.  */
+  char fullname[MAX_PATH];
+
+  if (fd != AT_FDCWD)
+    {
+      if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
+          < 0)
+        {
+          errno = ENAMETOOLONG;
+          return -1;
+        }
+      name = fullname;
+    }
+
+  return stat_worker (name, st, ! (flags & AT_SYMLINK_NOFOLLOW));
+}
+
 /* Provide fstat and utime as well as stat for consistent handling of
    file timestamps. */
 int
@@ -4816,6 +4840,28 @@ readlink (const char *name, char *buf, size_t buf_size)
   return retval;
 }
 
+ssize_t
+readlinkat (int fd, char const *name, char *buffer,
+            size_t buffer_size)
+{
+  /* Rely on a hack: an open directory is modeled as file descriptor 0,
+     as in fstatat.  FIXME: Add proper support for readlinkat.  */
+  char fullname[MAX_PATH];
+
+  if (fd != AT_FDCWD)
+    {
+      if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
+          < 0)
+        {
+          errno = ENAMETOOLONG;
+          return -1;
+        }
+      name = fullname;
+    }
+
+  return readlink (name, buffer, buffer_size);
+}
+
 /* If FILE is a symlink, return its target (stored in a static
    buffer); otherwise return FILE.
 
@@ -5168,12 +5214,6 @@ careadlinkat (int fd, char const *filename,
   char linkname[MAX_PATH];
   ssize_t link_size;
 
-  if (fd != AT_FDCWD)
-    {
-      errno = EINVAL;
-      return NULL;
-    }
-
   link_size = preadlinkat (fd, filename, linkname, sizeof(linkname));
 
   if (link_size > 0)
@@ -5191,14 +5231,6 @@ careadlinkat (int fd, char const *filename,
   return NULL;
 }
 
-ssize_t
-careadlinkatcwd (int fd, char const *filename, char *buffer,
-                 size_t buffer_size)
-{
-  (void) fd;
-  return readlink (filename, buffer, buffer_size);
-}
-
 
 /* Support for browsing other processes and their attributes.  See
    process.c for the Lisp bindings.  */
diff --git a/src/window.c b/src/window.c
index f75c17a3d4f..b9165e21d3b 100644
--- a/src/window.c
+++ b/src/window.c
@@ -117,9 +117,6 @@ Lisp_Object minibuf_selected_window;
 /* Hook run at end of temp_output_buffer_show.  */
 static Lisp_Object Qtemp_buffer_show_hook;
 
-/* Incremented for each window created.  */
-static int sequence_number;
-
 /* Nonzero after init_window_once has finished.  */
 static int window_initialized;
 
@@ -287,8 +284,9 @@ adjust_window_count (struct window *w, int arg)
         b = b->base_buffer;
       b->window_count += arg;
       eassert (b->window_count >= 0);
-      /* Catch redisplay's attention.  */
+      /* These should be recalculated by redisplay code.  */
       w->window_end_valid = 0;
+      w->base_line_pos = 0;
     }
 }
 
@@ -3430,8 +3428,6 @@ make_parent_window (Lisp_Object window, int horflag)
   adjust_window_count (p, 1);
   XSETWINDOW (parent, p);
 
-  p->sequence_number = ++sequence_number;
-
   replace_window (window, parent, 1);
 
   wset_next (o, Qnil);
@@ -3480,7 +3476,7 @@ make_window (void)
   w->nrows_scale_factor = w->ncols_scale_factor = 1;
   w->phys_cursor_type = -1;
   w->phys_cursor_width = -1;
-  w->sequence_number = ++sequence_number;
+  w->column_number_displayed = -1;
 
   /* Reset window_list.  */
   Vwindow_list = Qnil;
diff --git a/src/window.h b/src/window.h
index 135f591ded7..f28ce1424d0 100644
--- a/src/window.h
+++ b/src/window.h
@@ -192,23 +192,6 @@ struct window
        and Qt, so bitfield can't be used here.  */
     Lisp_Object dedicated;
 
-    /* Line number and position of a line somewhere above the top of the
-       screen.  If this field is nil, it means we don't have a base
-       line.  */
-    Lisp_Object base_line_number;
-    /* If this field is nil, it means we don't have a base line.
-       If it is a buffer, it means don't display the line number
-       as long as the window shows that buffer.  */
-    Lisp_Object base_line_pos;
-
-    /* If we have highlighted the region (or any part of it),
-       this is the mark position that we used, as an integer.  */
-    Lisp_Object region_showing;
-
-    /* The column number currently displayed in this window's mode line,
-       or nil if column numbers are not being displayed.  */
-    Lisp_Object column_number_displayed;
-
     /* If redisplay in this window goes beyond this buffer position,
        must run the redisplay-end-trigger-hook.  */
     Lisp_Object redisplay_end_trigger;
@@ -238,9 +221,6 @@ struct window
     /* Number saying how recently window was selected.  */
     int use_time;
 
-    /* Unique number of window assigned when it was created.  */
-    int sequence_number;
-
     /* Number of columns display within the window is scrolled to the left.  */
     ptrdiff_t hscroll;
 
@@ -260,6 +240,19 @@ struct window
        it should be positive.  */
     ptrdiff_t last_point;
 
+    /* Line number and position of a line somewhere above the top of the
+       screen.  If this field is zero, it means we don't have a base line.  */
+    ptrdiff_t base_line_number;
+
+    /* If this field is zero, it means we don't have a base line.
+       If it is -1, it means don't display the line number as long
+       as the window shows its buffer.  */
+    ptrdiff_t base_line_pos;
+
+    /* The column number currently displayed in this window's mode
+       line, or -1 if column numbers are not being displayed.  */
+    ptrdiff_t column_number_displayed;
+
     /* Scaling factor for the glyph_matrix size calculation in this window.
        Used if window contains many small images or uses proportional fonts,
        as the normal  may yield a matrix which is too small.  */
@@ -340,6 +333,9 @@ struct window
        the frame image that window_end_pos did not get onto the frame.  */
     unsigned window_end_valid : 1;
 
+    /* Nonzero if we have highlighted the region (or any part of it).  */
+    unsigned region_showing : 1;
+
     /* Amount by which lines of this window are scrolled in
        y-direction (smooth scrolling).  */
     int vscroll;
diff --git a/src/xdisp.c b/src/xdisp.c
index 9fb9487732f..33fe82e165e 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -369,28 +369,6 @@ Lisp_Object Qcenter;
 static Lisp_Object Qmargin, Qpointer;
 static Lisp_Object Qline_height;
 
-/* These setters are used only in this file, so they can be private.  */
-static void
-wset_base_line_number (struct window *w, Lisp_Object val)
-{
-  w->base_line_number = val;
-}
-static void
-wset_base_line_pos (struct window *w, Lisp_Object val)
-{
-  w->base_line_pos = val;
-}
-static void
-wset_column_number_displayed (struct window *w, Lisp_Object val)
-{
-  w->column_number_displayed = val;
-}
-static void
-wset_region_showing (struct window *w, Lisp_Object val)
-{
-  w->region_showing = val;
-}
-
 #ifdef HAVE_WINDOW_SYSTEM
 
 /* Test if overflow newline into fringe.  Called with iterator IT
@@ -10829,7 +10807,7 @@ window_buffer_changed (struct window *w)
 
   return (((BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star)
           || ((!NILP (Vtransient_mark_mode) && !NILP (BVAR (b, mark_active)))
-              != !NILP (w->region_showing)));
+              != w->region_showing));
 }
 
 /* Nonzero if W has %c in its mode line and mode line should be updated.  */
@@ -10837,9 +10815,9 @@ window_buffer_changed (struct window *w)
 static int
 mode_line_update_needed (struct window *w)
 {
-  return (!NILP (w->column_number_displayed)
+  return (w->column_number_displayed != -1
           && !(PT == w->last_point && !window_outdated (w))
-          && (XFASTINT (w->column_number_displayed) != current_column ()));
+          && (w->column_number_displayed != current_column ()));
 }
 
 /***********************************************************************
@@ -13092,18 +13070,6 @@ redisplay_internal (void)
       clear_garbaged_frames ();
     }
 
-
-  /* If showing the region, and mark has changed, we must redisplay
-     the whole window.  The assignment to this_line_start_pos prevents
-     the optimization directly below this if-statement.  */
-  if (((!NILP (Vtransient_mark_mode)
-        && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
-       != !NILP (w->region_showing))
-      || (!NILP (w->region_showing)
-          && !EQ (w->region_showing,
-                  Fmarker_position (BVAR (XBUFFER (w->buffer), mark)))))
-    CHARPOS (this_line_start_pos) = 0;
-
   /* Optimize the case that only the line containing the cursor in the
      selected window has changed.  Variables starting with this_ are
      set in display_line and record information about the line
@@ -13274,7 +13240,7 @@ redisplay_internal (void)
                && (EQ (selected_window,
                        BVAR (current_buffer, last_selected_window))
                    || highlight_nonselected_windows)
-               && NILP (w->region_showing)
+               && !w->region_showing
                && NILP (Vshow_trailing_whitespace)
                && !cursor_in_echo_area)
         {
@@ -14771,7 +14737,7 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
       if (!just_this_one_p
           || current_buffer->clip_changed
           || BEG_UNCHANGED < CHARPOS (startp))
-        wset_base_line_number (w, Qnil);
+        w->base_line_number = 0;
 
       /* If cursor ends up on a partially visible line,
          treat that as being off the bottom of the screen.  */
@@ -14920,7 +14886,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
          region exists, cursor movement has to do more than just
          set the cursor.  */
       && markpos_of_region () < 0
-      && NILP (w->region_showing)
+      && !w->region_showing
       && NILP (Vshow_trailing_whitespace)
       /* This code is not used for mini-buffer for the sake of the case
          of redisplaying to replace an echo area message; since in
@@ -15486,7 +15452,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
       /* Forget any recorded base line for line number display.  */
       if (!buffer_unchanged_p)
-        wset_base_line_number (w, Qnil);
+        w->base_line_number = 0;
 
       /* Redisplay the mode line.  Select the buffer properly for that.
          Also, run the hook window-scroll-functions
@@ -15726,7 +15692,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
               || current_buffer->clip_changed
               || BEG_UNCHANGED < CHARPOS (startp))
             /* Forget any recorded base line for line number display.  */
-            wset_base_line_number (w, Qnil);
+            w->base_line_number = 0;
 
           if (!cursor_row_fully_visible_p (w, 1, 0))
             {
@@ -15793,11 +15759,9 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   debug_method_add (w, "recenter");
 #endif
 
-  /* w->vscroll = 0; */
-
   /* Forget any previously recorded base line for line number display.  */
   if (!buffer_unchanged_p)
-    wset_base_line_number (w, Qnil);
+    w->base_line_number = 0;
 
   /* Determine the window start relative to point.  */
   init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
@@ -16017,10 +15981,10 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
            && !FRAME_WINDOW_P (f)
            && !WINDOW_FULL_WIDTH_P (w))
        /* Line number to display.  */
-       || INTEGERP (w->base_line_pos)
+       || w->base_line_pos > 0
        /* Column number is displayed and different from the one displayed.  */
-       || (!NILP (w->column_number_displayed)
-           && (XFASTINT (w->column_number_displayed) != current_column ())))
+       || (w->column_number_displayed != -1
+           && (w->column_number_displayed != current_column ())))
       /* This means that the window has a mode line.  */
       && (WINDOW_WANTS_MODELINE_P (w)
           || WINDOW_WANTS_HEADER_LINE_P (w)))
@@ -16051,11 +16015,10 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
         goto need_larger_matrices;
     }
 
-  if (!line_number_displayed
-      && !BUFFERP (w->base_line_pos))
+  if (!line_number_displayed && w->base_line_pos != -1)
     {
-      wset_base_line_pos (w, Qnil);
-      wset_base_line_number (w, Qnil);
+      w->base_line_pos = 0;
+      w->base_line_number = 0;
     }
 
  finish_menu_bars:
@@ -16306,7 +16269,7 @@ try_window_reusing_current_matrix (struct window *w)
 
   /* Can't do this if region may have changed.  */
   if (0 <= markpos_of_region ()
-      || !NILP (w->region_showing)
+      || w->region_showing
       || !NILP (Vshow_trailing_whitespace))
     return 0;
 
@@ -17152,7 +17115,7 @@ try_window_id (struct window *w)
     GIVE_UP (11);
 
   /* Likewise if showing a region.  */
-  if (!NILP (w->region_showing))
+  if (w->region_showing)
     GIVE_UP (10);
 
   /* Can't use this if overlay arrow position and/or string have
@@ -19262,7 +19225,7 @@ display_line (struct it *it)
     }
 
   /* Is IT->w showing the region?  */
-  wset_region_showing (it->w, it->region_beg_charpos > 0 ? Qt : Qnil);
+  it->w->region_showing = it->region_beg_charpos > 0;
 
   /* Clear the result glyph row and enable it.  */
   prepare_desired_row (row);
@@ -20266,7 +20229,7 @@ display_mode_lines (struct window *w)
 
   /* These will be set while the mode line specs are processed.  */
   line_number_displayed = 0;
-  wset_column_number_displayed (w, Qnil);
+  w->column_number_displayed = -1;
 
   if (WINDOW_WANTS_MODELINE_P (w))
     {
@@ -21289,8 +21252,7 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_
    returned with spaces to that value.  Return a Lisp string in
    *STRING if the resulting string is taken from that Lisp string.
 
-   Note we operate on the current buffer for most purposes,
-   the exception being w->base_line_pos.  */
+   Note we operate on the current buffer for most purposes.  */
 
 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
 
@@ -21401,7 +21363,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
       else
         {
           ptrdiff_t col = current_column ();
-          wset_column_number_displayed (w, make_number (col));
+          w->column_number_displayed = col;
           pint2str (decode_mode_spec_buf, width, col);
           return decode_mode_spec_buf;
         }
@@ -21460,27 +21422,24 @@ decode_mode_spec (struct window *w, register int c, int field_width,
 
         /* If we decided that this buffer isn't suitable for line numbers,
            don't forget that too fast.  */
-        if (EQ (w->base_line_pos, w->buffer))
+        if (w->base_line_pos == -1)
           goto no_value;
-        /* But do forget it, if the window shows a different buffer now.  */
-        else if (BUFFERP (w->base_line_pos))
-          wset_base_line_pos (w, Qnil);
 
         /* If the buffer is very big, don't waste time.  */
         if (INTEGERP (Vline_number_display_limit)
             && BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
           {
-            wset_base_line_pos (w, Qnil);
-            wset_base_line_number (w, Qnil);
+            w->base_line_pos = 0;
+            w->base_line_number = 0;
             goto no_value;
           }
 
-        if (INTEGERP (w->base_line_number)
-            && INTEGERP (w->base_line_pos)
-            && XFASTINT (w->base_line_pos) <= startpos)
+        if (w->base_line_number > 0
+            && w->base_line_pos > 0
+            && w->base_line_pos <= startpos)
           {
-            line = XFASTINT (w->base_line_number);
-            linepos = XFASTINT (w->base_line_pos);
+            line = w->base_line_number;
+            linepos = w->base_line_pos;
             linepos_byte = buf_charpos_to_bytepos (b, linepos);
           }
         else
@@ -21503,8 +21462,8 @@ decode_mode_spec (struct window *w, register int c, int field_width,
            go back past it.  */
         if (startpos == BUF_BEGV (b))
           {
-            wset_base_line_number (w, make_number (topline));
-            wset_base_line_pos (w, make_number (BUF_BEGV (b)));
+            w->base_line_number = topline;
+            w->base_line_pos = BUF_BEGV (b);
           }
         else if (nlines < height + 25 || nlines > height * 3 + 50
                  || linepos == BUF_BEGV (b))
@@ -21530,13 +21489,13 @@ decode_mode_spec (struct window *w, register int c, int field_width,
                give up on line numbers for this window.  */
             if (position == limit_byte && limit == startpos - distance)
               {
-                wset_base_line_pos (w, w->buffer);
-                wset_base_line_number (w, Qnil);
+                w->base_line_pos = -1;
+                w->base_line_number = 0;
                 goto no_value;
               }
 
-            wset_base_line_number (w, make_number (topline - nlines));
-            wset_base_line_pos (w, make_number (BYTE_TO_CHAR (position)));
+            w->base_line_number = topline - nlines;
+            w->base_line_pos = BYTE_TO_CHAR (position);
           }
 
         /* Now count lines from the start pos to point.  */