//===-- Variable.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/Symbol/Variable.h" #include "lldb/Core/Module.h" #include "lldb/Core/Stream.h" #include "lldb/Core/RegularExpression.h" #include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObjectVariable.h" #include "lldb/Symbol/Block.h" #include "lldb/Symbol/Function.h" #include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/Type.h" #include "lldb/Symbol/VariableList.h" #include "lldb/Target/ABI.h" #include "lldb/Target/Process.h" #include "lldb/Target/RegisterContext.h" #include "lldb/Target/StackFrame.h" #include "lldb/Target/Thread.h" #include "lldb/Target/Target.h" using namespace lldb; using namespace lldb_private; //---------------------------------------------------------------------- // Variable constructor //---------------------------------------------------------------------- Variable::Variable ( lldb::user_id_t uid, const char *name, const char *mangled, // The mangled variable name for variables in namespaces const lldb::SymbolFileTypeSP &symfile_type_sp, ValueType scope, SymbolContextScope *context, Declaration* decl_ptr, const DWARFExpression& location, bool external, bool artificial ) : UserID(uid), m_name(name), m_mangled (ConstString(mangled), true), m_symfile_type_sp(symfile_type_sp), m_scope(scope), m_owner_scope(context), m_declaration(decl_ptr), m_location(location), m_external(external), m_artificial(artificial) { } //---------------------------------------------------------------------- // Destructor //---------------------------------------------------------------------- Variable::~Variable() { } const ConstString& Variable::GetName() const { if (m_mangled) return m_mangled.GetName(); return m_name; } bool Variable::NameMatches (const RegularExpression& regex) const { if (regex.Execute (m_name.AsCString())) return true; return m_mangled.NameMatches (regex); } Type * Variable::GetType() { if (m_symfile_type_sp) return m_symfile_type_sp->GetType(); return NULL; } void Variable::Dump(Stream *s, bool show_context) const { s->Printf("%p: ", this); s->Indent(); *s << "Variable" << (const UserID&)*this; if (m_name) *s << ", name = \"" << m_name << "\""; if (m_symfile_type_sp) { Type *type = m_symfile_type_sp->GetType(); if (type) { *s << ", type = {" << type->GetID() << "} " << (void*)type << " ("; type->DumpTypeName(s); s->PutChar(')'); } } if (m_scope != eValueTypeInvalid) { s->PutCString(", scope = "); switch (m_scope) { case eValueTypeVariableGlobal: s->PutCString(m_external ? "global" : "static"); break; case eValueTypeVariableArgument: s->PutCString("parameter"); break; case eValueTypeVariableLocal: s->PutCString("local"); break; default: *s << "??? (" << m_scope << ')'; } } if (show_context && m_owner_scope != NULL) { s->PutCString(", context = ( "); m_owner_scope->DumpSymbolContext(s); s->PutCString(" )"); } bool show_fullpaths = false; m_declaration.Dump(s, show_fullpaths); if (m_location.IsValid()) { s->PutCString(", location = "); lldb::addr_t loclist_base_addr = LLDB_INVALID_ADDRESS; if (m_location.IsLocationList()) { SymbolContext variable_sc; m_owner_scope->CalculateSymbolContext(&variable_sc); if (variable_sc.function) loclist_base_addr = variable_sc.function->GetAddressRange().GetBaseAddress().GetFileAddress(); } ABI *abi = NULL; if (m_owner_scope) { ModuleSP module_sp (m_owner_scope->CalculateSymbolContextModule()); if (module_sp) abi = ABI::FindPlugin (module_sp->GetArchitecture()).get(); } m_location.GetDescription(s, lldb::eDescriptionLevelBrief, loclist_base_addr, abi); } if (m_external) s->PutCString(", external"); if (m_artificial) s->PutCString(", artificial"); s->EOL(); } bool Variable::DumpDeclaration (Stream *s, bool show_fullpaths, bool show_module) { bool dumped_declaration_info = false; if (m_owner_scope) { SymbolContext sc; m_owner_scope->CalculateSymbolContext(&sc); sc.block = NULL; sc.line_entry.Clear(); bool show_inlined_frames = false; dumped_declaration_info = sc.DumpStopContext (s, NULL, Address(), show_fullpaths, show_module, show_inlined_frames); if (sc.function) s->PutChar(':'); } if (m_declaration.DumpStopContext (s, false)) dumped_declaration_info = true; return dumped_declaration_info; } size_t Variable::MemorySize() const { return sizeof(Variable); } void Variable::CalculateSymbolContext (SymbolContext *sc) { if (m_owner_scope) m_owner_scope->CalculateSymbolContext(sc); else sc->Clear(false); } bool Variable::LocationIsValidForFrame (StackFrame *frame) { // Is the variable is described by a single location? if (!m_location.IsLocationList()) { // Yes it is, the location is valid. return true; } if (frame) { Function *function = frame->GetSymbolContext(eSymbolContextFunction).function; if (function) { TargetSP target_sp (frame->CalculateTarget()); addr_t loclist_base_load_addr = function->GetAddressRange().GetBaseAddress().GetLoadAddress (target_sp.get()); if (loclist_base_load_addr == LLDB_INVALID_ADDRESS) return false; // It is a location list. We just need to tell if the location // list contains the current address when converted to a load // address return m_location.LocationListContainsAddress (loclist_base_load_addr, frame->GetFrameCodeAddress().GetLoadAddress (target_sp.get())); } } return false; } bool Variable::LocationIsValidForAddress (const Address &address) { // Be sure to resolve the address to section offset prior to // calling this function. if (address.IsSectionOffset()) { SymbolContext sc; CalculateSymbolContext(&sc); if (sc.module_sp == address.GetModule()) { // Is the variable is described by a single location? if (!m_location.IsLocationList()) { // Yes it is, the location is valid. return true; } if (sc.function) { addr_t loclist_base_file_addr = sc.function->GetAddressRange().GetBaseAddress().GetFileAddress(); if (loclist_base_file_addr == LLDB_INVALID_ADDRESS) return false; // It is a location list. We just need to tell if the location // list contains the current address when converted to a load // address return m_location.LocationListContainsAddress (loclist_base_file_addr, address.GetFileAddress()); } } } return false; } bool Variable::IsInScope (StackFrame *frame) { switch (m_scope) { case eValueTypeRegister: case eValueTypeRegisterSet: return frame != NULL; case eValueTypeConstResult: case eValueTypeVariableGlobal: case eValueTypeVariableStatic: return true; case eValueTypeVariableArgument: case eValueTypeVariableLocal: if (frame) { // We don't have a location list, we just need to see if the block // that this variable was defined in is currently Block *deepest_frame_block = frame->GetSymbolContext(eSymbolContextBlock).block; if (deepest_frame_block) { SymbolContext variable_sc; CalculateSymbolContext (&variable_sc); // Check for static or global variable defined at the compile unit // level that wasn't defined in a block if (variable_sc.block == NULL) return true; if (variable_sc.block == deepest_frame_block) return true; return variable_sc.block->Contains (deepest_frame_block); } } break; default: break; } return false; } Error Variable::GetValuesForVariableExpressionPath (const char *variable_expr_path, ExecutionContextScope *scope, GetVariableCallback callback, void *baton, VariableList &variable_list, ValueObjectList &valobj_list) { Error error; if (variable_expr_path && callback) { switch (variable_expr_path[0]) { case '*': { error = Variable::GetValuesForVariableExpressionPath (variable_expr_path + 1, scope, callback, baton, variable_list, valobj_list); if (error.Success()) { for (uint32_t i=0; iDereference(tmp_error)); if (tmp_error.Fail()) { variable_list.RemoveVariableAtIndex (i); valobj_list.RemoveValueObjectAtIndex (i); } else { valobj_list.SetValueObjectAtIndex (i, valobj_sp); ++i; } } } else { error.SetErrorString ("unknown error"); } return error; } break; case '&': { error = Variable::GetValuesForVariableExpressionPath (variable_expr_path + 1, scope, callback, baton, variable_list, valobj_list); if (error.Success()) { for (uint32_t i=0; iAddressOf(tmp_error)); if (tmp_error.Fail()) { variable_list.RemoveVariableAtIndex (i); valobj_list.RemoveValueObjectAtIndex (i); } else { valobj_list.SetValueObjectAtIndex (i, valobj_sp); ++i; } } } else { error.SetErrorString ("unknown error"); } return error; } break; default: { static RegularExpression g_regex ("^([A-Za-z_:][A-Za-z_0-9:]*)(.*)"); RegularExpression::Match regex_match(1); if (g_regex.Execute(variable_expr_path, ®ex_match)) { std::string variable_name; if (regex_match.GetMatchAtIndex(variable_expr_path, 1, variable_name)) { variable_list.Clear(); if (callback (baton, variable_name.c_str(), variable_list)) { uint32_t i=0; while (i < variable_list.GetSize()) { VariableSP var_sp (variable_list.GetVariableAtIndex (i)); ValueObjectSP valobj_sp; if (var_sp) { ValueObjectSP variable_valobj_sp(ValueObjectVariable::Create (scope, var_sp)); if (variable_valobj_sp) { const char *variable_sub_expr_path = variable_expr_path + variable_name.size(); if (*variable_sub_expr_path) { const char* first_unparsed = NULL; ValueObject::ExpressionPathScanEndReason reason_to_stop; ValueObject::ExpressionPathEndResultType final_value_type; ValueObject::GetValueForExpressionPathOptions options; ValueObject::ExpressionPathAftermath final_task_on_target; valobj_sp = variable_valobj_sp->GetValueForExpressionPath (variable_sub_expr_path, &first_unparsed, &reason_to_stop, &final_value_type, options, &final_task_on_target); if (!valobj_sp) { error.SetErrorStringWithFormat ("invalid expression path '%s' for variable '%s'", variable_sub_expr_path, var_sp->GetName().GetCString()); } } else { // Just the name of a variable with no extras valobj_sp = variable_valobj_sp; } } } if (!var_sp || !valobj_sp) { variable_list.RemoveVariableAtIndex (i); } else { valobj_list.Append(valobj_sp); ++i; } } if (variable_list.GetSize() > 0) { error.Clear(); return error; } } } } error.SetErrorStringWithFormat ("unable to extract a variable name from '%s'", variable_expr_path); } break; } } error.SetErrorString ("unknown error"); return error; } bool Variable::DumpLocationForAddress (Stream *s, const Address &address) { // Be sure to resolve the address to section offset prior to // calling this function. if (address.IsSectionOffset()) { SymbolContext sc; CalculateSymbolContext(&sc); if (sc.module_sp == address.GetModule()) { ABI *abi = NULL; if (m_owner_scope) { ModuleSP module_sp (m_owner_scope->CalculateSymbolContextModule()); if (module_sp) abi = ABI::FindPlugin (module_sp->GetArchitecture()).get(); } const addr_t file_addr = address.GetFileAddress(); if (sc.function) { if (sc.function->GetAddressRange().ContainsFileAddress(address)) { addr_t loclist_base_file_addr = sc.function->GetAddressRange().GetBaseAddress().GetFileAddress(); if (loclist_base_file_addr == LLDB_INVALID_ADDRESS) return false; return m_location.DumpLocationForAddress (s, eDescriptionLevelBrief, loclist_base_file_addr, file_addr, abi); } } return m_location.DumpLocationForAddress (s, eDescriptionLevelBrief, LLDB_INVALID_ADDRESS, file_addr, abi); } } return false; } static void PrivateAutoComplete (StackFrame *frame, const std::string &partial_path, const std::string &prefix_path, // Anything that has been resolved already will be in here const ClangASTType& clang_type, StringList &matches, bool &word_complete); static void PrivateAutoCompleteMembers (StackFrame *frame, const std::string &partial_member_name, const std::string &partial_path, const std::string &prefix_path, // Anything that has been resolved already will be in here const ClangASTType& clang_type, StringList &matches, bool &word_complete); static void PrivateAutoCompleteMembers (StackFrame *frame, const std::string &partial_member_name, const std::string &partial_path, const std::string &prefix_path, // Anything that has been resolved already will be in here const ClangASTType& clang_type, StringList &matches, bool &word_complete) { // We are in a type parsing child members const uint32_t num_bases = clang_type.GetNumDirectBaseClasses(); if (num_bases > 0) { for (uint32_t i = 0; i < num_bases; ++i) { ClangASTType base_class_type (clang_type.GetDirectBaseClassAtIndex (i, NULL)); PrivateAutoCompleteMembers (frame, partial_member_name, partial_path, prefix_path, base_class_type.GetCanonicalType(), matches, word_complete); } } const uint32_t num_vbases = clang_type.GetNumVirtualBaseClasses(); if (num_vbases > 0) { for (uint32_t i = 0; i < num_vbases; ++i) { ClangASTType vbase_class_type (clang_type.GetVirtualBaseClassAtIndex(i,NULL)); PrivateAutoCompleteMembers (frame, partial_member_name, partial_path, prefix_path, vbase_class_type.GetCanonicalType(), matches, word_complete); } } // We are in a type parsing child members const uint32_t num_fields = clang_type.GetNumFields(); if (num_fields > 0) { for (uint32_t i = 0; i < num_fields; ++i) { std::string member_name; ClangASTType member_clang_type = clang_type.GetFieldAtIndex (i, member_name, NULL, NULL, NULL); if (partial_member_name.empty() || member_name.find(partial_member_name) == 0) { if (member_name == partial_member_name) { PrivateAutoComplete (frame, partial_path, prefix_path + member_name, // Anything that has been resolved already will be in here member_clang_type.GetCanonicalType(), matches, word_complete); } else { matches.AppendString (prefix_path + member_name); } } } } } static void PrivateAutoComplete (StackFrame *frame, const std::string &partial_path, const std::string &prefix_path, // Anything that has been resolved already will be in here const ClangASTType& clang_type, StringList &matches, bool &word_complete) { // printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path = '%s'\n", prefix_path.c_str(), partial_path.c_str()); std::string remaining_partial_path; const lldb::TypeClass type_class = clang_type.GetTypeClass(); if (partial_path.empty()) { if (clang_type.IsValid()) { switch (type_class) { default: case eTypeClassArray: case eTypeClassBlockPointer: case eTypeClassBuiltin: case eTypeClassComplexFloat: case eTypeClassComplexInteger: case eTypeClassEnumeration: case eTypeClassFunction: case eTypeClassMemberPointer: case eTypeClassReference: case eTypeClassTypedef: case eTypeClassVector: { matches.AppendString (prefix_path); word_complete = matches.GetSize() == 1; } break; case eTypeClassClass: case eTypeClassStruct: case eTypeClassUnion: if (prefix_path.back() != '.') matches.AppendString (prefix_path + '.'); break; case eTypeClassObjCObject: case eTypeClassObjCInterface: break; case eTypeClassObjCObjectPointer: case eTypeClassPointer: { bool omit_empty_base_classes = true; if (clang_type.GetNumChildren (omit_empty_base_classes) > 0) matches.AppendString (prefix_path + "->"); else { matches.AppendString (prefix_path); word_complete = true; } } break; } } else { if (frame) { const bool get_file_globals = true; VariableList *variable_list = frame->GetVariableList(get_file_globals); if (variable_list) { const size_t num_variables = variable_list->GetSize(); for (size_t i=0; iGetVariableAtIndex(i).get(); matches.AppendString (variable->GetName().AsCString()); } } } } } else { const char ch = partial_path[0]; switch (ch) { case '*': if (prefix_path.empty()) { PrivateAutoComplete (frame, partial_path.substr(1), std::string("*"), clang_type, matches, word_complete); } break; case '&': if (prefix_path.empty()) { PrivateAutoComplete (frame, partial_path.substr(1), std::string("&"), clang_type, matches, word_complete); } break; case '-': if (partial_path[1] == '>' && !prefix_path.empty()) { switch (type_class) { case lldb::eTypeClassPointer: { ClangASTType pointee_type(clang_type.GetPointeeType()); if (partial_path[2]) { // If there is more after the "->", then search deeper PrivateAutoComplete (frame, partial_path.substr(2), prefix_path + "->", pointee_type.GetCanonicalType(), matches, word_complete); } else { // Nothing after the "->", so list all members PrivateAutoCompleteMembers (frame, std::string(), std::string(), prefix_path + "->", pointee_type.GetCanonicalType(), matches, word_complete); } } default: break; } } break; case '.': if (clang_type.IsValid()) { switch (type_class) { case lldb::eTypeClassUnion: case lldb::eTypeClassStruct: case lldb::eTypeClassClass: if (partial_path[1]) { // If there is more after the ".", then search deeper PrivateAutoComplete (frame, partial_path.substr(1), prefix_path + ".", clang_type, matches, word_complete); } else { // Nothing after the ".", so list all members PrivateAutoCompleteMembers (frame, std::string(), partial_path, prefix_path + ".", clang_type, matches, word_complete); } default: break; } } break; default: if (isalpha(ch) || ch == '_' || ch == '$') { const size_t partial_path_len = partial_path.size(); size_t pos = 1; while (pos < partial_path_len) { const char curr_ch = partial_path[pos]; if (isalnum(curr_ch) || curr_ch == '_' || curr_ch == '$') { ++pos; continue; } break; } std::string token(partial_path, 0, pos); remaining_partial_path = partial_path.substr(pos); if (clang_type.IsValid()) { PrivateAutoCompleteMembers (frame, token, remaining_partial_path, prefix_path, clang_type, matches, word_complete); } else if (frame) { // We haven't found our variable yet const bool get_file_globals = true; VariableList *variable_list = frame->GetVariableList(get_file_globals); if (!variable_list) break; const size_t num_variables = variable_list->GetSize(); for (size_t i=0; iGetVariableAtIndex(i).get(); if (!variable) continue; const char *variable_name = variable->GetName().AsCString(); if (strstr(variable_name, token.c_str()) == variable_name) { if (strcmp (variable_name, token.c_str()) == 0) { Type *variable_type = variable->GetType(); if (variable_type) { ClangASTType variable_clang_type (variable_type->GetClangForwardType()); PrivateAutoComplete (frame, remaining_partial_path, prefix_path + token, // Anything that has been resolved already will be in here variable_clang_type.GetCanonicalType(), matches, word_complete); } else { matches.AppendString (prefix_path + variable_name); } } else if (remaining_partial_path.empty()) { matches.AppendString (prefix_path + variable_name); } } } } } break; } } } size_t Variable::AutoComplete (const ExecutionContext &exe_ctx, const char *partial_path_cstr, StringList &matches, bool &word_complete) { word_complete = false; std::string partial_path; std::string prefix_path; ClangASTType clang_type; if (partial_path_cstr && partial_path_cstr[0]) partial_path = partial_path_cstr; PrivateAutoComplete (exe_ctx.GetFramePtr(), partial_path, prefix_path, clang_type, matches, word_complete); return matches.GetSize(); }