2010-06-09 00:52:24 +08:00
|
|
|
//===-- 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/Stream.h"
|
Just like functions can have a basename and a mangled/demangled name, variable
can too. So now the lldb_private::Variable class has support for this.
Variables now have support for having a basename ("i"), and a mangled name
("_ZN12_GLOBAL__N_11iE"), and a demangled name ("(anonymous namespace)::i").
Nowwhen searching for a variable by name, users might enter the fully qualified
name, or just the basename. So new test functions were added to the Variable
and Mangled classes as:
bool NameMatches (const ConstString &name);
bool NameMatches (const RegularExpression ®ex);
I also modified "ClangExpressionDeclMap::FindVariableInScope" to also search
for global variables that are not in the current file scope by first starting
with the current module, then moving on to all modules.
Fixed an issue in the DWARF parser that could cause a varaible to get parsed
more than once. Now, once we have parsed a VariableSP for a DIE, we cache
the result even if a variable wasn't made so we don't do any re-parsing. Some
DW_TAG_variable DIEs don't have locations, or are missing vital info that
stops a debugger from being able to display anything for it, we parse a NULL
variable shared pointer for these DIEs so we don't keep trying to reparse it.
llvm-svn: 119085
2010-11-15 06:13:40 +08:00
|
|
|
#include "lldb/Core/RegularExpression.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Symbol/Block.h"
|
|
|
|
#include "lldb/Symbol/Function.h"
|
|
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
|
|
#include "lldb/Symbol/Type.h"
|
2010-09-15 07:36:40 +08:00
|
|
|
#include "lldb/Target/Process.h"
|
2010-08-25 05:05:24 +08:00
|
|
|
#include "lldb/Target/RegisterContext.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Target/StackFrame.h"
|
|
|
|
#include "lldb/Target/Thread.h"
|
2010-09-15 07:36:40 +08:00
|
|
|
#include "lldb/Target/Target.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Variable constructor
|
|
|
|
//----------------------------------------------------------------------
|
Just like functions can have a basename and a mangled/demangled name, variable
can too. So now the lldb_private::Variable class has support for this.
Variables now have support for having a basename ("i"), and a mangled name
("_ZN12_GLOBAL__N_11iE"), and a demangled name ("(anonymous namespace)::i").
Nowwhen searching for a variable by name, users might enter the fully qualified
name, or just the basename. So new test functions were added to the Variable
and Mangled classes as:
bool NameMatches (const ConstString &name);
bool NameMatches (const RegularExpression ®ex);
I also modified "ClangExpressionDeclMap::FindVariableInScope" to also search
for global variables that are not in the current file scope by first starting
with the current module, then moving on to all modules.
Fixed an issue in the DWARF parser that could cause a varaible to get parsed
more than once. Now, once we have parsed a VariableSP for a DIE, we cache
the result even if a variable wasn't made so we don't do any re-parsing. Some
DW_TAG_variable DIEs don't have locations, or are missing vital info that
stops a debugger from being able to display anything for it, we parse a NULL
variable shared pointer for these DIEs so we don't keep trying to reparse it.
llvm-svn: 119085
2010-11-15 06:13:40 +08:00
|
|
|
Variable::Variable
|
|
|
|
(
|
|
|
|
lldb::user_id_t uid,
|
|
|
|
const char *name,
|
|
|
|
const char *mangled, // The mangled variable name for variables in namespaces
|
|
|
|
Type *type,
|
|
|
|
ValueType scope,
|
|
|
|
SymbolContextScope *context,
|
|
|
|
Declaration* decl_ptr,
|
|
|
|
const DWARFExpression& location,
|
|
|
|
bool external,
|
|
|
|
bool artificial
|
|
|
|
) :
|
2010-06-09 00:52:24 +08:00
|
|
|
UserID(uid),
|
|
|
|
m_name(name),
|
Just like functions can have a basename and a mangled/demangled name, variable
can too. So now the lldb_private::Variable class has support for this.
Variables now have support for having a basename ("i"), and a mangled name
("_ZN12_GLOBAL__N_11iE"), and a demangled name ("(anonymous namespace)::i").
Nowwhen searching for a variable by name, users might enter the fully qualified
name, or just the basename. So new test functions were added to the Variable
and Mangled classes as:
bool NameMatches (const ConstString &name);
bool NameMatches (const RegularExpression ®ex);
I also modified "ClangExpressionDeclMap::FindVariableInScope" to also search
for global variables that are not in the current file scope by first starting
with the current module, then moving on to all modules.
Fixed an issue in the DWARF parser that could cause a varaible to get parsed
more than once. Now, once we have parsed a VariableSP for a DIE, we cache
the result even if a variable wasn't made so we don't do any re-parsing. Some
DW_TAG_variable DIEs don't have locations, or are missing vital info that
stops a debugger from being able to display anything for it, we parse a NULL
variable shared pointer for these DIEs so we don't keep trying to reparse it.
llvm-svn: 119085
2010-11-15 06:13:40 +08:00
|
|
|
m_mangled (mangled, true),
|
2010-06-09 00:52:24 +08:00
|
|
|
m_type(type),
|
|
|
|
m_scope(scope),
|
2010-08-31 02:11:35 +08:00
|
|
|
m_owner_scope(context),
|
2010-06-09 00:52:24 +08:00
|
|
|
m_declaration(decl_ptr),
|
|
|
|
m_location(location),
|
|
|
|
m_external(external),
|
|
|
|
m_artificial(artificial)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Destructor
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
Variable::~Variable()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Just like functions can have a basename and a mangled/demangled name, variable
can too. So now the lldb_private::Variable class has support for this.
Variables now have support for having a basename ("i"), and a mangled name
("_ZN12_GLOBAL__N_11iE"), and a demangled name ("(anonymous namespace)::i").
Nowwhen searching for a variable by name, users might enter the fully qualified
name, or just the basename. So new test functions were added to the Variable
and Mangled classes as:
bool NameMatches (const ConstString &name);
bool NameMatches (const RegularExpression ®ex);
I also modified "ClangExpressionDeclMap::FindVariableInScope" to also search
for global variables that are not in the current file scope by first starting
with the current module, then moving on to all modules.
Fixed an issue in the DWARF parser that could cause a varaible to get parsed
more than once. Now, once we have parsed a VariableSP for a DIE, we cache
the result even if a variable wasn't made so we don't do any re-parsing. Some
DW_TAG_variable DIEs don't have locations, or are missing vital info that
stops a debugger from being able to display anything for it, we parse a NULL
variable shared pointer for these DIEs so we don't keep trying to reparse it.
llvm-svn: 119085
2010-11-15 06:13:40 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
void
|
|
|
|
Variable::Dump(Stream *s, bool show_context) const
|
|
|
|
{
|
|
|
|
s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
|
|
|
|
s->Indent();
|
|
|
|
*s << "Variable" << (const UserID&)*this;
|
|
|
|
|
|
|
|
if (m_name)
|
|
|
|
*s << ", name = \"" << m_name << "\"";
|
|
|
|
|
|
|
|
if (m_type != NULL)
|
|
|
|
{
|
2010-10-13 11:15:28 +08:00
|
|
|
*s << ", type = {" << m_type->GetID() << "} " << (void*)m_type << " (";
|
2010-06-09 00:52:24 +08:00
|
|
|
m_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 << ')';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-31 02:11:35 +08:00
|
|
|
if (show_context && m_owner_scope != NULL)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
|
|
|
s->PutCString(", context = ( ");
|
2010-08-31 02:11:35 +08:00
|
|
|
m_owner_scope->DumpSymbolContext(s);
|
2010-06-09 00:52:24 +08:00
|
|
|
s->PutCString(" )");
|
|
|
|
}
|
|
|
|
|
2010-09-15 13:51:24 +08:00
|
|
|
bool show_fullpaths = false;
|
|
|
|
m_declaration.Dump(s, show_fullpaths);
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
if (m_location.IsValid())
|
|
|
|
{
|
|
|
|
s->PutCString(", location = ");
|
2010-09-14 10:20:48 +08:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
m_location.GetDescription(s, lldb::eDescriptionLevelBrief, loclist_base_addr);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (m_external)
|
|
|
|
s->PutCString(", external");
|
|
|
|
|
|
|
|
if (m_artificial)
|
|
|
|
s->PutCString(", artificial");
|
|
|
|
|
|
|
|
s->EOL();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
size_t
|
|
|
|
Variable::MemorySize() const
|
|
|
|
{
|
|
|
|
return sizeof(Variable);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
Variable::CalculateSymbolContext (SymbolContext *sc)
|
|
|
|
{
|
2010-08-31 02:11:35 +08:00
|
|
|
if (m_owner_scope)
|
|
|
|
m_owner_scope->CalculateSymbolContext(sc);
|
2010-06-09 00:52:24 +08:00
|
|
|
else
|
|
|
|
sc->Clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
|
|
Variable::IsInScope (StackFrame *frame)
|
|
|
|
{
|
|
|
|
switch (m_scope)
|
|
|
|
{
|
|
|
|
case eValueTypeVariableGlobal:
|
2010-09-14 10:20:48 +08:00
|
|
|
case eValueTypeVariableStatic:
|
2010-06-09 00:52:24 +08:00
|
|
|
// Globals and statics are always in scope.
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case eValueTypeVariableArgument:
|
|
|
|
case eValueTypeVariableLocal:
|
|
|
|
// Check if the location has a location list that describes the value
|
|
|
|
// of the variable with address ranges and different locations for each
|
|
|
|
// address range?
|
|
|
|
if (m_location.IsLocationList())
|
|
|
|
{
|
2010-09-14 10:20:48 +08:00
|
|
|
SymbolContext sc;
|
|
|
|
CalculateSymbolContext(&sc);
|
|
|
|
|
|
|
|
// Currently we only support functions that have things with
|
|
|
|
// locations lists. If this expands, we will need to add support
|
|
|
|
assert (sc.function);
|
2010-09-15 07:36:40 +08:00
|
|
|
Target *target = &frame->GetThread().GetProcess().GetTarget();
|
|
|
|
addr_t loclist_base_load_addr = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (target);
|
2010-09-14 10:20:48 +08:00
|
|
|
if (loclist_base_load_addr == LLDB_INVALID_ADDRESS)
|
|
|
|
return false;
|
2010-06-09 00:52:24 +08:00
|
|
|
// It is a location list. We just need to tell if the location
|
|
|
|
// list contains the current address when converted to a load
|
|
|
|
// address
|
2010-09-15 07:36:40 +08:00
|
|
|
return m_location.LocationListContainsAddress (loclist_base_load_addr, frame->GetFrameCodeAddress().GetLoadAddress (target));
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// We don't have a location list, we just need to see if the block
|
|
|
|
// that this variable was defined in is currently
|
2010-09-14 11:16:58 +08:00
|
|
|
Block *deepest_frame_block = frame->GetSymbolContext(eSymbolContextBlock).block;
|
|
|
|
if (deepest_frame_block)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
|
|
|
SymbolContext variable_sc;
|
|
|
|
CalculateSymbolContext (&variable_sc);
|
2010-09-14 11:16:58 +08:00
|
|
|
if (variable_sc.block == deepest_frame_block)
|
2010-09-14 10:20:48 +08:00
|
|
|
return true;
|
|
|
|
|
2010-09-14 11:16:58 +08:00
|
|
|
return variable_sc.block->Contains (deepest_frame_block);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2010-09-14 10:20:48 +08:00
|
|
|
assert (!"Unhandled case");
|
2010-06-09 00:52:24 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|