diff options
Diffstat (limited to 'source/Target/StackFrame.cpp')
| -rw-r--r-- | source/Target/StackFrame.cpp | 351 |
1 files changed, 172 insertions, 179 deletions
diff --git a/source/Target/StackFrame.cpp b/source/Target/StackFrame.cpp index e835521e7884..8488377158df 100644 --- a/source/Target/StackFrame.cpp +++ b/source/Target/StackFrame.cpp @@ -7,16 +7,16 @@ // //===----------------------------------------------------------------------===// -#include "lldb/Target/StackFrame.h" - // C Includes // C++ Includes // Other libraries and framework includes // Project includes -#include "lldb/Core/Module.h" +#include "lldb/Target/StackFrame.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/Disassembler.h" #include "lldb/Core/FormatEntity.h" +#include "lldb/Core/Mangled.h" +#include "lldb/Core/Module.h" #include "lldb/Core/Value.h" #include "lldb/Core/ValueObjectVariable.h" #include "lldb/Core/ValueObjectConstResult.h" @@ -44,135 +44,119 @@ using namespace lldb_private; #define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1) #define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1) -StackFrame::StackFrame (const ThreadSP &thread_sp, - user_id_t frame_idx, - user_id_t unwind_frame_index, - addr_t cfa, - bool cfa_is_valid, - addr_t pc, - uint32_t stop_id, - bool stop_id_is_valid, - bool is_history_frame, - const SymbolContext *sc_ptr) : - m_thread_wp (thread_sp), - m_frame_index (frame_idx), - m_concrete_frame_index (unwind_frame_index), - m_reg_context_sp (), - m_id (pc, cfa, NULL), - m_frame_code_addr (pc), - m_sc (), - m_flags (), - m_frame_base (), - m_frame_base_error (), - m_cfa_is_valid (cfa_is_valid), - m_stop_id (stop_id), - m_stop_id_is_valid (stop_id_is_valid), - m_is_history_frame (is_history_frame), - m_variable_list_sp (), - m_variable_list_value_objects (), - m_disassembly (), - m_mutex (Mutex::eMutexTypeRecursive) +StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index, addr_t cfa, + bool cfa_is_valid, addr_t pc, uint32_t stop_id, bool stop_id_is_valid, bool is_history_frame, + const SymbolContext *sc_ptr) + : m_thread_wp(thread_sp), + m_frame_index(frame_idx), + m_concrete_frame_index(unwind_frame_index), + m_reg_context_sp(), + m_id(pc, cfa, nullptr), + m_frame_code_addr(pc), + m_sc(), + m_flags(), + m_frame_base(), + m_frame_base_error(), + m_cfa_is_valid(cfa_is_valid), + m_stop_id(stop_id), + m_stop_id_is_valid(stop_id_is_valid), + m_is_history_frame(is_history_frame), + m_variable_list_sp(), + m_variable_list_value_objects(), + m_disassembly(), + m_mutex() { // If we don't have a CFA value, use the frame index for our StackID so that recursive // functions properly aren't confused with one another on a history stack. - if (m_is_history_frame && m_cfa_is_valid == false) + if (m_is_history_frame && !m_cfa_is_valid) { - m_id.SetCFA (m_frame_index); + m_id.SetCFA(m_frame_index); } - if (sc_ptr != NULL) + if (sc_ptr != nullptr) { m_sc = *sc_ptr; - m_flags.Set(m_sc.GetResolvedMask ()); + m_flags.Set(m_sc.GetResolvedMask()); } } -StackFrame::StackFrame (const ThreadSP &thread_sp, - user_id_t frame_idx, - user_id_t unwind_frame_index, - const RegisterContextSP ®_context_sp, - addr_t cfa, - addr_t pc, - const SymbolContext *sc_ptr) : - m_thread_wp (thread_sp), - m_frame_index (frame_idx), - m_concrete_frame_index (unwind_frame_index), - m_reg_context_sp (reg_context_sp), - m_id (pc, cfa, NULL), - m_frame_code_addr (pc), - m_sc (), - m_flags (), - m_frame_base (), - m_frame_base_error (), - m_cfa_is_valid (true), - m_stop_id (0), - m_stop_id_is_valid (false), - m_is_history_frame (false), - m_variable_list_sp (), - m_variable_list_value_objects (), - m_disassembly (), - m_mutex (Mutex::eMutexTypeRecursive) +StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index, + const RegisterContextSP ®_context_sp, addr_t cfa, addr_t pc, const SymbolContext *sc_ptr) + : m_thread_wp(thread_sp), + m_frame_index(frame_idx), + m_concrete_frame_index(unwind_frame_index), + m_reg_context_sp(reg_context_sp), + m_id(pc, cfa, nullptr), + m_frame_code_addr(pc), + m_sc(), + m_flags(), + m_frame_base(), + m_frame_base_error(), + m_cfa_is_valid(true), + m_stop_id(0), + m_stop_id_is_valid(false), + m_is_history_frame(false), + m_variable_list_sp(), + m_variable_list_value_objects(), + m_disassembly(), + m_mutex() { - if (sc_ptr != NULL) + if (sc_ptr != nullptr) { m_sc = *sc_ptr; - m_flags.Set(m_sc.GetResolvedMask ()); + m_flags.Set(m_sc.GetResolvedMask()); } - + if (reg_context_sp && !m_sc.target_sp) { m_sc.target_sp = reg_context_sp->CalculateTarget(); if (m_sc.target_sp) - m_flags.Set (eSymbolContextTarget); + m_flags.Set(eSymbolContextTarget); } } -StackFrame::StackFrame (const ThreadSP &thread_sp, - user_id_t frame_idx, - user_id_t unwind_frame_index, - const RegisterContextSP ®_context_sp, - addr_t cfa, - const Address& pc_addr, - const SymbolContext *sc_ptr) : - m_thread_wp (thread_sp), - m_frame_index (frame_idx), - m_concrete_frame_index (unwind_frame_index), - m_reg_context_sp (reg_context_sp), - m_id (pc_addr.GetLoadAddress (thread_sp->CalculateTarget().get()), cfa, NULL), - m_frame_code_addr (pc_addr), - m_sc (), - m_flags (), - m_frame_base (), - m_frame_base_error (), - m_cfa_is_valid (true), - m_stop_id (0), - m_stop_id_is_valid (false), - m_is_history_frame (false), - m_variable_list_sp (), - m_variable_list_value_objects (), - m_disassembly (), - m_mutex (Mutex::eMutexTypeRecursive) +StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index, + const RegisterContextSP ®_context_sp, addr_t cfa, const Address &pc_addr, + const SymbolContext *sc_ptr) + : m_thread_wp(thread_sp), + m_frame_index(frame_idx), + m_concrete_frame_index(unwind_frame_index), + m_reg_context_sp(reg_context_sp), + m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa, nullptr), + m_frame_code_addr(pc_addr), + m_sc(), + m_flags(), + m_frame_base(), + m_frame_base_error(), + m_cfa_is_valid(true), + m_stop_id(0), + m_stop_id_is_valid(false), + m_is_history_frame(false), + m_variable_list_sp(), + m_variable_list_value_objects(), + m_disassembly(), + m_mutex() { - if (sc_ptr != NULL) + if (sc_ptr != nullptr) { m_sc = *sc_ptr; - m_flags.Set(m_sc.GetResolvedMask ()); + m_flags.Set(m_sc.GetResolvedMask()); } - - if (m_sc.target_sp.get() == NULL && reg_context_sp) + + if (!m_sc.target_sp && reg_context_sp) { m_sc.target_sp = reg_context_sp->CalculateTarget(); if (m_sc.target_sp) - m_flags.Set (eSymbolContextTarget); + m_flags.Set(eSymbolContextTarget); } - - ModuleSP pc_module_sp (pc_addr.GetModule()); + + ModuleSP pc_module_sp(pc_addr.GetModule()); if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp) { if (pc_module_sp) { m_sc.module_sp = pc_module_sp; - m_flags.Set (eSymbolContextModule); + m_flags.Set(eSymbolContextModule); } else { @@ -181,18 +165,12 @@ StackFrame::StackFrame (const ThreadSP &thread_sp, } } - -//---------------------------------------------------------------------- -// Destructor -//---------------------------------------------------------------------- -StackFrame::~StackFrame() -{ -} +StackFrame::~StackFrame() = default; StackID& StackFrame::GetStackID() { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); // Make sure we have resolved the StackID object's symbol context scope if // we already haven't looked it up. @@ -209,13 +187,13 @@ StackFrame::GetStackID() // Calculate the frame block and use this for the stack ID symbol // context scope if we have one. SymbolContextScope *scope = GetFrameBlock (); - if (scope == NULL) + if (scope == nullptr) { // We don't have a block, so use the symbol if (m_flags.IsClear (eSymbolContextSymbol)) GetSymbolContext (eSymbolContextSymbol); - // It is ok if m_sc.symbol is NULL here + // It is ok if m_sc.symbol is nullptr here scope = m_sc.symbol; } // Set the symbol context scope (the accessor will set the @@ -239,7 +217,7 @@ StackFrame::GetFrameIndex () const void StackFrame::SetSymbolContextScope (SymbolContextScope *symbol_scope) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); m_flags.Set (RESOLVED_FRAME_ID_SYMBOL_SCOPE); m_id.SetSymbolContextScope (symbol_scope); } @@ -247,7 +225,7 @@ StackFrame::SetSymbolContextScope (SymbolContextScope *symbol_scope) const Address& StackFrame::GetFrameCodeAddress() { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) && !m_frame_code_addr.IsSectionOffset()) { m_flags.Set (RESOLVED_FRAME_CODE_ADDR); @@ -278,7 +256,7 @@ StackFrame::GetFrameCodeAddress() bool StackFrame::ChangePC (addr_t pc) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); // We can't change the pc value of a history stack frame - it is immutable. if (m_is_history_frame) return false; @@ -294,15 +272,15 @@ StackFrame::ChangePC (addr_t pc) const char * StackFrame::Disassemble () { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); if (m_disassembly.GetSize() == 0) { ExecutionContext exe_ctx (shared_from_this()); Target *target = exe_ctx.GetTargetPtr(); if (target) { - const char *plugin_name = NULL; - const char *flavor = NULL; + const char *plugin_name = nullptr; + const char *flavor = nullptr; Disassembler::Disassemble (target->GetDebugger(), target->GetArchitecture(), plugin_name, @@ -314,7 +292,7 @@ StackFrame::Disassemble () m_disassembly); } if (m_disassembly.GetSize() == 0) - return NULL; + return nullptr; } return m_disassembly.GetData(); } @@ -322,7 +300,7 @@ StackFrame::Disassemble () Block * StackFrame::GetFrameBlock () { - if (m_sc.block == NULL && m_flags.IsClear (eSymbolContextBlock)) + if (m_sc.block == nullptr && m_flags.IsClear(eSymbolContextBlock)) GetSymbolContext (eSymbolContextBlock); if (m_sc.block) @@ -342,7 +320,7 @@ StackFrame::GetFrameBlock () return &m_sc.function->GetBlock (false); } } - return NULL; + return nullptr; } //---------------------------------------------------------------------- @@ -354,7 +332,7 @@ StackFrame::GetFrameBlock () const SymbolContext& StackFrame::GetSymbolContext (uint32_t resolve_scope) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); // Copy our internal symbol context into "sc". if ((m_flags.Get() & resolve_scope) != resolve_scope) { @@ -368,7 +346,6 @@ StackFrame::GetSymbolContext (uint32_t resolve_scope) resolved |= eSymbolContextTarget; } - // Resolve our PC to section offset if we haven't already done so // and if we don't have a module. The resolved address section will // contain the module to which it belongs @@ -411,7 +388,6 @@ StackFrame::GetSymbolContext (uint32_t resolve_scope) } } - if (m_sc.module_sp) { // We have something in our stack frame symbol context, lets check @@ -487,25 +463,18 @@ StackFrame::GetSymbolContext (uint32_t resolve_scope) // Only replace what we didn't already have as we may have // information for an inlined function scope that won't match // what a standard lookup by address would match - if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == NULL) + if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr) m_sc.comp_unit = sc.comp_unit; - if ((resolved & eSymbolContextFunction) && m_sc.function == NULL) + if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr) m_sc.function = sc.function; - if ((resolved & eSymbolContextBlock) && m_sc.block == NULL) + if ((resolved & eSymbolContextBlock) && m_sc.block == nullptr) m_sc.block = sc.block; - if ((resolved & eSymbolContextSymbol) && m_sc.symbol == NULL) + if ((resolved & eSymbolContextSymbol) && m_sc.symbol == nullptr) m_sc.symbol = sc.symbol; if ((resolved & eSymbolContextLineEntry) && !m_sc.line_entry.IsValid()) { m_sc.line_entry = sc.line_entry; - if (m_sc.target_sp) - { - // Be sure to apply and file remappings to our file and line - // entries when handing out a line entry - FileSpec new_file_spec; - if (m_sc.target_sp->GetSourcePathMap().FindFile (m_sc.line_entry.file, new_file_spec)) - m_sc.line_entry.file = new_file_spec; - } + m_sc.line_entry.ApplyFileMappings(m_sc.target_sp); } } } @@ -533,11 +502,10 @@ StackFrame::GetSymbolContext (uint32_t resolve_scope) return m_sc; } - VariableList * StackFrame::GetVariableList (bool get_file_globals) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); if (m_flags.IsClear(RESOLVED_VARIABLES)) { m_flags.Set(RESOLVED_VARIABLES); @@ -550,7 +518,11 @@ StackFrame::GetVariableList (bool get_file_globals) const bool can_create = true; const bool stop_if_child_block_is_inlined_function = true; m_variable_list_sp.reset(new VariableList()); - frame_block->AppendBlockVariables(can_create, get_child_variables, stop_if_child_block_is_inlined_function, m_variable_list_sp.get()); + frame_block->AppendBlockVariables(can_create, + get_child_variables, + stop_if_child_block_is_inlined_function, + [this](Variable* v) { return true; }, + m_variable_list_sp.get()); } } @@ -576,9 +548,9 @@ StackFrame::GetVariableList (bool get_file_globals) } VariableListSP -StackFrame::GetInScopeVariableList (bool get_file_globals) +StackFrame::GetInScopeVariableList (bool get_file_globals, bool must_have_valid_location) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); // We can't fetch variable information for a history stack frame. if (m_is_history_frame) return VariableListSP(); @@ -594,10 +566,14 @@ StackFrame::GetInScopeVariableList (bool get_file_globals) m_sc.block->AppendVariables (can_create, get_parent_variables, stop_if_block_is_inlined_function, + [this, must_have_valid_location](Variable* v) + { + return v->IsInScope(this) && (!must_have_valid_location || v->LocationIsValidForFrame(this)); + }, var_list_sp.get()); } - if (m_sc.comp_unit) + if (m_sc.comp_unit && get_file_globals) { VariableListSP global_variable_list_sp (m_sc.comp_unit->GetVariableList(true)); if (global_variable_list_sp) @@ -607,7 +583,6 @@ StackFrame::GetInScopeVariableList (bool get_file_globals) return var_list_sp; } - ValueObjectSP StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, DynamicValueType use_dynamic, @@ -736,7 +711,6 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, const char separator_type = var_path[0]; switch (separator_type) { - case '-': if (var_path.size() >= 2 && var_path[1] != '>') return ValueObjectSP(); @@ -745,7 +719,7 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, { // Make sure we aren't trying to deref an objective // C ivar if this is not allowed - const uint32_t pointer_type_flags = valobj_sp->GetCompilerType().GetTypeInfo (NULL); + const uint32_t pointer_type_flags = valobj_sp->GetCompilerType().GetTypeInfo(nullptr); if ((pointer_type_flags & eTypeIsObjC) && (pointer_type_flags & eTypeIsPointer)) { @@ -756,7 +730,7 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, } } var_path.erase (0, 1); // Remove the '-' - // Fall through + LLVM_FALLTHROUGH; case '.': { const bool expr_is_ptr = var_path[0] == '>'; @@ -800,7 +774,7 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, child_valobj_sp = valobj_sp->GetChildMemberWithName (child_name, true); if (!child_valobj_sp) { - if (no_synth_child == false) + if (!no_synth_child) { child_valobj_sp = valobj_sp->GetSyntheticValue(); if (child_valobj_sp) @@ -854,7 +828,7 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, // Array member access, or treating pointer as an array if (var_path.size() > 2) // Need at least two brackets and a number { - char *end = NULL; + char *end = nullptr; long child_index = ::strtol (&var_path[1], &end, 0); if (end && *end == ']' && *(end-1) != '[') // this code forces an error in the case of arr[]. as bitfield[] is not a good syntax we're good to go @@ -919,7 +893,7 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, { // dereferencing ObjC variables is not valid.. so let's try and recur to synthetic children ValueObjectSP synthetic = valobj_sp->GetSyntheticValue(); - if (synthetic.get() == NULL /* no synthetic */ + if (!synthetic /* no synthetic */ || synthetic == valobj_sp) /* synthetic is the same as the original object */ { valobj_sp->GetExpressionPath (var_expr_path_strm, false); @@ -961,12 +935,12 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, } } } - else if (valobj_sp->GetCompilerType().IsArrayType (NULL, NULL, &is_incomplete_array)) + else if (valobj_sp->GetCompilerType().IsArrayType(nullptr, nullptr, &is_incomplete_array)) { // Pass false to dynamic_value here so we can tell the difference between // no dynamic value and no member of this type... child_valobj_sp = valobj_sp->GetChildAtIndex (child_index, true); - if (!child_valobj_sp && (is_incomplete_array || no_synth_child == false)) + if (!child_valobj_sp && (is_incomplete_array || !no_synth_child)) child_valobj_sp = valobj_sp->GetSyntheticArrayMember (child_index, true); if (!child_valobj_sp) @@ -995,7 +969,7 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, { ValueObjectSP synthetic = valobj_sp->GetSyntheticValue(); if (no_synth_child /* synthetic is forbidden */ || - synthetic.get() == NULL /* no synthetic */ + !synthetic /* no synthetic */ || synthetic == valobj_sp) /* synthetic is the same as the original object */ { valobj_sp->GetExpressionPath (var_expr_path_strm, false); @@ -1048,7 +1022,7 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, else if (end && *end == '-') { // this is most probably a BitField, let's take a look - char *real_end = NULL; + char *real_end = nullptr; long final_index = ::strtol (end+1, &real_end, 0); bool expand_bitfield = true; if (real_end && *real_end == ']') @@ -1174,7 +1148,6 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, if (var_path.empty()) break; - } if (valobj_sp) { @@ -1208,8 +1181,8 @@ StackFrame::GetValueForVariableExpressionPath (const char *var_expr_cstr, bool StackFrame::GetFrameBaseValue (Scalar &frame_base, Error *error_ptr) { - Mutex::Locker locker(m_mutex); - if (m_cfa_is_valid == false) + std::lock_guard<std::recursive_mutex> guard(m_mutex); + if (!m_cfa_is_valid) { m_frame_base_error.SetErrorString("No frame base available for this historical stack frame."); return false; @@ -1229,7 +1202,15 @@ StackFrame::GetFrameBaseValue (Scalar &frame_base, Error *error_ptr) if (m_sc.function->GetFrameBaseExpression().IsLocationList()) loclist_base_addr = m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (exe_ctx.GetTargetPtr()); - if (m_sc.function->GetFrameBaseExpression().Evaluate(&exe_ctx, NULL, NULL, NULL, loclist_base_addr, NULL, expr_value, &m_frame_base_error) == false) + if (m_sc.function->GetFrameBaseExpression().Evaluate(&exe_ctx, + nullptr, + nullptr, + nullptr, + loclist_base_addr, + nullptr, + nullptr, + expr_value, + &m_frame_base_error) == false) { // We should really have an error if evaluate returns, but in case // we don't, lets set the error to something at least. @@ -1258,7 +1239,7 @@ StackFrame::GetFrameBaseValue (Scalar &frame_base, Error *error_ptr) RegisterContextSP StackFrame::GetRegisterContext () { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); if (!m_reg_context_sp) { ThreadSP thread_sp (GetThread()); @@ -1275,11 +1256,10 @@ StackFrame::HasDebugInformation () return m_sc.line_entry.IsValid(); } - ValueObjectSP StackFrame::GetValueObjectForFrameVariable (const VariableSP &variable_sp, DynamicValueType use_dynamic) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); ValueObjectSP valobj_sp; if (m_is_history_frame) { @@ -1294,7 +1274,7 @@ StackFrame::GetValueObjectForFrameVariable (const VariableSP &variable_sp, Dynam if (var_idx < num_variables) { valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex (var_idx); - if (valobj_sp.get() == NULL) + if (!valobj_sp) { if (m_variable_list_value_objects.GetSize() < num_variables) m_variable_list_value_objects.Resize(num_variables); @@ -1315,7 +1295,7 @@ StackFrame::GetValueObjectForFrameVariable (const VariableSP &variable_sp, Dynam ValueObjectSP StackFrame::TrackGlobalVariable (const VariableSP &variable_sp, DynamicValueType use_dynamic) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); if (m_is_history_frame) return ValueObjectSP(); @@ -1326,7 +1306,7 @@ StackFrame::TrackGlobalVariable (const VariableSP &variable_sp, DynamicValueType // We aren't already tracking this global VariableList *var_list = GetVariableList (true); // If this frame has no variables, create a new list - if (var_list == NULL) + if (var_list == nullptr) m_variable_list_sp.reset (new VariableList()); // Add the global/static variable to this frame @@ -1341,10 +1321,10 @@ StackFrame::TrackGlobalVariable (const VariableSP &variable_sp, DynamicValueType bool StackFrame::IsInlined () { - if (m_sc.block == NULL) + if (m_sc.block == nullptr) GetSymbolContext (eSymbolContextBlock); if (m_sc.block) - return m_sc.block->GetContainingInlinedBlock() != NULL; + return m_sc.block->GetContainingInlinedBlock() != nullptr; return false; } @@ -1357,6 +1337,23 @@ StackFrame::GetLanguage () return lldb::eLanguageTypeUnknown; } +lldb::LanguageType +StackFrame::GuessLanguage () +{ + LanguageType lang_type = GetLanguage(); + + if (lang_type == eLanguageTypeUnknown) + { + Function *f = GetSymbolContext(eSymbolContextFunction).function; + if (f) + { + lang_type = f->GetMangled().GuessLanguage(); + } + } + + return lang_type; +} + TargetSP StackFrame::CalculateTarget () { @@ -1393,7 +1390,6 @@ StackFrame::CalculateStackFrame () return shared_from_this(); } - void StackFrame::CalculateExecutionContext (ExecutionContext &exe_ctx) { @@ -1403,7 +1399,7 @@ StackFrame::CalculateExecutionContext (ExecutionContext &exe_ctx) void StackFrame::DumpUsingSettingsFormat (Stream *strm, const char *frame_marker) { - if (strm == NULL) + if (strm == nullptr) return; GetSymbolContext(eSymbolContextEverything); @@ -1413,11 +1409,11 @@ StackFrame::DumpUsingSettingsFormat (Stream *strm, const char *frame_marker) if (frame_marker) s.PutCString(frame_marker); - const FormatEntity::Entry *frame_format = NULL; + const FormatEntity::Entry *frame_format = nullptr; Target *target = exe_ctx.GetTargetPtr(); if (target) frame_format = target->GetDebugger().GetFrameFormat(); - if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx, NULL, NULL, false, false)) + if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx, nullptr, nullptr, false, false)) { strm->Write(s.GetData(), s.GetSize()); } @@ -1431,7 +1427,7 @@ StackFrame::DumpUsingSettingsFormat (Stream *strm, const char *frame_marker) void StackFrame::Dump (Stream *strm, bool show_frame_index, bool show_fullpaths) { - if (strm == NULL) + if (strm == nullptr) return; if (show_frame_index) @@ -1459,19 +1455,18 @@ StackFrame::Dump (Stream *strm, bool show_frame_index, bool show_fullpaths) void StackFrame::UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); assert (GetStackID() == prev_frame.GetStackID()); // TODO: remove this after some testing m_variable_list_sp = prev_frame.m_variable_list_sp; m_variable_list_value_objects.Swap (prev_frame.m_variable_list_value_objects); if (!m_disassembly.GetString().empty()) m_disassembly.GetString().swap (m_disassembly.GetString()); } - void StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame) { - Mutex::Locker locker(m_mutex); + std::lock_guard<std::recursive_mutex> guard(m_mutex); assert (GetStackID() == curr_frame.GetStackID()); // TODO: remove this after some testing m_id.SetPC (curr_frame.m_id.GetPC()); // Update the Stack ID PC value assert (GetThread() == curr_frame.GetThread()); @@ -1479,10 +1474,10 @@ StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame) m_concrete_frame_index = curr_frame.m_concrete_frame_index; m_reg_context_sp = curr_frame.m_reg_context_sp; m_frame_code_addr = curr_frame.m_frame_code_addr; - assert (m_sc.target_sp.get() == NULL || curr_frame.m_sc.target_sp.get() == NULL || m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get()); - assert (m_sc.module_sp.get() == NULL || curr_frame.m_sc.module_sp.get() == NULL || m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get()); - assert (m_sc.comp_unit == NULL || curr_frame.m_sc.comp_unit == NULL || m_sc.comp_unit == curr_frame.m_sc.comp_unit); - assert (m_sc.function == NULL || curr_frame.m_sc.function == NULL || m_sc.function == curr_frame.m_sc.function); + assert (!m_sc.target_sp || !curr_frame.m_sc.target_sp || m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get()); + assert (!m_sc.module_sp || !curr_frame.m_sc.module_sp || m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get()); + assert (m_sc.comp_unit == nullptr || curr_frame.m_sc.comp_unit == nullptr || m_sc.comp_unit == curr_frame.m_sc.comp_unit); + assert (m_sc.function == nullptr || curr_frame.m_sc.function == nullptr || m_sc.function == curr_frame.m_sc.function); m_sc = curr_frame.m_sc; m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything); m_flags.Set (m_sc.GetResolvedMask()); @@ -1490,11 +1485,10 @@ StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame) m_frame_base_error.Clear(); } - bool StackFrame::HasCachedData () const { - if (m_variable_list_sp.get()) + if (m_variable_list_sp) return true; if (m_variable_list_value_objects.GetSize() > 0) return true; @@ -1554,12 +1548,12 @@ StackFrame::GetStatus (Stream& strm, case Debugger::eStopDisassemblyTypeNoDebugInfo: if (have_debuginfo) break; - // Fall through to next case + LLVM_FALLTHROUGH; case Debugger::eStopDisassemblyTypeNoSource: if (have_source) break; - // Fall through to next case + LLVM_FALLTHROUGH; case Debugger::eStopDisassemblyTypeAlways: if (target) @@ -1571,8 +1565,8 @@ StackFrame::GetStatus (Stream& strm, AddressRange pc_range; pc_range.GetBaseAddress() = GetFrameCodeAddress(); pc_range.SetByteSize(disasm_lines * target_arch.GetMaximumOpcodeByteSize()); - const char *plugin_name = NULL; - const char *flavor = NULL; + const char *plugin_name = nullptr; + const char *flavor = nullptr; Disassembler::Disassemble (target->GetDebugger(), target_arch, plugin_name, @@ -1591,4 +1585,3 @@ StackFrame::GetStatus (Stream& strm, } return true; } - |