//===-- Target.cpp ----------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "lldb/Target/Target.h" // C Includes // C++ Includes // Other libraries and framework includes // Project includes #include "lldb/Breakpoint/BreakpointResolver.h" #include "lldb/Breakpoint/BreakpointResolverAddress.h" #include "lldb/Breakpoint/BreakpointResolverFileLine.h" #include "lldb/Breakpoint/BreakpointResolverName.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/Event.h" #include "lldb/Core/Log.h" #include "lldb/Core/StreamString.h" #include "lldb/Core/Timer.h" #include "lldb/Core/ValueObject.h" #include "lldb/Host/Host.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/lldb-private-log.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Target/Process.h" #include "lldb/Target/StackFrame.h" #include "lldb/Target/Thread.h" #include "lldb/Target/ThreadSpec.h" using namespace lldb; using namespace lldb_private; //---------------------------------------------------------------------- // Target constructor //---------------------------------------------------------------------- Target::Target(Debugger &debugger) : Broadcaster("lldb.target"), TargetInstanceSettings (*GetSettingsController()), m_debugger (debugger), m_mutex (Mutex::eMutexTypeRecursive), m_images(), m_section_load_list (), m_breakpoint_list (false), m_internal_breakpoint_list (true), m_process_sp(), m_search_filter_sp(), m_image_search_paths (ImageSearchPathsChanged, this), m_scratch_ast_context_ap (NULL), m_persistent_variables (), m_stop_hook_next_id(0) { SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed"); SetEventName (eBroadcastBitModulesLoaded, "modules-loaded"); SetEventName (eBroadcastBitModulesUnloaded, "modules-unloaded"); LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); if (log) log->Printf ("%p Target::Target()", this); } //---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- Target::~Target() { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); if (log) log->Printf ("%p Target::~Target()", this); DeleteCurrentProcess (); } void Target::Dump (Stream *s, lldb::DescriptionLevel description_level) { // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); if (description_level != lldb::eDescriptionLevelBrief) { s->Indent(); s->PutCString("Target\n"); s->IndentMore(); m_images.Dump(s); m_breakpoint_list.Dump(s); m_internal_breakpoint_list.Dump(s); s->IndentLess(); } else { s->PutCString (GetExecutableModule()->GetFileSpec().GetFilename().GetCString()); } } void Target::DeleteCurrentProcess () { if (m_process_sp.get()) { m_section_load_list.Clear(); if (m_process_sp->IsAlive()) m_process_sp->Destroy(); m_process_sp->Finalize(); // Do any cleanup of the target we need to do between process instances. // NB It is better to do this before destroying the process in case the // clean up needs some help from the process. m_breakpoint_list.ClearAllBreakpointSites(); m_internal_breakpoint_list.ClearAllBreakpointSites(); m_process_sp.reset(); } } const lldb::ProcessSP & Target::CreateProcess (Listener &listener, const char *plugin_name) { DeleteCurrentProcess (); m_process_sp.reset(Process::FindPlugin(*this, plugin_name, listener)); return m_process_sp; } const lldb::ProcessSP & Target::GetProcessSP () const { return m_process_sp; } lldb::TargetSP Target::GetSP() { return m_debugger.GetTargetList().GetTargetSP(this); } BreakpointList & Target::GetBreakpointList(bool internal) { if (internal) return m_internal_breakpoint_list; else return m_breakpoint_list; } const BreakpointList & Target::GetBreakpointList(bool internal) const { if (internal) return m_internal_breakpoint_list; else return m_breakpoint_list; } BreakpointSP Target::GetBreakpointByID (break_id_t break_id) { BreakpointSP bp_sp; if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); else bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); return bp_sp; } BreakpointSP Target::CreateBreakpoint (const FileSpec *containingModule, const FileSpec &file, uint32_t line_no, bool check_inlines, bool internal) { SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule)); BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine (NULL, file, line_no, check_inlines)); return CreateBreakpoint (filter_sp, resolver_sp, internal); } BreakpointSP Target::CreateBreakpoint (lldb::addr_t addr, bool internal) { Address so_addr; // Attempt to resolve our load address if possible, though it is ok if // it doesn't resolve to section/offset. // Try and resolve as a load address if possible m_section_load_list.ResolveLoadAddress(addr, so_addr); if (!so_addr.IsValid()) { // The address didn't resolve, so just set this as an absolute address so_addr.SetOffset (addr); } BreakpointSP bp_sp (CreateBreakpoint(so_addr, internal)); return bp_sp; } BreakpointSP Target::CreateBreakpoint (Address &addr, bool internal) { TargetSP target_sp = this->GetSP(); SearchFilterSP filter_sp(new SearchFilter (target_sp)); BreakpointResolverSP resolver_sp (new BreakpointResolverAddress (NULL, addr)); return CreateBreakpoint (filter_sp, resolver_sp, internal); } BreakpointSP Target::CreateBreakpoint (FileSpec *containingModule, const char *func_name, uint32_t func_name_type_mask, bool internal) { BreakpointSP bp_sp; if (func_name) { SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule)); BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, func_name, func_name_type_mask, Breakpoint::Exact)); bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal); } return bp_sp; } SearchFilterSP Target::GetSearchFilterForModule (const FileSpec *containingModule) { SearchFilterSP filter_sp; lldb::TargetSP target_sp = this->GetSP(); if (containingModule != NULL) { // TODO: We should look into sharing module based search filters // across many breakpoints like we do for the simple target based one filter_sp.reset (new SearchFilterByModule (target_sp, *containingModule)); } else { if (m_search_filter_sp.get() == NULL) m_search_filter_sp.reset (new SearchFilter (target_sp)); filter_sp = m_search_filter_sp; } return filter_sp; } BreakpointSP Target::CreateBreakpoint (FileSpec *containingModule, RegularExpression &func_regex, bool internal) { SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule)); BreakpointResolverSP resolver_sp(new BreakpointResolverName (NULL, func_regex)); return CreateBreakpoint (filter_sp, resolver_sp, internal); } BreakpointSP Target::CreateBreakpoint (SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal) { BreakpointSP bp_sp; if (filter_sp && resolver_sp) { bp_sp.reset(new Breakpoint (*this, filter_sp, resolver_sp)); resolver_sp->SetBreakpoint (bp_sp.get()); if (internal) m_internal_breakpoint_list.Add (bp_sp, false); else m_breakpoint_list.Add (bp_sp, true); LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); if (log) { StreamString s; bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); log->Printf ("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__, internal ? "yes" : "no", s.GetData()); } bp_sp->ResolveBreakpoint(); } if (!internal && bp_sp) { m_last_created_breakpoint = bp_sp; } return bp_sp; } void Target::RemoveAllBreakpoints (bool internal_also) { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); if (log) log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); m_breakpoint_list.RemoveAll (true); if (internal_also) m_internal_breakpoint_list.RemoveAll (false); m_last_created_breakpoint.reset(); } void Target::DisableAllBreakpoints (bool internal_also) { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); if (log) log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); m_breakpoint_list.SetEnabledAll (false); if (internal_also) m_internal_breakpoint_list.SetEnabledAll (false); } void Target::EnableAllBreakpoints (bool internal_also) { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); if (log) log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no"); m_breakpoint_list.SetEnabledAll (true); if (internal_also) m_internal_breakpoint_list.SetEnabledAll (true); } bool Target::RemoveBreakpointByID (break_id_t break_id) { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); if (log) log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); if (DisableBreakpointByID (break_id)) { if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) m_internal_breakpoint_list.Remove(break_id, false); else { if (m_last_created_breakpoint) { if (m_last_created_breakpoint->GetID() == break_id) m_last_created_breakpoint.reset(); } m_breakpoint_list.Remove(break_id, true); } return true; } return false; } bool Target::DisableBreakpointByID (break_id_t break_id) { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); if (log) log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); BreakpointSP bp_sp; if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); else bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); if (bp_sp) { bp_sp->SetEnabled (false); return true; } return false; } bool Target::EnableBreakpointByID (break_id_t break_id) { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); if (log) log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no"); BreakpointSP bp_sp; if (LLDB_BREAK_ID_IS_INTERNAL (break_id)) bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id); else bp_sp = m_breakpoint_list.FindBreakpointByID (break_id); if (bp_sp) { bp_sp->SetEnabled (true); return true; } return false; } ModuleSP Target::GetExecutableModule () { ModuleSP executable_sp; if (m_images.GetSize() > 0) executable_sp = m_images.GetModuleAtIndex(0); return executable_sp; } void Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files) { m_images.Clear(); m_scratch_ast_context_ap.reset(); if (executable_sp.get()) { Timer scoped_timer (__PRETTY_FUNCTION__, "Target::SetExecutableModule (executable = '%s/%s')", executable_sp->GetFileSpec().GetDirectory().AsCString(), executable_sp->GetFileSpec().GetFilename().AsCString()); m_images.Append(executable_sp); // The first image is our exectuable file ArchSpec exe_arch = executable_sp->GetArchitecture(); // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module. if (!m_arch_spec.IsValid()) m_arch_spec = exe_arch; FileSpecList dependent_files; ObjectFile *executable_objfile = executable_sp->GetObjectFile(); assert (executable_objfile); // TODO: remote assertion above after verifying that it doesn't fire off // after the platform changes. The platform is what should be selecting // the right slice of an executable file, and it also should be the one // to resolve any executables in their bundles. // if (executable_objfile == NULL) // { // // FileSpec bundle_executable(executable_sp->GetFileSpec()); // if (Host::ResolveExecutableInBundle (bundle_executable)) // { // ModuleSP bundle_exe_module_sp(GetSharedModule(bundle_executable, // exe_arch)); // SetExecutableModule (bundle_exe_module_sp, get_dependent_files); // if (bundle_exe_module_sp->GetObjectFile() != NULL) // executable_sp = bundle_exe_module_sp; // return; // } // } if (executable_objfile) { executable_objfile->GetDependentModules(dependent_files); for (uint32_t i=0; iDump(&s);// REMOVE THIS, DEBUG ONLY ObjectFile *objfile = image_module_sp->GetObjectFile(); if (objfile) objfile->GetDependentModules(dependent_files); } } } // Now see if we know the target triple, and if so, create our scratch AST context: if (m_arch_spec.IsValid()) { m_scratch_ast_context_ap.reset (new ClangASTContext(m_arch_spec.GetTriple().str().c_str())); } } UpdateInstanceName(); } bool Target::SetArchitecture (const ArchSpec &arch_spec) { if (m_arch_spec == arch_spec) { // If we're setting the architecture to our current architecture, we // don't need to do anything. return true; } else if (!m_arch_spec.IsValid()) { // If we haven't got a valid arch spec, then we just need to set it. m_arch_spec = arch_spec; return true; } else { // If we have an executable file, try to reset the executable to the desired architecture m_arch_spec = arch_spec; ModuleSP executable_sp = GetExecutableModule (); m_images.Clear(); m_scratch_ast_context_ap.reset(); // Need to do something about unsetting breakpoints. if (executable_sp) { FileSpec exec_file_spec = executable_sp->GetFileSpec(); Error error = ModuleList::GetSharedModule(exec_file_spec, arch_spec, NULL, NULL, 0, executable_sp, NULL, NULL); if (!error.Fail() && executable_sp) { SetExecutableModule (executable_sp, true); return true; } else { return false; } } else { return false; } } } void Target::ModuleAdded (ModuleSP &module_sp) { // A module is being added to this target for the first time ModuleList module_list; module_list.Append(module_sp); ModulesDidLoad (module_list); } void Target::ModuleUpdated (ModuleSP &old_module_sp, ModuleSP &new_module_sp) { // A module is being added to this target for the first time ModuleList module_list; module_list.Append (old_module_sp); ModulesDidUnload (module_list); module_list.Clear (); module_list.Append (new_module_sp); ModulesDidLoad (module_list); } void Target::ModulesDidLoad (ModuleList &module_list) { m_breakpoint_list.UpdateBreakpoints (module_list, true); // TODO: make event data that packages up the module_list BroadcastEvent (eBroadcastBitModulesLoaded, NULL); } void Target::ModulesDidUnload (ModuleList &module_list) { m_breakpoint_list.UpdateBreakpoints (module_list, false); // Remove the images from the target image list m_images.Remove(module_list); // TODO: make event data that packages up the module_list BroadcastEvent (eBroadcastBitModulesUnloaded, NULL); } size_t Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error) { const Section *section = addr.GetSection(); if (section && section->GetModule()) { ObjectFile *objfile = section->GetModule()->GetObjectFile(); if (objfile) { size_t bytes_read = section->ReadSectionDataFromObjectFile (objfile, addr.GetOffset(), dst, dst_len); if (bytes_read > 0) return bytes_read; else error.SetErrorStringWithFormat("error reading data from section %s", section->GetName().GetCString()); } else { error.SetErrorString("address isn't from a object file"); } } else { error.SetErrorString("address doesn't contain a section that points to a section in a object file"); } return 0; } size_t Target::ReadMemory (const Address& addr, bool prefer_file_cache, void *dst, size_t dst_len, Error &error) { error.Clear(); bool process_is_valid = m_process_sp && m_process_sp->IsAlive(); size_t bytes_read = 0; Address resolved_addr(addr); if (!resolved_addr.IsSectionOffset()) { if (process_is_valid) { m_section_load_list.ResolveLoadAddress (addr.GetOffset(), resolved_addr); } else { m_images.ResolveFileAddress(addr.GetOffset(), resolved_addr); } } if (prefer_file_cache) { bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); if (bytes_read > 0) return bytes_read; } if (process_is_valid) { lldb::addr_t load_addr = resolved_addr.GetLoadAddress (this); if (load_addr == LLDB_INVALID_ADDRESS) { if (resolved_addr.GetModule() && resolved_addr.GetModule()->GetFileSpec()) error.SetErrorStringWithFormat("%s[0x%llx] can't be resolved, %s in not currently loaded.\n", resolved_addr.GetModule()->GetFileSpec().GetFilename().AsCString(), resolved_addr.GetFileAddress()); else error.SetErrorStringWithFormat("0x%llx can't be resolved.\n", resolved_addr.GetFileAddress()); } else { bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error); if (bytes_read != dst_len) { if (error.Success()) { if (bytes_read == 0) error.SetErrorStringWithFormat("Read memory from 0x%llx failed.\n", load_addr); else error.SetErrorStringWithFormat("Only %zu of %zu bytes were read from memory at 0x%llx.\n", bytes_read, dst_len, load_addr); } } if (bytes_read) return bytes_read; // If the address is not section offset we have an address that // doesn't resolve to any address in any currently loaded shared // libaries and we failed to read memory so there isn't anything // more we can do. If it is section offset, we might be able to // read cached memory from the object file. if (!resolved_addr.IsSectionOffset()) return 0; } } if (!prefer_file_cache) { // If we didn't already try and read from the object file cache, then // try it after failing to read from the process. return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error); } return 0; } ModuleSP Target::GetSharedModule ( const FileSpec& file_spec, const ArchSpec& arch, const lldb_private::UUID *uuid_ptr, const ConstString *object_name, off_t object_offset, Error *error_ptr ) { // Don't pass in the UUID so we can tell if we have a stale value in our list ModuleSP old_module_sp; // This will get filled in if we have a new version of the library bool did_create_module = false; ModuleSP module_sp; // If there are image search path entries, try to use them first to acquire a suitable image. Error error; if (m_image_search_paths.GetSize()) { FileSpec transformed_spec; if (m_image_search_paths.RemapPath (file_spec.GetDirectory(), transformed_spec.GetDirectory())) { transformed_spec.GetFilename() = file_spec.GetFilename(); error = ModuleList::GetSharedModule (transformed_spec, arch, uuid_ptr, object_name, object_offset, module_sp, &old_module_sp, &did_create_module); } } // If a module hasn't been found yet, use the unmodified path. if (!module_sp) { error = (ModuleList::GetSharedModule (file_spec, arch, uuid_ptr, object_name, object_offset, module_sp, &old_module_sp, &did_create_module)); } if (module_sp) { m_images.Append (module_sp); if (did_create_module) { if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32) ModuleUpdated(old_module_sp, module_sp); else ModuleAdded(module_sp); } } if (error_ptr) *error_ptr = error; return module_sp; } Target * Target::CalculateTarget () { return this; } Process * Target::CalculateProcess () { return NULL; } Thread * Target::CalculateThread () { return NULL; } StackFrame * Target::CalculateStackFrame () { return NULL; } void Target::CalculateExecutionContext (ExecutionContext &exe_ctx) { exe_ctx.target = this; exe_ctx.process = NULL; // Do NOT fill in process... exe_ctx.thread = NULL; exe_ctx.frame = NULL; } PathMappingList & Target::GetImageSearchPathList () { return m_image_search_paths; } void Target::ImageSearchPathsChanged ( const PathMappingList &path_list, void *baton ) { Target *target = (Target *)baton; if (target->m_images.GetSize() > 1) { ModuleSP exe_module_sp (target->GetExecutableModule()); if (exe_module_sp) { target->m_images.Clear(); target->SetExecutableModule (exe_module_sp, true); } } } ClangASTContext * Target::GetScratchClangASTContext() { return m_scratch_ast_context_ap.get(); } void Target::SettingsInitialize () { UserSettingsControllerSP &usc = GetSettingsController(); usc.reset (new SettingsController); UserSettingsController::InitializeSettingsController (usc, SettingsController::global_settings_table, SettingsController::instance_settings_table); // Now call SettingsInitialize() on each 'child' setting of Target Process::SettingsInitialize (); } void Target::SettingsTerminate () { // Must call SettingsTerminate() on each settings 'child' of Target, before terminating Target's Settings. Process::SettingsTerminate (); // Now terminate Target Settings. UserSettingsControllerSP &usc = GetSettingsController(); UserSettingsController::FinalizeSettingsController (usc); usc.reset(); } UserSettingsControllerSP & Target::GetSettingsController () { static UserSettingsControllerSP g_settings_controller; return g_settings_controller; } ArchSpec Target::GetDefaultArchitecture () { lldb::UserSettingsControllerSP settings_controller_sp (GetSettingsController()); if (settings_controller_sp) return static_cast(settings_controller_sp.get())->GetArchitecture (); return ArchSpec(); } void Target::SetDefaultArchitecture (const ArchSpec& arch) { lldb::UserSettingsControllerSP settings_controller_sp (GetSettingsController()); if (settings_controller_sp) static_cast(settings_controller_sp.get())->GetArchitecture () = arch; } Target * Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr) { // The target can either exist in the "process" of ExecutionContext, or in // the "target_sp" member of SymbolContext. This accessor helper function // will get the target from one of these locations. Target *target = NULL; if (sc_ptr != NULL) target = sc_ptr->target_sp.get(); if (target == NULL) { if (exe_ctx_ptr != NULL && exe_ctx_ptr->process != NULL) target = &exe_ctx_ptr->process->GetTarget(); } return target; } void Target::UpdateInstanceName () { StreamString sstr; ModuleSP module_sp = GetExecutableModule(); if (module_sp) { sstr.Printf ("%s_%s", module_sp->GetFileSpec().GetFilename().AsCString(), module_sp->GetArchitecture().GetArchitectureName()); GetSettingsController()->RenameInstanceSettings (GetInstanceName().AsCString(), sstr.GetData()); } } const char * Target::GetExpressionPrefixContentsAsCString () { return m_expr_prefix_contents.c_str(); } ExecutionResults Target::EvaluateExpression ( const char *expr_cstr, StackFrame *frame, bool unwind_on_error, bool keep_in_memory, lldb::ValueObjectSP &result_valobj_sp ) { ExecutionResults execution_results = eExecutionSetupError; result_valobj_sp.reset(); ExecutionContext exe_ctx; if (frame) { frame->CalculateExecutionContext(exe_ctx); Error error; const uint32_t expr_path_options = StackFrame::eExpressionPathOptionCheckPtrVsMember | StackFrame::eExpressionPathOptionsNoFragileObjcIvar; result_valobj_sp = frame->GetValueForVariableExpressionPath (expr_cstr, expr_path_options, error); } else if (m_process_sp) { m_process_sp->CalculateExecutionContext(exe_ctx); } else { CalculateExecutionContext(exe_ctx); } if (result_valobj_sp) { execution_results = eExecutionCompleted; // We got a result from the frame variable expression path above... ConstString persistent_variable_name (m_persistent_variables.GetNextPersistentVariableName()); lldb::ValueObjectSP const_valobj_sp; // Check in case our value is already a constant value if (result_valobj_sp->GetIsConstant()) { const_valobj_sp = result_valobj_sp; const_valobj_sp->SetName (persistent_variable_name); } else const_valobj_sp = result_valobj_sp->CreateConstantValue (exe_ctx.GetBestExecutionContextScope(), persistent_variable_name); lldb::ValueObjectSP live_valobj_sp = result_valobj_sp; result_valobj_sp = const_valobj_sp; ClangExpressionVariableSP clang_expr_variable_sp(m_persistent_variables.CreatePersistentVariable(result_valobj_sp)); assert (clang_expr_variable_sp.get()); // Set flags and live data as appropriate const Value &result_value = live_valobj_sp->GetValue(); switch (result_value.GetValueType()) { case Value::eValueTypeHostAddress: case Value::eValueTypeFileAddress: // we don't do anything with these for now break; case Value::eValueTypeScalar: clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated; clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVNeedsAllocation; break; case Value::eValueTypeLoadAddress: clang_expr_variable_sp->m_live_sp = live_valobj_sp; clang_expr_variable_sp->m_flags |= ClangExpressionVariable::EVIsProgramReference; break; } } else { // Make sure we aren't just trying to see the value of a persistent // variable (something like "$0") lldb::ClangExpressionVariableSP persistent_var_sp; // Only check for persistent variables the expression starts with a '$' if (expr_cstr[0] == '$') persistent_var_sp = m_persistent_variables.GetVariable (expr_cstr); if (persistent_var_sp) { result_valobj_sp = persistent_var_sp->GetValueObject (); execution_results = eExecutionCompleted; } else { const char *prefix = GetExpressionPrefixContentsAsCString(); execution_results = ClangUserExpression::Evaluate (exe_ctx, unwind_on_error, keep_in_memory, expr_cstr, prefix, result_valobj_sp); } } return execution_results; } lldb::user_id_t Target::AddStopHook (Target::StopHookSP &new_hook_sp) { lldb::user_id_t new_uid = ++m_stop_hook_next_id; new_hook_sp.reset (new StopHook(GetSP(), new_uid)); m_stop_hooks[new_uid] = new_hook_sp; return new_uid; } bool Target::RemoveStopHookByID (lldb::user_id_t user_id) { size_t num_removed; num_removed = m_stop_hooks.erase (user_id); if (num_removed == 0) return false; else return true; } void Target::RemoveAllStopHooks () { m_stop_hooks.clear(); } Target::StopHookSP Target::GetStopHookByID (lldb::user_id_t user_id) { StopHookSP found_hook; StopHookCollection::iterator specified_hook_iter; specified_hook_iter = m_stop_hooks.find (user_id); if (specified_hook_iter != m_stop_hooks.end()) found_hook = (*specified_hook_iter).second; return found_hook; } bool Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state) { StopHookCollection::iterator specified_hook_iter; specified_hook_iter = m_stop_hooks.find (user_id); if (specified_hook_iter == m_stop_hooks.end()) return false; (*specified_hook_iter).second->SetIsActive (active_state); return true; } void Target::SetAllStopHooksActiveState (bool active_state) { StopHookCollection::iterator pos, end = m_stop_hooks.end(); for (pos = m_stop_hooks.begin(); pos != end; pos++) { (*pos).second->SetIsActive (active_state); } } void Target::RunStopHooks () { if (!m_process_sp) return; if (m_stop_hooks.empty()) return; StopHookCollection::iterator pos, end = m_stop_hooks.end(); // If there aren't any active stop hooks, don't bother either: bool any_active_hooks = false; for (pos = m_stop_hooks.begin(); pos != end; pos++) { if ((*pos).second->IsActive()) { any_active_hooks = true; break; } } if (!any_active_hooks) return; CommandReturnObject result; std::vector exc_ctx_with_reasons; std::vector sym_ctx_with_reasons; ThreadList &cur_threadlist = m_process_sp->GetThreadList(); size_t num_threads = cur_threadlist.GetSize(); for (size_t i = 0; i < num_threads; i++) { lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i); if (cur_thread_sp->ThreadStoppedForAReason()) { lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0); exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get())); sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything)); } } // If no threads stopped for a reason, don't run the stop-hooks. size_t num_exe_ctx = exc_ctx_with_reasons.size(); if (num_exe_ctx == 0) return; result.SetImmediateOutputFile (m_debugger.GetOutputFile().GetStream()); result.SetImmediateErrorFile (m_debugger.GetErrorFile().GetStream()); bool keep_going = true; bool hooks_ran = false; for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++) { // result.Clear(); StopHookSP cur_hook_sp = (*pos).second; if (!cur_hook_sp->IsActive()) continue; bool any_thread_matched = false; for (size_t i = 0; keep_going && i < num_exe_ctx; i++) { if ((cur_hook_sp->GetSpecifier () == NULL || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i])) && (cur_hook_sp->GetThreadSpecifier() == NULL || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].thread))) { if (!hooks_ran) { result.AppendMessage("\n** Stop Hooks **\n"); hooks_ran = true; } if (!any_thread_matched) { result.AppendMessageWithFormat("\n- Hook %d\n", cur_hook_sp->GetID()); any_thread_matched = true; } result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].thread->GetIndexID()); bool stop_on_continue = true; bool stop_on_error = true; bool echo_commands = false; bool print_results = true; GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(), &exc_ctx_with_reasons[i], stop_on_continue, stop_on_error, echo_commands, print_results, result); // If the command started the target going again, we should bag out of // running the stop hooks. if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) || (result.GetStatus() == eReturnStatusSuccessContinuingResult)) { result.AppendMessageWithFormat ("Aborting stop hooks, hook %d set the program running.", cur_hook_sp->GetID()); keep_going = false; } } } } if (hooks_ran) result.AppendMessage ("\n** End Stop Hooks **\n"); } //-------------------------------------------------------------- // class Target::StopHook //-------------------------------------------------------------- Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) : UserID (uid), m_target_sp (target_sp), m_active (true), m_commands (), m_specifier_sp (), m_thread_spec_ap(NULL) { } Target::StopHook::StopHook (const StopHook &rhs) : UserID (rhs.GetID()), m_target_sp (rhs.m_target_sp), m_commands (rhs.m_commands), m_specifier_sp (rhs.m_specifier_sp), m_active (rhs.m_active), m_thread_spec_ap (NULL) { if (rhs.m_thread_spec_ap.get() != NULL) m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get())); } Target::StopHook::~StopHook () { } void Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier) { m_thread_spec_ap.reset (specifier); } void Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const { int indent_level = s->GetIndentLevel(); s->SetIndentLevel(indent_level + 2); s->Printf ("Hook: %d\n", GetID()); if (m_active) s->Indent ("State: enabled\n"); else s->Indent ("State: disabled\n"); if (m_specifier_sp) { s->Indent(); s->PutCString ("Specifier:\n"); s->SetIndentLevel (indent_level + 4); m_specifier_sp->GetDescription (s, level); s->SetIndentLevel (indent_level + 2); } if (m_thread_spec_ap.get() != NULL) { StreamString tmp; s->Indent("Thread:\n"); m_thread_spec_ap->GetDescription (&tmp, level); s->SetIndentLevel (indent_level + 4); s->Indent (tmp.GetData()); s->PutCString ("\n"); s->SetIndentLevel (indent_level + 2); } s->Indent ("Commands: \n"); s->SetIndentLevel (indent_level + 4); uint32_t num_commands = m_commands.GetSize(); for (uint32_t i = 0; i < num_commands; i++) { s->Indent(m_commands.GetStringAtIndex(i)); s->PutCString ("\n"); } s->SetIndentLevel (indent_level); } //-------------------------------------------------------------- // class Target::SettingsController //-------------------------------------------------------------- Target::SettingsController::SettingsController () : UserSettingsController ("target", Debugger::GetSettingsController()), m_default_architecture () { m_default_settings.reset (new TargetInstanceSettings (*this, false, InstanceSettings::GetDefaultName().AsCString())); } Target::SettingsController::~SettingsController () { } lldb::InstanceSettingsSP Target::SettingsController::CreateInstanceSettings (const char *instance_name) { TargetInstanceSettings *new_settings = new TargetInstanceSettings (*GetSettingsController(), false, instance_name); lldb::InstanceSettingsSP new_settings_sp (new_settings); return new_settings_sp; } #define TSC_DEFAULT_ARCH "default-arch" #define TSC_EXPR_PREFIX "expr-prefix" #define TSC_EXEC_LEVEL "execution-level" #define TSC_EXEC_MODE "execution-mode" #define TSC_EXEC_OS_TYPE "execution-os-type" static const ConstString & GetSettingNameForDefaultArch () { static ConstString g_const_string (TSC_DEFAULT_ARCH); return g_const_string; } static const ConstString & GetSettingNameForExpressionPrefix () { static ConstString g_const_string (TSC_EXPR_PREFIX); return g_const_string; } static const ConstString & GetSettingNameForExecutionLevel () { static ConstString g_const_string (TSC_EXEC_LEVEL); return g_const_string; } static const ConstString & GetSettingNameForExecutionMode () { static ConstString g_const_string (TSC_EXEC_MODE); return g_const_string; } static const ConstString & GetSettingNameForExecutionOSType () { static ConstString g_const_string (TSC_EXEC_OS_TYPE); return g_const_string; } bool Target::SettingsController::SetGlobalVariable (const ConstString &var_name, const char *index_value, const char *value, const SettingEntry &entry, const lldb::VarSetOperationType op, Error&err) { if (var_name == GetSettingNameForDefaultArch()) { m_default_architecture.SetTriple (value); if (!m_default_architecture.IsValid()) err.SetErrorStringWithFormat ("'%s' is not a valid architecture or triple.", value); } return true; } bool Target::SettingsController::GetGlobalVariable (const ConstString &var_name, StringList &value, Error &err) { if (var_name == GetSettingNameForDefaultArch()) { // If the arch is invalid (the default), don't show a string for it if (m_default_architecture.IsValid()) value.AppendString (m_default_architecture.GetArchitectureName()); return true; } else err.SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString()); return false; } //-------------------------------------------------------------- // class TargetInstanceSettings //-------------------------------------------------------------- TargetInstanceSettings::TargetInstanceSettings ( UserSettingsController &owner, bool live_instance, const char *name ) : InstanceSettings (owner, name ? name : InstanceSettings::InvalidName().AsCString(), live_instance), m_expr_prefix_path (), m_expr_prefix_contents (), m_execution_level (eExecutionLevelAuto), m_execution_mode (eExecutionModeAuto), m_execution_os_type (eExecutionOSTypeAuto) { // CopyInstanceSettings is a pure virtual function in InstanceSettings; it therefore cannot be called // until the vtables for TargetInstanceSettings are properly set up, i.e. AFTER all the initializers. // For this reason it has to be called here, rather than in the initializer or in the parent constructor. // This is true for CreateInstanceName() too. if (GetInstanceName () == InstanceSettings::InvalidName()) { ChangeInstanceName (std::string (CreateInstanceName().AsCString())); m_owner.RegisterInstanceSettings (this); } if (live_instance) { const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); CopyInstanceSettings (pending_settings,false); //m_owner.RemovePendingSettings (m_instance_name); } } TargetInstanceSettings::TargetInstanceSettings (const TargetInstanceSettings &rhs) : InstanceSettings (*Target::GetSettingsController(), CreateInstanceName().AsCString()) { if (m_instance_name != InstanceSettings::GetDefaultName()) { const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); CopyInstanceSettings (pending_settings,false); //m_owner.RemovePendingSettings (m_instance_name); } } TargetInstanceSettings::~TargetInstanceSettings () { } TargetInstanceSettings& TargetInstanceSettings::operator= (const TargetInstanceSettings &rhs) { if (this != &rhs) { } return *this; } void TargetInstanceSettings::UpdateInstanceSettingsVariable (const ConstString &var_name, const char *index_value, const char *value, const ConstString &instance_name, const SettingEntry &entry, lldb::VarSetOperationType op, Error &err, bool pending) { int new_enum = -1; if (var_name == GetSettingNameForExpressionPrefix ()) { switch (op) { default: err.SetErrorToGenericError (); err.SetErrorString ("Unrecognized operation. Cannot update value.\n"); return; case lldb::eVarSetOperationAssign: { FileSpec file_spec(value, true); if (!file_spec.Exists()) { err.SetErrorToGenericError (); err.SetErrorStringWithFormat ("%s does not exist.\n", value); return; } DataBufferSP data_sp (file_spec.ReadFileContents()); if (!data_sp && data_sp->GetByteSize() == 0) { err.SetErrorToGenericError (); err.SetErrorStringWithFormat ("Couldn't read from %s\n", value); return; } m_expr_prefix_path = value; m_expr_prefix_contents.assign(reinterpret_cast(data_sp->GetBytes()), data_sp->GetByteSize()); } return; case lldb::eVarSetOperationAppend: err.SetErrorToGenericError (); err.SetErrorString ("Cannot append to a path.\n"); return; case lldb::eVarSetOperationClear: m_expr_prefix_path.clear (); m_expr_prefix_contents.clear (); return; } } else if (var_name == GetSettingNameForExecutionLevel ()) { UserSettingsController::UpdateEnumVariable (entry.enum_values, &new_enum, value, err); if (err.Success()) m_execution_level = (ExecutionLevel)new_enum; } else if (var_name == GetSettingNameForExecutionMode ()) { UserSettingsController::UpdateEnumVariable (entry.enum_values, &new_enum, value, err); if (err.Success()) m_execution_mode = (ExecutionMode)new_enum; } else if (var_name == GetSettingNameForExecutionOSType ()) { UserSettingsController::UpdateEnumVariable (entry.enum_values, &new_enum, value, err); if (err.Success()) m_execution_os_type = (ExecutionOSType)new_enum; } } void TargetInstanceSettings::CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings, bool pending) { TargetInstanceSettings *new_settings_ptr = static_cast (new_settings.get()); if (!new_settings_ptr) return; m_expr_prefix_path = new_settings_ptr->m_expr_prefix_path; m_expr_prefix_contents = new_settings_ptr->m_expr_prefix_contents; m_execution_level = new_settings_ptr->m_execution_level; m_execution_mode = new_settings_ptr->m_execution_mode; m_execution_os_type = new_settings_ptr->m_execution_os_type; } bool TargetInstanceSettings::GetInstanceSettingsValue (const SettingEntry &entry, const ConstString &var_name, StringList &value, Error *err) { if (var_name == GetSettingNameForExpressionPrefix ()) { value.AppendString (m_expr_prefix_path.c_str(), m_expr_prefix_path.size()); } else if (var_name == GetSettingNameForExecutionLevel ()) { value.AppendString (UserSettingsController::EnumToString (entry.enum_values, m_execution_level)); } else if (var_name == GetSettingNameForExecutionMode ()) { value.AppendString (UserSettingsController::EnumToString (entry.enum_values, m_execution_mode)); } else if (var_name == GetSettingNameForExecutionOSType ()) { value.AppendString (UserSettingsController::EnumToString (entry.enum_values, m_execution_os_type)); } else { if (err) err->SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString()); return false; } return true; } const ConstString TargetInstanceSettings::CreateInstanceName () { StreamString sstr; static int instance_count = 1; sstr.Printf ("target_%d", instance_count); ++instance_count; const ConstString ret_val (sstr.GetData()); return ret_val; } //-------------------------------------------------- // Target::SettingsController Variable Tables //-------------------------------------------------- SettingEntry Target::SettingsController::global_settings_table[] = { // var-name var-type default enum init'd hidden help-text // ================= ================== =========== ==== ====== ====== ========================================================================= { TSC_DEFAULT_ARCH , eSetVarTypeString , NULL , NULL, false, false, "Default architecture to choose, when there's a choice." }, { NULL , eSetVarTypeNone , NULL , NULL, false, false, NULL } }; static lldb::OptionEnumValueElement g_execution_level_enums[] = { { eExecutionLevelAuto , "auto" , "Automatically detect the execution level (user/kernel)." }, { eExecutionLevelKernel , "kernel" , "Treat executables as kernel executables." }, { eExecutionLevelUser , "user" , "Treat executables as user space executables." }, { 0 , NULL , NULL } }; static lldb::OptionEnumValueElement g_execution_mode_enums[] = { { eExecutionModeAuto , "auto" , "Automatically detect the execution mode (static/dynamic)." }, { eExecutionModeStatic , "static" , "All executables are static and addresses at the virtual addresses in the object files." }, { eExecutionModeDynamic , "dynamic" , "Executables and shared libraries are dynamically loaded.." }, { 0 , NULL , NULL } }; static lldb::OptionEnumValueElement g_execution_os_enums[] = { { eExecutionOSTypeAuto , "auto" , "Automatically detect the execution OS (none/halted/live)." }, { eExecutionOSTypeNone , "none" , "There is no operating system available (no processes or threads)." }, { eExecutionOSTypeHalted, "halted" , "There is an operating system, but it is halted when the debugger is halted. " "Processes and threads must be discovered by accessing symbols and reading " "memory." }, { eExecutionOSTypeLive , "live" , "There is a live operating system with debug services that can be used to " "get processes, threads and theirs states." }, { 0, NULL, NULL } }; SettingEntry Target::SettingsController::instance_settings_table[] = { // var-name var-type default enum-table init'd hidden help-text // ================= ================== =========== ========================= ====== ====== ========================================================================= { TSC_EXPR_PREFIX , eSetVarTypeString , NULL , NULL , false, false, "Path to a file containing expressions to be prepended to all expressions." }, { TSC_EXEC_LEVEL , eSetVarTypeEnum , "auto" , g_execution_level_enums , false, false, "Sets the execution level for a target." }, { TSC_EXEC_MODE , eSetVarTypeEnum , "auto" , g_execution_mode_enums , false, false, "Sets the execution mode for a target." }, { TSC_EXEC_OS_TYPE , eSetVarTypeEnum , "auto" , g_execution_os_enums , false, false, "Sets the execution OS for a target." }, { NULL , eSetVarTypeNone , NULL , NULL , false, false, NULL } };