SearchFilterSP SearchFilterByModule::CreateFromStructuredData(
Target &target, const StructuredData::Dictionary &data_dict,
Status &error) {
StructuredData::Array *modules_array;
bool success = data_dict.GetValueForKeyAsArray(GetKey(OptionNames::ModList),
modules_array);
if (!success) {
error.SetErrorString("SFBM::CFSD: Could not find the module list key.");
return nullptr;
}
size_t num_modules = modules_array->GetSize();
if (num_modules > 1) {
error.SetErrorString(
"SFBM::CFSD: Only one modules allowed for SearchFilterByModule.");
return nullptr;
}
llvm::StringRef module;
success = modules_array->GetItemAtIndexAsString(0, module);
if (!success) {
error.SetErrorString("SFBM::CFSD: filter module item not a string.");
return nullptr;
}
FileSpec module_spec(module);
return std::make_shared<SearchFilterByModule>(target.shared_from_this(),
module_spec);
}
void IRMemoryMap::WriteScalarToMemory(lldb::addr_t process_address,
Scalar &scalar, size_t size,
Status &error) {
error.Clear();
if (size == UINT32_MAX)
size = scalar.GetByteSize();
if (size > 0) {
uint8_t buf[32];
const size_t mem_size =
scalar.GetAsMemoryData(buf, size, GetByteOrder(), error);
if (mem_size > 0) {
return WriteMemory(process_address, buf, mem_size, error);
} else {
error.SetErrorToGenericError();
error.SetErrorString(
"Couldn't write scalar: failed to get scalar as memory data");
}
} else {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't write scalar: its size was zero");
}
return;
}
Status FileSystem::Readlink(const FileSpec &src, FileSpec &dst) {
Status error;
std::wstring wsrc;
if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc)) {
error.SetErrorString(PATH_CONVERSION_ERROR);
return error;
}
HANDLE h = ::CreateFileW(wsrc.c_str(), GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT, NULL);
if (h == INVALID_HANDLE_VALUE) {
error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
return error;
}
std::vector<wchar_t> buf(PATH_MAX + 1);
// Subtract 1 from the path length since this function does not add a null
// terminator.
DWORD result = ::GetFinalPathNameByHandleW(
h, buf.data(), buf.size() - 1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
std::string path;
if (result == 0)
error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
else if (!llvm::convertWideToUTF8(buf.data(), path))
error.SetErrorString(PATH_CONVERSION_ERROR);
else
dst.SetFile(path, false);
::CloseHandle(h);
return error;
}
bool ValueObjectDynamicValue::SetData(DataExtractor &data, Status &error) {
if (!UpdateValueIfNeeded(false)) {
error.SetErrorString("unable to read value");
return false;
}
uint64_t my_value = GetValueAsUnsigned(UINT64_MAX);
uint64_t parent_value = m_parent->GetValueAsUnsigned(UINT64_MAX);
if (my_value == UINT64_MAX || parent_value == UINT64_MAX) {
error.SetErrorString("unable to read value");
return false;
}
// if we are at an offset from our parent, in order to set ourselves
// correctly we would need to change the new value so that it refers to the
// correct dynamic type. we choose not to deal with that - if anything more
// than a value overwrite is required, you should be using the expression
// parser instead of the value editing facility
if (my_value != parent_value) {
// but NULL'ing out a value should always be allowed
lldb::offset_t offset = 0;
if (data.GetPointer(&offset) != 0) {
error.SetErrorString(
"unable to modify dynamic value, use 'expression' command");
return false;
}
}
bool ret_val = m_parent->SetData(data, error);
SetNeedsUpdate();
return ret_val;
}
SearchFilterSP SearchFilter::CreateFromStructuredData(
Target &target, const StructuredData::Dictionary &filter_dict,
Status &error) {
SearchFilterSP result_sp;
if (!filter_dict.IsValid()) {
error.SetErrorString("Can't deserialize from an invalid data object.");
return result_sp;
}
llvm::StringRef subclass_name;
bool success = filter_dict.GetValueForKeyAsString(
GetSerializationSubclassKey(), subclass_name);
if (!success) {
error.SetErrorStringWithFormat("Filter data missing subclass key");
return result_sp;
}
FilterTy filter_type = NameToFilterTy(subclass_name);
if (filter_type == UnknownFilter) {
error.SetErrorStringWithFormatv("Unknown filter type: {0}.", subclass_name);
return result_sp;
}
StructuredData::Dictionary *subclass_options = nullptr;
success = filter_dict.GetValueForKeyAsDictionary(
GetSerializationSubclassOptionsKey(), subclass_options);
if (!success || !subclass_options || !subclass_options->IsValid()) {
error.SetErrorString("Filter data missing subclass options key.");
return result_sp;
}
switch (filter_type) {
case Unconstrained:
result_sp = SearchFilterForUnconstrainedSearches::CreateFromStructuredData(
target, *subclass_options, error);
break;
case ByModule:
result_sp = SearchFilterByModule::CreateFromStructuredData(
target, *subclass_options, error);
break;
case ByModules:
result_sp = SearchFilterByModuleList::CreateFromStructuredData(
target, *subclass_options, error);
break;
case ByModulesAndCU:
result_sp = SearchFilterByModuleListAndCU::CreateFromStructuredData(
target, *subclass_options, error);
break;
case Exception:
error.SetErrorString("Can't serialize exception breakpoints yet.");
break;
default:
llvm_unreachable("Should never get an uresolvable filter type.");
}
return result_sp;
}
Status ProcessFreeBSD::EnableWatchpoint(Watchpoint *wp, bool notify) {
Status error;
if (wp) {
user_id_t watchID = wp->GetID();
addr_t addr = wp->GetLoadAddress();
Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
if (log)
log->Printf("ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64 ")",
watchID);
if (wp->IsEnabled()) {
if (log)
log->Printf("ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64
") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
watchID, (uint64_t)addr);
return error;
}
// Try to find a vacant watchpoint slot in the inferiors' main thread
uint32_t wp_hw_index = LLDB_INVALID_INDEX32;
std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
FreeBSDThread *thread = static_cast<FreeBSDThread *>(
m_thread_list.GetThreadAtIndex(0, false).get());
if (thread)
wp_hw_index = thread->FindVacantWatchpointIndex();
if (wp_hw_index == LLDB_INVALID_INDEX32) {
error.SetErrorString("Setting hardware watchpoint failed.");
} else {
wp->SetHardwareIndex(wp_hw_index);
bool wp_enabled = true;
uint32_t thread_count = m_thread_list.GetSize(false);
for (uint32_t i = 0; i < thread_count; ++i) {
thread = static_cast<FreeBSDThread *>(
m_thread_list.GetThreadAtIndex(i, false).get());
if (thread)
wp_enabled &= thread->EnableHardwareWatchpoint(wp);
else
wp_enabled = false;
}
if (wp_enabled) {
wp->SetEnabled(true, notify);
return error;
} else {
// Watchpoint enabling failed on at least one of the threads so roll
// back all of them
DisableWatchpoint(wp, false);
error.SetErrorString("Setting hardware watchpoint failed");
}
}
} else
error.SetErrorString("Watchpoint argument was NULL.");
return error;
}
uint32_t CommunicationKDP::SendRequestWriteRegisters(uint32_t cpu,
uint32_t flavor,
const void *src,
uint32_t src_len,
Status &error) {
PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size,
m_byte_order);
const CommandType command = KDP_WRITEREGS;
// Size is header + 4 byte cpu and 4 byte flavor
const uint32_t command_length = 8 + 4 + 4 + src_len;
MakeRequestPacketHeader(command, request_packet, command_length);
request_packet.PutHex32(cpu);
request_packet.PutHex32(flavor);
request_packet.Write(src, src_len);
DataExtractor reply_packet;
if (SendRequestAndGetReply(command, request_packet, reply_packet)) {
lldb::offset_t offset = 8;
uint32_t kdp_error = reply_packet.GetU32(&offset);
if (kdp_error == 0)
return src_len;
error.SetErrorStringWithFormat(
"failed to read kdp registers for cpu %u flavor %u (error %u)", cpu,
flavor, kdp_error);
} else {
error.SetErrorString("failed to send packet");
}
return 0;
}
uint32_t CommunicationKDP::SendRequestWriteMemory(lldb::addr_t addr,
const void *src,
uint32_t src_len,
Status &error) {
PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size,
m_byte_order);
bool use_64 = (GetVersion() >= 11);
uint32_t command_addr_byte_size = use_64 ? 8 : 4;
const CommandType command = use_64 ? KDP_WRITEMEM64 : KDP_WRITEMEM;
// Size is header + address size + uint32_t length
const uint32_t command_length = 8 + command_addr_byte_size + 4 + src_len;
MakeRequestPacketHeader(command, request_packet, command_length);
request_packet.PutMaxHex64(addr, command_addr_byte_size);
request_packet.PutHex32(src_len);
request_packet.PutRawBytes(src, src_len);
DataExtractor reply_packet;
if (SendRequestAndGetReply(command, request_packet, reply_packet)) {
lldb::offset_t offset = 8;
uint32_t kdp_error = reply_packet.GetU32(&offset);
if (kdp_error)
error.SetErrorStringWithFormat("kdp write memory failed (error %u)",
kdp_error);
else {
error.Clear();
return src_len;
}
} else {
error.SetErrorString("failed to send packet");
}
return 0;
}
bool CommunicationKDP::SendRawRequest(
uint8_t command_byte,
const void *src, // Raw packet payload bytes
uint32_t src_len, // Raw packet payload length
DataExtractor &reply_packet, Status &error) {
PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size,
m_byte_order);
// Size is header + address size + uint32_t length
const uint32_t command_length = 8 + src_len;
const CommandType command = (CommandType)command_byte;
MakeRequestPacketHeader(command, request_packet, command_length);
request_packet.PutRawBytes(src, src_len);
if (SendRequestAndGetReply(command, request_packet, reply_packet)) {
lldb::offset_t offset = 8;
uint32_t kdp_error = reply_packet.GetU32(&offset);
if (kdp_error && (command_byte != KDP_DUMPINFO))
error.SetErrorStringWithFormat("request packet 0x%8.8x failed (error %u)",
command_byte, kdp_error);
else {
error.Clear();
return true;
}
} else {
error.SetErrorString("failed to send packet");
}
return false;
}
lldb_private::Status PlatformAppleSimulator::LaunchProcess(
lldb_private::ProcessLaunchInfo &launch_info) {
#if defined(__APPLE__)
LoadCoreSimulator();
CoreSimulatorSupport::Device device(GetSimulatorDevice());
if (device.GetState() != CoreSimulatorSupport::Device::State::Booted) {
Status boot_err;
device.Boot(boot_err);
if (boot_err.Fail())
return boot_err;
}
auto spawned = device.Spawn(launch_info);
if (spawned) {
launch_info.SetProcessID(spawned.GetPID());
return Status();
} else
return spawned.GetError();
#else
Status err;
err.SetErrorString(UNSUPPORTED_ERROR);
return err;
#endif
}
Status NativeRegisterContextLinux_mips64::SetHardwareWatchpointWithIndex(
lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) {
Status error;
error.SetErrorString("MIPS TODO: "
"NativeRegisterContextLinux_mips64::"
"SetHardwareWatchpointWithIndex not implemented");
return error;
}
Status HostProcessPosix::Signal(int signo) const {
if (m_process == kInvalidPosixProcess) {
Status error;
error.SetErrorString("HostProcessPosix refers to an invalid process");
return error;
}
return HostProcessPosix::Signal(m_process, signo);
}
Materializer::DematerializerSP
Materializer::Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
lldb::addr_t process_address, Status &error) {
ExecutionContextScope *exe_scope = frame_sp.get();
if (!exe_scope)
exe_scope = map.GetBestExecutionContextScope();
DematerializerSP dematerializer_sp = m_dematerializer_wp.lock();
if (dematerializer_sp) {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't materialize: already materialized");
}
DematerializerSP ret(
new Dematerializer(*this, frame_sp, map, process_address));
if (!exe_scope) {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't materialize: target doesn't exist");
}
for (EntityUP &entity_up : m_entities) {
entity_up->Materialize(frame_sp, map, process_address, error);
if (!error.Success())
return DematerializerSP();
}
if (Log *log =
lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
log->Printf(
"Materializer::Materialize (frame_sp = %p, process_address = 0x%" PRIx64
") materialized:",
static_cast<void *>(frame_sp.get()), process_address);
for (EntityUP &entity_up : m_entities)
entity_up->DumpToLog(map, process_address, log);
}
m_dematerializer_wp = ret;
return ret;
}
Status PlatformAppleSimulator::DisconnectRemote() {
#if defined(__APPLE__)
m_device.reset();
return Status();
#else
Status err;
err.SetErrorString(UNSUPPORTED_ERROR);
return err;
#endif
}
Status ProcessFreeBSD::DisableWatchpoint(Watchpoint *wp, bool notify) {
Status error;
if (wp) {
user_id_t watchID = wp->GetID();
addr_t addr = wp->GetLoadAddress();
Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
if (log)
log->Printf("ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64 ")",
watchID);
if (!wp->IsEnabled()) {
if (log)
log->Printf("ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64
") addr = 0x%8.8" PRIx64 ": watchpoint already disabled.",
watchID, (uint64_t)addr);
// This is needed (for now) to keep watchpoints disabled correctly
wp->SetEnabled(false, notify);
return error;
}
if (wp->IsHardware()) {
bool wp_disabled = true;
std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
uint32_t thread_count = m_thread_list.GetSize(false);
for (uint32_t i = 0; i < thread_count; ++i) {
FreeBSDThread *thread = static_cast<FreeBSDThread *>(
m_thread_list.GetThreadAtIndex(i, false).get());
if (thread)
wp_disabled &= thread->DisableHardwareWatchpoint(wp);
else
wp_disabled = false;
}
if (wp_disabled) {
wp->SetHardwareIndex(LLDB_INVALID_INDEX32);
wp->SetEnabled(false, notify);
return error;
} else
error.SetErrorString("Disabling hardware watchpoint failed");
}
} else
error.SetErrorString("Watchpoint argument was NULL.");
return error;
}
Status NativeRegisterContextLinux_mips64::ReadAllRegisterValues(
lldb::DataBufferSP &data_sp) {
Status error;
data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
if (!data_sp) {
error.SetErrorStringWithFormat(
"failed to allocate DataBufferHeap instance of size %" PRIu64,
REG_CONTEXT_SIZE);
return error;
}
error = ReadGPR();
if (!error.Success()) {
error.SetErrorString("ReadGPR() failed");
return error;
}
error = ReadCP1();
if (!error.Success()) {
error.SetErrorString("ReadCP1() failed");
return error;
}
uint8_t *dst = data_sp->GetBytes();
if (dst == nullptr) {
error.SetErrorStringWithFormat("DataBufferHeap instance of size %" PRIu64
" returned a null pointer",
REG_CONTEXT_SIZE);
return error;
}
::memcpy(dst, &m_gpr, GetRegisterInfoInterface().GetGPRSize());
dst += GetRegisterInfoInterface().GetGPRSize();
::memcpy(dst, &m_fpr, GetFPRSize());
dst += GetFPRSize();
::memcpy(dst, &m_msa, sizeof(MSA_linux_mips));
return error;
}
Status ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num) {
Status error;
std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
FreeBSDThread *thread = static_cast<FreeBSDThread *>(
m_thread_list.GetThreadAtIndex(0, false).get());
if (thread)
num = thread->NumSupportedHardwareWatchpoints();
else
error.SetErrorString("Process does not exist.");
return error;
}
std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
bool child_processes_inherit,
Status &error) {
error.Clear();
std::unique_ptr<Socket> socket_up;
switch (protocol) {
case ProtocolTcp:
socket_up =
llvm::make_unique<TCPSocket>(true, child_processes_inherit);
break;
case ProtocolUdp:
socket_up =
llvm::make_unique<UDPSocket>(true, child_processes_inherit);
break;
case ProtocolUnixDomain:
#ifndef LLDB_DISABLE_POSIX
socket_up =
llvm::make_unique<DomainSocket>(true, child_processes_inherit);
#else
error.SetErrorString(
"Unix domain sockets are not supported on this platform.");
#endif
break;
case ProtocolUnixAbstract:
#ifdef __linux__
socket_up =
llvm::make_unique<AbstractSocket>(child_processes_inherit);
#else
error.SetErrorString(
"Abstract domain sockets are not supported on this platform.");
#endif
break;
}
if (error.Fail())
socket_up.reset();
return socket_up;
}
void Materializer::Dematerializer::Dematerialize(Status &error,
lldb::addr_t frame_bottom,
lldb::addr_t frame_top) {
lldb::StackFrameSP frame_sp;
lldb::ThreadSP thread_sp = m_thread_wp.lock();
if (thread_sp)
frame_sp = thread_sp->GetFrameWithStackID(m_stack_id);
ExecutionContextScope *exe_scope = m_map->GetBestExecutionContextScope();
if (!IsValid()) {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't dematerialize: invalid dematerializer");
}
if (!exe_scope) {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't dematerialize: target is gone");
} else {
if (Log *log =
lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
log->Printf("Materializer::Dematerialize (frame_sp = %p, process_address "
"= 0x%" PRIx64 ") about to dematerialize:",
static_cast<void *>(frame_sp.get()), m_process_address);
for (EntityUP &entity_up : m_materializer->m_entities)
entity_up->DumpToLog(*m_map, m_process_address, log);
}
for (EntityUP &entity_up : m_materializer->m_entities) {
entity_up->Dematerialize(frame_sp, *m_map, m_process_address, frame_top,
frame_bottom, error);
if (!error.Success())
break;
}
}
Wipe();
}
Status RegisterContext::WriteRegisterValueToMemory(
const RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len,
const RegisterValue ®_value) {
uint8_t dst[RegisterValue::kMaxRegisterByteSize];
Status error;
ProcessSP process_sp(m_thread.GetProcess());
if (process_sp) {
// TODO: we might need to add a parameter to this function in case the byte
// order of the memory data doesn't match the process. For now we are
// assuming they are the same.
const uint32_t bytes_copied = reg_value.GetAsMemoryData(
reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
if (error.Success()) {
if (bytes_copied == 0) {
error.SetErrorString("byte copy failed.");
} else {
const uint32_t bytes_written =
process_sp->WriteMemory(dst_addr, dst, bytes_copied, error);
if (bytes_written != bytes_copied) {
if (error.Success()) {
// This might happen if we read _some_ bytes but not all
error.SetErrorStringWithFormat("only wrote %u of %u bytes",
bytes_written, bytes_copied);
}
}
}
}
} else
error.SetErrorString("invalid process");
return error;
}
Status PlatformAppleSimulator::ConnectRemote(Args &args) {
#if defined(__APPLE__)
Status error;
if (args.GetArgumentCount() == 1) {
if (m_device)
DisconnectRemote();
PlatformAppleSimulator::LoadCoreSimulator();
const char *arg_cstr = args.GetArgumentAtIndex(0);
if (arg_cstr) {
std::string arg_str(arg_cstr);
CoreSimulatorSupport::DeviceSet devices =
CoreSimulatorSupport::DeviceSet::GetAvailableDevices(
GetDeveloperDirectory());
devices.ForEach(
[this, &arg_str](const CoreSimulatorSupport::Device &device) -> bool {
if (arg_str == device.GetUDID() || arg_str == device.GetName()) {
m_device = device;
return false; // Stop iterating
} else {
return true; // Keep iterating
}
});
if (!m_device)
error.SetErrorStringWithFormat(
"no device with UDID or name '%s' was found", arg_cstr);
}
} else {
error.SetErrorString("this command take a single UDID argument of the "
"device you want to connect to.");
}
return error;
#else
Status err;
err.SetErrorString(UNSUPPORTED_ERROR);
return err;
#endif
}
Status ProcessFreeBSD::DoDetach(bool keep_stopped) {
Status error;
if (keep_stopped) {
error.SetErrorString("Detaching with keep_stopped true is not currently "
"supported on FreeBSD.");
return error;
}
error = m_monitor->Detach(GetID());
if (error.Success())
SetPrivateState(eStateDetached);
return error;
}
void IRMemoryMap::Leak(lldb::addr_t process_address, Status &error) {
error.Clear();
AllocationMap::iterator iter = m_allocations.find(process_address);
if (iter == m_allocations.end()) {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't leak: allocation doesn't exist");
return;
}
Allocation &allocation = iter->second;
allocation.m_leak = true;
}
void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
lldb::addr_t process_address, Status &err) override {
if (!m_is_program_reference) {
if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
err.SetErrorString("Trying to create a temporary region for the result "
"but one exists");
return;
}
const lldb::addr_t load_addr = process_address + m_offset;
ExecutionContextScope *exe_scope = map.GetBestExecutionContextScope();
size_t byte_size = m_type.GetByteSize(exe_scope);
size_t bit_align = m_type.GetTypeBitAlign();
size_t byte_align = (bit_align + 7) / 8;
if (!byte_align)
byte_align = 1;
Status alloc_error;
const bool zero_memory = true;
m_temporary_allocation = map.Malloc(
byte_size, byte_align,
lldb::ePermissionsReadable | lldb::ePermissionsWritable,
IRMemoryMap::eAllocationPolicyMirror, zero_memory, alloc_error);
m_temporary_allocation_size = byte_size;
if (!alloc_error.Success()) {
err.SetErrorStringWithFormat(
"couldn't allocate a temporary region for the result: %s",
alloc_error.AsCString());
return;
}
Status pointer_write_error;
map.WritePointerToMemory(load_addr, m_temporary_allocation,
pointer_write_error);
if (!pointer_write_error.Success()) {
err.SetErrorStringWithFormat("couldn't write the address of the "
"temporary region for the result: %s",
pointer_write_error.AsCString());
}
}
}
Status DynamicLoaderMacOSXDYLD::CanLoadImage() {
Status error;
// In order for us to tell if we can load a shared library we verify that the
// dylib_info_addr isn't zero (which means no shared libraries have been set
// yet, or dyld is currently mucking with the shared library list).
if (ReadAllImageInfosStructure()) {
// TODO: also check the _dyld_global_lock_held variable in
// libSystem.B.dylib?
// TODO: check the malloc lock?
// TODO: check the objective C lock?
if (m_dyld_all_image_infos.dylib_info_addr != 0)
return error; // Success
}
error.SetErrorString("unsafe to load or unload shared libraries");
return error;
}
lldb::SearchFilterSP SearchFilterByModuleListAndCU::CreateFromStructuredData(
Target &target, const StructuredData::Dictionary &data_dict,
Status &error) {
StructuredData::Array *modules_array = nullptr;
SearchFilterSP result_sp;
bool success = data_dict.GetValueForKeyAsArray(GetKey(OptionNames::ModList),
modules_array);
FileSpecList modules;
if (success) {
size_t num_modules = modules_array->GetSize();
for (size_t i = 0; i < num_modules; i++) {
llvm::StringRef module;
success = modules_array->GetItemAtIndexAsString(i, module);
if (!success) {
error.SetErrorStringWithFormat(
"SFBM::CFSD: filter module item %zu not a string.", i);
return result_sp;
}
modules.Append(FileSpec(module));
}
}
StructuredData::Array *cus_array = nullptr;
success =
data_dict.GetValueForKeyAsArray(GetKey(OptionNames::CUList), cus_array);
if (!success) {
error.SetErrorString("SFBM::CFSD: Could not find the CU list key.");
return result_sp;
}
size_t num_cus = cus_array->GetSize();
FileSpecList cus;
for (size_t i = 0; i < num_cus; i++) {
llvm::StringRef cu;
success = cus_array->GetItemAtIndexAsString(i, cu);
if (!success) {
error.SetErrorStringWithFormat(
"SFBM::CFSD: filter cu item %zu not a string.", i);
return nullptr;
}
cus.Append(FileSpec(cu));
}
return std::make_shared<SearchFilterByModuleListAndCU>(
target.shared_from_this(), modules, cus);
}
Status OptionValueLanguage::SetValueFromString(llvm::StringRef value,
VarSetOperationType op) {
Status error;
switch (op) {
case eVarSetOperationClear:
Clear();
break;
case eVarSetOperationReplace:
case eVarSetOperationAssign: {
ConstString lang_name(value.trim());
std::set<lldb::LanguageType> languages_for_types;
std::set<lldb::LanguageType> languages_for_expressions;
Language::GetLanguagesSupportingTypeSystems(languages_for_types,
languages_for_expressions);
LanguageType new_type =
Language::GetLanguageTypeFromString(lang_name.GetStringRef());
if (new_type && languages_for_types.count(new_type)) {
m_value_was_set = true;
m_current_value = new_type;
} else {
StreamString error_strm;
error_strm.Printf("invalid language type '%s', ", value.str().c_str());
error_strm.Printf("valid values are:\n");
for (lldb::LanguageType language : languages_for_types) {
error_strm.Printf("%s%s%s", " ",
Language::GetNameForLanguageType(language), "\n");
}
error.SetErrorString(error_strm.GetString());
}
} break;
case eVarSetOperationInsertBefore:
case eVarSetOperationInsertAfter:
case eVarSetOperationRemove:
case eVarSetOperationAppend:
case eVarSetOperationInvalid:
error = OptionValue::SetValueFromString(value, op);
break;
}
return error;
}
void IRMemoryMap::Free(lldb::addr_t process_address, Status &error) {
error.Clear();
AllocationMap::iterator iter = m_allocations.find(process_address);
if (iter == m_allocations.end()) {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't free: allocation doesn't exist");
return;
}
Allocation &allocation = iter->second;
switch (allocation.m_policy) {
default:
case eAllocationPolicyHostOnly: {
lldb::ProcessSP process_sp = m_process_wp.lock();
if (process_sp) {
if (process_sp->CanJIT() && process_sp->IsAlive())
process_sp->DeallocateMemory(
allocation.m_process_alloc); // FindSpace allocated this for real
}
break;
}
case eAllocationPolicyMirror:
case eAllocationPolicyProcessOnly: {
lldb::ProcessSP process_sp = m_process_wp.lock();
if (process_sp)
process_sp->DeallocateMemory(allocation.m_process_alloc);
}
}
if (lldb_private::Log *log =
lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
log->Printf("IRMemoryMap::Free (0x%" PRIx64 ") freed [0x%" PRIx64
"..0x%" PRIx64 ")",
(uint64_t)process_address, iter->second.m_process_start,
iter->second.m_process_start + iter->second.m_size);
}
m_allocations.erase(iter);
}
void IRMemoryMap::ReadScalarFromMemory(Scalar &scalar,
lldb::addr_t process_address,
size_t size, Status &error) {
error.Clear();
if (size > 0) {
DataBufferHeap buf(size, 0);
ReadMemory(buf.GetBytes(), process_address, size, error);
if (!error.Success())
return;
DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(),
GetAddressByteSize());
lldb::offset_t offset = 0;
switch (size) {
default:
error.SetErrorToGenericError();
error.SetErrorStringWithFormat(
"Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
return;
case 1:
scalar = extractor.GetU8(&offset);
break;
case 2:
scalar = extractor.GetU16(&offset);
break;
case 4:
scalar = extractor.GetU32(&offset);
break;
case 8:
scalar = extractor.GetU64(&offset);
break;
}
} else {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't read scalar: its size was zero");
}
return;
}
Status FileSystem::Symlink(const FileSpec &src, const FileSpec &dst) {
Status error;
std::wstring wsrc, wdst;
if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc) ||
!llvm::ConvertUTF8toWide(dst.GetCString(), wdst))
error.SetErrorString(PATH_CONVERSION_ERROR);
if (error.Fail())
return error;
DWORD attrib = ::GetFileAttributesW(wdst.c_str());
if (attrib == INVALID_FILE_ATTRIBUTES) {
error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
return error;
}
bool is_directory = !!(attrib & FILE_ATTRIBUTE_DIRECTORY);
DWORD flag = is_directory ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
BOOL result = ::CreateSymbolicLinkW(wsrc.c_str(), wdst.c_str(), flag);
if (!result)
error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
return error;
}
