Re: [PATCH 2/4] allow poisoning input_location in ranges it should not be used

[Martin Sebor <msebor@gmail.com>]

On 7/2/21 5:47 PM, Trevor Saunders wrote:
> On Fri, Jul 02, 2021 at 01:20:14PM -0600, Martin Sebor wrote:
>> On 6/29/21 11:35 PM, Trevor Saunders wrote:
>>> This makes it possible to assert if input_location is used during the lifetime
>>> of a scope.  This will allow us to find places that currently use it within a
>>> function and its callees, or prevent adding uses within the lifetime of a
>>> function after all existing uses are removed.
>>
>> I of course support removing global state but I have questions about
>> this approach.  I'm probably missing some context but I don't
>> understand how it's better than replacing the variables with
>> functions now (defining the variables as static in some .c file).
> 
> Other than requiring either hiding the function calls behind a macro,
> rahter than operator overloading, or needing to update all references I
> think they do more or less the same thing.
> 
>> Also, it seems as though the mechanism to enforce this policy of not
>> using global variables directly is to trigger an ICE when the piece
>> code that does end up using runs.  If this is correct, I would be
>> very uncomfortable with this approach, and not just because it would
>> expose our users to a GCC-internal policy but generally because
>> the enforcement of a policy should happen as early as possible so
>> that violators can fix them before they submit code for review.
> 
> Perhaps the asserts should be gcc_checking_assert, to avoid any overhead
> in release builds if nothing else.  One would really like to think that
> the changed code is covered by the testsuite, if not exercised in
> bootstraps, so in most cases it would be caught before patches are
> submitted.  Certainly something will eventually slip through, probably
> because it depends on the host or target, but that should be the
> exception.

It's always the exception when these things slip through, but they
do.  I don't think the risks in this case justify the benefits of
enforcing an internal policy whose violations are otherwise entirely
benign.

   Its a rather useful property to know that a global's value
> is not significant in a scope, to say remove save and restore of
> input_location, or even more importantly remove push / pop of cfun, and
> I can't see a way to do that statically, other than possibly a IPA
> pass that depends on a LTO build, or analysis of the binary either of
> which would be orders of magnitude more work.

My concern is that poisoning a variable in one scope/file could
expose latent violations in other files far removed from it, and
that could easily happen under conditions not be exercised during
testing because of less than complete coverage.  We would have to
carry this risk potentially for a number of releases, until a full
replacement took place.

IMO, a safer and less costly solution to the global state problem
is to fully remove accesses to one variable at a time, replacing
each with the preferred alternative.  A piecemeal approach seems
fraught with too much risk for what to me seems like very little
immediate gain.  I don't see a value in enforcing this policy one
scope at a time.

Martin

