bug#48264: [PATCH v4 07/14] Use BVAR_OR_DEFAULT for per-buffer vars with defaults

[Spencer Baugh <sbaugh@catern.com>]

Previously, per-buffer variables with defaults and without defaults
were treated identically: To access the value of a per-buffer
variable, we only looked at the field in the current buffer.  As a
result, whenever we changed the default value for a per-buffer
variable, we had to iterate over all buffers to find and update
buffers without a local binding to match the new default.

Now, we treat per-buffer variables with defaults differently: we use
BVAR_OR_DEFAULT to access them.  BVAR_OR_DEFAULT falls back to using
the value in buffer_defaults if there is no local binding for the
per-buffer variable in the specified buffer.  So changing the default
value for a variable doesn't require iterating over all buffers, and
is therefore much faster.

We also now set fields which are not buffer-local to Qunbound, and use
that to determine if a buffer has a buffer-local binding for a
variable.  If the field contains Qunbound, BVAR_OR_DEFAULT uses the
default value out of buffer_defaults; if the field contains something
other than Qunbound, there's a buffer-local binding, and we use the
per-buffer value.

This information duplicates local_flags, which we'll delete in a
followup commit.

* src/buffer.h (BVAR_OR_DEFAULT): Add.
* src/bidi.c (bidi_at_paragraph_end, bidi_paragraph_cache_on_off)
(bidi_find_paragraph_start):
* src/buffer.c (swapfield_defaulted, Fbuffer_swap_text):
* src/buffer.h (SANE_TAB_WIDTH, CHARACTER_WIDTH):
* src/category.c (check_category_table, Fcategory_table)
(char_category_set):
* src/cmds.c (internal_self_insert):
* src/editfns.c (Fcompare_buffer_substrings)
(Fchar_equal):
* src/fileio.c (choose_write_coding_system):
* src/fns.c (extract_data_from_object):
* src/fringe.c (get_logical_cursor_bitmap, get_logical_fringe_bitmap)
(update_window_fringes):
* src/hbfont.c (hbfont_shape):
* src/indent.c (buffer_display_table, width_run_cache_on_off, current_column)
(scan_for_column, compute_motion, vmotion):
* src/msdos.c (IT_frame_up_to_date):
* src/search.c (compile_pattern_1, compile_pattern, looking_at_1)
(string_match_1, newline_cache_on_off, search_command, Fnewline_cache_check):
* src/syntax.c
(update_syntax_table, Fsyntax_table, Fmodify_syntax_entry):
* src/syntax.h
(syntax_property_entry, SETUP_BUFFER_SYNTAX_TABLE):
* src/window.c
(window_display_table, set_window_buffer, window_wants_mode_line)
(window_wants_header_line, window_wants_tab_line):
* src/xdisp.c
(fill_column_indicator_column, default_line_pixel_height, pos_visible_p)
(init_iterator, reseat_to_string, set_message_1)
(text_outside_line_unchanged_p, try_scrolling, try_cursor_movement)
(redisplay_window, try_window_reusing_current_matrix, row_containing_pos)
(try_window_id, display_line, Fcurrent_bidi_paragraph_direction)
(Fbidi_find_overridden_directionality, display_mode_lines, decode_mode_spec)
(display_count_lines, get_window_cursor_type, note_mouse_highlight):
Use BVAR_OR_DEFAULT.
* src/buffer.h (bvar_get_value): Add an offset-based function version
of BVAR_OR_DEFAULT.
(PER_BUFFER_VALUE_P): Check if value is Qunbound instead of checking
local_flags.
(KILL_PER_BUFFER_VALUE): Set killed buffer-local vars to Qunbound, not
the default value.
* src/buffer.c (reset_buffer): Set killed buffer-local vars to
Qunbound, not the default value.
(buffer_local_value): Use bvar_get_value so we look up defaults.
(init_buffer_once): Don't call reset_buffer_local_variables on
pseudobuffers, so we don't set all their values to Qunbound.
* src/data.c (do_symval_forwarding): Use bvar_get_value so we look up
defaults.
(store_symval_forwarding, set_default_internal): Don't loop all over
buffers when setting buffer defaults; this fixes bug#41029.
* test/src/data-tests.el (data-tests--set-default-per-buffer): Enable,
this is fixed now.
---
 src/bidi.c             |  19 +++---
 src/buffer.c           |  24 ++++----
 src/buffer.h           |  27 ++++++---
 src/category.c         |   6 +-
 src/cmds.c             |   6 +-
 src/data.c             |  50 +---------------
 src/editfns.c          |   4 +-
 src/fileio.c           |   9 +--
 src/fns.c              |   8 ++-
 src/fringe.c           |  21 ++++---
 src/hbfont.c           |   2 +-
 src/indent.c           |  34 +++++------
 src/msdos.c            |   6 +-
 src/search.c           |  21 +++----
 src/syntax.c           |   7 ++-
 src/syntax.h           |   5 +-
 src/window.c           |  29 ++++-----
 src/xdisp.c            | 130 +++++++++++++++++++++--------------------
 test/src/data-tests.el |   1 -
 19 files changed, 191 insertions(+), 218 deletions(-)

diff --git a/src/bidi.c b/src/bidi.c
index 1413ba6b88..0d0587f5f5 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -1451,12 +1451,12 @@ bidi_at_paragraph_end (ptrdiff_t charpos, ptrdiff_t bytepos)
   Lisp_Object start_re;
   ptrdiff_t val;
 
-  if (STRINGP (BVAR (current_buffer, bidi_paragraph_separate_re)))
-    sep_re = BVAR (current_buffer, bidi_paragraph_separate_re);
+  if (STRINGP (BVAR_OR_DEFAULT (current_buffer, bidi_paragraph_separate_re)))
+    sep_re = BVAR_OR_DEFAULT (current_buffer, bidi_paragraph_separate_re);
   else
     sep_re = paragraph_separate_re;
-  if (STRINGP (BVAR (current_buffer, bidi_paragraph_start_re)))
-    start_re = BVAR (current_buffer, bidi_paragraph_start_re);
+  if (STRINGP (BVAR_OR_DEFAULT (current_buffer, bidi_paragraph_start_re)))
+    start_re = BVAR_OR_DEFAULT (current_buffer, bidi_paragraph_start_re);
   else
     start_re = paragraph_start_re;
 
@@ -1500,10 +1500,10 @@ bidi_paragraph_cache_on_off (void)
      This is because doing so will just make the cache pure overhead,
      since if we turn it on via indirect buffer, it will be
      immediately turned off by its base buffer.  */
