gccint: GIMPLE_DEBUG

1 
1 12.8.7 'GIMPLE_DEBUG'
1 ---------------------
1 
1  -- GIMPLE function: gdebug *gimple_build_debug_bind (tree var, tree
1           value, gimple stmt)
1      Build a 'GIMPLE_DEBUG' statement with 'GIMPLE_DEBUG_BIND'
1      'subcode'.  The effect of this statement is to tell debug
1      information generation machinery that the value of user variable
1      'var' is given by 'value' at that point, and to remain with that
1      value until 'var' runs out of scope, a dynamically-subsequent debug
1      bind statement overrides the binding, or conflicting values reach a
1      control flow merge point.  Even if components of the 'value'
1      expression change afterwards, the variable is supposed to retain
1      the same value, though not necessarily the same location.
1 
1      It is expected that 'var' be most often a tree for automatic user
1      variables ('VAR_DECL' or 'PARM_DECL') that satisfy the requirements
1      for gimple registers, but it may also be a tree for a scalarized
1      component of a user variable ('ARRAY_REF', 'COMPONENT_REF'), or a
1      debug temporary ('DEBUG_EXPR_DECL').
1 
1      As for 'value', it can be an arbitrary tree expression, but it is
1      recommended that it be in a suitable form for a gimple assignment
1      'RHS'.  It is not expected that user variables that could appear as
1      'var' ever appear in 'value', because in the latter we'd have their
1      'SSA_NAME's instead, but even if they were not in SSA form, user
1      variables appearing in 'value' are to be regarded as part of the
1      executable code space, whereas those in 'var' are to be regarded as
1      part of the source code space.  There is no way to refer to the
1      value bound to a user variable within a 'value' expression.
1 
1      If 'value' is 'GIMPLE_DEBUG_BIND_NOVALUE', debug information
1      generation machinery is informed that the variable 'var' is
1      unbound, i.e., that its value is indeterminate, which sometimes
1      means it is really unavailable, and other times that the compiler
1      could not keep track of it.
1 
1      Block and location information for the newly-created stmt are taken
1      from 'stmt', if given.
1 
1  -- GIMPLE function: tree gimple_debug_bind_get_var (gimple stmt)
1      Return the user variable VAR that is bound at 'stmt'.
1 
1  -- GIMPLE function: tree gimple_debug_bind_get_value (gimple stmt)
1      Return the value expression that is bound to a user variable at
1      'stmt'.
1 
1  -- GIMPLE function: tree * gimple_debug_bind_get_value_ptr (gimple
1           stmt)
1      Return a pointer to the value expression that is bound to a user
1      variable at 'stmt'.
1 
1  -- GIMPLE function: void gimple_debug_bind_set_var (gimple stmt, tree
1           var)
1      Modify the user variable bound at 'stmt' to VAR.
1 
1  -- GIMPLE function: void gimple_debug_bind_set_value (gimple stmt, tree
1           var)
1      Modify the value bound to the user variable bound at 'stmt' to
1      VALUE.
1 
1  -- GIMPLE function: void gimple_debug_bind_reset_value (gimple stmt)
1      Modify the value bound to the user variable bound at 'stmt' so that
1      the variable becomes unbound.
1 
1  -- GIMPLE function: bool gimple_debug_bind_has_value_p (gimple stmt)
1      Return 'TRUE' if 'stmt' binds a user variable to a value, and
1      'FALSE' if it unbinds the variable.
1 
1  -- GIMPLE function: gimple gimple_build_debug_begin_stmt (tree block,
1           location_t location)
1      Build a 'GIMPLE_DEBUG' statement with 'GIMPLE_DEBUG_BEGIN_STMT'
1      'subcode'.  The effect of this statement is to tell debug
1      information generation machinery that the user statement at the
1      given 'location' and 'block' starts at the point at which the
1      statement is inserted.  The intent is that side effects (e.g.
1      variable bindings) of all prior user statements are observable, and
1      that none of the side effects of subsequent user statements are.
1 
1  -- GIMPLE function: gimple gimple_build_debug_inline_entry (tree block,
1           location_t location)
1      Build a 'GIMPLE_DEBUG' statement with 'GIMPLE_DEBUG_INLINE_ENTRY'
1      'subcode'.  The effect of this statement is to tell debug
1      information generation machinery that a function call at 'location'
1      underwent inline substitution, that 'block' is the enclosing
1      lexical block created for the substitution, and that at the point
1      of the program in which the stmt is inserted, all parameters for
1      the inlined function are bound to the respective arguments, and
1      none of the side effects of its stmts are observable.
1