This is an archive of the discontinued LLVM Phabricator instance.

LGTM. The only time this plugin gets activated is when there's been some problem with the arch triple and we end up defaulting to this unwinder, which never works anyway.

LGTM. If UnwindLLDB is the unwinder, that makes things a little easier for plugin separation.

In D75680#1908368, @xiaobai wrote:

If UnwindLLDB is the unwinder, that makes things a little easier for plugin separation.

Yep, I think that after this we can just move UnwindLLDB into the core libraries. But that is a different patch...

Closed by commit rG71c1c184744c: [lldb] Delete UnwindMacOSXFrameBackchain (authored by labath). · Explain WhyMar 6 2020, 12:03 AM

This revision was automatically updated to reflect the committed changes.

Revision Contents

Path

Size

lldb/

source/

Plugins/

Process/

Utility/

CMakeLists.txt

2 lines

RegisterContextMacOSXFrameBackchain.h

RegisterContextMacOSXFrameBackchain.cpp

UnwindMacOSXFrameBackchain.h

UnwindMacOSXFrameBackchain.cpp

Target/

Thread.cpp

32 lines

Diff 248655

lldb/source/Plugins/Process/Utility/CMakeLists.txt

Show All 21 Lines	add_lldb_library(lldbPluginProcessUtility
RegisterContextFreeBSD_x86_64.cpp		RegisterContextFreeBSD_x86_64.cpp
RegisterContextHistory.cpp		RegisterContextHistory.cpp
RegisterContextLinux_i386.cpp		RegisterContextLinux_i386.cpp
RegisterContextLinux_x86_64.cpp		RegisterContextLinux_x86_64.cpp
RegisterContextLinux_mips64.cpp		RegisterContextLinux_mips64.cpp
RegisterContextLinux_mips.cpp		RegisterContextLinux_mips.cpp
RegisterContextLinux_s390x.cpp		RegisterContextLinux_s390x.cpp
RegisterContextLLDB.cpp		RegisterContextLLDB.cpp
RegisterContextMacOSXFrameBackchain.cpp
RegisterContextMach_arm.cpp		RegisterContextMach_arm.cpp
RegisterContextMach_i386.cpp		RegisterContextMach_i386.cpp
RegisterContextMach_x86_64.cpp		RegisterContextMach_x86_64.cpp
RegisterContextMemory.cpp		RegisterContextMemory.cpp
RegisterContextNetBSD_i386.cpp		RegisterContextNetBSD_i386.cpp
RegisterContextNetBSD_x86_64.cpp		RegisterContextNetBSD_x86_64.cpp
RegisterContextOpenBSD_i386.cpp		RegisterContextOpenBSD_i386.cpp
RegisterContextOpenBSD_x86_64.cpp		RegisterContextOpenBSD_x86_64.cpp
RegisterContextPOSIX_arm.cpp		RegisterContextPOSIX_arm.cpp
RegisterContextPOSIX_arm64.cpp		RegisterContextPOSIX_arm64.cpp
RegisterContextPOSIX_mips64.cpp		RegisterContextPOSIX_mips64.cpp
RegisterContextPOSIX_powerpc.cpp		RegisterContextPOSIX_powerpc.cpp
RegisterContextPOSIX_ppc64le.cpp		RegisterContextPOSIX_ppc64le.cpp
RegisterContextPOSIX_s390x.cpp		RegisterContextPOSIX_s390x.cpp
RegisterContextPOSIX_x86.cpp		RegisterContextPOSIX_x86.cpp
RegisterContextThreadMemory.cpp		RegisterContextThreadMemory.cpp
RegisterContextWindows_i386.cpp		RegisterContextWindows_i386.cpp
RegisterContextWindows_x86_64.cpp		RegisterContextWindows_x86_64.cpp
RegisterInfoPOSIX_arm.cpp		RegisterInfoPOSIX_arm.cpp
RegisterInfoPOSIX_arm64.cpp		RegisterInfoPOSIX_arm64.cpp
RegisterInfoPOSIX_ppc64le.cpp		RegisterInfoPOSIX_ppc64le.cpp
StopInfoMachException.cpp		StopInfoMachException.cpp
ThreadMemory.cpp		ThreadMemory.cpp
UnwindLLDB.cpp		UnwindLLDB.cpp
UnwindMacOSXFrameBackchain.cpp

LINK_LIBS		LINK_LIBS
lldbBreakpoint		lldbBreakpoint
lldbCore		lldbCore
lldbDataFormatters		lldbDataFormatters
lldbExpression		lldbExpression
lldbHost		lldbHost
lldbSymbol		lldbSymbol
lldbTarget		lldbTarget
lldbUtility		lldbUtility
LINK_COMPONENTS		LINK_COMPONENTS
Support		Support
)		)

