Merge "Implement new DEX PC lookup scheme." am: f1e55f7a99 am: c3aabea0b1 (5a33a4bf) · Commits · e / os / android_system_core

libunwindstack/DwarfOp.cpp

+40 −14

Original line number	Diff line number	Diff line
		@@ -36,13 +36,45 @@ template <typename AddressType>
		constexpr typename DwarfOp<AddressType>::OpCallback DwarfOp<AddressType>::kCallbackTable[256];

		template <typename AddressType>
		bool DwarfOp<AddressType>::Eval(uint64_t start, uint64_t end, uint8_t dwarf_version) {
		uint32_t iterations = 0;
		bool DwarfOp<AddressType>::Eval(uint64_t start, uint64_t end) {
		is_register_ = false;
		stack_.clear();
		memory_->set_cur_offset(start);
		dex_pc_set_ = false;

		// Unroll the first Decode calls to be able to check for a special
		// sequence of ops and values that indicate this is the dex pc.
		// The pattern is:
		// OP_const4u (0x0c) 'D' 'E' 'X' '1'
		// OP_drop (0x13)
		if (memory_->cur_offset() < end) {
		if (!Decode()) {
		return false;
		}
		} else {
		return true;
		}
		bool check_for_drop;
		if (cur_op_ == 0x0c && operands_.back() == 0x31584544) {
		check_for_drop = true;
		} else {
		check_for_drop = false;
		}
		if (memory_->cur_offset() < end) {
		if (!Decode()) {
		return false;
		}
		} else {
		return true;
		}

		if (check_for_drop && cur_op_ == 0x13) {
		dex_pc_set_ = true;
		}

		uint32_t iterations = 2;
		while (memory_->cur_offset() < end) {
		if (!Decode(dwarf_version)) {
		if (!Decode()) {
		return false;
		}
		// To protect against a branch that creates an infinite loop,
		@@ -56,7 +88,7 @@ bool DwarfOp<AddressType>::Eval(uint64_t start, uint64_t end, uint8_t dwarf_vers
		}

		template <typename AddressType>
		bool DwarfOp<AddressType>::Decode(uint8_t dwarf_version) {
		bool DwarfOp<AddressType>::Decode() {
		last_error_.code = DWARF_ERROR_NONE;
		if (!memory_->ReadBytes(&cur_op_, 1)) {
		last_error_.code = DWARF_ERROR_MEMORY_INVALID;
		@@ -71,12 +103,6 @@ bool DwarfOp<AddressType>::Decode(uint8_t dwarf_version) {
		return false;
		}

		// Check for an unsupported opcode.
		if (dwarf_version < op->supported_version) {
		last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
		return false;
		}

		// Make sure that the required number of stack elements is available.
		if (stack_.size() < op->num_required_stack_values) {
		last_error_.code = DWARF_ERROR_STACK_INDEX_NOT_VALID;
		@@ -434,22 +460,22 @@ bool DwarfOp<AddressType>::op_regx() {
		template <typename AddressType>
		bool DwarfOp<AddressType>::op_breg() {
		uint16_t reg = cur_op() - 0x70;
		if (reg >= regs_->total_regs()) {
		if (reg >= regs_info_->Total()) {
		last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
		return false;
		}
		stack_.push_front((*regs_)[reg] + OperandAt(0));
		stack_.push_front(regs_info_->Get(reg) + OperandAt(0));
		return true;
		}

		template <typename AddressType>
		bool DwarfOp<AddressType>::op_bregx() {
		AddressType reg = OperandAt(0);
		if (reg >= regs_->total_regs()) {
		if (reg >= regs_info_->Total()) {
		last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
		return false;
		}
		stack_.push_front((*regs_)[reg] + OperandAt(1));
		stack_.push_front(regs_info_->Get(reg) + OperandAt(1));
		return true;
		}

libunwindstack/DwarfOp.h

+114 −272

File changed.

Preview size limit exceeded, changes collapsed.

libunwindstack/DwarfSection.cpp

+30 −50

Original line number	Diff line number	Diff line
		@@ -26,16 +26,14 @@
		#include <unwindstack/Regs.h>

		#include "DwarfCfa.h"
		#include "DwarfEncoding.h"
		#include "DwarfOp.h"

		#include "DwarfDebugFrame.h"
		#include "DwarfEhFrame.h"
		#include "DwarfEncoding.h"
		#include "DwarfOp.h"
		#include "RegsInfo.h"

		namespace unwindstack {

		constexpr uint64_t DEX_PC_REG = 0x20444558;

		DwarfSection::DwarfSection(Memory* memory) : memory_(memory) {}

		const DwarfFde* DwarfSection::GetFdeFromPc(uint64_t pc) {
		@@ -75,14 +73,17 @@ bool DwarfSection::Step(uint64_t pc, Regs* regs, Memory* process_memory, bool* f
		}

		template <typename AddressType>
		bool DwarfSectionImpl<AddressType>::EvalExpression(const DwarfLocation& loc, uint8_t version,
		Memory* regular_memory, AddressType* value) {
		bool DwarfSectionImpl<AddressType>::EvalExpression(const DwarfLocation& loc, Memory* regular_memory,
		AddressType* value,
		RegsInfo<AddressType>* regs_info,
		bool* is_dex_pc) {
		DwarfOp<AddressType> op(&memory_, regular_memory);
		op.set_regs_info(regs_info);

		// Need to evaluate the op data.
		uint64_t start = loc.values[1];
		uint64_t end = start + loc.values[0];
		if (!op.Eval(start, end, version)) {
		uint64_t end = loc.values[1];
		uint64_t start = end - loc.values[0];
		if (!op.Eval(start, end)) {
		last_error_ = op.last_error();
		return false;
		}
		@@ -96,6 +97,9 @@ bool DwarfSectionImpl<AddressType>::EvalExpression(const DwarfLocation& loc, uin
		return false;
		}
		*value = op.StackAt(0);
		if (is_dex_pc != nullptr && op.dex_pc_set()) {
		*is_dex_pc = true;
		}
		return true;
		}

		@@ -103,12 +107,10 @@ template <typename AddressType>
		struct EvalInfo {
		const dwarf_loc_regs_t* loc_regs;
		const DwarfCie* cie;
		RegsImpl<AddressType>* cur_regs;
		Memory* regular_memory;
		AddressType cfa;
		bool return_address_undefined = false;
		uint64_t reg_map = 0;
		AddressType reg_values[64];
		RegsInfo<AddressType> regs_info;
		};

		template <typename AddressType>
		@@ -129,32 +131,18 @@ bool DwarfSectionImpl<AddressType>::EvalRegister(const DwarfLocation* loc, uint3
		break;
		case DWARF_LOCATION_REGISTER: {
		uint32_t cur_reg = loc->values[0];
		if (cur_reg >= eval_info->cur_regs->total_regs()) {
		if (cur_reg >= eval_info->regs_info.Total()) {
		last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
		return false;
		}
		AddressType* cur_reg_ptr = &(*eval_info->cur_regs)[cur_reg];
		const auto& entry = eval_info->loc_regs->find(cur_reg);
		if (entry != eval_info->loc_regs->end()) {
		if (!(eval_info->reg_map & (1 << cur_reg))) {
		eval_info->reg_map \|= 1 << cur_reg;
		eval_info->reg_values[cur_reg] = *cur_reg_ptr;
		if (!EvalRegister(&entry->second, cur_reg, cur_reg_ptr, eval_info)) {
		return false;
		}
		}

		// Use the register value from before any evaluations.
		*reg_ptr = eval_info->reg_values[cur_reg] + loc->values[1];
		} else {
		reg_ptr = cur_reg_ptr + loc->values[1];
		}
		*reg_ptr = eval_info->regs_info.Get(cur_reg) + loc->values[1];
		break;
		}
		case DWARF_LOCATION_EXPRESSION:
		case DWARF_LOCATION_VAL_EXPRESSION: {
		AddressType value;
		if (!EvalExpression(*loc, eval_info->cie->version, regular_memory, &value)) {
		bool is_dex_pc = false;
		if (!EvalExpression(*loc, regular_memory, &value, &eval_info->regs_info, &is_dex_pc)) {
		return false;
		}
		if (loc->type == DWARF_LOCATION_EXPRESSION) {
		@@ -165,6 +153,9 @@ bool DwarfSectionImpl<AddressType>::EvalRegister(const DwarfLocation* loc, uint3
		}
		} else {
		*reg_ptr = value;
		if (is_dex_pc) {
		eval_info->regs_info.regs->set_dex_pc(value);
		}
		}
		break;
		}
		@@ -201,8 +192,10 @@ bool DwarfSectionImpl<AddressType>::Eval(const DwarfCie* cie, Memory* regular_me

		AddressType prev_cfa = regs->sp();

		EvalInfo<AddressType> eval_info{
		.loc_regs = &loc_regs, .cie = cie, .regular_memory = regular_memory, .cur_regs = cur_regs};
		EvalInfo<AddressType> eval_info{.loc_regs = &loc_regs,
		.cie = cie,
		.regular_memory = regular_memory,
		.regs_info = RegsInfo<AddressType>(cur_regs)};
		const DwarfLocation* loc = &cfa_entry->second;
		// Only a few location types are valid for the cfa.
		switch (loc->type) {
		@@ -224,7 +217,7 @@ bool DwarfSectionImpl<AddressType>::Eval(const DwarfCie* cie, Memory* regular_me
		case DWARF_LOCATION_EXPRESSION:
		case DWARF_LOCATION_VAL_EXPRESSION: {
		AddressType value;
		if (!EvalExpression(*loc, cie->version, regular_memory, &value)) {
		if (!EvalExpression(*loc, regular_memory, &value, &eval_info.regs_info, nullptr)) {
		return false;
		}
		if (loc->type == DWARF_LOCATION_EXPRESSION) {
		@@ -249,28 +242,15 @@ bool DwarfSectionImpl<AddressType>::Eval(const DwarfCie* cie, Memory* regular_me
		if (reg == CFA_REG) continue;

		AddressType* reg_ptr;
		AddressType dex_pc = 0;
		if (reg == DEX_PC_REG) {
		// Special register that indicates this is a dex pc.
		dex_pc = 0;
		reg_ptr = &dex_pc;
		} else if (reg >= cur_regs->total_regs() \|\| eval_info.reg_map & (1 << reg)) {
		// Skip this unknown register, or a register that has already been
		// processed.
		if (reg >= cur_regs->total_regs()) {
		// Skip this unknown register.
		continue;
		} else {
		reg_ptr = &(*cur_regs)[reg];
		eval_info.reg_map \|= 1 << reg;
		eval_info.reg_values[reg] = *reg_ptr;
		}

		reg_ptr = eval_info.regs_info.Save(reg);
		if (!EvalRegister(&entry.second, reg, reg_ptr, &eval_info)) {
		return false;
		}

		if (reg == DEX_PC_REG) {
		cur_regs->set_dex_pc(dex_pc);
		}
		}

		// Find the return address location.

libunwindstack/RegsInfo.h

0 → 100644

+66 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef _LIBUNWINDSTACK_REGS_INFO_H
		#define _LIBUNWINDSTACK_REGS_INFO_H

		#include <stdint.h>

		#include <unwindstack/Regs.h>

		namespace unwindstack {

		template <typename AddressType>
		struct RegsInfo {
		RegsInfo(RegsImpl<AddressType>* regs) : regs(regs) {}

		RegsImpl<AddressType>* regs = nullptr;
		uint64_t saved_reg_map = 0;
		AddressType saved_regs[64];

		inline AddressType Get(uint32_t reg) {
		if (IsSaved(reg)) {
		return saved_regs[reg];
		}
		return (*regs)[reg];
		}

		inline AddressType* Save(uint32_t reg) {
		if (reg > sizeof(saved_regs) / sizeof(AddressType)) {
		// This should never happen as since all currently supported
		// architectures have the total number of registers < 64.
		abort();
		}
		saved_reg_map \|= 1 << reg;
		saved_regs[reg] = (*regs)[reg];
		return &(*regs)[reg];
		}

		inline bool IsSaved(uint32_t reg) {
		if (reg > sizeof(saved_regs) / sizeof(AddressType)) {
		// This should never happen as since all currently supported
		// architectures have the total number of registers < 64.
		abort();
		}
		return saved_reg_map & (1 << reg);
		}

		inline uint16_t Total() { return regs->total_regs(); }
		};

		} // namespace unwindstack

		#endif // _LIBUNWINDSTACK_REGS_INFO_H

libunwindstack/Unwinder.cpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -48,6 +48,7 @@ void Unwinder::FillInDexFrame() {
		size_t frame_num = frames_.size();
		frames_.resize(frame_num + 1);
		FrameData* frame = &frames_.at(frame_num);
		frame->num = frame_num;

		uint64_t dex_pc = regs_->dex_pc();
		frame->pc = dex_pc;