Lines Matching refs:stack

74 The bytecode interpreter is a stack-based machine; most instructions pop
75 their operands off the stack, perform some operation, and push the
76 result back on the stack for the next instruction to consume.  Each
77 element of the stack may contain either a integer or a floating point
83 stack element as follows:
95 the value of the expression should be the only value left on the stack.
97 have recorded the necessary data, and the value on the stack may be
101 Separate from the stack, the interpreter has two registers:
129 memory.  Once on the stack, however, the values are treated as full-size
168 stack.
174 Push the address of @code{z} onto the stack.
177 Fetch a 32-bit word from the address at the top of the stack; replace
178 the address on the stack with the value.  Thus, we replace the address
182 Sign-extend the value on the top of the stack from 32 bits to full
186 Pop the top two numbers on the stack, multiply them, and push their
187 product.  Now the top of the stack contains the value of the expression
192 stack contains the value of @code{x + y * z}.
195 Stop executing; the value left on the stack top is the value to be
210 Pop the top two stack items, @var{a} and @var{b}, as integers; push
218 the stack before and after the bytecode executes.  Beforehand, the stack
220 the stack is to the right, @var{b} is on the top of the stack, and
222 popped @var{a} and @var{b} from the stack, and replaced them with a
223 single value, @var{a+b}.  There may be other values on the stack below
231 Push the 8-bit integer constant @var{n} on the stack, without sign
243 For the @code{const8} bytecode, there are no stack items given before
245 from the stack.  If a bytecode consumes no values, or produces no
265 Pop two integers from the stack, and push their sum, as an integer.
268 Pop two integers from the stack, subtract the top value from the
272 Pop two integers from the stack, multiply them, and push the product on
273 the stack.  Note that, when one multiplies two @var{n}-bit numbers
278 Pop two signed integers from the stack; divide the next-to-top value by
283 Pop two unsigned integers from the stack; divide the next-to-top value
288 Pop two signed integers from the stack; divide the next-to-top value by
293 Pop two unsigned integers from the stack; divide the next-to-top value
298 Pop two integers from the stack; let @var{a} be the next-to-top value,
303 Pop two integers from the stack; let @var{a} be the next-to-top value,
308 Pop two integers from the stack; let @var{a} be the next-to-top value,
313 Pop an integer from the stack; if it is zero, push the value one;
317 Pop two integers from the stack, and push their bitwise @code{and}.
320 Pop two integers from the stack, and push their bitwise @code{or}.
323 Pop two integers from the stack, and push their bitwise
327 Pop an integer from the stack, and push its bitwise complement.
330 Pop two integers from the stack; if they are equal, push the value one;
334 Pop two signed integers from the stack; if the next-to-top value is less
338 Pop two unsigned integers from the stack; if the next-to-top value is less
342 Pop an unsigned value from the stack; treating it as an @var{n}-bit
346 larger than or equal to the width of the stack elements of the bytecode
353 Pop an unsigned value from the stack; zero all but the bottom @var{n}
364 Pop an address @var{addr} from the stack.  For bytecode
383 Push another copy of the stack's top element.
386 Exchange the top two items on the stack.
389 Discard the top value on the stack.
392 Pop an integer off the stack; if it is non-zero, branch to the given
416 Push the integer constant @var{n} on the stack, without sign extension.
459 stack.  If the purpose of the expression was to compute an lvalue or a
460 range of memory, then the next-to-top of the stack is the lvalue's
461 address, and the top of the stack is the lvalue's size, in bytes.
513 will have different stack sizes, and different bytecode buffer lengths.
532 maximum acceptable size of bytecode stack
595 of the stack.  EMC can arbitrarily change and enhance the tracing
600 the trace frame's stack area, memory ranges, and expression blocks can
688 @item What about stack overflow/underflow?
689 GDB should be able to query the target to discover its stack size.
691 given expression will overflow the stack.  But this spec isn't about
702 stack elements actually are on the target.  If the target only supports
734 @var{s-n} rsh_signed}, where @var{s} is the size of the stack elements;
819 consistent, and generally reduces the amount of stack rearrangement
824 know exactly what it should do with the stack.  If we're going to have a