-  if (NILP (BVAR (current_buffer, cache_long_scans)))
+  if (NILP (BVAR_OR_DEFAULT (current_buffer, cache_long_scans)))
     {
       if (!indirect_p
-	  || NILP (BVAR (cache_buffer, cache_long_scans)))
+	  || NILP (BVAR_OR_DEFAULT (cache_buffer, cache_long_scans)))
 	{
 	  if (cache_buffer->bidi_paragraph_cache)
 	    {
@@ -1516,7 +1516,7 @@ bidi_paragraph_cache_on_off (void)
   else
     {
       if (!indirect_p
-	  || !NILP (BVAR (cache_buffer, cache_long_scans)))
+	  || !NILP (BVAR_OR_DEFAULT (cache_buffer, cache_long_scans)))
 	{
 	  if (!cache_buffer->bidi_paragraph_cache)
 	    cache_buffer->bidi_paragraph_cache = new_region_cache ();
@@ -1538,9 +1538,8 @@ bidi_paragraph_cache_on_off (void)
 static ptrdiff_t
 bidi_find_paragraph_start (ptrdiff_t pos, ptrdiff_t pos_byte)
 {
-  Lisp_Object re =
-    STRINGP (BVAR (current_buffer, bidi_paragraph_start_re))
-    ? BVAR (current_buffer, bidi_paragraph_start_re)
+  Lisp_Object re = STRINGP (BVAR_OR_DEFAULT (current_buffer, bidi_paragraph_start_re))
+    ? BVAR_OR_DEFAULT (current_buffer, bidi_paragraph_start_re)
     : paragraph_start_re;
   ptrdiff_t limit = ZV, limit_byte = ZV_BYTE;
   struct region_cache *bpc = bidi_paragraph_cache_on_off ();
diff --git a/src/buffer.c b/src/buffer.c
index 2ecbaa91cc..1acf0fa724 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -53,9 +53,7 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 /* This structure holds the default values of the buffer-local variables
    defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
    The default value occupies the same slot in this structure
-   as an individual buffer's value occupies in that buffer.
-   Setting the default value also goes through the alist of buffers
-   and stores into each buffer that does not say it has a local value.  */
+   as an individual buffer's value occupies in that buffer.  */
 
 struct buffer buffer_defaults;
 
@@ -989,8 +987,6 @@ reset_buffer (register struct buffer *b)
   bset_display_count (b, make_fixnum (0));
   bset_display_time (b, Qnil);
   bset_enable_multibyte_characters (b, Qt);
-  bset_cursor_type (b, BVAR (&buffer_defaults, cursor_type));
-  bset_extra_line_spacing (b, BVAR (&buffer_defaults, extra_line_spacing));
 
   b->display_error_modiff = 0;
 }
@@ -1260,7 +1256,7 @@ buffer_local_value (Lisp_Object variable, Lisp_Object buffer)
       {
 	lispfwd fwd = SYMBOL_FWD (sym);
 	if (BUFFER_OBJFWDP (fwd))
-	  result = per_buffer_value (buf, XBUFFER_OBJFWD (fwd)->offset);
+	  result = bvar_get_value (buf, XBUFFER_OBJFWD (fwd)->offset);
 	else
 	  result = Fdefault_value (variable);
 	break;
@@ -2382,6 +2378,12 @@ results, see Info node `(elisp)Swapping Text'.  */)
     bset_##field (other_buffer, BVAR (current_buffer, field));	\
     bset_##field (current_buffer, tmp##field);			\
   } while (0)
+#define swapfield_defaulted(field, type) \
+  do {							\
+    type tmp##field = BVAR_OR_DEFAULT (other_buffer, field);		\
+    bset_##field (other_buffer, BVAR_OR_DEFAULT (current_buffer, field));	\
+    bset_##field (current_buffer, tmp##field);			\
+  } while (0)
 
   swapfield (own_text, struct buffer_text);
   eassert (current_buffer->text == &current_buffer->own_text);
@@ -2415,10 +2417,10 @@ results, see Info node `(elisp)Swapping Text'.  */)
   swapfield_ (mark, Lisp_Object);
   swapfield_ (mark_active, Lisp_Object); /* Belongs with the `mark'.  */
   swapfield_ (enable_multibyte_characters, Lisp_Object);
-  swapfield_ (bidi_display_reordering, Lisp_Object);
-  swapfield_ (bidi_paragraph_direction, Lisp_Object);
-  swapfield_ (bidi_paragraph_separate_re, Lisp_Object);
-  swapfield_ (bidi_paragraph_start_re, Lisp_Object);
+  swapfield_defaulted (bidi_display_reordering, Lisp_Object);
+  swapfield_defaulted (bidi_paragraph_direction, Lisp_Object);
+  swapfield_defaulted (bidi_paragraph_separate_re, Lisp_Object);
+  swapfield_defaulted (bidi_paragraph_start_re, Lisp_Object);
   /* FIXME: Not sure what we should do with these *_marker fields.
      Hopefully they're just nil anyway.  */
   swapfield_ (pt_marker, Lisp_Object);
@@ -5245,10 +5247,8 @@ init_buffer_once (void)
      are initialized reasonably, so mark_buffer won't choke.  */
   reset_buffer (&buffer_defaults);
   eassert (NILP (BVAR (&buffer_defaults, name)));
-  reset_buffer_local_variables (&buffer_defaults, 1);
   eassert (NILP (BVAR (&buffer_local_symbols, name)));
   reset_buffer (&buffer_local_symbols);
-  reset_buffer_local_variables (&buffer_local_symbols, 1);
   /* Prevent GC from getting confused.  */
   buffer_defaults.text = &buffer_defaults.own_text;
   buffer_local_symbols.text = &buffer_local_symbols.own_text;
diff --git a/src/buffer.h b/src/buffer.h
index 31ab4fb3dd..db725250d6 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -284,6 +284,10 @@ struct buffer_text
 
 #define BVAR(buf, field) ((buf)->field ## _)
 
+#define BVAR_OR_DEFAULT(buf, field) (EQ (BVAR ((buf), field), Qunbound) \
+				     ? BVAR (&buffer_defaults, field) \
+				     : BVAR ((buf), field))
+
 /* Max number of builtin per-buffer variables.  */
 enum { MAX_PER_BUFFER_VARS = 50 };
 
@@ -1104,9 +1108,7 @@ BUFFER_CHECK_INDIRECTION (struct buffer *b)
 /* This structure holds the default values of the buffer-local variables
    that have special slots in each buffer.
    The default value occupies the same slot in this structure
-   as an individual buffer's value occupies in that buffer.
-   Setting the default value also goes through the alist of buffers
-   and stores into each buffer that does not say it has a local value.  */
+   as an individual buffer's value occupies in that buffer.  */
 
 extern struct buffer buffer_defaults;
 
@@ -1497,9 +1499,16 @@ BVAR_HAS_DEFAULT_VALUE_P (int offset)
 INLINE bool
 PER_BUFFER_VALUE_P (struct buffer *b, int offset)
 {
-  int idx = PER_BUFFER_IDX (offset);
-  eassert (idx == -1 || valid_per_buffer_idx (idx));
-  return idx == -1 || b->local_flags[idx];
+  return !EQ (per_buffer_value (b, offset), Qunbound);
+}
+
+INLINE Lisp_Object
+bvar_get_value (struct buffer *b, ptrdiff_t offset)
+{
+  Lisp_Object val = per_buffer_value (b, offset);
+  return EQ (val, Qunbound)
+    ? per_buffer_default (offset)
+    : val;
 }
 
 /* Kill the per-buffer binding for this value, if there is one. */
@@ -1509,7 +1518,7 @@ KILL_PER_BUFFER_VALUE (struct buffer *b, int offset)
 {
   int idx = PER_BUFFER_IDX (offset);
   SET_PER_BUFFER_VALUE_P (b, idx, 0);
-  set_per_buffer_value (b, offset, per_buffer_default (offset));
+  set_per_buffer_value (b, offset, Qunbound);
 }
 
 /* Downcase a character C, or make no change if that cannot be done.  */
@@ -1556,7 +1565,7 @@ sanitize_tab_width (Lisp_Object width)
 INLINE int
 SANE_TAB_WIDTH (struct buffer *buf)
 {
-  return sanitize_tab_width (BVAR (buf, tab_width));
+  return sanitize_tab_width (BVAR_OR_DEFAULT (buf, tab_width));
 }
 
 /* Return a non-outlandish value for a character width.  */
@@ -1580,7 +1589,7 @@ CHARACTER_WIDTH (int c)
 			(XFIXNUM (CHAR_TABLE_REF (Vchar_width_table, c))))
 	  : c == '\t' ? SANE_TAB_WIDTH (current_buffer)
 	  : c == '\n' ? 0
-	  : !NILP (BVAR (current_buffer, ctl_arrow)) ? 2 : 4);
+	  : !NILP (BVAR_OR_DEFAULT (current_buffer, ctl_arrow)) ? 2 : 4);
 }
 
 
diff --git a/src/category.c b/src/category.c
index ec8f61f7f0..522f4da697 100644
--- a/src/category.c
+++ b/src/category.c
@@ -180,7 +180,7 @@ static Lisp_Object
 check_category_table (Lisp_Object table)
 {
   if (NILP (table))
-    return BVAR (current_buffer, category_table);
+    return BVAR_OR_DEFAULT (current_buffer, category_table);
   CHECK_TYPE (!NILP (Fcategory_table_p (table)), Qcategory_table_p, table);
   return table;
 }
@@ -190,7 +190,7 @@ DEFUN ("category-table", Fcategory_table, Scategory_table, 0, 0, 0,
 This is the one specified by the current buffer.  */)
   (void)
 {
-  return BVAR (current_buffer, category_table);
+  return BVAR_OR_DEFAULT (current_buffer, category_table);
 }
 
 DEFUN ("standard-category-table", Fstandard_category_table,
@@ -281,7 +281,7 @@ Return TABLE.  */)
 Lisp_Object
 char_category_set (int c)
 {
-  return CHAR_TABLE_REF (BVAR (current_buffer, category_table), c);
+  return CHAR_TABLE_REF (BVAR_OR_DEFAULT (current_buffer, category_table), c);
 }
 
 DEFUN ("char-category-set", Fchar_category_set, Schar_category_set, 1, 1, 0,
diff --git a/src/cmds.c b/src/cmds.c
index c8a96d918c..a355142480 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -320,7 +320,7 @@ internal_self_insert (int c, EMACS_INT n)
   ptrdiff_t chars_to_delete = 0;
   ptrdiff_t spaces_to_insert = 0;
 
-  overwrite = BVAR (current_buffer, overwrite_mode);
+  overwrite = BVAR_OR_DEFAULT (current_buffer, overwrite_mode);
   if (!NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))
     hairy = 1;
 
@@ -406,7 +406,7 @@ internal_self_insert (int c, EMACS_INT n)
 
   synt = SYNTAX (c);
 
