Lines Matching refs:stack
38 // Compute stack layouts for each instruction in method.
53 // For each basic block: store entry state (vars, stack). For instructions
73 // ' ' uninitialized; never occurs on operand stack in Java
90 // a return PC on the stack (a 'p' type in the abstract interpretation).
155 // Specialization of SignatureIterator - in order to set up first stack frame
704 // Merge the variable state for locals and stack from cts into bbts.
720 // Merge the monitor stack state from cts into bbts.
765 // block is reachable the locals and stack must be merged. If the
766 // stack heights don't match then this is a verification error and
788 report_monitor_mismatch("monitor stack height merge conflict");
791 // bad_monitors. This signals that, from here on, the monitor stack cannot
806 verify_error("stack height conflict: %d vs. %d", _stack_top, bb->_stack_top);
835 verify_error("stack underflow");
838 return stack()[--_stack_top];
843 verify_error("stack overflow");
846 stack()[_stack_top++] = cts;
850 assert(_monitor_top != bad_monitors, "monitor_pop called on error monitor stack");
852 // We have detected a pop of an empty monitor stack.
857 report_monitor_mismatch("monitor stack underflow");
865 assert(_monitor_top != bad_monitors, "monitor_push called on error monitor stack");
868 // This means that the monitor stack cannot be simulated.
873 report_monitor_mismatch("monitor stack overflow");
912 // (entry stack may not be of maximal height for every basic block).
913 // But cumbersome since we don't know the stack heights yet. (Nor the
914 // monitor stack heights...)
919 // This can be used an upper bound on the monitor stack depth in programs
920 // which obey stack discipline with their monitor usage. Initialize the
970 // Now that we have a bound on the depth of the monitor stack, we can
979 // basic blocks and stack/locals/monitors. Need to check to make sure
1018 // Initialize all locals to 'uninit' and set stack-height to 0
1119 // exception handlers and the monitor stack is currently
1169 // If the monitor stack height is not zero when we leave the method,
1170 // then we are either exiting with a non-empty stack or we have
1179 // If the monitor stack height is bad_monitors, then we have detected a
1181 // monitor stack height is 0, we are about to pop a monitor
1182 // off of an empty stack. In either case, the bytecode
1201 CellTypeState *excStk = excBB->stack();
1202 CellTypeState *cOpStck = stack();
1232 // ensure that the monitor stack is empty in this case.
1247 report_monitor_mismatch("non-empty monitor stack at exceptional exit");
1291 os->print(" stack = ");
1292 print_states(os, stack(), _stack_top);
1298 os->print(" [bad monitor stack]");
1303 os->print(" stack = '%s' ", state_vec_to_string(stack(), _stack_top));
1307 os->print(" [bad monitor stack]");
1347 fill_stackmap_for_opcodes(itr, vars(), stack(), _stack_top);
1626 verify_error("wrong type on stack (found: %c expected: %c)", actual.to_char(), expected.to_char());
1731 verify_error("stack underflow");
1804 // on the top of our monitor stack. This causes a monitor
1824 // out the lock when it is popped from the monitor stack
1837 // The monitor stack must be empty when we leave the method
1845 report_monitor_mismatch("non-empty monitor stack at return");
1882 verify_error("wrong type on stack (found: %c, expected: {pr})", r_or_p.to_char());
1958 fill_stackmap_for_opcodes(_itr_send, vars(), stack(), _stack_top);
2104 // Step 3: Calculate stack maps
2119 // at the bottom of the call stack, when it returns to compute_map(). The
2484 // Return true iff the top of the operand stack holds a return address at
2513 if (_stack_top > 0 && stack()[_stack_top-1].is_address()) {