debugadapter.cpp

/*
Copyright 2020-2026 Vector 35 Inc.

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 <binaryninjacore.h>
#include <binaryninjaapi.h>
#include <lowlevelilinstruction.h>
#include <mediumlevelilinstruction.h>
#include <highlevelilinstruction.h>
#ifndef WIN32
	#include "libgen.h"
#endif
#include "debugadapter.h"
#include "debuggercontroller.h"

using namespace BinaryNinjaDebugger;


DebugModule::DebugModule() : m_name(""), m_short_name(""), m_address(0), m_size(0), m_loaded(false)
{
	m_caseInsensitive = Settings::Instance()->Get<bool>("debugger.caseInsensitiveModuleName");
}


DebugModule::DebugModule(std::string name, std::string short_name, std::uintptr_t address, std::size_t size, bool loaded) :
	m_name(std::move(name)), m_short_name(std::move(short_name)), m_address(address), m_size(size), m_loaded(loaded)
{
	m_caseInsensitive = Settings::Instance()->Get<bool>("debugger.caseInsensitiveModuleName");
}


DebugAdapter::DebugAdapter(BinaryView* data)
{
	INIT_DEBUGGER_API_OBJECT();

	// These are just a workaround to avoid holding a reference to the data. Note, when DebugAdapter is constructed,
	// the binary view passed in is the one *before* rebasing. After the debugger launches the target and rebases the
	// binary view, the un-rebased binary view is released by the core and the debugger becomes the only place where
	// we hold a reference to it.
	// Though, a better approach would be to add a function SetData() to the DebugAdapter class and update the binary
	// view after the launch, similar to what we do for the DebuggerController. However, we will need to add new APIs
	// to get the original image base of the binary view, because LLDB requires the breakpoint address be relative to
	// the original image base, and it does not work with a rebased one.
	m_entryPoint = data->GetEntryPoint();
	// For shared libraries which do not have a valid entry point, the GetEntryPoint will return 0x0 anyways.
	// Here we check if there is actually a function at the entry point, to determine if the entry point is real.
	m_hasEntryFunction = (data->GetAnalysisEntryPoint() != nullptr);
	m_start = data->GetStart();
	m_originalImageBase = data->GetOriginalImageBase();
	if (data->GetDefaultArchitecture())
		m_defaultArchitecture = data->GetDefaultArchitecture()->GetName();
}


void DebugAdapter::PostDebuggerEvent(const DebuggerEvent& event)
{
	if (m_eventCallback)
		m_eventCallback(event);
}


std::string DebugModule::GetPathBaseName(const std::string& path)
{
#ifdef WIN32
	// TODO: someone please write it on Windows!
	char baseName[MAX_PATH];
	char ext[MAX_PATH];
	_splitpath_s(path.c_str(), NULL, 0, NULL, 0, baseName, MAX_PATH, ext, MAX_PATH);
	return std::string(baseName) + std::string(ext);
#else
	return basename(strdup(path.c_str()));
#endif
}


static bool StringsEqual(const std::string& str1, const std::string& str2, bool caseInsensitive)
{
	if (!caseInsensitive)
		return str1 == str2;

	if (str1.size() != str2.size())
		return false;

	return std::equal(str1.begin(), str1.end(), str2.begin(),
		[](char c1, char c2) { return std::tolower(c1) == std::tolower(c2); });
}


bool DebugModule::IsSameBaseModule(const DebugModule& other) const
{
	return (StringsEqual(m_name, other.m_name, m_caseInsensitive)
		|| StringsEqual(m_short_name, other.m_short_name, m_caseInsensitive)
		|| StringsEqual(GetPathBaseName(m_name), GetPathBaseName(other.m_name), m_caseInsensitive)
		|| StringsEqual(GetPathBaseName(m_short_name), GetPathBaseName(other.m_short_name), m_caseInsensitive));
}


bool DebugModule::IsSameBaseModule(const std::string& name) const
{
	return (StringsEqual(m_name, name, m_caseInsensitive)
		|| StringsEqual(m_short_name, name, m_caseInsensitive)
		|| StringsEqual(GetPathBaseName(m_name), GetPathBaseName(name), m_caseInsensitive)
		|| StringsEqual(GetPathBaseName(m_short_name), GetPathBaseName(name), m_caseInsensitive));
}


bool DebugModule::IsSameBaseModule(const std::string& module1, const std::string& module2)
{
	// Cache the setting value on first call. Note: This will not update if the setting changes during runtime,
	// but settings rarely change during a debugging session, and this avoids expensive Settings::Instance() calls.
	static bool caseInsensitive = Settings::Instance()->Get<bool>("debugger.caseInsensitiveModuleName");
	return (StringsEqual(module1, module2, caseInsensitive)
		|| StringsEqual(GetPathBaseName(module1), GetPathBaseName(module2), caseInsensitive));
}


bool DebugAdapter::GoReverse()
{
	return false;
}


bool DebugAdapter::StepIntoReverse()
{
	return false;
}


bool DebugAdapter::StepOverReverse()
{
	return false;
}


bool DebugAdapter::StepReturn()
{
	return false;
}

bool DebugAdapter::StepReturnReverse()
{
	return false;
}


uint64_t DebugAdapter::GetStackPointer()
{
	return 0;
}


void DebugAdapter::WriteStdin(const std::string& msg)
{
	LogWarn("WriteStdin operation not supported");
}


std::vector<DebugFrame> DebugAdapter::GetFramesOfThread(std::uint32_t tid)
{
	return {};
}


bool DebugAdapter::ConnectToDebugServer(const std::string& server, std::uint32_t port)
{
	return false;
}


bool DebugAdapter::DisconnectDebugServer()
{
	return true;
}


Ref<Metadata> DebugAdapter::GetProperty(const std::string& name)
{
	return nullptr;
}


bool DebugAdapter::SetProperty(const std::string& name, const BinaryNinja::Ref<BinaryNinja::Metadata>& value)
{
	return false;
}


Ref<BinaryView> DebugAdapter::GetData()
{
	if (!m_controller)
		return nullptr;

	return m_controller->GetData();
}


Ref<Settings> DebugAdapter::GetAdapterSettings()
{
	return nullptr;
}


// TTD (Time Travel Debugging) default implementations
std::vector<TTDMemoryEvent> DebugAdapter::GetTTDMemoryAccessForAddress(uint64_t startAddress, uint64_t endAddress, TTDMemoryAccessType accessType)
{
	// Default implementation returns empty results for adapters that don't support TTD
	return {};
}

std::vector<TTDPositionRangeIndexedMemoryEvent> DebugAdapter::GetTTDMemoryAccessForPositionRange(uint64_t startAddress, uint64_t endAddress, TTDMemoryAccessType accessType, const TTDPosition startTime, const TTDPosition endTime)
{
	// Default implementation returns empty results for adapters that don't support TTD
	return {};
}


std::vector<TTDCallEvent> DebugAdapter::GetTTDCallsForSymbols(const std::string& symbols, uint64_t startReturnAddress, uint64_t endReturnAddress)
{
	// Default implementation returns empty results
	return {};
}


std::vector<TTDEvent> DebugAdapter::GetTTDEvents(TTDEventType eventType)
{
	// Default implementation returns empty results for adapters that don't support TTD
	return {};
}


std::vector<TTDEvent> DebugAdapter::GetAllTTDEvents()
{
	// Default implementation returns empty results for adapters that don't support TTD
	return {};
}


TTDPosition DebugAdapter::GetCurrentTTDPosition()
{
	// Default implementation returns an empty position for adapters that don't support TTD
	return TTDPosition();
}


bool DebugAdapter::SetTTDPosition(const TTDPosition& position)
{
	// Default implementation returns false for adapters that don't support TTD
	return false;
}


std::pair<bool, TTDMemoryEvent> DebugAdapter::GetTTDNextMemoryAccess(uint64_t address, uint64_t size, TTDMemoryAccessType accessType)
{
	// Default implementation returns failure for adapters that don't support TTD
	return {false, TTDMemoryEvent()};
}


std::pair<bool, TTDMemoryEvent> DebugAdapter::GetTTDPrevMemoryAccess(uint64_t address, uint64_t size, TTDMemoryAccessType accessType)
{
	// Default implementation returns failure for adapters that don't support TTD
	return {false, TTDMemoryEvent()};
}


std::vector<TTDStringEntry> DebugAdapter::GetTTDStrings(const std::string& pattern, uint64_t maxResults)
{
	return {};
}