diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index dd122be35bf..855bd3811e2 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -880,7 +880,6 @@ set_breakpoint_condition (struct breakpoint *b, const char *exp,
 	{
 	  struct watchpoint *w = (struct watchpoint *) b;
 
-	  innermost_block.reset ();
 	  arg = exp;
 	  w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
 	  if (*arg)
@@ -10602,7 +10601,6 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   /* Parse the rest of the arguments.  From here on out, everything
      is in terms of a newly allocated string instead of the original
      ARG.  */
-  innermost_block.reset ();
   std::string expression (arg, exp_end - arg);
   exp_start = arg = expression.c_str ();
   expression_up exp = parse_exp_1 (&arg, 0, 0, 0);
@@ -10664,7 +10662,6 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   toklen = end_tok - tok;
   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
     {
-      innermost_block.reset ();
       tok = cond_start = end_tok + 1;
       parse_exp_1 (&tok, 0, 0, 0);
 
diff --git a/gdb/expression.h b/gdb/expression.h
index 9104ce61c0f..36f18be6af6 100644
--- a/gdb/expression.h
+++ b/gdb/expression.h
@@ -23,6 +23,23 @@
 
 #include "symtab.h"		/* Needed for "struct block" type.  */
 
+/* While parsing expressions we need to track the innermost lexical block
+   that we encounter.  In some situations we need to track the innermost
+   block just for symbols, and in other situations we want to track the
+   innermost block for symbols and registers.  These flags are used by the
+   innermost block tracker to control which blocks we consider for the
+   innermost block.  These flags can be combined together as needed.  */
+
+enum innermost_block_tracker_type
+{
+  /* Track the innermost block for symbols within an expression.  */
+  INNERMOST_BLOCK_FOR_SYMBOLS = (1 << 0),
+
+  /* Track the innermost block for registers within an expression.  */
+  INNERMOST_BLOCK_FOR_REGISTERS = (1 << 1)
+};
+DEF_ENUM_FLAGS_TYPE (enum innermost_block_tracker_type,
+		     innermost_block_tracker_types);
 
 /* Definitions for saved C expressions.  */
 
@@ -105,7 +122,9 @@ extern struct type *parse_expression_for_completion
     (const char *, gdb::unique_xmalloc_ptr<char> *, enum type_code *);
 
 extern expression_up parse_exp_1 (const char **, CORE_ADDR pc,
-				  const struct block *, int);
+				  const struct block *, int,
+				  innermost_block_tracker_types
+				    = INNERMOST_BLOCK_FOR_SYMBOLS);
 
 /* For use by parsers; set if we want to parse an expression and
    attempt completion.  */
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index 7d36a2a7114..1c95e068842 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -670,12 +670,6 @@ objfile::~objfile ()
      for example), so we need to call this here.  */
   clear_pc_function_cache ();
 
-  /* Clear globals which might have pointed into a removed objfile.
-     FIXME: It's not clear which of these are supposed to persist
-     between expressions and which ought to be reset each time.  */
-  expression_context_block = NULL;
-  innermost_block.reset ();
-
   /* Check to see if the current_source_symtab belongs to this objfile,
      and if so, call clear_current_source_symtab_and_line.  */
 
diff --git a/gdb/parse.c b/gdb/parse.c
index 661574e544e..c76e0d52c90 100644
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -116,10 +116,8 @@ static int prefixify_subexp (struct expression *, struct expression *, int,
 
 static expression_up parse_exp_in_context (const char **, CORE_ADDR,
 					   const struct block *, int,
-					   int, int *);
-static expression_up parse_exp_in_context_1 (const char **, CORE_ADDR,
-					     const struct block *, int,
-					     int, int *);
+					   int, int *,
+					   innermost_block_tracker_types);
 
 /* Documented at it's declaration.  */
 
@@ -1095,18 +1093,10 @@ prefixify_subexp (struct expression *inexpr,
 
 expression_up
 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
-	     int comma)
+	     int comma, innermost_block_tracker_types tracker_types)
 {
-  return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL);
-}
-
-static expression_up
-parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
-		      const struct block *block,
-		      int comma, int void_context_p, int *out_subexp)
-{
-  return parse_exp_in_context_1 (stringptr, pc, block, comma,
-				 void_context_p, out_subexp);
+  return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL,
+			       tracker_types);
 }
 
 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
@@ -1117,9 +1107,10 @@ parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
    is left untouched.  */
 
 static expression_up
-parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
-			const struct block *block,
-			int comma, int void_context_p, int *out_subexp)
+parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
+		      const struct block *block,
+		      int comma, int void_context_p, int *out_subexp,
+		      innermost_block_tracker_types tracker_types)
 {
   const struct language_defn *lang = NULL;
   int subexp;
@@ -1132,6 +1123,7 @@ parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
   expout_last_struct = -1;
   expout_tag_completion_type = TYPE_CODE_UNDEF;
   expout_completion_name.reset ();
+  innermost_block.reset (tracker_types);
 
   comma_terminates = comma;
 
@@ -1286,7 +1278,8 @@ parse_expression_for_completion (const char *string,
   TRY
     {
       parse_completion = 1;
-      exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
+      exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp,
+				  INNERMOST_BLOCK_FOR_SYMBOLS);
     }
   CATCH (except, RETURN_MASK_ERROR)
     {
diff --git a/gdb/parser-defs.h b/gdb/parser-defs.h
index a607eea2493..26e0a836c11 100644
--- a/gdb/parser-defs.h
+++ b/gdb/parser-defs.h
@@ -75,24 +75,6 @@ extern const struct block *expression_context_block;
    then look up the macro definitions active at that point.  */
 extern CORE_ADDR expression_context_pc;
 
-/* While parsing expressions we need to track the innermost lexical block
-   that we encounter.  In some situations we need to track the innermost
-   block just for symbols, and in other situations we want to track the
-   innermost block for symbols and registers.  These flags are used by the
-   innermost block tracker to control which blocks we consider for the
-   innermost block.  These flags can be combined together as needed.  */
-
-enum innermost_block_tracker_type
-{
-  /* Track the innermost block for symbols within an expression.  */
-  INNERMOST_BLOCK_FOR_SYMBOLS = (1 << 0),
-
-  /* Track the innermost block for registers within an expression.  */
-  INNERMOST_BLOCK_FOR_REGISTERS = (1 << 1)
-};
-DEF_ENUM_FLAGS_TYPE (enum innermost_block_tracker_type,
-		     innermost_block_tracker_types);
-
 /* When parsing expressions we track the innermost block that was
    referenced.  */
 
@@ -146,8 +128,9 @@ private:
 };
 
 /* The innermost context required by the stack and register variables
-   we've encountered so far.  This should be cleared before parsing an
-   expression, and queried once the parse is complete.  */
+   we've encountered so far.  This is cleared by the expression
+   parsing functions before parsing an expression, and can queried
+   once the parse is complete.  */
 extern innermost_block_tracker innermost_block;
 
 /* Number of arguments seen so far in innermost function call.  */
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index c442bb4e07e..e3f2f2e591c 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -1715,7 +1715,6 @@ display_command (const char *arg, int from_tty)
       fmt.raw = 0;
     }
 
-  innermost_block.reset ();
   expression_up expr = parse_expression (exp);
 
   newobj = new display ();
@@ -1883,7 +1882,6 @@ do_one_display (struct display *d)
 
       TRY
 	{
-	  innermost_block.reset ();
 	  d->exp = parse_expression (d->exp_string);
 	  d->block = innermost_block.block ();
 	}
diff --git a/gdb/symfile.c b/gdb/symfile.c
index 68ec491d357..dbfc306c521 100644
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -2901,12 +2901,6 @@ clear_symtab_users (symfile_add_flags add_flags)
   clear_pc_function_cache ();
   gdb::observers::new_objfile.notify (NULL);
 
-  /* Clear globals which might have pointed into a removed objfile.
-     FIXME: It's not clear which of these are supposed to persist
-     between expressions and which ought to be reset each time.  */
-  expression_context_block = NULL;
-  innermost_block.reset ();
-
   /* Varobj may refer to old symbols, perform a cleanup.  */
   varobj_invalidate ();
 
diff --git a/gdb/varobj.c b/gdb/varobj.c
index 3715bb6a7df..b2975be6b77 100644
--- a/gdb/varobj.c
+++ b/gdb/varobj.c
@@ -309,13 +309,13 @@ varobj_create (const char *objname,
 	}
 
       p = expression;
-      innermost_block.reset (INNERMOST_BLOCK_FOR_SYMBOLS
-			     | INNERMOST_BLOCK_FOR_REGISTERS);
       /* Wrap the call to parse expression, so we can 
          return a sensible error.  */
       TRY
 	{
-	  var->root->exp = parse_exp_1 (&p, pc, block, 0);
+	  var->root->exp = parse_exp_1 (&p, pc, block, 0,
+					INNERMOST_BLOCK_FOR_SYMBOLS
+					| INNERMOST_BLOCK_FOR_REGISTERS);
 	}
 
       CATCH (except, RETURN_MASK_ERROR)