-  if (!NILP (BVAR (current_buffer, abbrev_mode))
+  if (!NILP (BVAR_OR_DEFAULT (current_buffer, abbrev_mode))
       && synt != Sword
       && NILP (BVAR (current_buffer, read_only))
       && PT > BEGV
@@ -474,7 +474,7 @@ internal_self_insert (int c, EMACS_INT n)
   if ((CHAR_TABLE_P (Vauto_fill_chars)
        ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars, c))
        : (c == ' ' || c == '\n'))
-      && !NILP (BVAR (current_buffer, auto_fill_function)))
+      && !NILP (BVAR_OR_DEFAULT (current_buffer, auto_fill_function)))
     {
       Lisp_Object auto_fill_result;
 
diff --git a/src/data.c b/src/data.c
index 9d8b722a41..6835699236 100644
--- a/src/data.c
+++ b/src/data.c
@@ -1161,8 +1161,8 @@ do_symval_forwarding (lispfwd valcontents)
       return *XOBJFWD (valcontents)->objvar;
 
     case Lisp_Fwd_Buffer_Obj:
-      return per_buffer_value (current_buffer,
-			       XBUFFER_OBJFWD (valcontents)->offset);
+      return bvar_get_value (current_buffer,
+			     XBUFFER_OBJFWD (valcontents)->offset);
 
     case Lisp_Fwd_Kboard_Obj:
       /* We used to simply use current_kboard here, but from Lisp
@@ -1259,31 +1259,6 @@ store_symval_forwarding (lispfwd valcontents, Lisp_Object newval,
 
     case Lisp_Fwd_Obj:
       *XOBJFWD (valcontents)->objvar = newval;
-
-      /* If this variable is a default for something stored
-	 in the buffer itself, such as default-fill-column,
-	 find the buffers that don't have local values for it
-	 and update them.  */
-      if (XOBJFWD (valcontents)->objvar > (Lisp_Object *) &buffer_defaults
-	  && XOBJFWD (valcontents)->objvar < (Lisp_Object *) (&buffer_defaults + 1))
-	{
-	  int offset = ((char *) XOBJFWD (valcontents)->objvar
-			- (char *) &buffer_defaults);
-	  int idx = PER_BUFFER_IDX (offset);
-
-	  Lisp_Object tail, buf;
-
-	  if (idx <= 0)
-	    break;
-
-	  FOR_EACH_LIVE_BUFFER (tail, buf)
-	    {
-	      struct buffer *b = XBUFFER (buf);
-
-	      if (! PER_BUFFER_VALUE_P (b, offset))
-		set_per_buffer_value (b, offset, newval);
-	    }
-	}
       break;
 
     case Lisp_Fwd_Buffer_Obj:
@@ -1883,27 +1858,6 @@ set_default_internal (Lisp_Object symbol, Lisp_Object value,
 	    int offset = XBUFFER_OBJFWD (valcontents)->offset;
 
 	    set_per_buffer_default (offset, value);
-
-	    /* If this variable is not always local in all buffers,
-	       set it in the buffers that don't nominally have a local value.  */
-	    if (BVAR_HAS_DEFAULT_VALUE_P (offset))
-	      {
-		Lisp_Object buf, tail;
-
-		/* Do this only in live buffers, so that if there are
-		   a lot of buffers which are dead, that doesn't slow
-		   down let-binding of variables that are
-		   automatically local when set, like
-		   case-fold-search.  This is for Lisp programs that
-		   let-bind such variables in their inner loops.  */
-		FOR_EACH_LIVE_BUFFER (tail, buf)
-		  {
-		    struct buffer *b = XBUFFER (buf);
-
-		    if (!PER_BUFFER_VALUE_P (b, offset))
-		      set_per_buffer_value (b, offset, value);
-		  }
-	      }
 	  }
 	else
           set_internal (symbol, value, Qnil, bindflag);
diff --git a/src/editfns.c b/src/editfns.c
index 04b8e85d9c..01e56843a6 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1769,7 +1769,7 @@ determines whether case is significant or ignored.  */)
   register EMACS_INT begp1, endp1, begp2, endp2, temp;
   register struct buffer *bp1, *bp2;
   register Lisp_Object trt
