Lines Matching full:that
14 that allows both typed values and location descriptions to be manipulated on the
18 that is backwards compatible with DWARF 5. The extension involves changes to the
25 to provide support for other issues that have been raised that would benefit all
28 Other approaches were explored that involved adding specialized operations and
29 rules. However, these resulted in the need for more operations that did not
31 corner cases that had to be defined. The observation was that numerous
33 consumers than a smaller number of general composable operations that have
37 describes heterogeneous devices and the features they have that are not addressed by DWARF 5.
39 evaluation model that highlights the difficulties for supporting the
61 They may support masked vector instructions that are used by the compiler to map
74 For example, a GPU may have a per thread block address space that is implemented
80 that support interleaved access.
99 split into separate files that they reference.
131 operations that are evaluated on a simple stack machine.
142 value or with the location of a base object that is available using the
148 evaluated in DWARF 5. DWARF also has expressions involving location lists that
154 that provides the number of elements in a dynamic array type. Such an attribute
155 dictates that the expression must be evaluated in the context of providing a
183 and size of values of the type. DWARF defines that each architecture has a
185 ordering, that is the size of the architecture's global memory address.
188 memory address, and reads the contents of that location using the generic type.
195 expression that is evaluated with a value result kind context is the top element
200 This example is for an operation expression associated with a DIE attribute that
202 that the expression must be evaluated in the context of providing a location
218 The DW_OP_regx operation creates a location description that specifies the
228 an expression that is evaluated with a location result kind context is the
234 that provides the location of a source language variable that is allocated in a
257 result back on the stack with the same associated type. In this example, that
263 that is evaluated has a location result kind context, and the location area is
274 This example is for a source variable that is partly in a register, partly undefined, and partly in…
278 DWARF defines composite location descriptions that can have one or more parts.
307 undefined location description can be used to indicate a part that has been
329 that is evaluated has a location result kind context, and the location area has
365 This illustrates that operations on stack values are not composable with
382 That is, when a debug agent wishes to evaluate a pointer-to-member access
471 such a way that the containing object is not in memory at all:
522 Note that the compiler has promoted the entire object `x` into register `rdi`
627 That is, the address of an object of class `B` is equivalent to the address for
634 base class. In this case, that table layout is:
643 That is, to find the `vbase_offset` for the `A`-in-`B` subobject the address
653 in that it relies on the address of the derived object and inherited subobject,
657 such a way that the derived object is not in memory at all:
702 Note that the compiler has elided storage for the entire object `x` in the
743 This is required to describe a source variable that is located in a lane of a
750 the ability to factorize the creation of locations that involve other location
772 a manner that is backwards compatible with DWARF 5.
776 In order to have consistent, composable operations that act on location
778 That includes memory, register, implicit, implicit pointer, undefined, and
789 the size of that specific register.
802 Evaluation rules are defined to implicitly convert a stack element that is a
803 value to a location description, or vice versa, so that all DWARF 5 expressions
804 continue to have the same semantics. This reflects that a memory address is
807 For each place that allows a DWARF expression to be specified, it is defined if
810 Existing DWARF expression operations that are used to act on memory addresses
816 Existing DWARF expression operations that create location descriptions are
821 New operations that act on location descriptions can be added. For example, a
822 DW_OP_offset operation that modifies the offset of the location description on
823 top of the stack. Unlike the DW_OP_plus operation that only works with memory
831 A DW_OP_undefined operation can be defined that explicitly creates the undefined
837 This section provides some motivating examples to illustrate the benefits that
843 that it proves has the same value for every lane of a SIMT thread in a scalar
844 register. It may then need to spill that scalar register. To avoid the high cost
850 The following expression defines the location of a source language variable that
861 description conceptually references that storage with an initial offset of 0.
878 GPUs due to the sheer number of registers that would have to be defined. It
886 variables that are mapped to a register, are mapped to the lane component of the
902 The following expression defines the location of a source language variable that
904 that combines the two parts. It will give the correct result regardless of which
905 lane corresponds to the source language thread of execution that the user is
950 the register storage that comprises the part. Note that the 4 bytes start at the
1034 composite location description to be created on the stack that can be used as
1048 For example, GPUs that use SIMT execution may provide hardware support to access
1049 memory such that each lane can see a linear memory view, while the backing
1050 memory is actually being accessed in an interleaved manner so that the locations
1056 The following expression defines the location of a source language variable that
1068 This is the register that holds the address of the current stack frame.
1085 All operations that act on location descriptions work with memory locations
1095 operation works on memory location descriptions that have an address space just
1100 The only operations in DWARF 5 that take an address space are DW_OP_xderef*.
1102 contents. There is no operation to actually create a location description that
1109 allocated in a register are spilled to a stack frame that resides in the
1115 define a DW_OP_bit_offset operation that adjusts the offset of any kind of
1117 computed value. This is generally useful for any source language that support
1118 bit sized entities, and for registers that are not a whole number of bytes.
1125 The following example defines a location description for a source variable that
1154 DWARF defines call frame information (CFI) that can be used to virtually unwind
1168 is a problem for attributes that define DWARF expressions that require the
1169 location of some source language entity that is not allocated in byte aligned
1174 object. That object could be located in a register, in a non-global memory
1178 A similar problem exists for DWARF expressions that use the
1180 program object associated with the attribute that defines the expression.
1195 they perform optimizations that result in composites of these. Allowing
1197 expressions that support all of these.
1204 The generalization allows an elegant way to add higher order operations that
1219 These could be used in the expression of an attribute that computes the
1222 register that controls which SIMT lanes are executing. For active divergent
1227 Similarly, a DW_OP_overlay_piece operation could be defined that creates a
1229 value, and a size. The resulting composite would consist of parts that are
1232 to efficiently express a source language array that has had a set of elements
1241 Effectively, during that range, the source variable is in both memory and a
1243 of the source variable in that PC range, then it would need to change both
1248 express that a source language entity is in multiple places at the same time.
1262 DW_AT_data_member_location that are evaluated with an initial stack containing a
1263 location description, or a DWARF operation expression that uses the
1265 expression that returned a location description involving multiple places.
1267 Therefore, the extension needs to define how expression operations that use those
1273 All operations that act on location descriptions are extended to act on multiple
1284 A strength of DWARF is that it has generally sought to provide generalized
1285 composable solutions that address many problems, rather than solutions that only
1286 address one-off issues. This extension attempts to follow that tradition by
1287 defining a backwards compatible composable generalization that can address a
1295 > defined such that it is backwards compatible with DWARF Version 5.
1300 > location descriptions that support multiple places.
1303 > > the DWARF Version 5 standard. They also describe rational and issues that
1337 > descriptions having an undefined location description. Then operations that
1341 > All operations that act on values would return an undefined entity if given an
1346 > that GDB throws an exception when these evaluation errors occur.
1360 A DWARF expression is evaluated in a context that can include a number of
1363 elements that can be specified are:
1376 It is required for operations that are related to target architecture
1384 that corresponds to an active invocation of a subprogram in the current
1390 It is required for operations that specify target architecture registers to
1413 amongst multiple program location ranges. It is required for operations that
1423 F that invoked the callee frame.
1428 The compilation unit debug information entry that contains the DWARF
1431 It is required for operations that reference debug information associated
1438 <i>Note that this compilation unit may not be the same as the compilation
1442 the `DW_OP_call*` operations is evaluated with the compilation unit that
1443 contains E and not the one that contains the `DW_OP_call*` operation
1450 It is required for operations that specify target architecture specific
1499 This is a list of values or location descriptions that will be pushed on the
1503 Some debugger information entries have attributes that evaluate their DWARF
1510 If the evaluation requires a context element that is not specified, then the
1521 that do not require the compilation unit context to be specified.</i>
1536 > would be used for the type of the value that is produced when the
1543 type that has the size of an address in the target architecture default address
1549 An integral type is a base type that has an encoding of `DW_ATE_signed`,
1573 A single location description specifies the location storage that holds a
1578 A location storage is a linear stream of bits that can hold values. Each
1581 and direction conventions that are appropriate to the current language on the
1596 Corresponds to fixed values that can only be read.
1616 that specifies an operation expression of arbitrary complexity. In this usage
1619 Entries](#lexical-block-entries)) that owns it, and it does not move during
1623 that specifies a location list expression. In this usage they can describe the
1624 location of an object that has a limited lifetime, changes its location during
1630 value, except for the parts of the value that are uninitialized.
1632 <i>A location description that has more than one single location description can
1633 only be created by a location list expression that has overlapping program
1634 location ranges, or certain expression operations that act on a location
1635 description that has more than one single location description. There are no
1636 operation expression operations that can directly create a location description
1640 used to describe objects that reside in more than one piece of storage at the
1642 optimization. For example, a value that is only read may be promoted from memory
1651 descriptions (since they all refer to location storage that has the same value),
1661 denotes is that associated with the context element values specified when the
1666 context: the location storage is for the specified register of that thread.
1668 thread context: the location storage is the memory associated with that
1674 <i>Examples of context that can invalidate a location description are:</i>
1681 occurs. That could change the location list entry or call frame information
1682 entry that applies.</i>
1700 <i>For example, a location description may specify a register that no longer
1728 expression that has an evaluation error, then the result is an evaluation
1739 then the result is that, possibly converted, location description. Any other entries on the
1749 then the result is that, possibly converted, value. Any other entries on the stack are
1766 An operation expression is encoded as a byte block with some form of prefix that
1769 - as the value of a debugging information entry attribute that is encoded using
1781 The following operations manipulate the DWARF stack. Operations that index the
1782 stack assume that the top of the stack (most recently added entry) has index 0.
1789 > NOTE: These operations now support stack entries that are values and location
1793 > location descriptions, then would need to define that the composite location
1795 > replicated when a copy is pushed. This ensures that each copy of the
1809 `DW_OP_pick` has a single unsigned 1-byte operand that represents an index
1883 `DW_OP_call2` and `DW_OP_call4`, have one operand that is, respectively, a
1884 2-byte or 4-byte unsigned offset DR that represents the byte offset of a
1888 `DW_OP_call_ref` has one operand that is a 4-byte unsigned value in the
1890 that represents the byte offset DR of a debugging information entry D
1891 relative to the beginning of the `.debug_info` section that contains the
1894 > NOTE: DWARF Version 5 states that DR can be an offset in a `.debug_info`
1895 > section other than the one that contains the current compilation unit. It
1896 > states that relocation of references from one executable or shared object
1897 > file to another must be performed by the consumer. But given that DR is
1906 > not an offset in a `.debug_info` section. That would also need DR to be
1913 > GDB only interprets DR as an offset in the `.debug_info` section that
1919 `DW_OP_call_ref` is exactly like that for `DW_FORM_ref2`, `DW_FORM_ref4`,
1924 - If D has a `DW_AT_location` attribute that is encoded as a `exprloc` that
1930 current compilation unit is the one that contains D and the stack is the
1931 same as that being used by the call operation. After the call operation
1942 - If D has a `DW_AT_location` attribute that is encoded as a `loclist` or
1945 location description, the compilation unit is the one that contains D, and
1956 > attribute that is encoded as a `loclist` or `loclistsptr`, and the
1961 > But this is not attractive as if the attribute is for a variable that
1965 > entry is to push just one location description on the stack. That
1983 > A solution to that is to have a distinct `DW_AT_proc` attribute for the
1986 > pushes a location description (that may have multiple single location
1991 > `loclistproc`, and `loclistsptrproc` to indicate that the expression is
1996 > default entry is required. These forms indicate explicitly that the
2010 > the evaluation of an expression E that is the value of a
2013 > expression that does not match exactly one location list entry. In all
2014 > other cases the evaluation of an expression E that is the value of a
2017 > is the one that contains D, and the initial stack is empty. The location
2030 > entries that are constants and instead use `DW_AT_location` with an
2031 > operation expression that results in a location description with one
2037 > `DW_OP_call*` is defined to have no effect. It is unclear that this is
2042 > `DW_TAG_dwarf_procedure` that does not have a `DW_AT_location`
2047 define DWARF procedures that can be called.</i>
2051 This section describes the operations that push values on the stack.
2076 `DW_OP_const<N>u` operations have a single operand that is a 1, 2, 4, or
2082 `DW_OP_const<N>s` operations have a single operand that is a 1, 2, 4, or
2098 `DW_OP_constx` has a single unsigned LEB128 integer operand that represents
2104 <i>The `DW_OP_constx` operation is provided for constants that require
2111 integer DR that represents the byte offset of a debugging information entry
2112 D relative to the beginning of the current compilation unit, that provides
2125 definition, it is encoded explicitly into the operation so that the
2147 integer that represents a register number R. The second is an unsigned
2148 LEB128 integer DR that represents the byte offset of a debugging information
2149 entry D relative to the beginning of the current compilation unit, that
2161 > GDB has a per register hook that allows a target specific conversion on a
2187 `DW_OP_deref_size` has a single 1-byte unsigned integral constant that
2208 constant S. The second is an unsigned LEB128 integer DR that represents the
2210 the current compilation unit, that provides the type T of the result value.
2215 is encoded explicitly as the operand S so that the operation can be parsed
2223 It pops one stack entry that must be a location description L.
2229 part that is a subcomponent of L, has more than one single location
2240 > location description that has less than TS bits remaining in the register
2271 value that represents an address A. The second must be an integral type
2272 value that represents a target architecture specific address space
2276 architecture specific address space that corresponds to AS.
2282 SL specifies the memory location storage LS that corresponds to AS with a
2285 If AS is an address space that is specific to context elements, then LS
2303 `DW_OP_xderef_size` has a single 1-byte unsigned integral constant that
2307 that represents an address A. The second must be an integral type
2308 value that represents a target architecture specific address space
2321 that represents the byte offset of a debugging information entry D relative
2322 to the beginning of the current compilation unit, that provides the type T
2325 It pops two stack entries. The first must be an integral type value that
2326 represents an address A. The second must be an integral type value that
2337 `DW_OP_entry_value` pushes the value of an expression that is evaluated in
2348 unspecified, the call frame is the one that called the current frame, the
2376 `DW_TAG_call_site_parameter` debugger information entry for call sites that
2378 `DW_AT_call_data_value` attributes that provide DWARF expressions to compute
2388 This section describes the operations that push location descriptions on the
2400 <i>This object may correspond to an independent variable that is part of a
2401 user presented expression that is being evaluated. The object location
2408 involving descriptors) that is analogous to the implicit push of the base
2433 > The only attribute that specifies a current object is
2435 > this is being used. Or are there other attributes that need to state they
2442 <i>The undefined location storage represents a piece or all of an object that is
2458 memory location storage that denotes the linear addressable memory of that
2474 A memory location description that has a bit offset that is a multiple of 8 (the
2476 memory byte address A that is equal to the bit offset divided by 8.
2478 A memory location description that does not have a bit offset that is a multiple
2481 address A equal to the bit offset minus B that is then divided by 8.
2484 address space that corresponds to the memory location storage associated with
2487 A location description that is comprised of one byte address memory location
2497 storage that corresponds to the target architecture default address space with a
2528 address space with a bit offset B that is a multiple of 8, then it is implicitly
2535 the generic type, that represents an address A.
2549 `DW_OP_addrx` has a single unsigned LEB128 integer operand that represents a
2566 `DW_OP_form_tls_address` pops one stack entry that must be an integral type
2571 description that corresponds to the thread-local storage address TA.
2609 space efficient to reference that using the `DW_OP_call_frame_cfa`
2614 `DW_OP_fbreg` has a single signed LEB128 integer operand that represents a
2631 They have a single signed LEB128 integer operand that represents a byte
2648 description LS on the stack. LS specifies the memory location storage that
2653 `DW_OP_bregx` has two operands. The first is an unsigned LEB128 integer that
2654 represents a register number R. The second is a signed LEB128 integer that
2657 The action is the same as for `DW_OP_breg<N>`, except that R is used as the
2664 There is a register location storage that corresponds to each of the target
2683 `DW_OP_regx` has a single unsigned LEB128 integer operand that represents a
2687 description L that specifies one register location description SL on the
2688 stack. SL specifies the register location storage that corresponds to R with
2693 determine the location description that holds the register for the current
2697 <i>Note that if call frame information is used, the resulting location
2727 integer that represents a byte size S. The second is a block of bytes with a
2738 `DW_OP_stack_value` pops one stack entry that must be a value V.
2746 <i>The `DW_OP_stack_value` operation specifies that the object does not
2749 specifying the memory or register storage that holds the value.</i>
2762 value that the pointer addressed. `DW_OP_implicit_pointer` allows a producer
2766 architecture default address space that cannot be represented as a real
2768 form, the location description specifies a debugging information entry that
2776 the 64-bit DWARF format, that represents the byte offset DR of a debugging
2778 that contains the current compilation unit. The second operand is a signed
2779 LEB128 integer that represents a byte displacement B.
2781 <i>Note that D might not be in the current compilation unit.</i>
2783 <i>The first operand interpretation is exactly like that for
2795 It pushes a location description L that comprises one implicit location
2799 description L', and retrieves S bits, such that any retrieved bits come from
2800 an implicit location storage that is the same as LS, unless both the
2803 1. All retrieved bits come from an implicit location description that
2804 refers to an implicit location storage that is the same as LS.
2806 <i>Note that all bits do not have to come from the same implicit
2828 that the result kind is a location description, the compilation unit is
2829 the one that contains D, the object is unspecified, and the initial stack
2832 <i>Note that E is evaluated with the context of the expression accessing
2833 IPV, and not the context of the expression that contained the
2834 `DW_OP_implicit_pointer` operation that created L.</i>
2851 If a `DW_OP_stack_value` operation pops a value that is the same as IPV,
2852 then it pushes a location description that is the same as L.
2871 object pointed to by that pointer object.</i>
2873 <i>However, D<sub>2</sub> may be any debugging information entry that contains a
2889 that indicates that part is located in more than one place. The bits of each
2895 contiguous such that the zero-based location storage bit index will range over
2905 There are operations that create a composite location storage.
2907 There are other operations that allow a composite location storage to be
2911 that are in the order that the associated part operations are executed.
2917 A composite location description that specifies a composite location storage
2918 that is incomplete is termed an incomplete composite location description. A
2919 composite location description that specifies a composite location storage that
2922 If the top stack entry is a location description that has one incomplete
2926 <i>Note that this conversion does not happen after the completion of an
2927 operation expression that is evaluated on the same stack by the `DW_OP_call*`
2930 that contains the `DW_OP_call*` operation.</i>
2937 <i>Note that a DWARF operation expression may arbitrarily compose composite
2938 location descriptions from any other location description, including those that
2939 have multiple single location descriptions, and those that have composite
2947 `DW_OP_piece` has a single unsigned LEB128 integer that represents a byte
2964 composite location storage LS that SL specifies is updated to append a new
2974 incomplete composite location storage LS that SL specifies is updated to
2998 > could be defined. For example, just one operation that specifies how many
3008 that represents the part bit size S. The second is an unsigned LEB128
3009 integer that represents a bit displacement B.
3011 The action is the same as for `DW_OP_piece`, except that any part created
3035 This kind of location list entry provides an operation expression that
3036 evaluates to the location description of an object that is valid over a
3046 in the way that they specify the starting and ending addresses.
3050 This kind of location list entry provides an operation expression that
3051 evaluates to the location description of an object that is valid when no
3083 assumed that the object is not available for the portion of the range that is
3091 > NOTE: If the location list only has a single default entry, should that be
3094 > program location as that indicates the location depends on the program
3098 description that comprises one undefined location description.
3100 evaluated with the current context, except that the result kind is a location
3105 The result is a location description that is comprised of the union of the
3110 information entry attribute that is encoded using class `loclist` or
3113 `.debug_loclists` or `.debug_loclists.dwo` (for split DWARF object files) that
3117 debugger information entry attribute that has a location list expression.
3118 Several debugger information entry attributes allow DWARF expressions that are
3119 evaluated with an initial stack that includes a location description that may
3143 The result of the attribute is obtained by evaluating E with a context that
3145 compilation unit that contains E, an empty initial stack, and other context
3163 The result of the attribute is obtained by evaluating E with a context that
3165 compilation unit that contains E, an empty initial stack, and other context
3198 The result of the attribute is obtained by evaluating E with a context that
3200 compilation unit that contains E, an empty initial stack, and other context
3205 subprogram instance that immediately lexically encloses the current call
3220 E<sub>1</sub> with a context that has a result kind of a value, an unspecified
3221 object, the compilation unit that contains E, an empty initial stack, and other
3234 E<sub>2</sub> with a context that has a result kind of a location description,
3235 an unspecified object, the compilation unit that contains E, an empty initial
3243 > NOTE: The DWARF Version 5 implies that `DW_OP_push_object_address` may be
3249 E<sub>3</sub> with a context that has a result kind of a value, an unspecified
3250 object, the compilation unit that contains E, an empty initial stack, and other
3268 accessing registers or memory locations that might be clobbered by the
3272 <i>The reason for the restriction is that the parameter may need to be accessed
3277 that have been clobbered, and clobbered memory will no longer have the value at
3296 *The tag `DW_TAG_constant` is used for languages that have true named constants.*
3301 1. A `DW_AT_location` attribute, whose value is a DWARF expression E that
3304 The result of the attribute is obtained by evaluating E with a context that
3306 compilation unit that contains E, an empty initial stack, and other context
3315 > a `DW_AT_location` attribute as that is now described in the operations.
3320 > consumer that no longer have to track the context. It makes it easier for
3323 > For that reason, limiting the `DW_AT_location` attribute to only
3333 > entries that have been optimized to a constant. Instead, `DW_AT_location`
3334 > could be used with a DWARF expression that produces an implicit location
3335 > description now that any location description can be used within a DWARF
3343 expression E that describes the location of the common block at run-time. The
3344 result of the attribute is obtained by evaluating E with a context that has a
3346 unit that contains E, an empty initial stack, and other context elements
3377 with a context that has a result kind of a location description, an
3378 unspecified object, the compilation unit that contains E, an initial
3387 > description, and those with single location descriptions that are of any
3395 The result of the attribute is obtained by evaluating E with a context that
3397 compilation unit that contains E, an initial stack comprising the location
3412 class, structure, or union is common to any instance of that class, structure,
3414 associated with the pointer to member type, rather than with each object that
3421 The result of the attribute is obtained by evaluating E with a context that has
3423 unit that contains E, an initial stack comprising two entries, and other context
3436 1. The `DW_AT_data_location` attribute may be used with any type that provides one
3443 The result of the attribute is obtained by evaluating E with a context that has
3444 a result kind of a location description, an object that is the location
3445 description of the data descriptor, the compilation unit that contains E, an
3450 <i>E will typically involve an operation expression that begins with a
3458 > they apply to data objects so less likely that optimization would cause
3488 A register that has this rule has no recoverable value in the previous
3500 register is the location description L that specifies one register location
3501 description SL. SL specifies the register location storage that corresponds
3544 > GDB has a per register hook that allows a target specific conversion on a
3548 > tests that read a register out of bounds (except an illegal hand written
3596 > allowing any operations that specify a type in a CFI operation expression.
3597 > This makes it unusable for registers that are larger than the generic
3605 A Common Information Entry (CIE) holds information that is shared among many
3611 A constant that gives the number of bytes of the CIE structure, not
3618 A constant that is used to distinguish CIEs from FDEs.
3635 A null-terminated UTF-8 string that identifies the augmentation to this CIE
3636 or to the FDEs that use it. If a reader encounters an augmentation string
3637 that is unexpected, then only the following fields can be read:
3644 <i>The augmentation string allows users to indicate that there is additional
3656 The size of a target address in this CIE and any FDEs that use it, in bytes.
3662 The size of a segment selector in this CIE and any FDEs that use it, in
3667 A constant that is factored out of all advance location instructions (see
3673 A constant that is factored out of certain offset instructions (see [6.4.2.2
3680 An unsigned LEB128 constant that indicates which column in the rule table
3681 represents the return address of the subprogram. Note that this column might
3690 A sequence of rules that are interpreted to create the initial setting of
3707 A constant that gives the number of bytes of the header and instruction
3714 A constant offset into the `.debug_frame` section that denotes the CIE that
3729 A sequence of table defining instructions that are described in [6.4.2 Call
3739 Some call frame instructions have operands that are encoded as DWARF operation
3741 Expressions](#dwarf-operation-expressions)). The DWARF operations that can be
3780 <i>The action is the same as `DW_CFA_def_cfa`, except that the second
3816 <i>The action is the same as `DW_CFA_def_cfa_offset`, except that the
3829 restrictions on the DWARF expression operations that can be used in E.</i>
3839 that represents a register number R. The required action is to set the rule
3845 that represents a register number R. The required action is to set the rule
3874 except that B is signed.
3891 that B is signed.
3908 <i>That is, E computes the location description where the register value can
3912 restrictions on the DWARF expression operations that can be used in E.</i>
3922 <i>That is, E computes the value of register R.</i>
3925 restrictions on the DWARF expression operations that can be used in E.</i>
3927 If the result of evaluating E is not a value with a base type size that
3933 opcode) that represents a register number R. The required action is to
3940 operand that represents a register number R. This instruction is identical
3992 > NOTE: Rename DWARF Version 5 section 7.7.3 to reflect that location lists are
4002 many figures that help illustrate the textual description, especially of the