static bool is_last_aligned_frame(struct unwind_state *state) { unsigned long *last_bp = last_frame(state); unsigned long *aligned_bp = last_aligned_frame(state); /* * GCC can occasionally decide to realign the stack pointer and change * the offset of the stack frame in the prologue of a function called * by head/entry code. Examples: * * <start_secondary>: * push %edi * lea 0x8(%esp),%edi * and $0xfffffff8,%esp * pushl -0x4(%edi) * push %ebp * mov %esp,%ebp * * <x86_64_start_kernel>: * lea 0x8(%rsp),%r10 * and $0xfffffffffffffff0,%rsp * pushq -0x8(%r10) * push %rbp * mov %rsp,%rbp * * After aligning the stack, it pushes a duplicate copy of the return * address before pushing the frame pointer. */ return (state->bp == aligned_bp && *(aligned_bp + 1) == *(last_bp + 1)); }
void Libdc1394SequenceGrabber::idle() { dc1394error_t err; dc1394video_frame_t *last_frame(NULL), *frame(NULL); if (!_camera) { fakeTracking(); return; } do{ err = dc1394_capture_dequeue(_camera, DC1394_CAPTURE_POLICY_POLL, &frame); if (frame) { if (last_frame) err=dc1394_capture_enqueue(_camera, last_frame); last_frame = frame; } } while (frame); checkSuccess(err, "dc1394_capture_dequeue failed"); if (_firstFrame) { setupBayer(); _firstFrame = false; } if (last_frame) { processCameraImageData( last_frame->image ); newFrameAvailable(); err=dc1394_capture_enqueue(_camera, last_frame); checkSuccess(err, "dc1394_capture_enqueue failed"); } }
deltaVFrame* DeltaProcess::last_delta_vframe() { // If no stack is present return NULL if (!has_stack()) return NULL; frame f = last_frame(); for (vframe* vf = vframe::new_vframe(&f); vf; vf = vf->sender() ) { if (vf->is_delta_frame()) return (deltaVFrame*) vf; } return NULL; }
void DeltaProcess::deoptimized_wrt_marked_nmethods() { // chop the stack into stretches of frames in need for deoptimization if (!has_stack()) return; frame v = last_frame(); do { if (v.should_be_deoptimized()) deoptimize_stretch(&v, &v); v = v.sender(); } while (!v.is_first_frame()); }
void DeltaProcess::follow_roots() { MarkSweep::follow_root((oop*) &_receiver); MarkSweep::follow_root((oop*) &_selector); MarkSweep::follow_root((oop*) &_processObj); if (has_stack()) { frame v = last_frame(); do { v.follow_roots(); v = v.sender(); } while (!v.is_first_frame()); } }
void DeltaProcess::frame_iterate(FrameClosure* blk) { blk->begin_process(this); if (has_stack()) { frame v = last_frame(); do { blk->do_frame(&v); v = v.sender(); } while (!v.is_first_frame()); } blk->end_process(this); }
void DeltaProcess::trace_stack_for_deoptimization(frame* f) { if (has_stack()) { int vframe_no = 1; frame v = f ? *f : last_frame(); do { v.print_for_deoptimization(std); v = v.sender(); if (vframe_no == StackPrintLimit) { std->print_cr("...<more frames>..."); return; } vframe_no++; } while (!v.is_first_frame()); } }
void DeltaProcess::oop_iterate(OopClosure* blk) { blk->do_oop((oop*) &_receiver); blk->do_oop((oop*) &_selector); blk->do_oop((oop*) &_processObj); for (unwindInfo* p = _unwind_head; p; p = p->next()) blk->do_oop((oop*) &p->_nlr_result); if (has_stack()) { frame v = last_frame(); do { v.oop_iterate(blk); v = v.sender(); } while (!v.is_first_frame()); } }
static bool is_last_ftrace_frame(struct unwind_state *state) { unsigned long *last_bp = last_frame(state); unsigned long *last_ftrace_bp = last_bp - 3; /* * When unwinding from an ftrace handler of a function called by entry * code, the stack layout of the last frame is: * * bp * parent ret addr * bp * function ret addr * parent ret addr * pt_regs * ----------------- */ return (state->bp == last_ftrace_bp && *state->bp == *(state->bp + 2) && *(state->bp + 1) == *(state->bp + 4)); }
static int bci(JavaThread *thread) { return last_frame(thread).interpreter_frame_bci(); }
static address bcp(JavaThread *thread) { return last_frame(thread).interpreter_frame_bcp(); }
static methodOop method(JavaThread *thread) { return last_frame(thread).interpreter_frame_method(); }
static inline unsigned long *last_aligned_frame(struct unwind_state *state) { return last_frame(state) - GCC_REALIGN_WORDS; }
int DeltaProcess::depth() { int d = 0; for(frame v = last_frame(); v.link(); v = v.sender()) d++; return d; }
static bool is_last_frame(struct unwind_state *state) { return state->bp == last_frame(state); }
bool Packet::addFrame(RoutedFrame f) { /* Description: * Add the frame to the frame list of the packet, if the frame belongs to * the packet. * This method is needed to build up the packet on the receiver side. * The method also checks, if frames are received in the right order. * * * Returns: * (true) if packet is complete and ready to publish * * (false) in every other case */ this->ts_ = getMillisecondsTime(); if (this->size_ == this->frames_l_.size()) return true; if (this->highest_seq < f.header_.packet_sequence_num) this->highest_seq = f.header_.packet_sequence_num; if (this->isMcFrame() && this->frameAlreadyExsits(f) == true) { this->refreshLists(); return false; } if (frames_l_.size() == 0 && f.header_.packet_sequence_num != 0) { for (uint32_t mis_seq = 0; mis_seq < f.header_.packet_sequence_num; mis_seq++) missed_sequences_l_.push_back(mis_seq); } if (f.header_.packet_id != this->id_) { ROS_ERROR("packet error"); exit(22); } if ((unsigned)frames_l_.size() < size_) { bool missed_sequence_frame = false; /* check if frame is on with a missed sequence*/ for (std::list<uint32_t>::iterator it = missed_sequences_l_.begin(); it != missed_sequences_l_.end(); ++it) { if (f.header_.packet_sequence_num == *it) { // ROS_ERROR("Frame was in missed squ // %u",f.header_.packet_sequence_num); missed_sequence_frame = true; missed_sequences_l_.erase(it); // todo try remove break; } } if (!missed_sequence_frame) { // std::list<RoutedFrame>::reverse_iterator iter = // frames_l_.rbegin(); //points to the last instered frame RoutedFrame &last_frame(*frames_l_.rbegin()); /*Check if the new frame has the expected sequence*/ if (last_frame.header_.packet_sequence_num == f.header_.packet_sequence_num - 1 || frames_l_.size() == 0) { frames_l_.push_back(f); } else if (last_frame.header_.packet_sequence_num < f.header_.packet_sequence_num) { /*Insert all sequence numbers between the current incoming frame * and the last inserted one*/ for (uint32_t i = 1; i < f.header_.packet_sequence_num - last_frame.header_.packet_sequence_num; i++) { missed_sequences_l_.push_front( last_frame.header_.packet_sequence_num + i); } frames_l_.push_back(f); } else { // this->refreshLists(); // return this->addFrame(f); } } /*Missed sequence frame*/ else { frames_l_.push_front(f); } if (frames_l_.size() == size_) { this->wrong_sequence_ = true; sortFrameList(); return frames_l_.size() == size_; } else return false; } return false; }
static Method* method(JavaThread *thread) { return last_frame(thread)->method(); }