uint32_t PlatformRemoteiOS::FindFileInAllSDKs (const char *platform_file_path, FileSpecList &file_list) { Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST | LIBLLDB_LOG_VERBOSE); if (platform_file_path && platform_file_path[0] && UpdateSDKDirectoryInfosIfNeeded()) { const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); lldb_private::FileSpec local_file; // First try for an exact match of major, minor and update for (uint32_t sdk_idx=0; sdk_idx<num_sdk_infos; ++sdk_idx) { if (log) { log->Printf ("Searching for %s in sdk path %s", platform_file_path, m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str()); } if (GetFileInSDK (platform_file_path, sdk_idx, local_file)) { file_list.Append(local_file); } } } return file_list.GetSize(); }
size_t FileSpecList::GetFilesMatchingPartialPath (const char *path, bool dir_okay, FileSpecList &matches) { #if 0 // FIXME: Just sketching... matches.Clear(); FileSpec path_spec = FileSpec (path); if (path_spec.Exists ()) { FileSpec::FileType type = path_spec.GetFileType(); if (type == FileSpec::eFileTypeSymbolicLink) // Shouldn't there be a Resolve on a file spec that real-path's it? { } if (type == FileSpec::eFileTypeRegular || (type == FileSpec::eFileTypeDirectory && dir_okay)) { matches.Append (path_spec); return 1; } else if (type == FileSpec::eFileTypeDirectory) { // Fill the match list with all the files in the directory: } else { return 0; } } else { ConstString dir_name = path_spec.GetDirectory(); Constring file_name = GetFilename(); if (dir_name == NULL) { // Match files in the CWD. } else { // Match files in the given directory: } } #endif return 0; }
void SearchFilter::SerializeFileSpecList( StructuredData::DictionarySP &options_dict_sp, OptionNames name, FileSpecList &file_list) { size_t num_modules = file_list.GetSize(); // Don't serialize empty lists. if (num_modules == 0) return; auto module_array_sp = std::make_shared<StructuredData::Array>(); for (size_t i = 0; i < num_modules; i++) { module_array_sp->AddItem(std::make_shared<StructuredData::String>( file_list.GetFileSpecAtIndex(i).GetPath())); } options_dict_sp->AddItem(GetKey(name), module_array_sp); }
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); }
uint32_t ObjectFileJIT::GetDependentModules (FileSpecList& files) { // JIT modules don't have dependencies, but they could // if external functions are called and we know where they are files.Clear(); return 0; }
uint32_t PlatformRemoteDarwinDevice::FindFileInAllSDKs(const char *platform_file_path, FileSpecList &file_list) { Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST); if (platform_file_path && platform_file_path[0] && UpdateSDKDirectoryInfosIfNeeded()) { const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); lldb_private::FileSpec local_file; // First try for an exact match of major, minor and update for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) { LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file_path, m_sdk_directory_infos[sdk_idx].directory); if (GetFileInSDK(platform_file_path, sdk_idx, local_file)) { file_list.Append(local_file); } } } return file_list.GetSize(); }
uint32_t PlatformRemoteiOS::FindFileInAllSDKs (const char *platform_file_path, FileSpecList &file_list) { if (platform_file_path && platform_file_path[0] && UpdateSDKDirectoryInfosInNeeded()) { const uint32_t num_sdk_infos = m_sdk_directory_infos.size(); lldb_private::FileSpec local_file; // First try for an exact match of major, minor and update for (uint32_t sdk_idx=0; sdk_idx<num_sdk_infos; ++sdk_idx) { if (GetFileInSDK (platform_file_path, sdk_idx, local_file)) { file_list.Append(local_file); } } } return file_list.GetSize(); }
uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) { size_t num_modules = ParseDependentModules(); uint32_t num_specs = 0; for (unsigned i = 0; i < num_modules; ++i) { if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i))) num_specs++; } return num_specs; }
SearchFilterSP SearchFilterByModuleList::CreateFromStructuredData( Target &target, const StructuredData::Dictionary &data_dict, Status &error) { StructuredData::Array *modules_array; 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 nullptr; } modules.Append(FileSpec(module)); } } return std::make_shared<SearchFilterByModuleList>(target.shared_from_this(), modules); }
lldb::REPLSP SwiftREPL::CreateInstance (Error &err, lldb::LanguageType language, Debugger *debugger, Target *target, const char *repl_options) { if (language != eLanguageTypeSwift) { return lldb::REPLSP(); } if (target) { // Sanity check the target to make sure a REPL would work here. if (!target->GetProcessSP() || !target->GetProcessSP()->IsAlive()) { err.SetErrorString ("can't launch a Swift REPL without a running process"); return lldb::REPLSP(); } SymbolContextList sc_list; target->GetImages().FindSymbolsWithNameAndType(ConstString("_swift_release"), eSymbolTypeAny, sc_list); if (!sc_list.GetSize()) { err.SetErrorString ("can't launch a Swift REPL in a process that doesn't have the Swift standard library"); return lldb::REPLSP(); } // Sanity checks succeeded. Go ahead. SwiftREPL *repl = new SwiftREPL(*target); REPLSP repl_sp(repl); repl->SetCompilerOptions(repl_options); return repl_sp; } else if (debugger) { const char *bp_name = "repl_main"; FileSpec repl_executable; if (HostInfo::GetLLDBPath (ePathTypeSupportExecutableDir, repl_executable)) { repl_executable.GetFilename().SetCString("repl_swift"); std::string repl_exe_path(repl_executable.GetPath()); if (repl_executable.Exists()) { const char *target_triple = NULL; bool add_dependent_modules = true; TargetSP target_sp; err = debugger->GetTargetList().CreateTarget (*debugger, repl_exe_path.c_str(), target_triple, add_dependent_modules, NULL, target_sp); if (err.Success()) { // Limit the breakpoint to our executable module FileSpecList containingModules; ModuleSP exe_module_sp (target_sp->GetExecutableModule()); if (exe_module_sp) { FileSpec exe_spec(exe_module_sp->GetFileSpec()); containingModules.Append(exe_spec); BreakpointSP main_bp_sp = target_sp->CreateBreakpoint (&containingModules, // Limit to these modules NULL, // Don't limit the breakpoint to any source files bp_name, // Function name eFunctionNameTypeAuto, // Name type eLanguageTypeUnknown, // Language 0, // offset eLazyBoolYes, // skip_prologue, true, // internal false); // request_hardware if (main_bp_sp->GetNumLocations() > 0) { main_bp_sp->SetBreakpointKind("REPL"); assert (main_bp_sp->IsInternal()); // We made an internal breakpoint above, it better say it is internal lldb_private::ProcessLaunchInfo launch_info; const char *target_settings_argv0 = target_sp->GetArg0(); if (target_sp->GetDisableASLR()) launch_info.GetFlags().Set (eLaunchFlagDisableASLR); if (target_sp->GetDisableSTDIO()) launch_info.GetFlags().Set (eLaunchFlagDisableSTDIO); if (target_settings_argv0) { launch_info.GetArguments().AppendArgument (target_settings_argv0); launch_info.SetExecutableFile(exe_module_sp->GetPlatformFileSpec(), false); } else { launch_info.SetExecutableFile(exe_module_sp->GetPlatformFileSpec(), true); } debugger->SetAsyncExecution(false); err = target_sp->Launch(launch_info, nullptr); debugger->SetAsyncExecution(true); if (err.Success()) { ProcessSP process_sp (target_sp->GetProcessSP()); if (process_sp) { // Start handling process events automatically debugger->StartEventHandlerThread(); StateType state = process_sp->GetState(); if (state == eStateStopped) { ThreadList &thread_list = process_sp->GetThreadList(); const uint32_t num_threads = thread_list.GetSize(); if (num_threads > 0) { ThreadSP thread_sp = thread_list.GetSelectedThread(); if (!thread_sp) { thread_sp = thread_list.GetThreadAtIndex(0); thread_list.SetSelectedThreadByID(thread_sp->GetID()); } if (thread_sp) { thread_sp->SetSelectedFrameByIndex(0); std::string swift_full_version(swift::version::getSwiftFullVersion()); printf ("Welcome to %s. Type :help for assistance.\n", swift_full_version.c_str()); REPLSP repl_sp(new SwiftREPL(*target_sp)); ((SwiftREPL*)repl_sp.get())->SetCompilerOptions(repl_options); target_sp->SetREPL(lldb::eLanguageTypeSwift, repl_sp); return repl_sp; } } else { err.SetErrorString ("process is not in valid state (no threads)"); } } else { err.SetErrorString ("failed to stop process at REPL breakpoint"); } process_sp->Destroy(false); debugger->StopEventHandlerThread(); } else { err.SetErrorString ("failed to launch REPL process"); } } else { err.SetErrorStringWithFormat ("failed to launch REPL process: %s", err.AsCString()); } } else { err.SetErrorStringWithFormat ("failed to resolve REPL breakpoint for '%s'", bp_name); } } else { err.SetErrorString ("unable to resolve REPL executable module"); target_sp->Destroy(); } } else { err.SetErrorStringWithFormat ("failed to create REPL target: %s", err.AsCString()); } } else { err.SetErrorStringWithFormat ("REPL executable does not exist: '%s'", repl_exe_path.c_str()); } } else { err.SetErrorString ("unable to locate REPL executable"); } return lldb::REPLSP(); } else { err.SetErrorString ("must have a debugger or a target to create a REPL"); return lldb::REPLSP(); } }