-    = (!NILP (BVAR (current_buffer, case_fold_search))
+    = (!NILP (BVAR_OR_DEFAULT (current_buffer, case_fold_search))
        ? BVAR (current_buffer, case_canon_table) : Qnil);
   ptrdiff_t chars = 0;
   ptrdiff_t i1, i2, i1_byte, i2_byte;
@@ -4022,7 +4022,7 @@ Case is ignored if `case-fold-search' is non-nil in the current buffer.  */)
 
   if (XFIXNUM (c1) == XFIXNUM (c2))
     return Qt;
-  if (NILP (BVAR (current_buffer, case_fold_search)))
+  if (NILP (BVAR_OR_DEFAULT (current_buffer, case_fold_search)))
     return Qnil;
 
   i1 = XFIXNAT (c1);
diff --git a/src/fileio.c b/src/fileio.c
index 741e297d29..2c941d82cc 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -4919,7 +4919,7 @@ choose_write_coding_system (Lisp_Object start, Lisp_Object end, Lisp_Object file
       bool using_default_coding = 0;
       bool force_raw_text = 0;
 
-      val = BVAR (current_buffer, buffer_file_coding_system);
+      val = BVAR_OR_DEFAULT (current_buffer, buffer_file_coding_system);
       if (NILP (val)
 	  || NILP (Flocal_variable_p (Qbuffer_file_coding_system, Qnil)))
 	{
@@ -4942,7 +4942,7 @@ choose_write_coding_system (Lisp_Object start, Lisp_Object end, Lisp_Object file
 	{
 	  /* If we still have not decided a coding system, use the
 	     current buffer's value of buffer-file-coding-system.  */
-	  val = BVAR (current_buffer, buffer_file_coding_system);
+	  val = BVAR_OR_DEFAULT (current_buffer, buffer_file_coding_system);
 	  using_default_coding = 1;
 	}
 
@@ -4974,7 +4974,8 @@ choose_write_coding_system (Lisp_Object start, Lisp_Object end, Lisp_Object file
 	 format, we use that of `buffer-file-coding-system'.  */
       if (! using_default_coding)
 	{
-	  Lisp_Object dflt = BVAR (&buffer_defaults, buffer_file_coding_system);
+	  Lisp_Object dflt = BVAR_OR_DEFAULT (&buffer_defaults,
+					     buffer_file_coding_system);
 
 	  if (! NILP (dflt))
 	    val = coding_inherit_eol_type (val, dflt);
@@ -4989,7 +4990,7 @@ choose_write_coding_system (Lisp_Object start, Lisp_Object end, Lisp_Object file
   val = coding_inherit_eol_type (val, eol_parent);
   setup_coding_system (val, coding);
 
-  if (!STRINGP (start) && EQ (Qt, BVAR (current_buffer, selective_display)))
+  if (!STRINGP (start) && EQ (Qt, BVAR_OR_DEFAULT (current_buffer, selective_display)))
     coding->mode |= CODING_MODE_SELECTIVE_DISPLAY;
   return val;
 }
diff --git a/src/fns.c b/src/fns.c
index 41429c8863..283ee96143 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -5416,7 +5416,8 @@ extract_data_from_object (Lisp_Object spec,
 	    {
 	      bool force_raw_text = false;
 
-	      coding_system = BVAR (XBUFFER (object), buffer_file_coding_system);
+	      coding_system = BVAR_OR_DEFAULT (XBUFFER(object),
+					      buffer_file_coding_system);
 	      if (NILP (coding_system)
 		  || NILP (Flocal_variable_p (Qbuffer_file_coding_system, Qnil)))
 		{
@@ -5437,11 +5438,12 @@ extract_data_from_object (Lisp_Object spec,
 		}
 
 	      if (NILP (coding_system)
-		  && !NILP (BVAR (XBUFFER (object), buffer_file_coding_system)))
+		  && !NILP (BVAR_OR_DEFAULT (XBUFFER(object), buffer_file_coding_system)))
 		{
 		  /* If we still have not decided a coding system, use the
 		     default value of buffer-file-coding-system.  */
-		  coding_system = BVAR (XBUFFER (object), buffer_file_coding_system);
+		  coding_system = BVAR_OR_DEFAULT (XBUFFER(object),
+						  buffer_file_coding_system);
 		}
 
 	      if (!force_raw_text
diff --git a/src/fringe.c b/src/fringe.c
index 65c9a84ac9..42ba9b0682 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -697,7 +697,8 @@ get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
 {
   Lisp_Object cmap, bm = Qnil;
 
-  if ((cmap = BVAR (XBUFFER (w->contents), fringe_cursor_alist)), !NILP (cmap))
+  if ((cmap = BVAR_OR_DEFAULT (XBUFFER(w->contents), fringe_cursor_alist)),
+      !NILP (cmap))
     {
       bm = Fassq (cursor, cmap);
       if (CONSP (bm))
@@ -707,9 +708,9 @@ get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
 	  return lookup_fringe_bitmap (bm);
 	}
     }
-  if (EQ (cmap, BVAR (&buffer_defaults, fringe_cursor_alist)))
+  if (EQ (cmap, BVAR_OR_DEFAULT (&buffer_defaults, fringe_cursor_alist)))
     return NO_FRINGE_BITMAP;
-  bm = Fassq (cursor, BVAR (&buffer_defaults, fringe_cursor_alist));
+  bm = Fassq (cursor, BVAR_OR_DEFAULT (&buffer_defaults, fringe_cursor_alist));
   if (!CONSP (bm) || ((bm = XCDR (bm)), NILP (bm)))
     return NO_FRINGE_BITMAP;
   return lookup_fringe_bitmap (bm);
@@ -734,7 +735,8 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
      If partial, lookup partial bitmap in default value if not found here.
      If not partial, or no partial spec is present, use non-partial bitmap.  */
 
-  if ((cmap = BVAR (XBUFFER (w->contents), fringe_indicator_alist)), !NILP (cmap))
+  if ((cmap = BVAR_OR_DEFAULT (XBUFFER(w->contents), fringe_indicator_alist)),
+      !NILP (cmap))
     {
       bm1 = Fassq (bitmap, cmap);
       if (CONSP (bm1))
@@ -768,10 +770,11 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
 	}
     }
 
-  if (!EQ (cmap, BVAR (&buffer_defaults, fringe_indicator_alist))
-      && !NILP (BVAR (&buffer_defaults, fringe_indicator_alist)))
+  if (!EQ (cmap, BVAR_OR_DEFAULT (&buffer_defaults, fringe_indicator_alist))
+      && !NILP (BVAR_OR_DEFAULT (&buffer_defaults, fringe_indicator_alist)))
     {
-      bm2 = Fassq (bitmap, BVAR (&buffer_defaults, fringe_indicator_alist));
+      bm2 = Fassq (bitmap,
+		   BVAR_OR_DEFAULT (&buffer_defaults, fringe_indicator_alist));
       if (CONSP (bm2))
 	{
 	  if ((bm2 = XCDR (bm2)), !NILP (bm2))
@@ -970,7 +973,7 @@ update_window_fringes (struct window *w, bool keep_current_p)
     return 0;
 
   if (!MINI_WINDOW_P (w)
-      && (ind = BVAR (XBUFFER (w->contents), indicate_buffer_boundaries), !NILP (ind)))
+      && (ind = BVAR_OR_DEFAULT (XBUFFER (w->contents), indicate_buffer_boundaries), !NILP (ind)))
     {
       if (EQ (ind, Qleft) || EQ (ind, Qright))
 	boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
@@ -1031,7 +1034,7 @@ update_window_fringes (struct window *w, bool keep_current_p)
 	}
     }
 
-  empty_pos = BVAR (XBUFFER (w->contents), indicate_empty_lines);
+  empty_pos = BVAR_OR_DEFAULT (XBUFFER (w->contents), indicate_empty_lines);
   if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
     empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
 
diff --git a/src/hbfont.c b/src/hbfont.c
index e9f4085b1a..5f8f4d2445 100644
--- a/src/hbfont.c
+++ b/src/hbfont.c
@@ -443,7 +443,7 @@ hbfont_shape (Lisp_Object lgstring, Lisp_Object direction)
       /* If they bind bidi-display-reordering to nil, the DIRECTION
 	 they provide is meaningless, and we should let HarfBuzz guess
 	 the real direction.  */
-      && !NILP (BVAR (current_buffer, bidi_display_reordering)))
+      && !NILP (BVAR_OR_DEFAULT (current_buffer, bidi_display_reordering)))
     {
       hb_direction_t dir = HB_DIRECTION_LTR;
       if (EQ (direction, QL2R))
diff --git a/src/indent.c b/src/indent.c
index 6246b544fb..d30b5b3ad9 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -60,7 +60,7 @@ buffer_display_table (void)
 {
   Lisp_Object thisbuf;
 
-  thisbuf = BVAR (current_buffer, display_table);
+  thisbuf = BVAR_OR_DEFAULT (current_buffer, display_table);
   if (DISP_TABLE_P (thisbuf))
     return XCHAR_TABLE (thisbuf);
   if (DISP_TABLE_P (Vstandard_display_table))
@@ -153,13 +153,13 @@ width_run_cache_on_off (void)
       indirect_p = true;
     }
 
-  if (NILP (BVAR (current_buffer, cache_long_scans))
+  if (NILP (BVAR_OR_DEFAULT (current_buffer, cache_long_scans))
       /* And, for the moment, this feature doesn't work on multibyte
          characters.  */
       || !NILP (BVAR (current_buffer, enable_multibyte_characters)))
     {
       if (!indirect_p
-	  || NILP (BVAR (cache_buffer, cache_long_scans))
+	  || NILP (BVAR_OR_DEFAULT (cache_buffer, cache_long_scans))
 	  || !NILP (BVAR (cache_buffer, enable_multibyte_characters)))
 	{
 	  /* It should be off.  */
@@ -175,7 +175,7 @@ width_run_cache_on_off (void)
   else
     {
       if (!indirect_p
-	  || (!NILP (BVAR (cache_buffer, cache_long_scans))
+	  || (!NILP (BVAR_OR_DEFAULT (cache_buffer, cache_long_scans))
 	      && NILP (BVAR (cache_buffer, enable_multibyte_characters))))
 	{
 	  /* It should be on.  */
@@ -334,7 +334,7 @@ current_column (void)
   ptrdiff_t post_tab;
   int c;
   int tab_width = SANE_TAB_WIDTH (current_buffer);
-  bool ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
+  bool ctl_arrow = !NILP (BVAR_OR_DEFAULT (current_buffer, ctl_arrow));
   struct Lisp_Char_Table *dp = buffer_display_table ();
 
   if (PT == last_known_column_point
@@ -416,7 +416,7 @@ current_column (void)
 	    col++;
 	  else if (c == '\n'
 		   || (c == '\r'
-		       && EQ (BVAR (current_buffer, selective_display), Qt)))
+		       && EQ (BVAR_OR_DEFAULT (current_buffer, selective_display), Qt)))
 	    {
 	      ptr++;
 	      goto start_of_line_found;
@@ -531,7 +531,7 @@ scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol,
 		 ptrdiff_t *prevpos, ptrdiff_t *prevbpos, ptrdiff_t *prevcol)
 {
   int tab_width = SANE_TAB_WIDTH (current_buffer);
-  bool ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
+  bool ctl_arrow = !NILP (BVAR_OR_DEFAULT (current_buffer, ctl_arrow));
   struct Lisp_Char_Table *dp = buffer_display_table ();
   bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
   struct composition_it cmp_it;
@@ -652,7 +652,7 @@ scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol,
 
 	      if (c == '\n')
 		goto endloop;
-	      if (c == '\r' && EQ (BVAR (current_buffer, selective_display), Qt))
+	      if (c == '\r' && EQ (BVAR_OR_DEFAULT (current_buffer, selective_display), Qt))
 		goto endloop;
 	      if (c == '\t')
 		{
@@ -670,7 +670,7 @@ scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol,
 
 	  if (c == '\n')
 	    goto endloop;
-	  if (c == '\r' && EQ (BVAR (current_buffer, selective_display), Qt))
+	  if (c == '\r' && EQ (BVAR_OR_DEFAULT (current_buffer, selective_display), Qt))
 	    goto endloop;
 	  if (c == '\t')
 	    {
@@ -1131,12 +1131,12 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
   ptrdiff_t pos_byte;
   int c = 0;
   int tab_width = SANE_TAB_WIDTH (current_buffer);
-  bool ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
+  bool ctl_arrow = !NILP (BVAR_OR_DEFAULT (current_buffer, ctl_arrow));
   struct Lisp_Char_Table *dp = window_display_table (win);
   EMACS_INT selective
-    = (FIXNUMP (BVAR (current_buffer, selective_display))
-       ? XFIXNUM (BVAR (current_buffer, selective_display))
-       : !NILP (BVAR (current_buffer, selective_display)) ? -1 : 0);
+    = (FIXNUMP (BVAR_OR_DEFAULT (current_buffer, selective_display))
+       ? XFIXNUM (BVAR_OR_DEFAULT (current_buffer, selective_display))
+       : !NILP (BVAR_OR_DEFAULT (current_buffer, selective_display)) ? -1 : 0);
   ptrdiff_t selective_rlen
     = (selective && dp && VECTORP (DISP_INVIS_VECTOR (dp))
        ? ASIZE (DISP_INVIS_VECTOR (dp)) : 0);
@@ -1352,7 +1352,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
 	    }
 
 	  if (hscroll || truncate
-	      || !NILP (BVAR (current_buffer, truncate_lines)))
+	      || !NILP (BVAR_OR_DEFAULT (current_buffer, truncate_lines)))
 	    {
 	      /* Truncating: skip to newline, unless we are already past
                  TO (we need to go back below).  */
@@ -1837,10 +1837,10 @@ vmotion (ptrdiff_t from, ptrdiff_t from_byte,
   register ptrdiff_t first;
   ptrdiff_t lmargin = hscroll > 0 ? 1 - hscroll : 0;
   ptrdiff_t selective
-    = (FIXNUMP (BVAR (current_buffer, selective_display))
-       ? clip_to_bounds (-1, XFIXNUM (BVAR (current_buffer, selective_display)),
+    = (FIXNUMP (BVAR_OR_DEFAULT (current_buffer, selective_display))
+       ? clip_to_bounds (-1, XFIXNUM (BVAR_OR_DEFAULT (current_buffer, selective_display)),
 			 PTRDIFF_MAX)
-       : !NILP (BVAR (current_buffer, selective_display)) ? -1 : 0);
+       : !NILP (BVAR_OR_DEFAULT (current_buffer, selective_display)) ? -1 : 0);
   Lisp_Object window;
   bool did_motion;
   /* This is the object we use for fetching character properties.  */
diff --git a/src/msdos.c b/src/msdos.c
index 5da01c9e7c..e3426d9403 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -1321,12 +1321,12 @@ IT_frame_up_to_date (struct frame *f)
     {
       struct buffer *b = XBUFFER (sw->contents);
 
-      if (EQ (BVAR (b,cursor_type), Qt))
+      if (EQ (BVAR_OR_DEFAULT (b, cursor_type), Qt))
 	new_cursor = frame_desired_cursor;
-      else if (NILP (BVAR (b, cursor_type))) /* nil means no cursor */
+      else if (NILP (BVAR_OR_DEFAULT (b, cursor_type))) /* nil means no cursor */
 	new_cursor = Fcons (Qbar, make_fixnum (0));
       else
-	new_cursor = BVAR (b, cursor_type);
+	new_cursor = BVAR_OR_DEFAULT (b, cursor_type);
     }
 
   IT_set_cursor_type (f, new_cursor);
diff --git a/src/search.c b/src/search.c
index c757bf3d1f..107034bf62 100644
--- a/src/search.c
+++ b/src/search.c
@@ -125,7 +125,8 @@ compile_pattern_1 (struct regexp_cache *cp, Lisp_Object pattern,
 
   /* If the compiled pattern hard codes some of the contents of the
      syntax-table, it can only be reused with *this* syntax table.  */
-  cp->syntax_table = cp->buf.used_syntax ? BVAR (current_buffer, syntax_table) : Qt;
+  cp->syntax_table = cp->buf.used_syntax ? BVAR_OR_DEFAULT (current_buffer,
+							   syntax_table) : Qt;
 
   if (val)
     xsignal1 (Qinvalid_regexp, build_string (val));
@@ -219,7 +220,7 @@ compile_pattern (Lisp_Object pattern, struct re_registers *regp,
 	  && EQ (cp->buf.translate, translate)
 	  && cp->posix == posix
 	  && (EQ (cp->syntax_table, Qt)
-	      || EQ (cp->syntax_table, BVAR (current_buffer, syntax_table)))
+	      || EQ (cp->syntax_table, BVAR_OR_DEFAULT (current_buffer, syntax_table)))
 	  && !NILP (Fequal (cp->f_whitespace_regexp, Vsearch_spaces_regexp))
 	  && cp->buf.charset_unibyte == charset_unibyte)
 	break;
@@ -282,7 +283,7 @@ looking_at_1 (Lisp_Object string, bool posix)
   struct regexp_cache *cache_entry = compile_pattern (
     string,
     preserve_match_data ? &search_regs : NULL,
-    (!NILP (BVAR (current_buffer, case_fold_search))
+    (!NILP (BVAR_OR_DEFAULT (current_buffer, case_fold_search))
      ? BVAR (current_buffer, case_canon_table) : Qnil),
     posix,
     !NILP (BVAR (current_buffer, enable_multibyte_characters)));
@@ -401,7 +402,7 @@ string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start,
   bufp = &compile_pattern (regexp,
                            (NILP (Vinhibit_changing_match_data)
                             ? &search_regs : NULL),
-                           (!NILP (BVAR (current_buffer, case_fold_search))
+			   (!NILP (BVAR_OR_DEFAULT (current_buffer, case_fold_search))
                             ? BVAR (current_buffer, case_canon_table) : Qnil),
                            posix,
                            STRING_MULTIBYTE (string))->buf;
@@ -592,10 +593,10 @@ newline_cache_on_off (struct buffer *buf)
      This is because doing so will just make the cache pure overhead,
      since if we turn it on via indirect buffer, it will be
      immediately turned off by its base buffer.  */
-  if (NILP (BVAR (buf, cache_long_scans)))
+  if (NILP (BVAR_OR_DEFAULT (buf, cache_long_scans)))
     {
       if (!indirect_p
-	  || NILP (BVAR (base_buf, cache_long_scans)))
+	  || NILP (BVAR_OR_DEFAULT (base_buf, cache_long_scans)))
 	{
 	  /* It should be off.  */
 	  if (base_buf->newline_cache)
@@ -609,7 +610,7 @@ newline_cache_on_off (struct buffer *buf)
   else
     {
       if (!indirect_p
-	  || !NILP (BVAR (base_buf, cache_long_scans)))
+	  || !NILP (BVAR_OR_DEFAULT (base_buf, cache_long_scans)))
 	{
 	  /* It should be on.  */
 	  if (base_buf->newline_cache == 0)
@@ -1048,10 +1049,10 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
 			 BVAR (current_buffer, case_eqv_table));
 
   np = search_buffer (string, PT, PT_BYTE, lim, lim_byte, n, RE,
-		      (!NILP (BVAR (current_buffer, case_fold_search))
+		      (!NILP (BVAR_OR_DEFAULT (current_buffer, case_fold_search))
 		       ? BVAR (current_buffer, case_canon_table)
 		       : Qnil),
-		      (!NILP (BVAR (current_buffer, case_fold_search))
+		      (!NILP (BVAR_OR_DEFAULT (current_buffer, case_fold_search))
 		       ? BVAR (current_buffer, case_eqv_table)
 		       : Qnil),
 		      posix);
@@ -3275,7 +3276,7 @@ the buffer.  If the buffer doesn't have a cache, the value is nil.  */)
     buf = buf->base_buffer;
 
   /* If the buffer doesn't have a newline cache, return nil.  */
-  if (NILP (BVAR (buf, cache_long_scans))
+  if (NILP (BVAR_OR_DEFAULT (buf, cache_long_scans))
       || buf->newline_cache == NULL)
     return Qnil;
 
diff --git a/src/syntax.c b/src/syntax.c
index 9fbf88535f..17753f50b7 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -416,7 +416,8 @@ update_syntax_table (ptrdiff_t charpos, EMACS_INT count, bool init,
       else
 	{
 	  gl_state.use_global = 0;
-	  gl_state.current_syntax_table = BVAR (current_buffer, syntax_table);
+	  gl_state.current_syntax_table = BVAR_OR_DEFAULT (current_buffer,
+							  syntax_table);
 	}
     }
 
@@ -998,7 +999,7 @@ DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
 This is the one specified by the current buffer.  */)
   (void)
 {
-  return BVAR (current_buffer, syntax_table);
+  return BVAR_OR_DEFAULT (current_buffer, syntax_table);
 }
 
 DEFUN ("standard-syntax-table", Fstandard_syntax_table,
@@ -1254,7 +1255,7 @@ usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE)  */)
     CHECK_CHARACTER (c);
 
   if (NILP (syntax_table))
-    syntax_table = BVAR (current_buffer, syntax_table);
+    syntax_table = BVAR_OR_DEFAULT (current_buffer, syntax_table);
   else
     check_syntax_table (syntax_table);
 
diff --git a/src/syntax.h b/src/syntax.h
index 66ee139a96..187946c899 100644
--- a/src/syntax.h
+++ b/src/syntax.h
@@ -103,7 +103,7 @@ syntax_property_entry (int c, bool via_property)
     return (gl_state.use_global
 	    ? gl_state.global_code
 	    : CHAR_TABLE_REF (gl_state.current_syntax_table, c));
-  return CHAR_TABLE_REF (BVAR (current_buffer, syntax_table), c);
+  return CHAR_TABLE_REF (BVAR_OR_DEFAULT (current_buffer, syntax_table), c);
 }
 INLINE Lisp_Object
 SYNTAX_ENTRY (int c)
@@ -212,7 +212,8 @@ SETUP_BUFFER_SYNTAX_TABLE (void)
 {
   gl_state.use_global = false;
   gl_state.e_property_truncated = false;
-  gl_state.current_syntax_table = BVAR (current_buffer, syntax_table);
+  gl_state.current_syntax_table = BVAR_OR_DEFAULT (current_buffer,
+						  syntax_table);
 }
 
 extern ptrdiff_t scan_words (ptrdiff_t, EMACS_INT);
diff --git a/src/window.c b/src/window.c
index 0a14eca58f..b85f758679 100644
--- a/src/window.c
+++ b/src/window.c
@@ -2315,8 +2315,8 @@ window_display_table (struct window *w)
     {
       struct buffer *b = XBUFFER (w->contents);
 
-      if (DISP_TABLE_P (BVAR (b, display_table)))
-	dp = XCHAR_TABLE (BVAR (b, display_table));
+      if (DISP_TABLE_P (BVAR_OR_DEFAULT (b, display_table)))
+	dp = XCHAR_TABLE (BVAR_OR_DEFAULT (b, display_table));
       else if (DISP_TABLE_P (Vstandard_display_table))
 	dp = XCHAR_TABLE (Vstandard_display_table);
     }
@@ -4044,17 +4044,18 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
       /* Set fringes and scroll bars from buffer unless they have been
 	 declared as persistent.  */
       if (!w->fringes_persistent)
-	set_window_fringes (w, BVAR (b, left_fringe_width),
-			    BVAR (b, right_fringe_width),
-			    BVAR (b, fringes_outside_margins), Qnil);
+	set_window_fringes (w, BVAR_OR_DEFAULT (b, left_fringe_width),
+			    BVAR_OR_DEFAULT (b, right_fringe_width),
+			    BVAR_OR_DEFAULT (b, fringes_outside_margins), Qnil);
       if (!w->scroll_bars_persistent)
-	set_window_scroll_bars (w, BVAR (b, scroll_bar_width),
-				BVAR (b, vertical_scroll_bar_type),
-				BVAR (b, scroll_bar_height),
-				BVAR (b, horizontal_scroll_bar_type), Qnil);
+	set_window_scroll_bars (w, BVAR_OR_DEFAULT (b, scroll_bar_width),
+				BVAR_OR_DEFAULT (b, vertical_scroll_bar_type),
+				BVAR_OR_DEFAULT (b, scroll_bar_height),
+				BVAR_OR_DEFAULT (b, horizontal_scroll_bar_type),
+				Qnil);
       /* Set left and right marginal area width from buffer.  */
-      set_window_margins (w, BVAR (b, left_margin_cols),
-			  BVAR (b, right_margin_cols));
+      set_window_margins (w, BVAR_OR_DEFAULT (b, left_margin_cols),
+			  BVAR_OR_DEFAULT (b, right_margin_cols));
       apply_window_adjustment (w);
     }
 
@@ -5372,7 +5373,7 @@ window_wants_mode_line (struct window *w)
 	  && !WINDOW_PSEUDO_P (w)
 	  && !EQ (window_mode_line_format, Qnone)
 	  && (!NILP (window_mode_line_format)
-	      || !NILP (BVAR (XBUFFER (WINDOW_BUFFER (w)), mode_line_format)))
+	      || !NILP (BVAR_OR_DEFAULT (XBUFFER(WINDOW_BUFFER(w)), mode_line_format)))
 	  && WINDOW_PIXEL_HEIGHT (w) > WINDOW_FRAME_LINE_HEIGHT (w));
 }
 
@@ -5401,7 +5402,7 @@ window_wants_header_line (struct window *w)
 	  && !WINDOW_PSEUDO_P (w)
 	  && !EQ (window_header_line_format, Qnone)
 	  && (!NILP (window_header_line_format)
-	      || !NILP (BVAR (XBUFFER (WINDOW_BUFFER (w)), header_line_format)))
+	      || !NILP (BVAR_OR_DEFAULT (XBUFFER(WINDOW_BUFFER(w)), header_line_format)))
 	  && (WINDOW_PIXEL_HEIGHT (w)
 	      > (window_wants_mode_line (w)
 		 ? 2 * WINDOW_FRAME_LINE_HEIGHT (w)
@@ -5435,7 +5436,7 @@ window_wants_tab_line (struct window *w)
 	  && !WINDOW_PSEUDO_P (w)
 	  && !EQ (window_tab_line_format, Qnone)
 	  && (!NILP (window_tab_line_format)
-	      || !NILP (BVAR (XBUFFER (WINDOW_BUFFER (w)), tab_line_format)))
+	      || !NILP (BVAR_OR_DEFAULT (XBUFFER(WINDOW_BUFFER(w)), tab_line_format)))
 	  && (WINDOW_PIXEL_HEIGHT (w)
 	      > (((window_wants_mode_line (w) ? 1 : 0)
 		  + (window_wants_header_line (w) ? 1 : 0)
diff --git a/src/xdisp.c b/src/xdisp.c
index 23b4ba5c39..d978bf69e6 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -595,7 +595,7 @@ fill_column_indicator_column (struct it *it, int char_width)
       && CHARACTERP (Vdisplay_fill_column_indicator_character))
     {
       Lisp_Object col = (EQ (Vdisplay_fill_column_indicator_column, Qt)
-			 ? BVAR (current_buffer, fill_column)
+			 ? BVAR_OR_DEFAULT (current_buffer, fill_column)
 			 : Vdisplay_fill_column_indicator_column);
 
       /* The stretch width needs to consider the latter
@@ -1543,10 +1543,10 @@ default_line_pixel_height (struct window *w)
   if (!FRAME_INITIAL_P (f) && BUFFERP (w->contents))
     {
       struct buffer *b = XBUFFER (w->contents);
-      Lisp_Object val = BVAR (b, extra_line_spacing);
+      Lisp_Object val = BVAR_OR_DEFAULT (b, extra_line_spacing);
 
       if (NILP (val))
-	val = BVAR (&buffer_defaults, extra_line_spacing);
+	val = BVAR_OR_DEFAULT (&buffer_defaults, extra_line_spacing);
       if (!NILP (val))
 	{
 	  if (RANGED_FIXNUMP (0, val, INT_MAX))
@@ -1684,7 +1684,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
       w->mode_line_height
 	= display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
 			     NILP (window_mode_line_format)
-			     ? BVAR (current_buffer, mode_line_format)
+			     ? BVAR_OR_DEFAULT (current_buffer, mode_line_format)
 			     : window_mode_line_format);
     }
 
@@ -1696,7 +1696,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
       w->tab_line_height
 	= display_mode_line (w, TAB_LINE_FACE_ID,
 			     NILP (window_tab_line_format)
-			     ? BVAR (current_buffer, tab_line_format)
+			     ? BVAR_OR_DEFAULT (current_buffer, tab_line_format)
 			     : window_tab_line_format);
     }
 
@@ -1708,7 +1708,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
       w->header_line_height
 	= display_mode_line (w, HEADER_LINE_FACE_ID,
 			     NILP (window_header_line_format)
-			     ? BVAR (current_buffer, header_line_format)
+			     ? BVAR_OR_DEFAULT (current_buffer, header_line_format)
 			     : window_header_line_format);
     }
 
@@ -3205,10 +3205,10 @@ init_iterator (struct it *it, struct window *w,
   if (base_face_id == DEFAULT_FACE_ID
       && FRAME_WINDOW_P (it->f))
     {
-      if (FIXNATP (BVAR (current_buffer, extra_line_spacing)))
-	it->extra_line_spacing = XFIXNAT (BVAR (current_buffer, extra_line_spacing));
-      else if (FLOATP (BVAR (current_buffer, extra_line_spacing)))
-	it->extra_line_spacing = (XFLOAT_DATA (BVAR (current_buffer, extra_line_spacing))
+      if (FIXNATP (BVAR_OR_DEFAULT (current_buffer, extra_line_spacing)))
+	it->extra_line_spacing = XFIXNAT (BVAR_OR_DEFAULT (current_buffer, extra_line_spacing));
+      else if (FLOATP (BVAR_OR_DEFAULT (current_buffer, extra_line_spacing)))
+	it->extra_line_spacing = (XFLOAT_DATA (BVAR_OR_DEFAULT (current_buffer, extra_line_spacing))
 				  * FRAME_LINE_HEIGHT (it->f));
       else if (it->f->extra_line_spacing > 0)
 	it->extra_line_spacing = it->f->extra_line_spacing;
@@ -3226,19 +3226,19 @@ init_iterator (struct it *it, struct window *w,
   it->override_ascent = -1;
 
   /* Are control characters displayed as `^C'?  */
-  it->ctl_arrow_p = !NILP (BVAR (current_buffer, ctl_arrow));
+  it->ctl_arrow_p = !NILP (BVAR_OR_DEFAULT (current_buffer, ctl_arrow));
 
   /* -1 means everything between a CR and the following line end
      is invisible.  >0 means lines indented more than this value are
      invisible.  */
-  it->selective = (FIXNUMP (BVAR (current_buffer, selective_display))
+  it->selective = (FIXNUMP (BVAR_OR_DEFAULT (current_buffer, selective_display))
 		   ? (clip_to_bounds
-		      (-1, XFIXNUM (BVAR (current_buffer, selective_display)),
+		      (-1, XFIXNUM (BVAR_OR_DEFAULT (current_buffer, selective_display)),
 		       PTRDIFF_MAX))
-		   : (!NILP (BVAR (current_buffer, selective_display))
+		   : (!NILP (BVAR_OR_DEFAULT (current_buffer, selective_display))
 		      ? -1 : 0));
   it->selective_display_ellipsis_p
-    = !NILP (BVAR (current_buffer, selective_display_ellipses));
+    = !NILP (BVAR_OR_DEFAULT (current_buffer, selective_display_ellipses));
 
   /* Display table to use.  */
   it->dp = window_display_table (w);
@@ -3270,8 +3270,8 @@ init_iterator (struct it *it, struct window *w,
 	      /* PXW: Shall we do something about this?  */
 	      && (XFIXNUM (Vtruncate_partial_width_windows)
 		  <= WINDOW_TOTAL_COLS (it->w))))
-      && NILP (BVAR (current_buffer, truncate_lines)))
-    it->line_wrap = NILP (BVAR (current_buffer, word_wrap))
+      && NILP (BVAR_OR_DEFAULT (current_buffer, truncate_lines)))
+    it->line_wrap = NILP (BVAR_OR_DEFAULT (current_buffer, word_wrap))
       ? WINDOW_WRAP : WORD_WRAP;
 
   /* Get dimensions of truncation and continuation glyphs.  These are
@@ -3416,7 +3416,7 @@ init_iterator (struct it *it, struct window *w,
 	 available.  */
       it->bidi_p =
 	!redisplay__inhibit_bidi
-	&& !NILP (BVAR (current_buffer, bidi_display_reordering))
+	&& !NILP (BVAR_OR_DEFAULT (current_buffer, bidi_display_reordering))
 	&& it->multibyte_p;
 
       /* If we are to reorder bidirectional text, init the bidi
@@ -3438,10 +3438,10 @@ init_iterator (struct it *it, struct window *w,
 	    }
 	  /* Note the paragraph direction that this buffer wants to
 	     use.  */
-	  if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
+	  if (EQ (BVAR_OR_DEFAULT (current_buffer, bidi_paragraph_direction),
 		  Qleft_to_right))
 	    it->paragraph_embedding = L2R;
-	  else if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
+	  else if (EQ (BVAR_OR_DEFAULT (current_buffer, bidi_paragraph_direction),
 		       Qright_to_left))
 	    it->paragraph_embedding = R2L;
 	  else
@@ -7208,7 +7208,7 @@ reseat_to_string (struct it *it, const char *s, Lisp_Object string,
      not yet available.  */
   it->bidi_p =
     !redisplay__inhibit_bidi
-    && !NILP (BVAR (&buffer_defaults, bidi_display_reordering));
+    && !NILP (BVAR_OR_DEFAULT (&buffer_defaults, bidi_display_reordering));
 
   if (s == NULL)
     {
@@ -12140,7 +12140,7 @@ set_message_1 (void *a1, Lisp_Object string)
     Fset_buffer_multibyte (Qt);
 
   bset_truncate_lines (current_buffer, message_truncate_lines ? Qt : Qnil);
-  if (!NILP (BVAR (current_buffer, bidi_display_reordering)))
+  if (!NILP (BVAR_OR_DEFAULT (current_buffer, bidi_display_reordering)))
     bset_bidi_paragraph_direction (current_buffer, Qleft_to_right);
 
   /* Insert new message at BEG.  */
@@ -15187,8 +15187,8 @@ text_outside_line_unchanged_p (struct window *w,
       /* If selective display, can't optimize if changes start at the
 	 beginning of the line.  */
       if (unchanged_p
-	  && FIXNUMP (BVAR (current_buffer, selective_display))
-	  && XFIXNUM (BVAR (current_buffer, selective_display)) > 0
+	  && FIXNUMP (BVAR_OR_DEFAULT (current_buffer, selective_display))
+	  && XFIXNUM (BVAR_OR_DEFAULT (current_buffer, selective_display)) > 0
 	  && (BEG_UNCHANGED < start || GPT <= start))
 	unchanged_p = false;
 
@@ -15216,8 +15216,8 @@ text_outside_line_unchanged_p (struct window *w,
 	 require redisplaying the whole paragraph.  It might be worthwhile
 	 to find the paragraph limits and widen the range of redisplayed
 	 lines to that, but for now just give up this optimization.  */
-      if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
-	  && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
+      if (!NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), bidi_display_reordering))
+	  && NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), bidi_paragraph_direction)))
 	unchanged_p = false;
     }
 
@@ -17395,8 +17395,8 @@ try_scrolling (Lisp_Object window, bool just_this_one_p,
       int scroll_lines = clip_to_bounds (0, scroll_lines_max, 1000000);
       scroll_max = scroll_lines * frame_line_height;
     }
-  else if (NUMBERP (BVAR (current_buffer, scroll_down_aggressively))
-	   || NUMBERP (BVAR (current_buffer, scroll_up_aggressively)))
+  else if (NUMBERP (BVAR_OR_DEFAULT (current_buffer, scroll_down_aggressively))
+	   || NUMBERP (BVAR_OR_DEFAULT (current_buffer, scroll_up_aggressively)))
     /* We're trying to scroll because of aggressive scrolling but no
        scroll_step is set.  Choose an arbitrary one.  */
     scroll_max = 10 * frame_line_height;
@@ -17494,7 +17494,7 @@ try_scrolling (Lisp_Object window, bool just_this_one_p,
 	amount_to_scroll = scroll_max;
       else
 	{
-	  aggressive = BVAR (current_buffer, scroll_up_aggressively);
+	  aggressive = BVAR_OR_DEFAULT (current_buffer, scroll_up_aggressively);
 	  height = WINDOW_BOX_TEXT_HEIGHT (w);
 	  if (NUMBERP (aggressive))
 	    {
@@ -17610,7 +17610,8 @@ try_scrolling (Lisp_Object window, bool just_this_one_p,
 	    amount_to_scroll = scroll_max;
 	  else
 	    {
-	      aggressive = BVAR (current_buffer, scroll_down_aggressively);
+	      aggressive = BVAR_OR_DEFAULT (current_buffer,
+					   scroll_down_aggressively);
 	      height = WINDOW_BOX_TEXT_HEIGHT (w);
 	      if (NUMBERP (aggressive))
 		{
@@ -17997,7 +17998,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp,
 	      must_scroll = true;
 	    }
 	  else if (rc != CURSOR_MOVEMENT_SUCCESS
-		   && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
+		   && !NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), bidi_display_reordering)))
 	    {
 	      struct glyph_row *row1;
 
@@ -18061,7 +18062,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp,
 	  else if (scroll_p)
 	    rc = CURSOR_MOVEMENT_MUST_SCROLL;
 	  else if (rc != CURSOR_MOVEMENT_SUCCESS
-		   && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
+		   && !NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), bidi_display_reordering)))
 	    {
 	      /* With bidi-reordered rows, there could be more than
 		 one candidate row whose start and end positions
@@ -18906,8 +18907,8 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
        || (scroll_minibuffer_conservatively && MINI_WINDOW_P (w))
        || 0 < emacs_scroll_step
        || temp_scroll_step
-       || NUMBERP (BVAR (current_buffer, scroll_up_aggressively))
-       || NUMBERP (BVAR (current_buffer, scroll_down_aggressively)))
+       || NUMBERP (BVAR_OR_DEFAULT (current_buffer, scroll_up_aggressively))
+       || NUMBERP (BVAR_OR_DEFAULT (current_buffer, scroll_down_aggressively)))
       && CHARPOS (startp) >= BEGV
       && CHARPOS (startp) <= ZV)
     {
@@ -18981,8 +18982,8 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
       scrolling_up = PT > margin_pos;
       aggressive =
 	scrolling_up
-	? BVAR (current_buffer, scroll_up_aggressively)
-	: BVAR (current_buffer, scroll_down_aggressively);
+	? BVAR_OR_DEFAULT (current_buffer, scroll_up_aggressively)
+	: BVAR_OR_DEFAULT (current_buffer, scroll_down_aggressively);
 
       if (!MINI_WINDOW_P (w)
 	  && (scroll_conservatively > SCROLL_LIMIT || NUMBERP (aggressive)))
@@ -19917,7 +19918,7 @@ try_window_reusing_current_matrix (struct window *w)
 		 bidi-reordered glyph rows.  Let set_cursor_from_row
 		 figure out where to put the cursor, and if it fails,
 		 give up.  */
-	      if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
+	      if (!NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), bidi_display_reordering)))
 		{
 		  if (!set_cursor_from_row (w, row, w->current_matrix,
 					    0, 0, 0, 0))
@@ -20236,7 +20237,7 @@ row_containing_pos (struct window *w, ptrdiff_t charpos,
 	{
 	  struct glyph *g;
 
-	  if (NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
+	  if (NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), bidi_display_reordering))
 	      || (!best_row && !row->continued_p))
 	    return row;
 	  /* In bidi-reordered rows, there could be several rows whose
@@ -20406,7 +20407,7 @@ try_window_id (struct window *w)
      wrapped line can change the wrap position, altering the line
      above it.  It might be worthwhile to handle this more
      intelligently, but for now just redisplay from scratch.  */
-  if (!NILP (BVAR (XBUFFER (w->contents), word_wrap)))
+  if (!NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), word_wrap)))
     GIVE_UP (21);
 
   /* Under bidi reordering, adding or deleting a character in the
@@ -20417,13 +20418,13 @@ try_window_id (struct window *w)
      to find the paragraph limits and widen the range of redisplayed
      lines to that, but for now just give up this optimization and
      redisplay from scratch.  */
-  if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
-      && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
+  if (!NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), bidi_display_reordering))
+      && NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), bidi_paragraph_direction)))
     GIVE_UP (22);
 
   /* Give up if the buffer has line-spacing set, as Lisp-level changes
      to that variable require thorough redisplay.  */
-  if (!NILP (BVAR (XBUFFER (w->contents), extra_line_spacing)))
+  if (!NILP (BVAR_OR_DEFAULT (XBUFFER(w->contents), extra_line_spacing)))
     GIVE_UP (23);
 
   /* Give up if display-line-numbers is in relative mode, or when the
@@ -23532,7 +23533,7 @@ display_line (struct it *it, int cursor_vpos)
 	      if (!row_has_glyphs)
 		row->displays_text_p = false;
 
-	      if (!NILP (BVAR (XBUFFER (it->w->contents), indicate_empty_lines))
+	      if (!NILP (BVAR_OR_DEFAULT (XBUFFER (it->w->contents), indicate_empty_lines))
 		  && (!MINI_WINDOW_P (it->w)))
 		row->indicate_empty_line_p = true;
 	    }
@@ -24306,14 +24307,14 @@ See also `bidi-paragraph-direction'.  */)
       buf = XBUFFER (buffer);
     }
 
