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