Lines Matching refs:ptr

42     uintptr_t i = 0, ptr = tableData;

44     while (i++ < fdeCount && ptr < uti.endPc) {

45         uintptr_t fdeAddr = ptr;

46         if (GetCieOrFde(ptr, fdeInfo)) {

71     uintptr_t ptr = 0;

78         ptr = (uintptr_t) tableData + cur * sizeof(DwarfTableEntry);

79         if (!memory_->ReadS32(ptr, &dwarfTableEntry.startPc, true)) {

80             lastErrorData_.SetAddrAndCode(ptr, UNW_ERROR_INVALID_MEMORY);

85             if (!memory_->ReadS32(ptr, &dwarfTableEntry.fdeOffset, true)) {

86                 lastErrorData_.SetAddrAndCode(ptr, UNW_ERROR_INVALID_MEMORY);

100             ptr = static_cast<uintptr_t>(tableData) + (high - 1) * sizeof(DwarfTableEntry) + 4; // 4 : four bytes

101             if (!memory_->ReadS32(ptr, &dwarfTableEntry.fdeOffset, true)) {

102                 lastErrorData_.SetAddrAndCode(ptr, UNW_ERROR_INVALID_MEMORY);

143     uintptr_t ptr = addr;

145     ParseCieOrFdeHeader(ptr, fdeInfo, isCieEntry);

148         if (!ParseCie(addr, ptr, fdeInfo.cie)) {

154         if (!ParseFde(addr, ptr, fdeInfo)) {

163 void DwarfSection::ParseCieOrFdeHeader(uintptr_t& ptr, FrameDescEntry &fdeInfo, bool& isCieEntry)

166     memory_->ReadU32(ptr, &value32, true);

171         memory_->ReadU64(ptr, &value64, true);

172         instructionsEnd = ptr + value64;

174         memory_->ReadU64(ptr, &value64, true);

182             fdeInfo.cieAddr = static_cast<uintptr_t>(ptr - ciePtr);

184         ptr += sizeof(uint64_t);

186         instructionsEnd = ptr + value32;

187         memory_->ReadU32(ptr, &value32, false);

195             fdeInfo.cieAddr = static_cast<uintptr_t>(ptr - ciePtr);

197         ptr += sizeof(uint32_t);

229 bool DwarfSection::FillInFde(uintptr_t ptr, FrameDescEntry &fdeInfo)

238         ptr += fdeInfo.cie.segmentSize;

242     uintptr_t pcStart = memory_->ReadEncodedValue(ptr, fdeInfo.cie.pointerEncoding);

243     uintptr_t pcRange = memory_->ReadEncodedValue(ptr, (fdeInfo.cie.pointerEncoding & 0x0F));

248         uintptr_t augLen = memory_->ReadUleb128(ptr);

249         uintptr_t instructionsPtr = ptr + augLen;

251             uintptr_t lsdaPtr = ptr;

252             if (memory_->ReadEncodedValue(ptr, (fdeInfo.cie.lsdaEncoding & 0x0F)) != 0) {

256         ptr = instructionsPtr;

259     fdeInfo.instructionsOff = ptr;

296 bool DwarfSection::FillInCie(uintptr_t ptr, CommonInfoEntry &cieInfo)

299     memory_->ReadU8(ptr, &version, true);

303         lastErrorData_.SetAddrAndCode(ptr, UNW_ERROR_UNSUPPORTED_VERSION);

312         memory_->ReadU8(ptr, &ch, true);

322         ptr += 1;

323         memory_->ReadU8(ptr, &cieInfo.segmentSize, true);

329     cieInfo.codeAlignFactor = (uint32_t)memory_->ReadUleb128(ptr);

333     cieInfo.dataAlignFactor = (int32_t)memory_->ReadSleb128(ptr);

339         memory_->ReadU8(ptr, &val, true);

342         cieInfo.returnAddressRegister = (uintptr_t)memory_->ReadUleb128(ptr);

348         cieInfo.instructionsOff = ptr;

353     MAYBE_UNUSED uintptr_t augSize = memory_->ReadUleb128(ptr);

355     cieInfo.instructionsOff = ptr + augSize;

361                 memory_->ReadU8(ptr, &personalityEncoding, true);

362                 cieInfo.personality = memory_->ReadEncodedValue(ptr, personalityEncoding);

365                 memory_->ReadU8(ptr, &cieInfo.lsdaEncoding, true);

369                 memory_->ReadU8(ptr, &cieInfo.pointerEncoding, true);