Lines Matching refs:bytecode

35 expressions in the source language into a simpler bytecode language, and
36 then sends the bytecode to the agent; the agent then executes the
37 bytecode, and records the values for GDB to retrieve later.
39 The bytecode language is simple; there are forty-odd opcodes, the bulk
42 operations.  The bytecode interpreter operates strictly on machine-level
45 internal data structures are simple, and each bytecode requires only a
69 The agent represents bytecode expressions as an array of bytes.  Each
70 instruction is one byte long (thus the term @dfn{bytecode}).  Some
74 The bytecode interpreter is a stack-based machine; most instructions pop
80 carry no record of their type; bytecode could push a value as an
94 By the time the bytecode interpreter reaches the end of the expression,
104 The address of the next bytecode to execute.
107 The address of the start of the bytecode expression, necessary for
112 Neither of these registers is directly visible to the bytecode language
113 itself, but they are useful for defining the meanings of the bytecode
121 Most bytecode instructions do not distinguish between the various sizes
147 Even complicated C expressions compile to a few bytecode instructions;
204 Each bytecode description has the following form:
215 In this example, @code{add} is the name of the bytecode, and
216 @code{(0x02)} is the one-byte value used to encode the bytecode, in
218 the stack before and after the bytecode executes.  Beforehand, the stack
221 @var{a} is underneath it.  After execution, the bytecode will have
224 those shown, but the bytecode affects only those shown.
236 In this example, the bytecode @code{const8} takes an operand @var{n}
237 directly from the bytecode stream; the operand follows the @code{const8}
238 bytecode itself.  We write any such operands immediately after the name
239 of the bytecode, before the colon, and describe the exact encoding of
240 the operand in the bytecode stream in the body of the bytecode
243 For the @code{const8} bytecode, there are no stack items given before
244 the @result{}; this simply means that the bytecode consumes no values
245 from the stack.  If a bytecode consumes no values, or produces no
248 If a value is written as @var{a}, @var{b}, or @var{n}, then the bytecode
250 bytecode treats it as an address.
346 larger than or equal to the width of the stack elements of the bytecode
347 engine; in this case, the bytecode should have no effect.
350 byte unsigned integer following the @code{ext} bytecode.
358 byte unsigned integer following the @code{zero_ext} bytecode.
364 Pop an address @var{addr} from the stack.  For bytecode
393 offset in the bytecode string.  Otherwise, continue to the next
394 instruction in the bytecode stream.  In other words, if @var{a} is
399 immediately following the @code{if_goto} bytecode.  It is always stored
402 alignment within the bytecode stream; thus, on machines where fetching a
410 The offset is stored in the same way as for the @code{if_goto} bytecode.
418 and then sign-extend it using the @code{ext} bytecode.
421 following the @code{const}@var{b} bytecode.  The constant @var{n} is
424 particular alignment within the bytecode stream; thus, on machines where
433 immediately following the @code{reg} bytecode.  It is always stored most
436 alignment within the bytecode stream; thus, on machines where fetching a
449 This bytecode is equivalent to the sequence @code{dup const8 @var{size}
450 trace}, but we provide it anyway to save space in bytecode strings.
458 Stop executing bytecode; the result should be the top element of the
513 will have different stack sizes, and different bytecode buffer lengths.
532 maximum acceptable size of bytecode stack
535 maximum acceptable length of bytecode expressions
593 there at the request of a bytecode expression, or because it falls in
728 keep bytecode strings short.
744 need the @code{ext} bytecode anyway for accessing bitfields.
751 GDB will generate bytecode that fetches multi-byte values at unaligned
754 generates the bytecode, so it cannot determine whether a particular
795 @item Where is the function call bytecode?
799 @item Why does the @code{reg} bytecode take a 16-bit register number?