Merge "New version of unwinder." (e69b1b98) · Commits · e / os / android_system_core

libunwindstack/Android.bp

0 → 100644

+129 −0

Original line number	Diff line number	Diff line
		//
		// Copyright (C) 2017 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.
		//

		cc_defaults {
		name: "libunwindstack_flags",

		host_supported: true,

		cflags: [
		"-Wall",
		"-Werror",
		"-Wextra",
		],
		}

		cc_defaults {
		name: "libunwindstack_common",
		defaults: ["libunwindstack_flags"],

		srcs: [
		"ArmExidx.cpp",
		"Memory.cpp",
		"Log.cpp",
		],

		shared_libs: [
		"libbase",
		"liblog",
		],
		}

		cc_library {
		name: "libunwindstack",
		defaults: ["libunwindstack_common"],
		}

		cc_library {
		name: "libunwindstack_debug",
		defaults: ["libunwindstack_common"],

		cflags: [
		"-UNDEBUG",
		"-O0",
		"-g",
		],
		}

		//-------------------------------------------------------------------------
		// Unit Tests
		//-------------------------------------------------------------------------
		cc_defaults {
		name: "libunwindstack_test_common",
		defaults: ["libunwindstack_flags"],

		srcs: [
		"tests/ArmExidxDecodeTest.cpp",
		"tests/ArmExidxExtractTest.cpp",
		"tests/LogFake.cpp",
		"tests/MemoryFake.cpp",
		"tests/MemoryFileTest.cpp",
		"tests/MemoryLocalTest.cpp",
		"tests/MemoryRangeTest.cpp",
		"tests/MemoryRemoteTest.cpp",
		"tests/RegsTest.cpp",
		],

		cflags: [
		"-O0",
		"-g",
		],

		shared_libs: [
		"libbase",
		"liblog",
		],

		multilib: {
		lib32: {
		suffix: "32",
		},
		lib64: {
		suffix: "64",
		},
		},

		target: {
		darwin: {
		enabled: false,
		},
		linux: {
		host_ldlibs: [
		"-lrt",
		],
		},
		},
		}

		// These unit tests run against the shared library.
		cc_test {
		name: "libunwindstack_test",
		defaults: ["libunwindstack_test_common"],

		shared_libs: [
		"libunwindstack",
		],
		}

		// These unit tests run against the static debug library.
		cc_test {
		name: "libunwindstack_test_debug",
		defaults: ["libunwindstack_test_common"],

		static_libs: [
		"libunwindstack_debug",
		],
		}

libunwindstack/ArmExidx.cpp

0 → 100644

