Lines Matching refs:frame
179 void AddFrame(DfxFrame& frame);
186 void FillFrame(DfxFrame& frame);
187 void FillJsFrame(DfxFrame& frame);
188 bool GetFrameByPc(uintptr_t pc, std::shared_ptr<DfxMaps> maps, DfxFrame& frame);
229 void AddFrame(const StepFrame& frame, std::shared_ptr<DfxMap> map);
230 bool StepInner(const bool isSigFrame, StepFrame& frame, void *ctx);
233 bool StepArkJsFrame(StepFrame& frame);
389 void Unwinder::AddFrame(DfxFrame& frame)
391 impl_->AddFrame(frame);
409 void Unwinder::FillFrame(DfxFrame& frame)
411 impl_->FillFrame(frame);
414 void Unwinder::FillJsFrame(DfxFrame& frame)
416 impl_->FillJsFrame(frame);
419 bool Unwinder::GetFrameByPc(uintptr_t pc, std::shared_ptr<DfxMaps> maps, DfxFrame& frame)
421 return impl_->GetFrameByPc(pc, maps, frame);
669 bool Unwinder::Impl::StepArkJsFrame(StepFrame& frame)
671 DFX_TRACE_SCOPED_DLSYM("StepArkJsFrame pc: %p", reinterpret_cast<void *>(frame.pc));
673 timeLimitCheck += "StepArkJsFrame, ark pc: " + std::to_string(frame.pc) +
674 ", fp:" + std::to_string(frame.fp) + ", sp:" + std::to_string(frame.sp) +
675 ", isJsFrame:" + std::to_string(frame.isJsFrame);
679 reinterpret_cast<void *>(frame.pc),
680 reinterpret_cast<void *>(frame.fp), reinterpret_cast<void *>(frame.sp), frame.isJsFrame);
694 if (DfxArk::GetArkNativeFrameInfo(pid, frame.pc, frame.fp, frame.sp, jsFrames, size) < 0) {
695 DFXLOGE("Failed to get ark frame info");
700 DFXLOGI("---ark js frame size: %{public}zu.", size);
714 uintptr_t *methodId = (pid_ > 0 || enableMethodIdLocal_) ? (&frame.methodid) : nullptr;
716 ArkUnwindParam arkParam(memory_.get(), &(Unwinder::AccessMem), &frame.fp, &frame.sp, &frame.pc,
717 methodId, &frame.isJsFrame, jitCache_);
720 ret = DfxArk::StepArkFrame(memory_.get(), &(Unwinder::AccessMem), &frame.fp, &frame.sp, &frame.pc,
721 methodId, &frame.isJsFrame);
724 DFXLOGE("Failed to step ark frame");
728 DFXLOGI("---ark js frame methodid: %{public}" PRIx64 "", (uint64_t)frame.methodid);
733 reinterpret_cast<void *>(frame.pc),
734 reinterpret_cast<void *>(frame.fp), reinterpret_cast<void *>(frame.sp), frame.isJsFrame);
752 StepFrame frame;
765 frame.pc = regs_->GetPc();
766 frame.sp = regs_->GetSp();
767 frame.fp = regs_->GetFp();
768 // Check if this is a signal frame.
770 regs_->StepIfSignalFrame(static_cast<uintptr_t>(frame.pc), memory_)) {
771 DFXLOGW("Step signal frame, pc: %{public}p", reinterpret_cast<void *>(frame.pc));
772 StepInner(true, frame, ctx);
776 if (!frame.isJsFrame && needAdjustPc) {
777 DoPcAdjust(frame.pc);
781 uintptr_t prevPc = frame.pc;
782 uintptr_t prevSp = frame.sp;
783 if (!StepInner(false, frame, ctx)) {
787 if (frame.pc == prevPc && frame.sp == prevSp) {
794 lastErrorData_.SetAddrAndCode(frame.pc, UNW_ERROR_REPEATED_FRAME);
800 DFXLOGU("Last frame size: %{public}zu, last frame pc: %{public}p",
880 StepFrame frame;
881 frame.pc = pc;
882 frame.sp = sp;
883 frame.fp = regs_->GetFp();
884 // Check if this is a signal frame.
885 if (regs_->StepIfSignalFrame(frame.pc, memory_)) {
886 DFXLOGW("Step signal frame, pc: %{public}p", reinterpret_cast<void *>(frame.pc));
887 ret = StepInner(true, frame, ctx);
889 ret = StepInner(false, frame, ctx);
891 pc = frame.pc;
892 sp = frame.sp;
896 bool Unwinder::Impl::StepInner(const bool isSigFrame, StepFrame& frame, void *ctx)
903 DFXLOGU("+pc: %{public}p, sp: %{public}p, fp: %{public}p", reinterpret_cast<void *>(frame.pc),
904 reinterpret_cast<void *>(frame.sp), reinterpret_cast<void *>(frame.fp));
905 uintptr_t prevSp = frame.sp;
913 auto iter = stepCache_.find(frame.pc);
916 DFXLOGU("Find rs cache, pc: %{public}p", reinterpret_cast<void *>(frame.pc));
920 AddFrame(frame, map);
927 MAYBE_UNUSED int mapRet = acc_->GetMapByPc(frame.pc, map, ctx);
929 if (frame.isJsFrame) {
933 if (frames_.size() > 2) { // 2, least 2 frame
935 lastErrorData_.SetAddrAndCode(frame.pc, mapRet);
939 AddFrame(frame, map);
946 DFXLOGU("Stop by ark frame");
949 if ((enableMixstack_) && ((map != nullptr && map->IsArkExecutable()) || frame.isJsFrame)) {
950 if (!StepArkJsFrame(frame)) {
951 DFXLOGE("Failed to step ark Js frame, pc: %{public}p", reinterpret_cast<void *>(frame.pc));
952 lastErrorData_.SetAddrAndCode(frame.pc, UNW_ERROR_STEP_ARK_FRAME);
956 regs_->SetPc(StripPac(frame.pc, pacMask_));
957 regs_->SetSp(frame.sp);
958 regs_->SetFp(frame.fp);
974 MAYBE_UNUSED int utiRet = acc_->FindUnwindTable(frame.pc, uti, ctx);
976 lastErrorData_.SetAddrAndCode(frame.pc, utiRet);
986 if (!armExidx_->SearchEntry(frame.pc, uti, uei)) {
1000 if ((uti.isLinear == false && !dwarfSection_->SearchEntry(frame.pc, uti, uei)) ||
1001 (uti.isLinear == true && !dwarfSection_->LinearSearchEntry(frame.pc, uti, uei))) {
1007 if (!dwarfSection_->Step(frame.pc, (uintptr_t)uei.unwindInfo, rs)) {
1020 stepCache_.emplace(frame.pc, cache);
1037 DFXLOGW("Failed to apply first frame, lr fallback");
1045 DFXLOGW("Failed to step first frame, lr fallback");
1053 ret = FpStep(frame.fp, frame.pc, ctx);
1056 DFXLOGI("First enter fp step, pc: %{public}p", reinterpret_cast<void *>(frame.pc));
1063 frame.pc = regs_->GetPc();
1064 frame.sp = regs_->GetSp();
1065 frame.fp = regs_->GetFp();
1066 if (!isFpStep_ && (map != nullptr) && (!map->IsVdsoMap()) && (frame.sp < prevSp)) {
1068 lastErrorData_.SetAddrAndCode(frame.pc, UNW_ERROR_ILLEGAL_VALUE);
1071 if (ret && (frame.pc == 0)) {
1074 DFXLOGU("-pc: %{public}p, sp: %{public}p, fp: %{public}p, ret: %{public}d", reinterpret_cast<void *>(frame.pc),
1075 reinterpret_cast<void *>(frame.sp), reinterpret_cast<void *>(frame.fp), ret);
1154 void Unwinder::Impl::AddFrame(const StepFrame& frame, std::shared_ptr<DfxMap> map)
1157 if (ignoreMixstack_ && frame.isJsFrame) {
1161 pcs_.emplace_back(frame.pc);
1163 dfxFrame.isJsFrame = frame.isJsFrame;
1165 dfxFrame.pc = static_cast<uint64_t>(frame.pc);
1166 dfxFrame.sp = static_cast<uint64_t>(frame.sp);
1168 if (frame.isJsFrame) {
1169 dfxFrame.funcOffset = static_cast<uint64_t>(frame.methodid);
1176 void Unwinder::Impl::AddFrame(DfxFrame& frame)
1178 frames_.emplace_back(frame);
1194 // clean up frames after first invalid frame
1205 auto& frame = frames[i];
1206 if (frame.isJsFrame) {
1208 FillJsFrame(frame);
1211 FillFrame(frame);
1216 void Unwinder::Impl::FillFrame(DfxFrame& frame)
1218 if (frame.map == nullptr) {
1219 frame.relPc = frame.pc;
1220 frame.mapName = "Not mapped";
1221 DFXLOGU("Current frame is not mapped.");
1224 frame.mapName = frame.map->GetElfName();
1225 DFX_TRACE_SCOPED_DLSYM("FillFrame:%s", frame.mapName.c_str());
1226 frame.relPc = frame.map->GetRelPc(frame.pc);
1227 frame.mapOffset = frame.map->offset;
1228 DFXLOGU("mapName: %{public}s, mapOffset: %{public}" PRIx64 "", frame.mapName.c_str(), frame.mapOffset);
1229 auto elf = frame.map->GetElf();
1232 FillJsFrame(frame);
1236 if (!DfxSymbols::GetFuncNameAndOffsetByPc(frame.relPc, elf, frame.funcName, frame.funcOffset)) {
1238 frame.relPc, frame.mapName.c_str());
1240 frame.buildId = elf->GetBuildId();
1243 void Unwinder::Impl::FillJsFrame(DfxFrame& frame)
1245 if (frame.map == nullptr) {
1246 DFXLOGU("Current js frame is not map.");
1249 DFX_TRACE_SCOPED_DLSYM("FillJsFrame:%s", frame.map->name.c_str());
1250 DFXLOGU("Fill js frame, map name: %{public}s", frame.map->name.c_str());
1251 auto hap = frame.map->GetHap();
1253 DFXLOGW("Get hap error, name: %{public}s", frame.map->name.c_str());
1258 if (DfxArk::ParseArkFrameInfoLocal(static_cast<uintptr_t>(frame.pc), static_cast<uintptr_t>(frame.funcOffset),
1259 static_cast<uintptr_t>(frame.map->begin), static_cast<uintptr_t>(frame.map->offset), &jsFunction) < 0) {
1260 DFXLOGW("Failed to parse ark frame info local, pc: %{public}p, begin: %{public}p",
1261 reinterpret_cast<void *>(frame.pc), reinterpret_cast<void *>(frame.map->begin));
1264 frame.isJsFrame = true;
1266 if (!hap->ParseHapInfo(pid_, frame.pc, static_cast<uintptr_t>(frame.funcOffset), frame.map, &jsFunction)) {
1271 frame.mapName = std::string(jsFunction.url);
1272 frame.funcName = std::string(jsFunction.functionName);
1273 frame.line = static_cast<int32_t>(jsFunction.line);
1274 frame.column = jsFunction.column;
1275 DFXLOGU("Js frame mapName: %{public}s, funcName: %{public}s, line: %{public}d, column: %{public}d",
1276 frame.mapName.c_str(), frame.funcName.c_str(), frame.line, frame.column);
1279 bool Unwinder::Impl::GetFrameByPc(uintptr_t pc, std::shared_ptr<DfxMaps> maps, DfxFrame &frame)
1281 frame.pc = static_cast<uint64_t>(StripPac(pc, 0));
1288 frame.map = map;
1289 FillFrame(frame);
1329 DfxFrame frame;
1330 frame.index = i;
1331 frame.pc = static_cast<uint64_t>(StripPac(pcs[i], 0));
1332 if ((map != nullptr) && map->Contain(frame.pc)) {
1339 frame.map = map;
1340 FillFrame(frame);
1341 frames.emplace_back(frame);
1349 DfxFrame frame;
1350 frame.index = i;
1351 frame.pc = static_cast<uint64_t>(pcs[i]);
1352 frames.emplace_back(frame);
1383 auto frame = reinterpret_cast<DfxFrame *>(data);
1385 frame->pc = StripPac(frame->pc, 0);
1389 if (frame->pc >= vaddr && frame->pc < vaddr + phdr->p_memsz) {
1390 frame->relPc = frame->pc - info->dlpi_addr;
1391 frame->mapName = std::string(info->dlpi_name);
1392 DFXLOGU("relPc: %{public}" PRIx64 ", mapName: %{public}s", frame->relPc, frame->mapName.c_str());