-  if (NILP (BVAR (buf, bidi_display_reordering))
+  if (NILP (BVAR_OR_DEFAULT (buf, bidi_display_reordering))
       || NILP (BVAR (buf, enable_multibyte_characters))
       /* When we are loading loadup.el, the character property tables
 	 needed for bidi iteration are not yet available.  */
       || redisplay__inhibit_bidi)
     return Qleft_to_right;
-  else if (!NILP (BVAR (buf, bidi_paragraph_direction)))
-    return BVAR (buf, bidi_paragraph_direction);
+  else if (!NILP (BVAR_OR_DEFAULT (buf, bidi_paragraph_direction)))
+    return BVAR_OR_DEFAULT (buf, bidi_paragraph_direction);
   else
     {
       /* Determine the direction from buffer text.  We could try to
@@ -24457,7 +24458,7 @@ the `bidi-class' property of a character.  */)
     {
       /* Nothing this fancy can happen in unibyte buffers, or in a
 	 buffer that disabled reordering, or if FROM is at EOB.  */
-      if (NILP (BVAR (buf, bidi_display_reordering))
+      if (NILP (BVAR_OR_DEFAULT (buf, bidi_display_reordering))
 	  || NILP (BVAR (buf, enable_multibyte_characters))
 	  /* When we are loading loadup.el, the character property
 	     tables needed for bidi iteration are not yet
@@ -25412,7 +25413,7 @@ display_mode_lines (struct window *w)
       /* Select mode line face based on the real selected window.  */
       display_mode_line (w, CURRENT_MODE_LINE_FACE_ID_3 (sel_w, sel_w, w),
 			 NILP (window_mode_line_format)
-			 ? BVAR (current_buffer, mode_line_format)
+			 ? BVAR_OR_DEFAULT (current_buffer, mode_line_format)
 			 : window_mode_line_format);
       ++n;
     }
@@ -25424,7 +25425,7 @@ display_mode_lines (struct window *w)
 
       display_mode_line (w, TAB_LINE_FACE_ID,
 			 NILP (window_tab_line_format)
-			 ? BVAR (current_buffer, tab_line_format)
+			 ? BVAR_OR_DEFAULT (current_buffer, tab_line_format)
 			 : window_tab_line_format);
       ++n;
     }
@@ -25436,7 +25437,7 @@ display_mode_lines (struct window *w)
 
       display_mode_line (w, HEADER_LINE_FACE_ID,
 			 NILP (window_header_line_format)
-			 ? BVAR (current_buffer, header_line_format)
+			 ? BVAR_OR_DEFAULT (current_buffer, header_line_format)
 			 : window_header_line_format);
       ++n;
     }
@@ -26971,7 +26972,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
 					 (FRAME_TERMINAL_CODING (f)->id),
 					 p, false);
 	  }