+680 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		#include <assert.h>
		#include <stdint.h>

		#include <deque>
		#include <string>

		#include <android-base/stringprintf.h>

		#include "ArmExidx.h"
		#include "Log.h"
		#include "Machine.h"

		void ArmExidx::LogRawData() {
		std::string log_str("Raw Data:");
		for (const uint8_t data : data_) {
		log_str += android::base::StringPrintf(" 0x%02x", data);
		}
		log(log_indent_, log_str.c_str());
		}

		bool ArmExidx::ExtractEntryData(uint32_t entry_offset) {
		data_.clear();
		status_ = ARM_STATUS_NONE;

		if (entry_offset & 1) {
		// The offset needs to be at least two byte aligned.
		status_ = ARM_STATUS_INVALID_ALIGNMENT;
		return false;
		}

		// Each entry is a 32 bit prel31 offset followed by 32 bits
		// of unwind information. If bit 31 of the unwind data is zero,
		// then this is a prel31 offset to the start of the unwind data.
		// If the unwind data is 1, then this is a cant unwind entry.
		// Otherwise, this data is the compact form of the unwind information.
		uint32_t data;
		if (!elf_memory_->Read32(entry_offset + 4, &data)) {
		status_ = ARM_STATUS_READ_FAILED;
		return false;
		}
		if (data == 1) {
		// This is a CANT UNWIND entry.
		status_ = ARM_STATUS_NO_UNWIND;
		if (log_) {
		log(log_indent_, "Raw Data: 0x00 0x00 0x00 0x01");
		log(log_indent_, "[cantunwind]");
		}
		return false;
		}

		if (data & (1UL << 31)) {
		// This is a compact table entry.
		if ((data >> 24) & 0xf) {
		// This is a non-zero index, this code doesn't support
		// other formats.
		status_ = ARM_STATUS_INVALID_PERSONALITY;
		return false;
		}
		data_.push_back((data >> 16) & 0xff);
		data_.push_back((data >> 8) & 0xff);
		uint8_t last_op = data & 0xff;
		data_.push_back(last_op);
		if (last_op != ARM_OP_FINISH) {
		// If this didn't end with a finish op, add one.
		data_.push_back(ARM_OP_FINISH);
		}
		if (log_) {
		LogRawData();
		}
		return true;
		}

		// Get the address of the ops.
		// Sign extend the data value if necessary.
		int32_t signed_data = static_cast<int32_t>(data << 1) >> 1;
		uint32_t addr = (entry_offset + 4) + signed_data;
		if (!elf_memory_->Read32(addr, &data)) {
		status_ = ARM_STATUS_READ_FAILED;
		return false;
		}

		size_t num_table_words;
		if (data & (1UL << 31)) {
		// Compact model.
		switch ((data >> 24) & 0xf) {
		case 0:
		num_table_words = 0;
		data_.push_back((data >> 16) & 0xff);
		break;
		case 1:
		case 2:
		num_table_words = (data >> 16) & 0xff;
		addr += 4;
		break;
		default:
		// Only a personality of 0, 1, 2 is valid.
		status_ = ARM_STATUS_INVALID_PERSONALITY;
		return false;
		}
		data_.push_back((data >> 8) & 0xff);
		data_.push_back(data & 0xff);
		} else {
		// Generic model.

		// Skip the personality routine data, it doesn't contain any data
		// needed to decode the unwind information.
		addr += 4;
		if (!elf_memory_->Read32(addr, &data)) {
		status_ = ARM_STATUS_READ_FAILED;
		return false;
		}
		num_table_words = (data >> 24) & 0xff;
		data_.push_back((data >> 16) & 0xff);
		data_.push_back((data >> 8) & 0xff);
		data_.push_back(data & 0xff);
		addr += 4;
		}

		if (num_table_words > 5) {
		status_ = ARM_STATUS_MALFORMED;
		return false;
		}

		for (size_t i = 0; i < num_table_words; i++) {
		if (!elf_memory_->Read32(addr, &data)) {
		status_ = ARM_STATUS_READ_FAILED;
		return false;
		}
		data_.push_back((data >> 24) & 0xff);
		data_.push_back((data >> 16) & 0xff);
		data_.push_back((data >> 8) & 0xff);
		data_.push_back(data & 0xff);
		addr += 4;
		}

		if (data_.back() != ARM_OP_FINISH) {
		// If this didn't end with a finish op, add one.
		data_.push_back(ARM_OP_FINISH);
		}

		if (log_) {
		LogRawData();
		}
		return true;
		}

		inline bool ArmExidx::GetByte(uint8_t* byte) {
		if (data_.empty()) {
		status_ = ARM_STATUS_TRUNCATED;
		return false;
		}
		*byte = data_.front();
		data_.pop_front();
		return true;
		}

		inline bool ArmExidx::DecodePrefix_10_00(uint8_t byte) {
		assert((byte >> 4) == 0x8);

		uint16_t registers = (byte & 0xf) << 8;
		if (!GetByte(&byte)) {
		return false;
		}

		registers \|= byte;
		if (registers == 0) {
		// 10000000 00000000: Refuse to unwind
		if (log_) {
		log(log_indent_, "Refuse to unwind");
		}
		status_ = ARM_STATUS_NO_UNWIND;
		return false;
		}
		// 1000iiii iiiiiiii: Pop up to 12 integer registers under masks {r15-r12}, {r11-r4}
		if (log_) {
		bool add_comma = false;
		std::string msg = "pop {";
		for (size_t i = 0; i < 12; i++) {
		if (registers & (1 << i)) {
		if (add_comma) {
		msg += ", ";
		}
		msg += android::base::StringPrintf("r%zu", i + 4);
		add_comma = true;
		}
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}

		registers <<= 4;
		for (size_t reg = 4; reg < 16; reg++) {
		if (registers & (1 << reg)) {
		if (!process_memory_->Read32(cfa_, &(*regs_)[reg])) {
		status_ = ARM_STATUS_READ_FAILED;
		return false;
		}
		cfa_ += 4;
		}
		}
		// If the sp register is modified, change the cfa value.
		if (registers & (1 << ARM_REG_SP)) {
		cfa_ = (*regs_)[ARM_REG_SP];
		}
		return true;
		}

		inline bool ArmExidx::DecodePrefix_10_01(uint8_t byte) {
		assert((byte >> 4) == 0x9);

		uint8_t bits = byte & 0xf;
		if (bits == 13 \|\| bits == 15) {
		// 10011101: Reserved as prefix for ARM register to register moves
		// 10011111: Reserved as prefix for Intel Wireless MMX register to register moves
		if (log_) {
		log(log_indent_, "[Reserved]");
		}
		status_ = ARM_STATUS_RESERVED;
		return false;
		}
		// 1001nnnn: Set vsp = r[nnnn] (nnnn != 13, 15)
		if (log_) {
		log(log_indent_, "vsp = r%d", bits);
		if (log_skip_execution_) {
		return true;
		}
		}
		// It is impossible for bits to be larger than the total number of
		// arm registers, so don't bother checking if bits is a valid register.
		cfa_ = (*regs_)[bits];
		return true;
		}

		inline bool ArmExidx::DecodePrefix_10_10(uint8_t byte) {
		assert((byte >> 4) == 0xa);

		// 10100nnn: Pop r4-r[4+nnn]
		// 10101nnn: Pop r4-r[4+nnn], r14
		if (log_) {
		std::string msg = "pop {r4";
		uint8_t end_reg = byte & 0x7;
		if (end_reg) {
		msg += android::base::StringPrintf("-r%d", 4 + end_reg);
		}
		if (byte & 0x8) {
		log(log_indent_, "%s, r14}", msg.c_str());
		} else {
		log(log_indent_, "%s}", msg.c_str());
		}
		if (log_skip_execution_) {
		return true;
		}
		}

		for (size_t i = 4; i <= 4 + (byte & 0x7); i++) {
		if (!process_memory_->Read32(cfa_, &(*regs_)[i])) {
		status_ = ARM_STATUS_READ_FAILED;
		return false;
		}
		cfa_ += 4;
		}
		if (byte & 0x8) {
		if (!process_memory_->Read32(cfa_, &(*regs_)[ARM_REG_R14])) {
		status_ = ARM_STATUS_READ_FAILED;
		return false;
		}
		cfa_ += 4;
		}
		return true;
		}

		inline bool ArmExidx::DecodePrefix_10_11_0000() {
		// 10110000: Finish
		if (log_) {
		log(log_indent_, "finish");
		if (log_skip_execution_) {
		status_ = ARM_STATUS_FINISH;
		return false;
		}
		}
		if (!(*regs_)[ARM_REG_PC]) {
		(regs_)[ARM_REG_PC] = (regs_)[ARM_REG_LR];
		}
		status_ = ARM_STATUS_FINISH;
		return false;
		}

		inline bool ArmExidx::DecodePrefix_10_11_0001() {
		uint8_t byte;
		if (!GetByte(&byte)) {
		return false;
		}

		if (byte == 0) {
		// 10110001 00000000: Spare
		if (log_) {
		log(log_indent_, "Spare");
		}
		status_ = ARM_STATUS_SPARE;
		return false;
		}
		if (byte >> 4) {
		// 10110001 xxxxyyyy: Spare (xxxx != 0000)
		if (log_) {
		log(log_indent_, "Spare");
		}
		status_ = ARM_STATUS_SPARE;
		return false;
		}

		// 10110001 0000iiii: Pop integer registers under mask {r3, r2, r1, r0}
		if (log_) {
		bool add_comma = false;
		std::string msg = "pop {";
		for (size_t i = 0; i < 4; i++) {
		if (byte & (1 << i)) {
		if (add_comma) {
		msg += ", ";
		}
		msg += android::base::StringPrintf("r%zu", i);
		add_comma = true;
		}
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}

		for (size_t reg = 0; reg < 4; reg++) {
		if (byte & (1 << reg)) {
		if (!process_memory_->Read32(cfa_, &(*regs_)[reg])) {
		status_ = ARM_STATUS_READ_FAILED;
		return false;
		}
		cfa_ += 4;
		}
		}
		return true;
		}

		inline bool ArmExidx::DecodePrefix_10_11_0010() {
		// 10110010 uleb128: vsp = vsp + 0x204 + (uleb128 << 2)
		uint32_t result = 0;
		uint32_t shift = 0;
		uint8_t byte;
		do {
		if (!GetByte(&byte)) {
		return false;
		}

		result \|= (byte & 0x7f) << shift;
		shift += 7;
		} while (byte & 0x80);
		result <<= 2;
		if (log_) {
		log(log_indent_, "vsp = vsp + %d", 0x204 + result);
		if (log_skip_execution_) {
		return true;
		}
		}
		cfa_ += 0x204 + result;
		return true;
		}

		inline bool ArmExidx::DecodePrefix_10_11_0011() {
		// 10110011 sssscccc: Pop VFP double precision registers D[ssss]-D[ssss+cccc] by FSTMFDX
		uint8_t byte;
		if (!GetByte(&byte)) {
		return false;
		}

		if (log_) {
		uint8_t start_reg = byte >> 4;
		std::string msg = android::base::StringPrintf("pop {d%d", start_reg);
		uint8_t end_reg = start_reg + (byte & 0xf);
		if (end_reg) {
		msg += android::base::StringPrintf("-d%d", end_reg);
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}
		cfa_ += (byte & 0xf) * 8 + 12;
		return true;
		}

		inline bool ArmExidx::DecodePrefix_10_11_01nn() {
		// 101101nn: Spare
		if (log_) {
		log(log_indent_, "Spare");
		}
		status_ = ARM_STATUS_SPARE;
		return false;
		}

		inline bool ArmExidx::DecodePrefix_10_11_1nnn(uint8_t byte) {
		assert((byte & ~0x07) == 0xb8);

		// 10111nnn: Pop VFP double-precision registers D[8]-D[8+nnn] by FSTMFDX
		if (log_) {
		std::string msg = "pop {d8";
		uint8_t last_reg = (byte & 0x7);
		if (last_reg) {
		msg += android::base::StringPrintf("-d%d", last_reg + 8);
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}
		// Only update the cfa.
		cfa_ += (byte & 0x7) * 8 + 12;
		return true;
		}

		inline bool ArmExidx::DecodePrefix_10(uint8_t byte) {
		assert((byte >> 6) == 0x2);

		switch ((byte >> 4) & 0x3) {
		case 0:
		return DecodePrefix_10_00(byte);
		case 1:
		return DecodePrefix_10_01(byte);
		case 2:
		return DecodePrefix_10_10(byte);
		default:
		switch (byte & 0xf) {
		case 0:
		return DecodePrefix_10_11_0000();
		case 1:
		return DecodePrefix_10_11_0001();
		case 2:
		return DecodePrefix_10_11_0010();
		case 3:
		return DecodePrefix_10_11_0011();
		default:
		if (byte & 0x8) {
		return DecodePrefix_10_11_1nnn(byte);
		} else {
		return DecodePrefix_10_11_01nn();
		}
		}
		}
		}

		inline bool ArmExidx::DecodePrefix_11_000(uint8_t byte) {
		assert((byte & ~0x07) == 0xc0);

		uint8_t bits = byte & 0x7;
		if (bits == 6) {
		if (!GetByte(&byte)) {
		return false;
		}

		// 11000110 sssscccc: Intel Wireless MMX pop wR[ssss]-wR[ssss+cccc]
		if (log_) {
		uint8_t start_reg = byte >> 4;
		std::string msg = android::base::StringPrintf("pop {wR%d", start_reg);
		uint8_t end_reg = byte & 0xf;
		if (end_reg) {
		msg += android::base::StringPrintf("-wR%d", start_reg + end_reg);
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}
		// Only update the cfa.
		cfa_ += (byte & 0xf) * 8 + 8;
		} else if (bits == 7) {
		if (!GetByte(&byte)) {
		return false;
		}

		if (byte == 0) {
		// 11000111 00000000: Spare
		if (log_) {
		log(log_indent_, "Spare");
		}
		status_ = ARM_STATUS_SPARE;
		return false;
		} else if ((byte >> 4) == 0) {
		// 11000111 0000iiii: Intel Wireless MMX pop wCGR registers {wCGR0,1,2,3}
		if (log_) {
		bool add_comma = false;
		std::string msg = "pop {";
		for (size_t i = 0; i < 4; i++) {
		if (byte & (1 << i)) {
		if (add_comma) {
		msg += ", ";
		}
		msg += android::base::StringPrintf("wCGR%zu", i);
		add_comma = true;
		}
		}
		log(log_indent_, "%s}", msg.c_str());
		}
		// Only update the cfa.
		cfa_ += __builtin_popcount(byte) * 4;
		} else {
		// 11000111 xxxxyyyy: Spare (xxxx != 0000)
		if (log_) {
		log(log_indent_, "Spare");
		}
		status_ = ARM_STATUS_SPARE;
		return false;
		}
		} else {
		// 11000nnn: Intel Wireless MMX pop wR[10]-wR[10+nnn] (nnn != 6, 7)
		if (log_) {
		std::string msg = "pop {wR10";
		uint8_t nnn = byte & 0x7;
		if (nnn) {
		msg += android::base::StringPrintf("-wR%d", 10 + nnn);
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}
		// Only update the cfa.
		cfa_ += (byte & 0x7) * 8 + 8;
		}
		return true;
		}

		inline bool ArmExidx::DecodePrefix_11_001(uint8_t byte) {
		assert((byte & ~0x07) == 0xc8);

		uint8_t bits = byte & 0x7;
		if (bits == 0) {
		// 11001000 sssscccc: Pop VFP double precision registers D[16+ssss]-D[16+ssss+cccc] by VPUSH
		if (!GetByte(&byte)) {
		return false;
		}

		if (log_) {
		uint8_t start_reg = byte >> 4;
		std::string msg = android::base::StringPrintf("pop {d%d", 16 + start_reg);
		uint8_t end_reg = byte & 0xf;
		if (end_reg) {
		msg += android::base::StringPrintf("-d%d", 16 + start_reg + end_reg);
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}
		// Only update the cfa.
		cfa_ += (byte & 0xf) * 8 + 8;
		} else if (bits == 1) {
		// 11001001 sssscccc: Pop VFP double precision registers D[ssss]-D[ssss+cccc] by VPUSH
		if (!GetByte(&byte)) {
		return false;
		}

		if (log_) {
		uint8_t start_reg = byte >> 4;
		std::string msg = android::base::StringPrintf("pop {d%d", start_reg);
		uint8_t end_reg = byte & 0xf;
		if (end_reg) {
		msg += android::base::StringPrintf("-d%d", start_reg + end_reg);
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}
		// Only update the cfa.
		cfa_ += (byte & 0xf) * 8 + 8;
		} else {
		// 11001yyy: Spare (yyy != 000, 001)
		if (log_) {
		log(log_indent_, "Spare");
		}
		status_ = ARM_STATUS_SPARE;
		return false;
		}
		return true;
		}

		inline bool ArmExidx::DecodePrefix_11_010(uint8_t byte) {
		assert((byte & ~0x07) == 0xd0);

		// 11010nnn: Pop VFP double precision registers D[8]-D[8+nnn] by VPUSH
		if (log_) {
		std::string msg = "pop {d8";
		uint8_t end_reg = byte & 0x7;
		if (end_reg) {
		msg += android::base::StringPrintf("-d%d", 8 + end_reg);
		}
		log(log_indent_, "%s}", msg.c_str());
		if (log_skip_execution_) {
		return true;
		}
		}
		cfa_ += (byte & 0x7) * 8 + 8;
		return true;
		}

		inline bool ArmExidx::DecodePrefix_11(uint8_t byte) {
		assert((byte >> 6) == 0x3);

		switch ((byte >> 3) & 0x7) {
		case 0:
		return DecodePrefix_11_000(byte);
		case 1:
		return DecodePrefix_11_001(byte);
		case 2:
		return DecodePrefix_11_010(byte);
		default:
		// 11xxxyyy: Spare (xxx != 000, 001, 010)
		if (log_) {
		log(log_indent_, "Spare");
		}
		status_ = ARM_STATUS_SPARE;
		return false;
		}
		}

		bool ArmExidx::Decode() {
		status_ = ARM_STATUS_NONE;
		uint8_t byte;
		if (!GetByte(&byte)) {
		return false;
		}

		switch (byte >> 6) {
		case 0:
		// 00xxxxxx: vsp = vsp + (xxxxxxx << 2) + 4
		if (log_) {
		log(log_indent_, "vsp = vsp + %d", ((byte & 0x3f) << 2) + 4);
		if (log_skip_execution_) {
		break;
		}
		}
		cfa_ += ((byte & 0x3f) << 2) + 4;
		break;
		case 1:
		// 01xxxxxx: vsp = vsp - (xxxxxxx << 2) + 4
		if (log_) {
		log(log_indent_, "vsp = vsp - %d", ((byte & 0x3f) << 2) + 4);
		if (log_skip_execution_) {
		break;
		}
		}
		cfa_ -= ((byte & 0x3f) << 2) + 4;
		break;
		case 2:
		return DecodePrefix_10(byte);
		default:
		return DecodePrefix_11(byte);
		}
		return true;
		}

		bool ArmExidx::Eval() {
		while (Decode());
		return status_ == ARM_STATUS_FINISH;
		}

libunwindstack/ArmExidx.h

0 → 100644

+103 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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_ARM_EXIDX_H
		#define _LIBUNWINDSTACK_ARM_EXIDX_H

		#include <stdint.h>

		#include <deque>

		#include "Memory.h"
		#include "Regs.h"

		enum ArmStatus : size_t {
		ARM_STATUS_NONE = 0,
		ARM_STATUS_NO_UNWIND,
		ARM_STATUS_FINISH,
		ARM_STATUS_RESERVED,
		ARM_STATUS_SPARE,
		ARM_STATUS_TRUNCATED,
		ARM_STATUS_READ_FAILED,
		ARM_STATUS_MALFORMED,
		ARM_STATUS_INVALID_ALIGNMENT,
		ARM_STATUS_INVALID_PERSONALITY,
		};

		enum ArmOp : uint8_t {
		ARM_OP_FINISH = 0xb0,
		};

		class ArmExidx {
		public:
		ArmExidx(Regs32* regs, Memory* elf_memory, Memory* process_memory)
		: regs_(regs), elf_memory_(elf_memory), process_memory_(process_memory) {}
		virtual ~ArmExidx() {}

		void LogRawData();

		bool ExtractEntryData(uint32_t entry_offset);

		bool Eval();

		bool Decode();

		std::deque<uint8_t>* data() { return &data_; }

		ArmStatus status() { return status_; }

		Regs32* regs() { return regs_; }

		uint32_t cfa() { return cfa_; }
		void set_cfa(uint32_t cfa) { cfa_ = cfa; }

		void set_log(bool log) { log_ = log; }
		void set_log_skip_execution(bool skip_execution) { log_skip_execution_ = skip_execution; }
		void set_log_indent(uint8_t indent) { log_indent_ = indent; }

		private:
		bool GetByte(uint8_t* byte);

		bool DecodePrefix_10_00(uint8_t byte);
		bool DecodePrefix_10_01(uint8_t byte);
		bool DecodePrefix_10_10(uint8_t byte);
		bool DecodePrefix_10_11_0000();
		bool DecodePrefix_10_11_0001();
		bool DecodePrefix_10_11_0010();
		bool DecodePrefix_10_11_0011();
		bool DecodePrefix_10_11_01nn();
		bool DecodePrefix_10_11_1nnn(uint8_t byte);
		bool DecodePrefix_10(uint8_t byte);

		bool DecodePrefix_11_000(uint8_t byte);
		bool DecodePrefix_11_001(uint8_t byte);
		bool DecodePrefix_11_010(uint8_t byte);
		bool DecodePrefix_11(uint8_t byte);

		Regs32* regs_ = nullptr;
		uint32_t cfa_ = 0;
		std::deque<uint8_t> data_;
		ArmStatus status_ = ARM_STATUS_NONE;

		Memory* elf_memory_;
		Memory* process_memory_;

		bool log_ = false;
		uint8_t log_indent_ = 0;
		bool log_skip_execution_ = false;
		};

		#endif // _LIBUNWINDSTACK_ARM_EXIDX_H

libunwindstack/Log.cpp

0 → 100644

+53 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		#include <stdarg.h>
		#include <stdint.h>
		#include <stdio.h>

		#include <string>

		#define LOG_TAG "unwind"
		#include <log/log.h>

		#include <android-base/stringprintf.h>

		#include "Log.h"

		static bool g_print_to_stdout = false;

		void log_to_stdout(bool enable) {
		g_print_to_stdout = enable;
		}

		// Send the data to the log.
		void log(uint8_t indent, const char* format, ...) {
		std::string real_format;
		if (indent > 0) {
		real_format = android::base::StringPrintf("%s%s", 2 indent, " ", format);
		} else {
		real_format = format;
		}
		va_list args;
		va_start(args, format);
		if (g_print_to_stdout) {
		real_format += '\n';
		vprintf(real_format.c_str(), args);
		} else {
		LOG_PRI_VA(ANDROID_LOG_INFO, LOG_TAG, real_format.c_str(), args);
		}
		va_end(args);
		}

libunwindstack/Log.h

0 → 100644

+25 −0

File added.

Preview size limit exceeded, changes collapsed.