lldb/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.h

This file was deleted.

	//===-- RegisterContextMacOSXFrameBackchain.h -------------------- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTMACOSXFRAMEBACKCHAIN_H
	#define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTMACOSXFRAMEBACKCHAIN_H

	#include "lldb/Target/RegisterContext.h"
	#include "lldb/lldb-private.h"

	#include "UnwindMacOSXFrameBackchain.h"

	class RegisterContextMacOSXFrameBackchain
	: public lldb_private::RegisterContext {
	public:
	RegisterContextMacOSXFrameBackchain(
	lldb_private::Thread &thread, uint32_t concrete_frame_idx,
	const UnwindMacOSXFrameBackchain::Cursor &cursor);

	~RegisterContextMacOSXFrameBackchain() override;

	void InvalidateAllRegisters() override;

	size_t GetRegisterCount() override;

	const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;

	size_t GetRegisterSetCount() override;

	const lldb_private::RegisterSet *GetRegisterSet(size_t reg_set) override;

	bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
	lldb_private::RegisterValue &value) override;

	bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
	const lldb_private::RegisterValue &value) override;

	bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;

	bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;

	uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
	uint32_t num) override;

	private:
	UnwindMacOSXFrameBackchain::Cursor m_cursor;
	bool m_cursor_is_valid;

	DISALLOW_COPY_AND_ASSIGN(RegisterContextMacOSXFrameBackchain);
	};

	#endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTMACOSXFRAMEBACKCHAIN_H

lldb/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp

This file was deleted.

	//===-- RegisterContextMacOSXFrameBackchain.cpp ---------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "RegisterContextMacOSXFrameBackchain.h"

	#include "lldb/Target/Thread.h"
	#include "lldb/Utility/DataBufferHeap.h"
	#include "lldb/Utility/DataExtractor.h"
	#include "lldb/Utility/RegisterValue.h"
	#include "lldb/Utility/Scalar.h"
	#include "lldb/Utility/StreamString.h"
	#include "lldb/Utility/StringExtractorGDBRemote.h"

	using namespace lldb;
	using namespace lldb_private;

	// RegisterContextMacOSXFrameBackchain constructor
	RegisterContextMacOSXFrameBackchain::RegisterContextMacOSXFrameBackchain(
	Thread &thread, uint32_t concrete_frame_idx,
	const UnwindMacOSXFrameBackchain::Cursor &cursor)
	: RegisterContext(thread, concrete_frame_idx), m_cursor(cursor),
	m_cursor_is_valid(true) {}

	// Destructor
	RegisterContextMacOSXFrameBackchain::~RegisterContextMacOSXFrameBackchain() {}

	void RegisterContextMacOSXFrameBackchain::InvalidateAllRegisters() {
	m_cursor_is_valid = false;
	}

	size_t RegisterContextMacOSXFrameBackchain::GetRegisterCount() {
	return m_thread.GetRegisterContext()->GetRegisterCount();
	}

	const RegisterInfo *
	RegisterContextMacOSXFrameBackchain::GetRegisterInfoAtIndex(size_t reg) {
	return m_thread.GetRegisterContext()->GetRegisterInfoAtIndex(reg);
	}

	size_t RegisterContextMacOSXFrameBackchain::GetRegisterSetCount() {
	return m_thread.GetRegisterContext()->GetRegisterSetCount();
	}

	const RegisterSet *
	RegisterContextMacOSXFrameBackchain::GetRegisterSet(size_t reg_set) {
	return m_thread.GetRegisterContext()->GetRegisterSet(reg_set);
	}

	bool RegisterContextMacOSXFrameBackchain::ReadRegister(
	const RegisterInfo *reg_info, RegisterValue &value) {
	if (!m_cursor_is_valid)
	return false;

	uint64_t reg_value = LLDB_INVALID_ADDRESS;

	switch (reg_info->kinds[eRegisterKindGeneric]) {
	case LLDB_REGNUM_GENERIC_PC:
	if (m_cursor.pc == LLDB_INVALID_ADDRESS)
	return false;
	reg_value = m_cursor.pc;
	break;

	case LLDB_REGNUM_GENERIC_FP:
	if (m_cursor.fp == LLDB_INVALID_ADDRESS)
	return false;
	reg_value = m_cursor.fp;
	break;

	default:
	return false;
	}

	switch (reg_info->encoding) {
	case eEncodingInvalid:
	case eEncodingVector:
	break;

	case eEncodingUint:
	case eEncodingSint:
	value.SetUInt(reg_value, reg_info->byte_size);
	return true;

	case eEncodingIEEE754:
	switch (reg_info->byte_size) {
	case sizeof(float):
	if (sizeof(float) == sizeof(uint32_t)) {
	value.SetUInt32(reg_value, RegisterValue::eTypeFloat);
	return true;
	} else if (sizeof(float) == sizeof(uint64_t)) {
	value.SetUInt64(reg_value, RegisterValue::eTypeFloat);
	return true;
	}
	break;

	case sizeof(double):
	if (sizeof(double) == sizeof(uint32_t)) {
	value.SetUInt32(reg_value, RegisterValue::eTypeDouble);
	return true;
	} else if (sizeof(double) == sizeof(uint64_t)) {
	value.SetUInt64(reg_value, RegisterValue::eTypeDouble);
	return true;
	}
	break;

	// TOOD: need a better way to detect when "long double" types are
	// the same bytes size as "double"
	#if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__) && \
	!defined(_MSC_VER) && !defined(__mips__) && !defined(__powerpc__) && \
	!defined(__ANDROID__)
	case sizeof(long double):
	if (sizeof(long double) == sizeof(uint32_t)) {
	value.SetUInt32(reg_value, RegisterValue::eTypeLongDouble);
	return true;
	} else if (sizeof(long double) == sizeof(uint64_t)) {
	value.SetUInt64(reg_value, RegisterValue::eTypeLongDouble);
	return true;
	}
	break;
	#endif
	}
	break;
	}
	return false;
	}

	bool RegisterContextMacOSXFrameBackchain::WriteRegister(
	const RegisterInfo *reg_info, const RegisterValue &value) {
	// Not supported yet. We could easily add support for this by remembering the
	// address of each entry (it would need to be part of the cursor)
	return false;
	}

	bool RegisterContextMacOSXFrameBackchain::ReadAllRegisterValues(
	lldb::DataBufferSP &data_sp) {
	// libunwind frames can't handle this it doesn't always have all register
	// values. This call should only be called on frame zero anyway so there
	// shouldn't be any problem
	return false;
	}

	bool RegisterContextMacOSXFrameBackchain::WriteAllRegisterValues(
	const lldb::DataBufferSP &data_sp) {
	// Since this class doesn't respond to "ReadAllRegisterValues()", it must not
	// have been the one that saved all the register values. So we just let the
	// thread's register context (the register context for frame zero) do the
	// writing.
	return m_thread.GetRegisterContext()->WriteAllRegisterValues(data_sp);
	}

	uint32_t
	RegisterContextMacOSXFrameBackchain::ConvertRegisterKindToRegisterNumber(
	lldb::RegisterKind kind, uint32_t num) {
	return m_thread.GetRegisterContext()->ConvertRegisterKindToRegisterNumber(
	kind, num);
	}

lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h

This file was deleted.

	//===-- UnwindMacOSXFrameBackchain.h ----------------------------- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_UNWINDMACOSXFRAMEBACKCHAIN_H
	#define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_UNWINDMACOSXFRAMEBACKCHAIN_H

	#include <vector>

	#include "lldb/Target/Unwind.h"
	#include "lldb/lldb-private.h"

	class UnwindMacOSXFrameBackchain : public lldb_private::Unwind {
	public:
	UnwindMacOSXFrameBackchain(lldb_private::Thread &thread);

	~UnwindMacOSXFrameBackchain() override = default;

	protected:
	void DoClear() override { m_cursors.clear(); }

	uint32_t DoGetFrameCount() override;

	bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
	lldb::addr_t &pc,
	bool &behaves_like_zeroth_frame) override;

	lldb::RegisterContextSP
	DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;

	friend class RegisterContextMacOSXFrameBackchain;

	struct Cursor {
	lldb::addr_t pc; // Program counter
	lldb::addr_t fp; // Frame pointer for us with backchain
	};

	private:
	std::vector<Cursor> m_cursors;

	size_t GetStackFrameData_i386(const lldb_private::ExecutionContext &exe_ctx);

	size_t
	GetStackFrameData_x86_64(const lldb_private::ExecutionContext &exe_ctx);

	// For UnwindMacOSXFrameBackchain only
	DISALLOW_COPY_AND_ASSIGN(UnwindMacOSXFrameBackchain);
	};

	#endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_UNWINDMACOSXFRAMEBACKCHAIN_H

lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp

This file was deleted.

	//===-- UnwindMacOSXFrameBackchain.cpp ------------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "lldb/Symbol/Function.h"
	#include "lldb/Symbol/ObjectFile.h"
	#include "lldb/Symbol/Symbol.h"
	#include "lldb/Target/ExecutionContext.h"
	#include "lldb/Target/Process.h"
	#include "lldb/Target/Target.h"
	#include "lldb/Target/Thread.h"
	#include "lldb/Utility/ArchSpec.h"

	#include "RegisterContextMacOSXFrameBackchain.h"

	#include <memory>

	using namespace lldb;
	using namespace lldb_private;

	UnwindMacOSXFrameBackchain::UnwindMacOSXFrameBackchain(Thread &thread)
	: Unwind(thread), m_cursors() {}

	uint32_t UnwindMacOSXFrameBackchain::DoGetFrameCount() {
	if (m_cursors.empty()) {
	ExecutionContext exe_ctx(m_thread.shared_from_this());
	Target *target = exe_ctx.GetTargetPtr();
	if (target) {
	const ArchSpec &target_arch = target->GetArchitecture();
	// Frame zero should always be supplied by the thread...
	exe_ctx.SetFrameSP(m_thread.GetStackFrameAtIndex(0));

	if (target_arch.GetAddressByteSize() == 8)
	GetStackFrameData_x86_64(exe_ctx);
	else
	GetStackFrameData_i386(exe_ctx);
	}
	}
	return m_cursors.size();
	}

	bool UnwindMacOSXFrameBackchain::DoGetFrameInfoAtIndex(
	uint32_t idx, addr_t &cfa, addr_t &pc, bool &behaves_like_zeroth_frame) {
	const uint32_t frame_count = GetFrameCount();
	if (idx < frame_count) {
	if (m_cursors[idx].pc == LLDB_INVALID_ADDRESS)
	return false;
	if (m_cursors[idx].fp == LLDB_INVALID_ADDRESS)
	return false;

	pc = m_cursors[idx].pc;
	cfa = m_cursors[idx].fp;
	behaves_like_zeroth_frame = (idx == 0);

	return true;
	}
	return false;
	}

	lldb::RegisterContextSP
	UnwindMacOSXFrameBackchain::DoCreateRegisterContextForFrame(StackFrame *frame) {
	lldb::RegisterContextSP reg_ctx_sp;
	uint32_t concrete_idx = frame->GetConcreteFrameIndex();
	const uint32_t frame_count = GetFrameCount();
	if (concrete_idx < frame_count)
	reg_ctx_sp = std::make_shared<RegisterContextMacOSXFrameBackchain>(
	m_thread, concrete_idx, m_cursors[concrete_idx]);
	return reg_ctx_sp;
	}

	size_t UnwindMacOSXFrameBackchain::GetStackFrameData_i386(
	const ExecutionContext &exe_ctx) {
	m_cursors.clear();

	StackFrame *first_frame = exe_ctx.GetFramePtr();

	Process *process = exe_ctx.GetProcessPtr();
	if (process == nullptr)
	return 0;

	struct Frame_i386 {
	uint32_t fp;
	uint32_t pc;
	};

	RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
	assert(reg_ctx);

	Cursor cursor;
	cursor.pc = reg_ctx->GetPC(LLDB_INVALID_ADDRESS);
	cursor.fp = reg_ctx->GetFP(0);

	Frame_i386 frame = {static_cast<uint32_t>(cursor.fp),
	static_cast<uint32_t>(cursor.pc)};

	m_cursors.push_back(cursor);

	const size_t k_frame_size = sizeof(frame);
	Status error;
	while (frame.fp != 0 && frame.pc != 0 && ((frame.fp & 7) == 0)) {
	// Read both the FP and PC (8 bytes)
	if (process->ReadMemory(frame.fp, &frame.fp, k_frame_size, error) !=
	k_frame_size)
	break;
	if (frame.pc >= 0x1000) {
	cursor.pc = frame.pc;
	cursor.fp = frame.fp;
	m_cursors.push_back(cursor);
	}
	}
	if (!m_cursors.empty()) {
	lldb::addr_t first_frame_pc = m_cursors.front().pc;
	if (first_frame_pc != LLDB_INVALID_ADDRESS) {
	const SymbolContextItem resolve_scope =
	eSymbolContextModule \| eSymbolContextCompUnit \|
	eSymbolContextFunction \| eSymbolContextSymbol;

	SymbolContext first_frame_sc(
	first_frame->GetSymbolContext(resolve_scope));
	const AddressRange *addr_range_ptr = nullptr;
	AddressRange range;
	if (first_frame_sc.function)
	addr_range_ptr = &first_frame_sc.function->GetAddressRange();
	else if (first_frame_sc.symbol) {
	range.GetBaseAddress() = first_frame_sc.symbol->GetAddress();
	range.SetByteSize(first_frame_sc.symbol->GetByteSize());
	addr_range_ptr = &range;
	}

	if (addr_range_ptr) {
	if (first_frame->GetFrameCodeAddress() ==
	addr_range_ptr->GetBaseAddress()) {
	// We are at the first instruction, so we can recover the previous PC
	// by dereferencing the SP
	lldb::addr_t first_frame_sp = reg_ctx->GetSP(0);
	// Read the real second frame return address into frame.pc
	if (first_frame_sp &&
	process->ReadMemory(first_frame_sp, &frame.pc, sizeof(frame.pc),
	error) == sizeof(frame.pc)) {
	cursor.fp = m_cursors.front().fp;
	cursor.pc = frame.pc; // Set the new second frame PC

	// Insert the second frame
	m_cursors.insert(m_cursors.begin() + 1, cursor);

	m_cursors.front().fp = first_frame_sp;
	}
	}
	}
	}
	}
	// uint32_t i=0;
	// printf(" PC FP\n");
	// printf(" ------------------ ------------------ \n");
	// for (i=0; i<m_cursors.size(); ++i)
	// {
	// printf("[%3u] 0x%16.16" PRIx64 " 0x%16.16" PRIx64 "\n", i,
	// m_cursors[i].pc, m_cursors[i].fp);
	// }
	return m_cursors.size();
	}

	size_t UnwindMacOSXFrameBackchain::GetStackFrameData_x86_64(
	const ExecutionContext &exe_ctx) {
	m_cursors.clear();

	Process *process = exe_ctx.GetProcessPtr();
	if (process == nullptr)
	return 0;

	StackFrame *first_frame = exe_ctx.GetFramePtr();

	struct Frame_x86_64 {
	uint64_t fp;
	uint64_t pc;
	};

	RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
	assert(reg_ctx);

	Cursor cursor;
	cursor.pc = reg_ctx->GetPC(LLDB_INVALID_ADDRESS);
	cursor.fp = reg_ctx->GetFP(0);

	Frame_x86_64 frame = {cursor.fp, cursor.pc};

	m_cursors.push_back(cursor);
	Status error;
	const size_t k_frame_size = sizeof(frame);
	while (frame.fp != 0 && frame.pc != 0 && ((frame.fp & 7) == 0)) {
	// Read both the FP and PC (16 bytes)
	if (process->ReadMemory(frame.fp, &frame.fp, k_frame_size, error) !=
	k_frame_size)
	break;

	if (frame.pc >= 0x1000) {
	cursor.pc = frame.pc;
	cursor.fp = frame.fp;
	m_cursors.push_back(cursor);
	}
	}
	if (!m_cursors.empty()) {
	lldb::addr_t first_frame_pc = m_cursors.front().pc;
	if (first_frame_pc != LLDB_INVALID_ADDRESS) {
	const SymbolContextItem resolve_scope =
	eSymbolContextModule \| eSymbolContextCompUnit \|
	eSymbolContextFunction \| eSymbolContextSymbol;

	SymbolContext first_frame_sc(
	first_frame->GetSymbolContext(resolve_scope));
	const AddressRange *addr_range_ptr = nullptr;
	AddressRange range;
	if (first_frame_sc.function)
	addr_range_ptr = &first_frame_sc.function->GetAddressRange();
	else if (first_frame_sc.symbol) {
	range.GetBaseAddress() = first_frame_sc.symbol->GetAddress();
	range.SetByteSize(first_frame_sc.symbol->GetByteSize());
	addr_range_ptr = &range;
	}

	if (addr_range_ptr) {
	if (first_frame->GetFrameCodeAddress() ==
	addr_range_ptr->GetBaseAddress()) {
	// We are at the first instruction, so we can recover the previous PC
	// by dereferencing the SP
	lldb::addr_t first_frame_sp = reg_ctx->GetSP(0);
	// Read the real second frame return address into frame.pc
	if (process->ReadMemory(first_frame_sp, &frame.pc, sizeof(frame.pc),
	error) == sizeof(frame.pc)) {
	cursor.fp = m_cursors.front().fp;
	cursor.pc = frame.pc; // Set the new second frame PC

	// Insert the second frame
	m_cursors.insert(m_cursors.begin() + 1, cursor);

	m_cursors.front().fp = first_frame_sp;
	}
	}
	}
	}
	}
	return m_cursors.size();
	}