> 
>> Finally, I've been under the impression that defining global objects
>> that require dynamic initialization is discouraged in GCC.  This patch
>> seems to do just that: define poisonable objects in each file that
>> defines such a variable.  I don't see any uses of auto_poison in
>> this patch, so it looks as though the poisonable definitions aren't
>> actually doing anything useful yet but might start enforcing
>> the policy if some other patch defines an auto_poison variable
>> referring to the same global in a file/scope from which functions
>> changed in this patch that access the variable are called?  (This
>> probably exposes my overall confusion with how this works.)
> 
> As for dynamic initialization, that's technically true, but would be
> fixed by making the constructor constexpr.
> The first three patches in the series do just add infrastructure with
> out making use of it to actually block anything, and the final patch
> blocks usage in a minimal function as a somewhat toyish example of what
> can be done.
> 
> thanks
> 
> Trev
> 
>>
>> Martin
>>
>>>
>>> bootstrapped and regtested on x86_64-linux-gnu, ok?
>>>
>>> Trev
>>>
>>> gcc/cp/ChangeLog:
>>>
>>> 	* call.c (add_builtin_candidate): Adjust.
>>> 	* decl.c (compute_array_index_type_loc): Likewise.
>>> 	* decl2.c (get_guard_cond): Likewise.
>>> 	(one_static_initialization_or_destruction): Likewise.
>>> 	(do_static_initialization_or_destruction): Likewise.
>>> 	* init.c (build_new_1): Likewise.
>>> 	(build_vec_init): Likewise.
>>> 	* module.cc (finish_module_processing): Likewise.
>>> 	* parser.c (cp_convert_range_for): Likewise.
>>> 	(cp_parser_perform_range_for_lookup): Likewise.
>>> 	(cp_parser_omp_for_incr): Likewise.
>>> 	(cp_convert_omp_range_for): Likewise.
>>> 	* pt.c (fold_expression): Likewise.
>>> 	(tsubst_copy_and_build): Likewise.
>>> 	* typeck.c (common_pointer_type): Likewise.
>>> 	(cp_build_array_ref): Likewise.
>>> 	(get_member_function_from_ptrfunc): Likewise.
>>> 	(cp_build_unary_op): Likewise.
>>> 	(convert_ptrmem): Likewise.
>>> 	(cp_build_modify_expr): Likewise.
>>> 	(build_ptrmemfunc): Likewise.
>>>
>>> gcc/ChangeLog:
>>>
>>> 	* diagnostic.c (internal_error): Remove use of input_location.
>>> 	* input.c (input_location): Change type to poisonable<location_t>.
>>> 	* input.h (input_location): Adjust prototype.
>>>
>>> gcc/objc/ChangeLog:
>>>
>>> 	* objc-next-runtime-abi-02.c (build_v2_objc_method_fixup_call): Adjust.
>>> ---
>>>    gcc/cp/call.c                       |  2 +-
>>>    gcc/cp/decl.c                       |  2 +-
>>>    gcc/cp/decl2.c                      | 12 +++++------
>>>    gcc/cp/init.c                       | 14 ++++++------
>>>    gcc/cp/module.cc                    |  2 +-
>>>    gcc/cp/parser.c                     | 11 +++++-----
>>>    gcc/cp/pt.c                         |  4 ++--
>>>    gcc/cp/typeck.c                     | 33 ++++++++++++++++-------------
>>>    gcc/diagnostic.c                    |  2 +-
>>>    gcc/input.c                         |  2 +-
>>>    gcc/input.h                         |  3 ++-
>>>    gcc/objc/objc-next-runtime-abi-02.c |  2 +-
>>>    12 files changed, 47 insertions(+), 42 deletions(-)
>>>
>>> diff --git a/gcc/cp/call.c b/gcc/cp/call.c
>>> index e4df72ec1a3..c94fe0b3bd2 100644
>>> --- a/gcc/cp/call.c
>>> +++ b/gcc/cp/call.c
>>> @@ -3126,7 +3126,7 @@ add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
>>>        {
>>>          if (TYPE_PTR_OR_PTRMEM_P (type1))
>>>    	{
>>> -	  tree cptype = composite_pointer_type (input_location,
>>> +	  tree cptype = composite_pointer_type (op_location_t (input_location),
>>>    						type1, type2,
>>>    						error_mark_node,
>>>    						error_mark_node,
>>> diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
>>> index fa6af6fec11..84e2bdae6bf 100644
>>> --- a/gcc/cp/decl.c
>>> +++ b/gcc/cp/decl.c
>>> @@ -10884,7 +10884,7 @@ compute_array_index_type_loc (location_t name_loc, tree name, tree size,
>>>    	 cp_build_binary_op will be appropriately folded.  */
>>>          {
>>>    	processing_template_decl_sentinel s;
>>> -	itype = cp_build_binary_op (input_location,
>>> +	itype = cp_build_binary_op (op_location_t (input_location),
>>>    				    MINUS_EXPR,
>>>    				    cp_convert (ssizetype, size, complain),
>>>    				    cp_convert (ssizetype, integer_one_node,
>>> diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
>>> index 090a83bd670..ddb7e248c63 100644
>>> --- a/gcc/cp/decl2.c
>>> +++ b/gcc/cp/decl2.c
>>> @@ -3386,7 +3386,7 @@ get_guard_cond (tree guard, bool thread_safe)
>>>          guard_value = integer_one_node;
>>>          if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
>>>    	guard_value = fold_convert (TREE_TYPE (guard), guard_value);
>>> -      guard = cp_build_binary_op (input_location,
>>> +      guard = cp_build_binary_op (location_t (input_location),
>>>    				  BIT_AND_EXPR, guard, guard_value,
>>>    				  tf_warning_or_error);
>>>        }
>>> @@ -3394,7 +3394,7 @@ get_guard_cond (tree guard, bool thread_safe)
>>>      guard_value = integer_zero_node;
>>>      if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
>>>        guard_value = fold_convert (TREE_TYPE (guard), guard_value);
>>> -  return cp_build_binary_op (input_location,
>>> +  return cp_build_binary_op (location_t (input_location),
>>>    			     EQ_EXPR, guard, guard_value,
>>>    			     tf_warning_or_error);
>>>    }
>>> @@ -4056,7 +4056,7 @@ one_static_initialization_or_destruction (tree decl, tree init, bool initp)
>>>    	 last to destroy the variable.  */
>>>          else if (initp)
>>>    	guard_cond
>>> -	  = cp_build_binary_op (input_location,
>>> +	  = cp_build_binary_op (location_t (input_location),
>>>    				EQ_EXPR,
>>>    				cp_build_unary_op (PREINCREMENT_EXPR,
>>>    						   guard,
>>> @@ -4066,7 +4066,7 @@ one_static_initialization_or_destruction (tree decl, tree init, bool initp)
>>>    				tf_warning_or_error);
>>>          else
>>>    	guard_cond
>>> -	  = cp_build_binary_op (input_location,
>>> +	  = cp_build_binary_op (location_t (input_location),
>>>    				EQ_EXPR,
>>>    				cp_build_unary_op (PREDECREMENT_EXPR,
>>>    						   guard,
>>> @@ -4132,7 +4132,7 @@ do_static_initialization_or_destruction (tree vars, bool initp)
>>>      /* Build the outer if-stmt to check for initialization or destruction.  */
>>>      init_if_stmt = begin_if_stmt ();
>>>      cond = initp ? integer_one_node : integer_zero_node;
>>> -  cond = cp_build_binary_op (input_location,
>>> +  cond = cp_build_binary_op (location_t (input_location),
>>>    			     EQ_EXPR,
>>>    			     initialize_p_decl,
>>>    			     cond,
>>> @@ -4176,7 +4176,7 @@ do_static_initialization_or_destruction (tree vars, bool initp)
>>>        /* Conditionalize this initialization on being in the right priority
>>>           and being initializing/finalizing appropriately.  */
>>>        priority_if_stmt = begin_if_stmt ();
>>> -    cond = cp_build_binary_op (input_location,
>>> +    cond = cp_build_binary_op (location_t (input_location),
>>>    			       EQ_EXPR,
>>>    			       priority_decl,
>>>    			       build_int_cst (NULL_TREE, priority),
>>> diff --git a/gcc/cp/init.c b/gcc/cp/init.c
>>> index 88f6f90a800..d9acdefae7c 100644
>>> --- a/gcc/cp/init.c
>>> +++ b/gcc/cp/init.c
>>> @@ -2907,7 +2907,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
>>>    	  nelts = error_mark_node;
>>>    	}
>>>          if (nelts != error_mark_node)
>>> -	nelts = cp_build_binary_op (input_location,
>>> +	nelts = cp_build_binary_op (location_t (input_location),
>>>    				    MULT_EXPR, nelts,
>>>    				    inner_nelts_cst,
>>>    				    complain);
>>> @@ -3428,7 +3428,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
>>>                }
>>>    	  init_expr
>>>    	    = build_vec_init (data_addr,
>>> -			      cp_build_binary_op (input_location,
>>> +			      cp_build_binary_op (location_t (input_location),
>>>    						  MINUS_EXPR, outer_nelts,
>>>    						  integer_one_node,
>>>    						  complain),
>>> @@ -3600,12 +3600,12 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
>>>        {
>>>          if (check_new)
>>>    	{
>>> -	  tree ifexp = cp_build_binary_op (input_location,
>>> +	  tree ifexp = cp_build_binary_op (location_t (input_location),
>>>    					   NE_EXPR, alloc_node,
>>>    					   nullptr_node,
>>>    					   complain);
>>> -	  rval = build_conditional_expr (input_location, ifexp, rval,
>>> -					 alloc_node, complain);
>>> +	  rval = build_conditional_expr (location_t (input_location), ifexp,
>>> +					 rval, alloc_node, complain);
>>>    	}
>>>          /* Perform the allocation before anything else, so that ALLOC_NODE
>>> @@ -4612,14 +4612,14 @@ build_vec_init (tree base, tree maxindex, tree init,
>>>          && from_array != 2)
>>>        {
>>>          tree e;
>>> -      tree m = cp_build_binary_op (input_location,
>>> +      tree m = cp_build_binary_op (location_t (input_location),
>>>    				   MINUS_EXPR, maxindex, iterator,
>>>    				   complain);
>>>          /* Flatten multi-dimensional array since build_vec_delete only
>>>    	 expects one-dimensional array.  */
>>>          if (TREE_CODE (type) == ARRAY_TYPE)
>>> -	m = cp_build_binary_op (input_location,
>>> +	m = cp_build_binary_op (location_t (input_location),
>>>    				MULT_EXPR, m,
>>>    				/* Avoid mixing signed and unsigned.  */
>>>    				convert (TREE_TYPE (m),
>>> diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc
>>> index f259515a498..72f32487e51 100644
>>> --- a/gcc/cp/module.cc
>>> +++ b/gcc/cp/module.cc
>>> @@ -19852,7 +19852,7 @@ finish_module_processing (cpp_reader *reader)
>>>    	  elf_out to (fd, e);
>>>    	  if (to.begin ())
>>>    	    {
>>> -	      auto loc = input_location;
>>> +	      location_t loc = input_location;
>>>    	      /* So crashes finger-point the module decl.  */
>>>    	      input_location = state->loc;
>>>    	      state->write (&to, reader);
>>> diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
>>> index 02daa7a6f6a..e90ee873a94 100644
>>> --- a/gcc/cp/parser.c
>>> +++ b/gcc/cp/parser.c
>>> @@ -13206,7 +13206,7 @@ cp_convert_range_for (tree statement, tree range_decl, tree range_expr,
>>>      finish_init_stmt (statement);
>>>      /* The new for condition.  */
>>> -  condition = build_x_binary_op (input_location, NE_EXPR,
>>> +  condition = build_x_binary_op (location_t (input_location), NE_EXPR,
>>>    				 begin, ERROR_MARK,
>>>    				 end, ERROR_MARK,
>>>    				 NULL, tf_warning_or_error);
>>> @@ -13326,7 +13326,7 @@ cp_parser_perform_range_for_lookup (tree range, tree *begin, tree *end)
>>>    	  if (!same_type_p (iter_type, cv_unqualified (TREE_TYPE (*end))))
>>>    	    {
>>>    	      if (cxx_dialect >= cxx17
>>> -		  && (build_x_binary_op (input_location, NE_EXPR,
>>> +		  && (build_x_binary_op (location_t (input_location), NE_EXPR,
>>>    					 *begin, ERROR_MARK,
>>>    					 *end, ERROR_MARK,
>>>    					 NULL, tf_none)
>>> @@ -39961,8 +39961,9 @@ cp_parser_omp_for_incr (cp_parser *parser, tree decl)
>>>    					tf_warning_or_error);
>>>    	    }
>>>    	  else
>>> -	    lhs = build_x_binary_op (input_location, op, lhs, ERROR_MARK, rhs,
>>> -				     ERROR_MARK, NULL, tf_warning_or_error);
>>> +	    lhs = build_x_binary_op (location_t (input_location), op, lhs,
>>> +				     ERROR_MARK, rhs, ERROR_MARK, NULL,
>>> +				     tf_warning_or_error);
>>>    	}
>>>        }
>>>      while (token->type == CPP_PLUS || token->type == CPP_MINUS);
>>> @@ -40309,7 +40310,7 @@ cp_convert_omp_range_for (tree &this_pre_body, vec<tree, va_gc> *for_block,
>>>      if (CLASS_TYPE_P (iter_type))
>>>        cond = build2 (NE_EXPR, boolean_type_node, begin, end);
>>>      else
>>> -    cond = build_x_binary_op (input_location, NE_EXPR,
>>> +    cond = build_x_binary_op (location_t (input_location), NE_EXPR,
>>>    			      begin, ERROR_MARK,
>>>    			      end, ERROR_MARK,
>>>    			      NULL, tf_warning_or_error);
>>> diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
>>> index f2039e09cd7..b679e34bfa4 100644
>>> --- a/gcc/cp/pt.c
>>> +++ b/gcc/cp/pt.c
>>> @@ -12624,7 +12624,7 @@ fold_expression (tree t, tree left, tree right, tsubst_flags_t complain)
>>>        case COMPOUND_EXPR:
>>>          return build_x_compound_expr (input_location, left, right, complain);
>>>        default:
>>> -      return build_x_binary_op (input_location, code,
>>> +      return build_x_binary_op (location_t (input_location), code,
>>>                                    left, TREE_CODE (left),
>>>                                    right, TREE_CODE (right),
>>>                                    /*overload=*/NULL,
>>> @@ -19854,7 +19854,7 @@ tsubst_copy_and_build (tree t,
>>>    	warning_sentinel s4(warn_tautological_compare, was_dep);
>>>    	tree r = build_x_binary_op
>>> -	  (input_location, TREE_CODE (t),
>>> +	  (location_t (input_location), TREE_CODE (t),
>>>    	   op0,
>>>    	   (warning_suppressed_p (TREE_OPERAND (t, 0))
>>>    	    ? ERROR_MARK
>>> diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
>>> index a483e1f988d..98aa9e69612 100644
>>> --- a/gcc/cp/typeck.c
>>> +++ b/gcc/cp/typeck.c
>>> @@ -982,7 +982,7 @@ common_pointer_type (tree t1, tree t2)
>>>                  || (TYPE_PTRDATAMEM_P (t1) && TYPE_PTRDATAMEM_P (t2))
>>>                  || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)));
>>> -  return composite_pointer_type (input_location, t1, t2,
>>> +  return composite_pointer_type (location_t (input_location), t1, t2,
>>>    				 error_mark_node, error_mark_node,
>>>                                     CPO_CONVERSION, tf_warning_or_error);
>>>    }
>>> @@ -3702,7 +3702,8 @@ cp_build_array_ref (location_t loc, tree array, tree idx,
>>>        warn_array_subscript_with_type_char (loc, idx);
>>> -    ret = cp_build_binary_op (input_location, PLUS_EXPR, ar, ind, complain);
>>> +    ret = cp_build_binary_op (location_t (input_location), PLUS_EXPR, ar, ind,
>>> +			      complain);
>>>        if (first)
>>>          ret = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (ret), first, ret);
>>>        ret = cp_build_indirect_ref (loc, ret, RO_ARRAY_INDEXING, complain);
>>> @@ -3793,10 +3794,10 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function,
>>>    	{
>>>    	  int flag_sanitize_save;
>>>    	case ptrmemfunc_vbit_in_pfn:
>>> -	  e1 = cp_build_binary_op (input_location,
>>> +	  e1 = cp_build_binary_op (location_t (input_location),
>>>    				   BIT_AND_EXPR, idx, integer_one_node,
>>>    				   complain);
>>> -	  idx = cp_build_binary_op (input_location,
>>> +	  idx = cp_build_binary_op (location_t (input_location),
>>>    				    MINUS_EXPR, idx, integer_one_node,
>>>    				    complain);
>>>    	  if (idx == error_mark_node)
>>> @@ -3804,7 +3805,7 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function,
>>>    	  break;
>>>    	case ptrmemfunc_vbit_in_delta:
>>> -	  e1 = cp_build_binary_op (input_location,
>>> +	  e1 = cp_build_binary_op (location_t (input_location),
>>>    				   BIT_AND_EXPR, delta, integer_one_node,
>>>    				   complain);
>>>    	  /* Don't instrument the RSHIFT_EXPR we're about to create because
>>> @@ -3812,7 +3813,7 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function,
>>>    	     well with SAVE_EXPRs therein.  */
>>>    	  flag_sanitize_save = flag_sanitize;
>>>    	  flag_sanitize = 0;
>>> -	  delta = cp_build_binary_op (input_location,
>>> +	  delta = cp_build_binary_op (location_t (input_location),
>>>    				      RSHIFT_EXPR, delta, integer_one_node,
>>>    				      complain);
>>>    	  flag_sanitize = flag_sanitize_save;
>>> @@ -3874,7 +3875,8 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function,
>>>    		     cp_build_addr_expr (e2, complain));
>>>          e2 = fold_convert (TREE_TYPE (e3), e2);
>>> -      e1 = build_conditional_expr (input_location, e1, e2, e3, complain);
>>> +      e1 = build_conditional_expr (location_t (input_location), e1, e2, e3,
>>> +				   complain);
>>>          if (e1 == error_mark_node)
>>>    	return error_mark_node;
>>> @@ -6754,7 +6756,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, bool noconvert,
>>>        case TRUTH_NOT_EXPR:
>>>          if (gnu_vector_type_p (TREE_TYPE (arg)))
>>> -	return cp_build_binary_op (input_location, EQ_EXPR, arg,
>>> +	return cp_build_binary_op (location_t (input_location), EQ_EXPR, arg,
>>>    				   build_zero_cst (TREE_TYPE (arg)), complain);
>>>          arg = perform_implicit_conversion (boolean_type_node, arg,
>>>    					 complain);
>>> @@ -7501,12 +7503,13 @@ convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
>>>    	  if (TREE_CODE (expr) == PTRMEM_CST)
>>>    	    expr = cplus_expand_constant (expr);
>>> -	  tree cond = cp_build_binary_op (input_location, EQ_EXPR, expr,
>>> +	  tree cond = cp_build_binary_op (location_t (input_location), EQ_EXPR,
>>> +					  expr,
>>>    					  build_int_cst (TREE_TYPE (expr), -1),
>>>    					  complain);
>>>    	  tree op1 = build_nop (ptrdiff_type_node, expr);
>>> -	  tree op2 = cp_build_binary_op (input_location, PLUS_EXPR, op1, delta,
>>> -					 complain);
>>> +	  tree op2 = cp_build_binary_op (location_t (input_location),
>>> +					 PLUS_EXPR, op1, delta, complain);
>>>    	  expr = fold_build3_loc (input_location,
>>>    				  COND_EXPR, ptrdiff_type_node, cond, op1, op2);
>>> @@ -8686,7 +8689,7 @@ cp_build_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
>>>    	tree op2 = TREE_OPERAND (lhs, 2);
>>>    	if (TREE_CODE (op2) != THROW_EXPR)
>>>    	  op2 = cp_build_modify_expr (loc, op2, modifycode, rhs, complain);
>>> -	tree cond = build_conditional_expr (input_location,
>>> +	tree cond = build_conditional_expr (location_t (input_location),
>>>    					    TREE_OPERAND (lhs, 0), op1, op2,
>>>    					    complain);
>>> @@ -8767,7 +8770,7 @@ cp_build_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
>>>    	    /* Do the default thing.  */;
>>>    	  else
>>>    	    {
>>> -	      result = build_new_op (input_location, MODIFY_EXPR,
>>> +	      result = build_new_op (location_t (input_location), MODIFY_EXPR,
>>>    				     LOOKUP_NORMAL, lhs, rhs,
>>>    				     make_node (NOP_EXPR), /*overload=*/NULL,
>>>    				     complain);
>>> @@ -9263,10 +9266,10 @@ build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p,
>>>          if (!integer_zerop (n))
>>>    	{
>>>    	  if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
>>> -	    n = cp_build_binary_op (input_location,
>>> +	    n = cp_build_binary_op (location_t (input_location),
>>>    				    LSHIFT_EXPR, n, integer_one_node,
>>>    				    complain);
>>> -	  delta = cp_build_binary_op (input_location,
>>> +	  delta = cp_build_binary_op (location_t (input_location),
>>>    				      PLUS_EXPR, delta, n, complain);
>>>    	}
>>>          return build_ptrmemfunc1 (to_type, delta, npfn);
>>> diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c
>>> index d58586f2526..3f68d1d79eb 100644
>>> --- a/gcc/diagnostic.c
>>> +++ b/gcc/diagnostic.c
>>> @@ -1835,7 +1835,7 @@ internal_error (const char *gmsgid, ...)
>>>      auto_diagnostic_group d;
>>>      va_list ap;
>>>      va_start (ap, gmsgid);
>>> -  rich_location richloc (line_table, input_location);
>>> +  rich_location richloc (line_table, UNKNOWN_LOCATION);
>>>      diagnostic_impl (&richloc, NULL, -1, gmsgid, &ap, DK_ICE);
>>>      va_end (ap);
>>> diff --git a/gcc/input.c b/gcc/input.c
>>> index 9e39e7df83c..1843c3077aa 100644
>>> --- a/gcc/input.c
>>> +++ b/gcc/input.c
>>> @@ -122,7 +122,7 @@ public:
>>>    /* Current position in real source file.  */
>>> -location_t input_location = UNKNOWN_LOCATION;
>>> +poisonable<location_t> input_location (UNKNOWN_LOCATION);
>>>    class line_maps *line_table;
>>> diff --git a/gcc/input.h b/gcc/input.h
>>> index f1ef5d76cfd..2b96ce8008e 100644
>>> --- a/gcc/input.h
>>> +++ b/gcc/input.h
>>> @@ -21,6 +21,7 @@ along with GCC; see the file COPYING3.  If not see
>>>    #ifndef GCC_INPUT_H
>>>    #define GCC_INPUT_H
>>> +#include "poison.h"
>>>    #include "line-map.h"
>>>    extern GTY(()) class line_maps *line_table;
>>> @@ -95,7 +96,7 @@ expand_location_to_spelling_point (location_t,
>>>    extern location_t expansion_point_location_if_in_system_header (location_t);
>>>    extern location_t expansion_point_location (location_t);
>>> -extern location_t input_location;
>>> +extern poisonable<location_t> input_location;
>>>    #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
>>>    #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
>>> diff --git a/gcc/objc/objc-next-runtime-abi-02.c b/gcc/objc/objc-next-runtime-abi-02.c
>>> index 3cfcd0b1a57..9ecb91cc56b 100644
>>> --- a/gcc/objc/objc-next-runtime-abi-02.c
>>> +++ b/gcc/objc/objc-next-runtime-abi-02.c
>>> @@ -1690,7 +1690,7 @@ build_v2_objc_method_fixup_call (int super_flag, tree method_prototype,
>>>    			       fold_convert (rcv_p, integer_zero_node), 1);
>>>    #ifdef OBJCPLUS
>>> -      ret_val = build_conditional_expr (input_location,
>>> +      ret_val = build_conditional_expr (location_t (input_location),
>>>    					ifexp, ret_val, ftree,
>>>    					tf_warning_or_error);
>>>    #else
>>>
>>