src/developer/debug/zxdb/client/function_thread_controller_unittest.cc - fuchsia - Git at Google

 // Copyright 2021 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "src/developer/debug/zxdb/client/function_thread_controller.h"

 #include <gtest/gtest.h>

 #include "src/developer/debug/zxdb/client/inline_thread_controller_test.h"
 #include "src/developer/debug/zxdb/client/process.h"
 #include "src/developer/debug/zxdb/client/session.h"
 #include "src/developer/debug/zxdb/client/setting_schema_definition.h"
 #include "src/developer/debug/zxdb/client/step_over_thread_controller.h"
 #include "src/developer/debug/zxdb/client/step_thread_controller.h"
 #include "src/developer/debug/zxdb/client/thread.h"
 #include "src/developer/debug/zxdb/symbols/elf_symbol.h"
 #include "src/developer/debug/zxdb/symbols/line_details.h"

 namespace zxdb {

 namespace {

 class FunctionThreadControllerTest : public InlineThreadControllerTest {
  public:
   void SetUnsymbolizedSetting(bool stop_on_no_symbols) {
     thread()->session()->system().settings().SetBool(ClientSettings::System::kSkipUnsymbolized,
                                                      !stop_on_no_symbols);
   }

   // Backend that runs a test for stepping into an unsymbolized function, both for when we want it
   // to stop (param = true) and continue (param = false).
   void DoUnsymbolizedPltCallTest(bool stop_on_no_symbols);
 };

 }  // namespace

 // This also tests the StepThroughPltThreadController and both of their integration with the
 // StepThreadController. Both of these sub-controllers are used by the "step into" controller.
 void FunctionThreadControllerTest::DoUnsymbolizedPltCallTest(bool stop_on_no_symbols) {
   SymbolContext sym_context(kSymbolizedModuleAddress);

   // Jump from src to dest and return, then to kOutOfRange.
   const uint64_t kAddrSrc = kSymbolizedModuleAddress + 0x100;
   const uint64_t kAddrDest = kUnsymbolizedModuleAddress + 0x200;
   const uint64_t kAddrReturn = kAddrSrc + 4;
   const uint64_t kAddrOutOfRange = kAddrReturn + 4;

   const uint64_t kSrcSP = 0x5000;
   const uint64_t kDestSP = 0x4ff0;

   auto src_sym = fxl::MakeRefCounted<Function>(DwarfTag::kSubprogram);

   // The line where the step starts from.
   FileLine src_line("/path/src.cc", 1);
   LineDetails src_details(src_line);
   src_details.entries().push_back({0, AddressRange(kAddrSrc, kAddrOutOfRange)});
   module_symbols()->AddLineDetails(kAddrSrc, src_details);

   // The line after the step operation.
   FileLine out_of_range_line("/path/src.cc", 2);
   LineDetails out_of_range_details(out_of_range_line);
   out_of_range_details.entries().push_back({0, AddressRange(kAddrOutOfRange, kAddrOutOfRange + 1)});
   module_symbols()->AddLineDetails(kAddrOutOfRange, out_of_range_details);

   // PLT symbol info. This thunk is in the symbolized module to call into the unsymbolized one.
   const uint64_t kAddrPltRelative = 0x5980;
   const uint64_t kAddrPltAbsolute = kAddrPltRelative + kSymbolizedModuleAddress;
   const std::string kPltName = "plt_call";
   ElfSymbolRecord plt_record(ElfSymbolType::kPlt, kAddrPltRelative, 1, kPltName);
   auto plt_symbol = fxl::MakeRefCounted<ElfSymbol>(module_symbols()->GetWeakPtr(), plt_record);
   Location plt_loc(kAddrPltAbsolute, FileLine(), 0, sym_context, plt_symbol);
   Identifier plt_identifier(IdentifierComponent(SpecialIdentifier::kPlt, kPltName));
   module_symbols()->AddSymbolLocations(plt_identifier, {plt_loc});

   // Other locations for each step below.
   Location source_loc(kAddrSrc, src_line, 0, sym_context, src_sym);
   Location dest_loc(kAddrDest, FileLine("foo.cc", 1), 0, sym_context);
   Location return_loc(kAddrReturn, src_line, 0, sym_context, src_sym);
   Location out_of_range_loc(kAddrOutOfRange, out_of_range_line, 0, sym_context, src_sym);

   // Destination of the PLT call. This is an ELF symbol (not a PLT one which is for the trampoline).
   // The "until" controller will look up this symbol to set a breakpoint on the destination.
   Identifier plt_dest_identifier(IdentifierComponent(SpecialIdentifier::kElf, kPltName));
   unsymbolized_module_symbols()->AddSymbolLocations(plt_dest_identifier, {dest_loc});

   // Set up the thread to be stopped at the beginning of our range.
   std::vector<std::unique_ptr<Frame>> stack;
   stack.push_back(std::make_unique<MockFrame>(&session(), thread(), source_loc, kSrcSP, kSrcSP));
   InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
                            debug_ipc::ExceptionType::kSingleStep, std::move(stack), true);

   // Continue the thread with the controller stepping in range.
   auto step_into = std::make_unique<StepThreadController>(StepMode::kSourceLine);
   SetUnsymbolizedSetting(stop_on_no_symbols);
   bool continued = false;
   thread()->ContinueWith(std::move(step_into), [&continued](const Err& err) {
     if (!err.has_error())
       continued = true;
   });

   // It should have been able to step without doing any further async work.
   EXPECT_TRUE(continued);
   EXPECT_EQ(1, mock_remote_api()->GetAndResetResumeCount());

   // Stop on the PLT call. The PLT controller should continue it.
   stack.push_back(std::make_unique<MockFrame>(&session(), thread(), plt_loc, kDestSP, kDestSP));
   stack.push_back(std::make_unique<MockFrame>(&session(), thread(), return_loc, kSrcSP, kSrcSP));
   InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
                            debug_ipc::ExceptionType::kSingleStep, std::move(stack), true);
   EXPECT_TRUE(continued);

   // The PLT controller initializes asynchronously after the breakpoint is confirmed set. In real
   // life this will be woken up by the debug_agent's set breakpoint reply, but our mock breakpoints
   // just post a task to respond.
   EXPECT_EQ(0, mock_remote_api()->GetAndResetResumeCount());
   loop().RunUntilNoTasks();
   // That should wake up the "until" controller which should then tell the PLT controller which will
   // then request a continue.
   EXPECT_EQ(1, mock_remote_api()->GetAndResetResumeCount());

   // The PLT controller will have created an "until" controller which should set a breakpoint at the
   // destination of the call.
   EXPECT_EQ(mock_remote_api()->last_breakpoint_address(), kAddrDest);
   debug_ipc::BreakpointStats breakpoint_hit{
       .id = static_cast<uint32_t>(mock_remote_api()->last_breakpoint_id()), .hit_count = 1};
   stack.push_back(std::make_unique<MockFrame>(&session(), thread(), dest_loc, kDestSP, kDestSP));
   stack.push_back(std::make_unique<MockFrame>(&session(), thread(), return_loc, kSrcSP, kSrcSP));
   InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
                            debug_ipc::ExceptionType::kSoftwareBreakpoint, std::move(stack), true,
                            {breakpoint_hit});
   if (stop_on_no_symbols) {
     // For this variant of the test, the unsymbolized thunk should have stopped stepping.
     EXPECT_EQ(0, mock_remote_api()->GetAndResetResumeCount());  // Stopped
     EXPECT_EQ(debug_ipc::ThreadRecord::State::kBlocked, thread()->GetState());
     return;
   }

   // The rest of this test is the "step over unsymbolized thunks" case. It should have automatically
   // resumed from the previous exception.
   EXPECT_EQ(1, mock_remote_api()->GetAndResetResumeCount());

   // Send a breakpoint completion notification at the previous stack frame. Breakpoint exceptions
   // are "software". We also have to send the hit breakpoint ID.
   stack.push_back(std::make_unique<MockFrame>(&session(), thread(), return_loc, kSrcSP, kSrcSP));
   debug_ipc::BreakpointStats breakpoint{
       .id = static_cast<uint32_t>(mock_remote_api()->last_breakpoint_id()), .hit_count = 1};
   InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
                            debug_ipc::ExceptionType::kSoftwareBreakpoint, std::move(stack), true,
                            {breakpoint});

   // This should have continued since the return address is still in the original address range.
   EXPECT_EQ(1, mock_remote_api()->GetAndResetResumeCount());

   // Stop on dest instruction, this is still in range so we should continue.
   stack.push_back(
       std::make_unique<MockFrame>(&session(), thread(), out_of_range_loc, kSrcSP, kSrcSP));
   InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
                            debug_ipc::ExceptionType::kSingleStep, std::move(stack), true);
   EXPECT_EQ(0, mock_remote_api()->GetAndResetResumeCount());  // Stopped
   EXPECT_EQ(debug_ipc::ThreadRecord::State::kBlocked, thread()->GetState());
 }

 TEST_F(FunctionThreadControllerTest, UnsymbolizedPltCallStepOver) {
   DoUnsymbolizedPltCallTest(false);
 }

 TEST_F(FunctionThreadControllerTest, UnsymbolizedPltCallStepInto) {
   DoUnsymbolizedPltCallTest(true);
 }

 }  // namespace zxdb
	// Copyright 2021 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "src/developer/debug/zxdb/client/function_thread_controller.h"

	#include <gtest/gtest.h>

	#include "src/developer/debug/zxdb/client/inline_thread_controller_test.h"
	#include "src/developer/debug/zxdb/client/process.h"
	#include "src/developer/debug/zxdb/client/session.h"
	#include "src/developer/debug/zxdb/client/setting_schema_definition.h"
	#include "src/developer/debug/zxdb/client/step_over_thread_controller.h"
	#include "src/developer/debug/zxdb/client/step_thread_controller.h"
	#include "src/developer/debug/zxdb/client/thread.h"
	#include "src/developer/debug/zxdb/symbols/elf_symbol.h"
	#include "src/developer/debug/zxdb/symbols/line_details.h"

	namespace zxdb {

	namespace {

	class FunctionThreadControllerTest : public InlineThreadControllerTest {
	public:
	void SetUnsymbolizedSetting(bool stop_on_no_symbols) {
	thread()->session()->system().settings().SetBool(ClientSettings::System::kSkipUnsymbolized,
	!stop_on_no_symbols);
	}

	// Backend that runs a test for stepping into an unsymbolized function, both for when we want it
	// to stop (param = true) and continue (param = false).
	void DoUnsymbolizedPltCallTest(bool stop_on_no_symbols);
	};

	} // namespace

	// This also tests the StepThroughPltThreadController and both of their integration with the
	// StepThreadController. Both of these sub-controllers are used by the "step into" controller.
	void FunctionThreadControllerTest::DoUnsymbolizedPltCallTest(bool stop_on_no_symbols) {
	SymbolContext sym_context(kSymbolizedModuleAddress);

	// Jump from src to dest and return, then to kOutOfRange.
	const uint64_t kAddrSrc = kSymbolizedModuleAddress + 0x100;
	const uint64_t kAddrDest = kUnsymbolizedModuleAddress + 0x200;
	const uint64_t kAddrReturn = kAddrSrc + 4;
	const uint64_t kAddrOutOfRange = kAddrReturn + 4;

	const uint64_t kSrcSP = 0x5000;
	const uint64_t kDestSP = 0x4ff0;

	auto src_sym = fxl::MakeRefCounted<Function>(DwarfTag::kSubprogram);

	// The line where the step starts from.
	FileLine src_line("/path/src.cc", 1);
	LineDetails src_details(src_line);
	src_details.entries().push_back({0, AddressRange(kAddrSrc, kAddrOutOfRange)});
	module_symbols()->AddLineDetails(kAddrSrc, src_details);

	// The line after the step operation.
	FileLine out_of_range_line("/path/src.cc", 2);
	LineDetails out_of_range_details(out_of_range_line);
	out_of_range_details.entries().push_back({0, AddressRange(kAddrOutOfRange, kAddrOutOfRange + 1)});
	module_symbols()->AddLineDetails(kAddrOutOfRange, out_of_range_details);

	// PLT symbol info. This thunk is in the symbolized module to call into the unsymbolized one.
	const uint64_t kAddrPltRelative = 0x5980;
	const uint64_t kAddrPltAbsolute = kAddrPltRelative + kSymbolizedModuleAddress;
	const std::string kPltName = "plt_call";
	ElfSymbolRecord plt_record(ElfSymbolType::kPlt, kAddrPltRelative, 1, kPltName);
	auto plt_symbol = fxl::MakeRefCounted<ElfSymbol>(module_symbols()->GetWeakPtr(), plt_record);
	Location plt_loc(kAddrPltAbsolute, FileLine(), 0, sym_context, plt_symbol);
	Identifier plt_identifier(IdentifierComponent(SpecialIdentifier::kPlt, kPltName));
	module_symbols()->AddSymbolLocations(plt_identifier, {plt_loc});

	// Other locations for each step below.
	Location source_loc(kAddrSrc, src_line, 0, sym_context, src_sym);
	Location dest_loc(kAddrDest, FileLine("foo.cc", 1), 0, sym_context);
	Location return_loc(kAddrReturn, src_line, 0, sym_context, src_sym);
	Location out_of_range_loc(kAddrOutOfRange, out_of_range_line, 0, sym_context, src_sym);

	// Destination of the PLT call. This is an ELF symbol (not a PLT one which is for the trampoline).
	// The "until" controller will look up this symbol to set a breakpoint on the destination.
	Identifier plt_dest_identifier(IdentifierComponent(SpecialIdentifier::kElf, kPltName));
	unsymbolized_module_symbols()->AddSymbolLocations(plt_dest_identifier, {dest_loc});

	// Set up the thread to be stopped at the beginning of our range.
	std::vector<std::unique_ptr<Frame>> stack;
	stack.push_back(std::make_unique<MockFrame>(&session(), thread(), source_loc, kSrcSP, kSrcSP));
	InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
	debug_ipc::ExceptionType::kSingleStep, std::move(stack), true);

	// Continue the thread with the controller stepping in range.
	auto step_into = std::make_unique<StepThreadController>(StepMode::kSourceLine);
	SetUnsymbolizedSetting(stop_on_no_symbols);
	bool continued = false;
	thread()->ContinueWith(std::move(step_into), [&continued](const Err& err) {
	if (!err.has_error())
	continued = true;
	});

	// It should have been able to step without doing any further async work.
	EXPECT_TRUE(continued);
	EXPECT_EQ(1, mock_remote_api()->GetAndResetResumeCount());

	// Stop on the PLT call. The PLT controller should continue it.
	stack.push_back(std::make_unique<MockFrame>(&session(), thread(), plt_loc, kDestSP, kDestSP));
	stack.push_back(std::make_unique<MockFrame>(&session(), thread(), return_loc, kSrcSP, kSrcSP));
	InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
	debug_ipc::ExceptionType::kSingleStep, std::move(stack), true);
	EXPECT_TRUE(continued);

	// The PLT controller initializes asynchronously after the breakpoint is confirmed set. In real
	// life this will be woken up by the debug_agent's set breakpoint reply, but our mock breakpoints
	// just post a task to respond.
	EXPECT_EQ(0, mock_remote_api()->GetAndResetResumeCount());
	loop().RunUntilNoTasks();
	// That should wake up the "until" controller which should then tell the PLT controller which will
	// then request a continue.
	EXPECT_EQ(1, mock_remote_api()->GetAndResetResumeCount());

	// The PLT controller will have created an "until" controller which should set a breakpoint at the
	// destination of the call.
	EXPECT_EQ(mock_remote_api()->last_breakpoint_address(), kAddrDest);
	debug_ipc::BreakpointStats breakpoint_hit{
	.id = static_cast<uint32_t>(mock_remote_api()->last_breakpoint_id()), .hit_count = 1};
	stack.push_back(std::make_unique<MockFrame>(&session(), thread(), dest_loc, kDestSP, kDestSP));
	stack.push_back(std::make_unique<MockFrame>(&session(), thread(), return_loc, kSrcSP, kSrcSP));
	InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
	debug_ipc::ExceptionType::kSoftwareBreakpoint, std::move(stack), true,
	{breakpoint_hit});
	if (stop_on_no_symbols) {
	// For this variant of the test, the unsymbolized thunk should have stopped stepping.
	EXPECT_EQ(0, mock_remote_api()->GetAndResetResumeCount()); // Stopped
	EXPECT_EQ(debug_ipc::ThreadRecord::State::kBlocked, thread()->GetState());
	return;
	}

	// The rest of this test is the "step over unsymbolized thunks" case. It should have automatically
	// resumed from the previous exception.
	EXPECT_EQ(1, mock_remote_api()->GetAndResetResumeCount());

	// Send a breakpoint completion notification at the previous stack frame. Breakpoint exceptions
	// are "software". We also have to send the hit breakpoint ID.
	stack.push_back(std::make_unique<MockFrame>(&session(), thread(), return_loc, kSrcSP, kSrcSP));
	debug_ipc::BreakpointStats breakpoint{
	.id = static_cast<uint32_t>(mock_remote_api()->last_breakpoint_id()), .hit_count = 1};
	InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
	debug_ipc::ExceptionType::kSoftwareBreakpoint, std::move(stack), true,
	{breakpoint});

	// This should have continued since the return address is still in the original address range.
	EXPECT_EQ(1, mock_remote_api()->GetAndResetResumeCount());

	// Stop on dest instruction, this is still in range so we should continue.
	stack.push_back(
	std::make_unique<MockFrame>(&session(), thread(), out_of_range_loc, kSrcSP, kSrcSP));
	InjectExceptionWithStack(process()->GetKoid(), thread()->GetKoid(),
	debug_ipc::ExceptionType::kSingleStep, std::move(stack), true);
	EXPECT_EQ(0, mock_remote_api()->GetAndResetResumeCount()); // Stopped
	EXPECT_EQ(debug_ipc::ThreadRecord::State::kBlocked, thread()->GetState());
	}

	TEST_F(FunctionThreadControllerTest, UnsymbolizedPltCallStepOver) {
	DoUnsymbolizedPltCallTest(false);
	}

	TEST_F(FunctionThreadControllerTest, UnsymbolizedPltCallStepInto) {
	DoUnsymbolizedPltCallTest(true);
	}

	} // namespace zxdb