-	p = decode_mode_spec_coding (BVAR (b, buffer_file_coding_system),
+	p = decode_mode_spec_coding (BVAR_OR_DEFAULT (b, buffer_file_coding_system),
 				     p, eol_flag);
 
 #if false /* This proves to be annoying; I think we can do without. -- rms.  */
@@ -27035,8 +27036,8 @@ display_count_lines (ptrdiff_t start_byte,
   /* If we are not in selective display mode,
      check only for newlines.  */
   bool selective_display
-    = (!NILP (BVAR (current_buffer, selective_display))
-       && !FIXNUMP (BVAR (current_buffer, selective_display)));
+    = (!NILP (BVAR_OR_DEFAULT (current_buffer, selective_display))
+       && !FIXNUMP (BVAR_OR_DEFAULT (current_buffer, selective_display)));
 
   if (count > 0)
     {
@@ -31350,13 +31351,14 @@ get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
     {
       if (w == XWINDOW (echo_area_window))
 	{
-	  if (EQ (BVAR (b, cursor_type), Qt) || NILP (BVAR (b, cursor_type)))
+	  if (EQ (BVAR_OR_DEFAULT (b, cursor_type), Qt) || NILP (BVAR_OR_DEFAULT (b, cursor_type)))
 	    {
 	      *width = FRAME_CURSOR_WIDTH (f);
 	      return FRAME_DESIRED_CURSOR (f);
 	    }
 	  else
-	    return get_specified_cursor_type (BVAR (b, cursor_type), width);
+	    return get_specified_cursor_type (BVAR_OR_DEFAULT (b, cursor_type),
+					      width);
 	}
 
       *active_cursor = false;
@@ -31378,23 +31380,24 @@ get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
     }
 
   /* Never display a cursor in a window in which cursor-type is nil.  */
-  if (NILP (BVAR (b, cursor_type)))
+  if (NILP (BVAR_OR_DEFAULT (b, cursor_type)))
     return NO_CURSOR;
 
   /* Get the normal cursor type for this window.  */
-  if (EQ (BVAR (b, cursor_type), Qt))
+  if (EQ (BVAR_OR_DEFAULT (b, cursor_type), Qt))
     {
       cursor_type = FRAME_DESIRED_CURSOR (f);
       *width = FRAME_CURSOR_WIDTH (f);
     }
   else
-    cursor_type = get_specified_cursor_type (BVAR (b, cursor_type), width);
+    cursor_type = get_specified_cursor_type (BVAR_OR_DEFAULT (b, cursor_type),
+					     width);
 
   /* Use cursor-in-non-selected-windows instead
      for non-selected window or frame.  */
   if (non_selected)
     {
-      alt_cursor = BVAR (b, cursor_in_non_selected_windows);
+      alt_cursor = BVAR_OR_DEFAULT (b, cursor_in_non_selected_windows);
       if (!EQ (Qt, alt_cursor))
 	return get_specified_cursor_type (alt_cursor, width);
       /* t means modify the normal cursor type.  */
@@ -31428,7 +31431,7 @@ get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
 		     should cover most of the "tiny" icons people may
 		     use.  */
 		  if (!img->mask
-		      || (CONSP (BVAR (b, cursor_type))
+		      || (CONSP (BVAR_OR_DEFAULT (b, cursor_type))
 			  && img->width > max (*width, WINDOW_FRAME_COLUMN_WIDTH (w))
 			  && img->height > max (*width, WINDOW_FRAME_LINE_HEIGHT (w))))
 		    cursor_type = HOLLOW_BOX_CURSOR;
@@ -31448,7 +31451,7 @@ get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
   /* Cursor is blinked off, so determine how to "toggle" it.  */
 
   /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist.  */
-  if ((alt_cursor = Fassoc (BVAR (b, cursor_type), Vblink_cursor_alist, Qnil), !NILP (alt_cursor)))
+  if ((alt_cursor = Fassoc (BVAR_OR_DEFAULT (b, cursor_type), Vblink_cursor_alist, Qnil), !NILP (alt_cursor)))
     return get_specified_cursor_type (XCDR (alt_cursor), width);
 
   /* Then see if frame has specified a specific blink off cursor type.  */
@@ -33853,11 +33856,10 @@ note_mouse_highlight (struct frame *f, int x, int y)
 		     necessarily display the character whose position
 		     is the smallest.  */
 		  Lisp_Object lim1
-		    = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
+		    = NILP (BVAR_OR_DEFAULT (XBUFFER(buffer), bidi_display_reordering))
 		    ? Fmarker_position (w->start)
 		    : Qnil;
-		  Lisp_Object lim2
-		    = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
+		  Lisp_Object lim2 = NILP (BVAR_OR_DEFAULT (XBUFFER(buffer), bidi_display_reordering))
 		    ? make_fixnum (BUF_Z (XBUFFER (buffer))
 				   - w->window_end_pos)
 		    : Qnil;
diff --git a/test/src/data-tests.el b/test/src/data-tests.el
index b1e5fa0767..eae2109fe6 100644
--- a/test/src/data-tests.el
+++ b/test/src/data-tests.el
@@ -424,7 +424,6 @@ comparing the subr with a much slower lisp implementation."
   (with-no-warnings (should (setq :keyword :keyword))))
 
 (ert-deftest data-tests--set-default-per-buffer ()
-  :expected-result t ;; Not fixed yet!
   ;; FIXME: Performance tests are inherently unreliable.
   ;; Using wall-clock time makes it even worse, so don't bother unless
   ;; we have the primitive to measure cpu-time.
-- 
2.31.1