lldb/source/Target/Thread.cpp

	//===-- Thread.cpp --------------------------------------------------------===//			//===-- Thread.cpp --------------------------------------------------------===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "lldb/Target/Thread.h"			#include "lldb/Target/Thread.h"
	#include "Plugins/Process/Utility/UnwindLLDB.h"			#include "Plugins/Process/Utility/UnwindLLDB.h"
	#include "Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h"
	#include "lldb/Breakpoint/BreakpointLocation.h"			#include "lldb/Breakpoint/BreakpointLocation.h"
	#include "lldb/Core/Debugger.h"			#include "lldb/Core/Debugger.h"
	#include "lldb/Core/FormatEntity.h"			#include "lldb/Core/FormatEntity.h"
	#include "lldb/Core/Module.h"			#include "lldb/Core/Module.h"
	#include "lldb/Core/StructuredDataImpl.h"			#include "lldb/Core/StructuredDataImpl.h"
	#include "lldb/Core/ValueObject.h"			#include "lldb/Core/ValueObject.h"
	#include "lldb/Host/Host.h"			#include "lldb/Host/Host.h"
	#include "lldb/Interpreter/OptionValueFileSpecList.h"			#include "lldb/Interpreter/OptionValueFileSpecList.h"
	▲ Show 20 Lines • Show All 2,076 Lines • ▼ Show 20 Lines
	size_t Thread::GetStackFrameStatus(Stream &strm, uint32_t first_frame,			size_t Thread::GetStackFrameStatus(Stream &strm, uint32_t first_frame,
	uint32_t num_frames, bool show_frame_info,			uint32_t num_frames, bool show_frame_info,
	uint32_t num_frames_with_source) {			uint32_t num_frames_with_source) {
	return GetStackFrameList()->GetStatus(			return GetStackFrameList()->GetStatus(
	strm, first_frame, num_frames, show_frame_info, num_frames_with_source);			strm, first_frame, num_frames, show_frame_info, num_frames_with_source);
	}			}

	Unwind *Thread::GetUnwinder() {			Unwind *Thread::GetUnwinder() {
	if (!m_unwinder_up) {			if (!m_unwinder_up)
	const ArchSpec target_arch(CalculateTarget()->GetArchitecture());
	const llvm::Triple::ArchType machine = target_arch.GetMachine();
	switch (machine) {
	case llvm::Triple::x86_64:
	case llvm::Triple::x86:
	case llvm::Triple::arm:
	case llvm::Triple::aarch64:
	case llvm::Triple::aarch64_32:
	case llvm::Triple::thumb:
	case llvm::Triple::mips:
	case llvm::Triple::mipsel:
	case llvm::Triple::mips64:
	case llvm::Triple::mips64el:
	case llvm::Triple::ppc:
	case llvm::Triple::ppc64:
	case llvm::Triple::ppc64le:
	case llvm::Triple::systemz:
	case llvm::Triple::hexagon:
	case llvm::Triple::arc:
	m_unwinder_up.reset(new UnwindLLDB(*this));			m_unwinder_up.reset(new UnwindLLDB(*this));
	break;

	default:
	if (target_arch.GetTriple().getVendor() == llvm::Triple::Apple)
	m_unwinder_up.reset(new UnwindMacOSXFrameBackchain(*this));
	break;
	}
	}
	return m_unwinder_up.get();			return m_unwinder_up.get();
	}			}

	void Thread::Flush() {			void Thread::Flush() {
	ClearStackFrames();			ClearStackFrames();
	m_reg_context_sp.reset();			m_reg_context_sp.reset();
	}			}

	▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[lldb] Delete UnwindMacOSXFrameBackchainClosedPublic

Details

Diff Detail

Event Timeline