[Lldb-commits] [lldb] r121745 - in /lldb/trunk: include/lldb/ include/lldb/Core/ include/lldb/Expression/ include/lldb/Symbol/ include/lldb/Target/ source/API/ source/Commands/ source/Core/ source/Expression/ source/Plugins/DynamicLoader/MacOSX-DYLD/ source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/ source/Symbol/ source/Target/ test/load_unload/
Greg Clayton
gclayton at apple.com
Mon Dec 13 18:59:59 PST 2010
Author: gclayton
Date: Mon Dec 13 20:59:59 2010
New Revision: 121745
URL: http://llvm.org/viewvc/llvm-project?rev=121745&view=rev
Log:
Modified LLDB expressions to not have to JIT and run code just to see variable
values or persistent expression variables. Now if an expression consists of
a value that is a child of a variable, or of a persistent variable only, we
will create a value object for it and make a ValueObjectConstResult from it to
freeze the value (for program variables only, not persistent variables) and
avoid running JITed code. For everything else we still parse up and JIT code
and run it in the inferior.
There was also a lot of clean up in the expression code. I made the
ClangExpressionVariables be stored in collections of shared pointers instead
of in collections of objects. This will help stop a lot of copy constructors on
these large objects and also cleans up the code considerably. The persistent
clang expression variables were moved over to the Target to ensure they persist
across process executions.
Added the ability for lldb_private::Target objects to evaluate expressions.
We want to evaluate expressions at the target level in case we aren't running
yet, or we have just completed running. We still want to be able to access the
persistent expression variables between runs, and also evaluate constant
expressions.
Added extra logging to the dynamic loader plug-in for MacOSX. ModuleList objects
can now dump their contents with the UUID, arch and full paths being logged with
appropriate prefix values.
Thread hardened the Communication class a bit by making the connection auto_ptr
member into a shared pointer member and then making a local copy of the shared
pointer in each method that uses it to make sure another thread can't nuke the
connection object while it is being used by another thread.
Added a new file to the lldb/test/load_unload test that causes the test a.out file
to link to the libd.dylib file all the time. This will allow us to test using
the DYLD_LIBRARY_PATH environment variable after moving libd.dylib somewhere else.
Added:
lldb/trunk/test/load_unload/d.c
Modified:
lldb/trunk/include/lldb/Core/Communication.h
lldb/trunk/include/lldb/Core/ModuleList.h
lldb/trunk/include/lldb/Core/Value.h
lldb/trunk/include/lldb/Core/ValueObject.h
lldb/trunk/include/lldb/Core/ValueObjectConstResult.h
lldb/trunk/include/lldb/Expression/ClangExpression.h
lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h
lldb/trunk/include/lldb/Expression/ClangExpressionVariable.h
lldb/trunk/include/lldb/Expression/ClangFunction.h
lldb/trunk/include/lldb/Expression/ClangPersistentVariables.h
lldb/trunk/include/lldb/Expression/ClangUserExpression.h
lldb/trunk/include/lldb/Expression/ClangUtilityFunction.h
lldb/trunk/include/lldb/Expression/IRToDWARF.h
lldb/trunk/include/lldb/Symbol/ClangASTContext.h
lldb/trunk/include/lldb/Target/Process.h
lldb/trunk/include/lldb/Target/StackFrame.h
lldb/trunk/include/lldb/Target/Target.h
lldb/trunk/include/lldb/lldb-enumerations.h
lldb/trunk/include/lldb/lldb-forward-rtti.h
lldb/trunk/include/lldb/lldb-forward.h
lldb/trunk/source/API/SBFrame.cpp
lldb/trunk/source/Commands/CommandObjectExpression.cpp
lldb/trunk/source/Core/Communication.cpp
lldb/trunk/source/Core/ModuleList.cpp
lldb/trunk/source/Core/Value.cpp
lldb/trunk/source/Core/ValueObject.cpp
lldb/trunk/source/Core/ValueObjectChild.cpp
lldb/trunk/source/Core/ValueObjectConstResult.cpp
lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp
lldb/trunk/source/Expression/ClangExpressionParser.cpp
lldb/trunk/source/Expression/ClangExpressionVariable.cpp
lldb/trunk/source/Expression/ClangFunction.cpp
lldb/trunk/source/Expression/ClangPersistentVariables.cpp
lldb/trunk/source/Expression/ClangUserExpression.cpp
lldb/trunk/source/Expression/IRToDWARF.cpp
lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp
lldb/trunk/source/Symbol/ClangASTContext.cpp
lldb/trunk/source/Symbol/ClangASTType.cpp
lldb/trunk/source/Target/Process.cpp
lldb/trunk/source/Target/SectionLoadList.cpp
lldb/trunk/source/Target/StackFrame.cpp
lldb/trunk/source/Target/Target.cpp
lldb/trunk/source/Target/ThreadPlanTestCondition.cpp
lldb/trunk/test/load_unload/Makefile
Modified: lldb/trunk/include/lldb/Core/Communication.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Communication.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/Communication.h (original)
+++ lldb/trunk/include/lldb/Core/Communication.h Mon Dec 13 20:59:59 2010
@@ -354,7 +354,7 @@
protected:
- std::auto_ptr<Connection> m_connection_ap; ///< The connection that is current in use by this communications class.
+ lldb::ConnectionSP m_connection_sp; ///< The connection that is current in use by this communications class.
lldb::thread_t m_read_thread; ///< The read thread handle in case we need to cancel the thread.
bool m_read_thread_enabled;
std::string m_bytes; ///< A buffer to cache bytes read in the ReadThread function.
Modified: lldb/trunk/include/lldb/Core/ModuleList.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/ModuleList.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/ModuleList.h (original)
+++ lldb/trunk/include/lldb/Core/ModuleList.h Mon Dec 13 20:59:59 2010
@@ -102,6 +102,10 @@
void
Dump (Stream *s) const;
+ void
+ LogUUIDAndPaths (lldb::LogSP &log_sp,
+ const char *prefix_cstr);
+
uint32_t
GetIndexForModule (const Module *module) const;
Modified: lldb/trunk/include/lldb/Core/Value.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Value.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/Value.h (original)
+++ lldb/trunk/include/lldb/Core/Value.h Mon Dec 13 20:59:59 2010
@@ -131,6 +131,9 @@
static const char *
GetContextTypeAsCString (ContextType context_type);
+ bool
+ GetData (DataExtractor &data);
+
protected:
Scalar m_value;
ValueType m_value_type;
Modified: lldb/trunk/include/lldb/Core/ValueObject.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/ValueObject.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/ValueObject.h (original)
+++ lldb/trunk/include/lldb/Core/ValueObject.h Mon Dec 13 20:59:59 2010
@@ -113,6 +113,12 @@
{
return 0;
}
+
+ virtual bool
+ SetClangAST (clang::ASTContext *ast)
+ {
+ return false;
+ }
virtual const char *
GetValueAsCString (ExecutionContextScope *exe_scope);
@@ -197,6 +203,25 @@
return m_dynamic_value_sp;
}
+ virtual lldb::ValueObjectSP
+ CreateConstantValue (ExecutionContextScope *exe_scope, const ConstString &name);
+
+ virtual lldb::ValueObjectSP
+ Dereference (ExecutionContextScope *exe_scope, Error *error_ptr);
+
+ virtual lldb::ValueObjectSP
+ AddressOf ();
+
+ // The backing bits of this value object were updated, clear any value
+ // values, summaries or descriptions so we refetch them.
+ virtual void
+ ValueUpdated ()
+ {
+ m_value_str.clear();
+ m_summary_str.clear();
+ m_object_desc_str.clear();
+ }
+
bool
SetDynamicValue ();
@@ -249,6 +274,13 @@
{
return m_parent;
}
+
+ void
+ SetPointersPointToLoadAddrs (bool b)
+ {
+ m_pointers_point_to_load_addrs = b;
+ }
+
protected:
//------------------------------------------------------------------
// Classes that inherit from ValueObject can see and modify these
@@ -277,8 +309,12 @@
bool m_value_is_valid:1,
m_value_did_change:1,
m_children_count_valid:1,
- m_old_value_valid:1;
-
+ m_old_value_valid:1,
+ m_pointers_point_to_load_addrs:1;
+
+ friend class CommandObjectExpression;
+ friend class ClangExpressionVariable;
+ friend class Target;
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
Modified: lldb/trunk/include/lldb/Core/ValueObjectConstResult.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/ValueObjectConstResult.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/ValueObjectConstResult.h (original)
+++ lldb/trunk/include/lldb/Core/ValueObjectConstResult.h Mon Dec 13 20:59:59 2010
@@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_ValueObjectChild_h_
-#define liblldb_ValueObjectChild_h_
+#ifndef liblldb_ValueObjectConstResult_h_
+#define liblldb_ValueObjectConstResult_h_
// C Includes
// C++ Includes
@@ -24,6 +24,14 @@
class ValueObjectConstResult : public ValueObject
{
public:
+ ValueObjectConstResult (lldb::ByteOrder byte_order,
+ uint32_t addr_byte_size);
+
+ ValueObjectConstResult (clang::ASTContext *clang_ast,
+ void *clang_type,
+ const ConstString &name,
+ const DataExtractor &data);
+
ValueObjectConstResult (clang::ASTContext *clang_ast,
void *clang_type,
const ConstString &name,
@@ -31,6 +39,12 @@
lldb::ByteOrder byte_order,
uint8_t addr_size);
+ ValueObjectConstResult (clang::ASTContext *clang_ast,
+ void *clang_type,
+ const ConstString &name,
+ lldb::addr_t address,
+ lldb::AddressType address_type,
+ uint8_t addr_byte_size);
// When an expression fails to evaluate, we return an error
ValueObjectConstResult (const Error& error);
@@ -61,9 +75,20 @@
virtual bool
IsInScope (StackFrame *frame);
+ virtual bool
+ SetClangAST (clang::ASTContext *ast)
+ {
+ m_clang_ast = ast;
+ return true;
+ }
+
+ void
+ SetByteSize (size_t size);
+
protected:
clang::ASTContext *m_clang_ast; // The clang AST that the clang type comes from
ConstString m_type_name;
+ uint32_t m_byte_size;
private:
DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResult);
@@ -71,4 +96,4 @@
} // namespace lldb_private
-#endif // liblldb_ValueObjectChild_h_
+#endif // liblldb_ValueObjectConstResult_h_
Modified: lldb/trunk/include/lldb/Expression/ClangExpression.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/ClangExpression.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/ClangExpression.h (original)
+++ lldb/trunk/include/lldb/Expression/ClangExpression.h Mon Dec 13 20:59:59 2010
@@ -74,7 +74,7 @@
/// Return the object that the parser should use when registering
/// local variables. May be NULL if the Expression doesn't care.
//------------------------------------------------------------------
- virtual ClangExpressionVariableStore *
+ virtual ClangExpressionVariableList *
LocalVariables () = 0;
//------------------------------------------------------------------
Modified: lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h (original)
+++ lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h Mon Dec 13 20:59:59 2010
@@ -72,12 +72,12 @@
///
/// Initializes class variabes.
//------------------------------------------------------------------
- ClangExpressionDeclMap();
+ ClangExpressionDeclMap ();
//------------------------------------------------------------------
/// Destructor
//------------------------------------------------------------------
- ~ClangExpressionDeclMap();
+ ~ClangExpressionDeclMap ();
//------------------------------------------------------------------
/// Enable the state needed for parsing and IR transformation.
@@ -86,12 +86,14 @@
/// The execution context to use when finding types for variables.
/// Also used to find a "scratch" AST context to store result types.
//------------------------------------------------------------------
- void WillParse(ExecutionContext &exe_ctx);
+ void
+ WillParse (ExecutionContext &exe_ctx);
//------------------------------------------------------------------
/// Disable the state needed for parsing and IR transformation.
//------------------------------------------------------------------
- void DidParse();
+ void
+ DidParse ();
//------------------------------------------------------------------
/// [Used by IRForTarget] Get a new result variable name of the form
@@ -124,9 +126,10 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool AddPersistentVariable (const clang::NamedDecl *decl,
- const ConstString &name,
- TypeFromParser type);
+ bool
+ AddPersistentVariable (const clang::NamedDecl *decl,
+ const ConstString &name,
+ TypeFromParser type);
//------------------------------------------------------------------
/// [Used by IRForTarget] Add a variable to the struct that needs to
@@ -150,11 +153,12 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool AddValueToStruct (const clang::NamedDecl *decl,
- const ConstString &name,
- llvm::Value *value,
- size_t size,
- off_t alignment);
+ bool
+ AddValueToStruct (const clang::NamedDecl *decl,
+ const ConstString &name,
+ llvm::Value *value,
+ size_t size,
+ off_t alignment);
//------------------------------------------------------------------
/// [Used by IRForTarget] Finalize the struct, laying out the position
@@ -163,7 +167,8 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool DoStructLayout ();
+ bool
+ DoStructLayout ();
//------------------------------------------------------------------
/// [Used by IRForTarget] Get general information about the laid-out
@@ -181,9 +186,10 @@
/// @return
/// True if the information could be retrieved; false otherwise.
//------------------------------------------------------------------
- bool GetStructInfo (uint32_t &num_elements,
- size_t &size,
- off_t &alignment);
+ bool
+ GetStructInfo (uint32_t &num_elements,
+ size_t &size,
+ off_t &alignment);
//------------------------------------------------------------------
/// [Used by IRForTarget] Get specific information about one field
@@ -216,11 +222,12 @@
/// @return
/// True if the information could be retrieved; false otherwise.
//------------------------------------------------------------------
- bool GetStructElement (const clang::NamedDecl *&decl,
- llvm::Value *&value,
- off_t &offset,
- ConstString &name,
- uint32_t index);
+ bool
+ GetStructElement (const clang::NamedDecl *&decl,
+ llvm::Value *&value,
+ off_t &offset,
+ ConstString &name,
+ uint32_t index);
//------------------------------------------------------------------
/// [Used by IRForTarget] Get information about a function given its
@@ -240,9 +247,10 @@
/// @return
/// True if the information could be retrieved; false otherwise.
//------------------------------------------------------------------
- bool GetFunctionInfo (const clang::NamedDecl *decl,
- llvm::Value**& value,
- uint64_t &ptr);
+ bool
+ GetFunctionInfo (const clang::NamedDecl *decl,
+ llvm::Value**& value,
+ uint64_t &ptr);
//------------------------------------------------------------------
/// [Used by IRForTarget] Get the address of a function given nothing
@@ -259,8 +267,9 @@
/// @return
/// True if the address could be retrieved; false otherwise.
//------------------------------------------------------------------
- bool GetFunctionAddress (const ConstString &name,
- uint64_t &ptr);
+ bool
+ GetFunctionAddress (const ConstString &name,
+ uint64_t &ptr);
//------------------------------------------------------------------
/// [Used by CommandObjectExpression] Materialize the entire struct
@@ -280,9 +289,10 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool Materialize(ExecutionContext &exe_ctx,
- lldb::addr_t &struct_address,
- Error &error);
+ bool
+ Materialize (ExecutionContext &exe_ctx,
+ lldb::addr_t &struct_address,
+ Error &error);
//------------------------------------------------------------------
/// [Used by CommandObjectExpression] Get the "this" pointer
@@ -308,11 +318,12 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool GetObjectPointer(lldb::addr_t &object_ptr,
- ConstString &object_name,
- ExecutionContext &exe_ctx,
- Error &error,
- bool suppress_type_check = false);
+ bool
+ GetObjectPointer (lldb::addr_t &object_ptr,
+ ConstString &object_name,
+ ExecutionContext &exe_ctx,
+ Error &error,
+ bool suppress_type_check = false);
//------------------------------------------------------------------
/// [Used by CommandObjectExpression] Pretty-print a materialized
@@ -332,9 +343,10 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool DumpMaterializedStruct(ExecutionContext &exe_ctx,
- Stream &s,
- Error &error);
+ bool
+ DumpMaterializedStruct (ExecutionContext &exe_ctx,
+ Stream &s,
+ Error &error);
//------------------------------------------------------------------
/// [Used by CommandObjectExpression] Deaterialize the entire struct.
@@ -353,9 +365,10 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool Dematerialize(ExecutionContext &exe_ctx,
- ClangExpressionVariable *&result,
- Error &error);
+ bool
+ Dematerialize (ExecutionContext &exe_ctx,
+ lldb::ClangExpressionVariableSP &result_sp,
+ Error &error);
//------------------------------------------------------------------
/// [Used by ClangASTSource] Find all entities matching a given name,
@@ -373,8 +386,9 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- void GetDecls (NameSearchContext &context,
- const ConstString &name);
+ void
+ GetDecls (NameSearchContext &context,
+ const ConstString &name);
//------------------------------------------------------------------
/// [Used by ClangASTSource] Report whether a $__lldb variable has
@@ -405,8 +419,8 @@
}
private:
- ClangExpressionVariableStore m_found_entities; ///< All entities that were looked up for the parser.
- ClangExpressionVariableList m_struct_members; ///< All entities that need to be placed in the struct.
+ ClangExpressionVariableList m_found_entities; ///< All entities that were looked up for the parser.
+ ClangExpressionVariableList m_struct_members; ///< All entities that need to be placed in the struct.
//----------------------------------------------------------------------
/// The following values should not live beyond parsing
@@ -421,6 +435,15 @@
{
}
+ Target *
+ GetTarget()
+ {
+ if (m_exe_ctx && m_exe_ctx->target)
+ return m_exe_ctx->target;
+ else if (m_sym_ctx.target_sp)
+ m_sym_ctx.target_sp.get();
+ return NULL;
+ }
ExecutionContext *m_exe_ctx; ///< The execution context to use when parsing.
SymbolContext m_sym_ctx; ///< The symbol context to use in finding variables and types.
ClangPersistentVariables *m_persistent_vars; ///< The persistent variables for the process.
@@ -433,7 +456,8 @@
//----------------------------------------------------------------------
/// Activate parser-specific variables
//----------------------------------------------------------------------
- void EnableParserVars()
+ void
+ EnableParserVars()
{
if (!m_parser_vars.get())
m_parser_vars.reset(new struct ParserVars);
@@ -442,7 +466,8 @@
//----------------------------------------------------------------------
/// Deallocate parser-specific variables
//----------------------------------------------------------------------
- void DisableParserVars()
+ void
+ DisableParserVars()
{
m_parser_vars.reset();
}
@@ -473,7 +498,8 @@
//----------------------------------------------------------------------
/// Activate struct variables
//----------------------------------------------------------------------
- void EnableStructVars()
+ void
+ EnableStructVars()
{
if (!m_struct_vars.get())
m_struct_vars.reset(new struct StructVars);
@@ -482,7 +508,8 @@
//----------------------------------------------------------------------
/// Deallocate struct variables
//----------------------------------------------------------------------
- void DisableStructVars()
+ void
+ DisableStructVars()
{
m_struct_vars.reset();
}
@@ -508,7 +535,8 @@
//----------------------------------------------------------------------
/// Activate materialization-specific variables
//----------------------------------------------------------------------
- void EnableMaterialVars()
+ void
+ EnableMaterialVars()
{
if (!m_material_vars.get())
m_material_vars.reset(new struct MaterialVars);
@@ -517,7 +545,8 @@
//----------------------------------------------------------------------
/// Deallocate materialization-specific variables
//----------------------------------------------------------------------
- void DisableMaterialVars()
+ void
+ DisableMaterialVars()
{
m_material_vars.reset();
}
@@ -542,9 +571,10 @@
/// @return
/// The LLDB Variable found, or NULL if none was found.
//------------------------------------------------------------------
- Variable *FindVariableInScope(StackFrame &frame,
- const ConstString &name,
- TypeFromUser *type = NULL);
+ Variable *
+ FindVariableInScope (StackFrame &frame,
+ const ConstString &name,
+ TypeFromUser *type = NULL);
//------------------------------------------------------------------
/// Get the value of a variable in a given execution context and return
@@ -575,11 +605,12 @@
/// @return
/// The LLDB Value for the variable.
//------------------------------------------------------------------
- Value *GetVariableValue(ExecutionContext &exe_ctx,
- Variable *var,
- clang::ASTContext *parser_ast_context,
- TypeFromUser *found_type = NULL,
- TypeFromParser *parser_type = NULL);
+ Value *
+ GetVariableValue (ExecutionContext &exe_ctx,
+ Variable *var,
+ clang::ASTContext *parser_ast_context,
+ TypeFromUser *found_type = NULL,
+ TypeFromParser *parser_type = NULL);
//------------------------------------------------------------------
/// Use the NameSearchContext to generate a Decl for the given LLDB
@@ -591,8 +622,9 @@
/// @param[in] var
/// The LLDB Variable that needs a Decl.
//------------------------------------------------------------------
- void AddOneVariable(NameSearchContext &context,
- Variable *var);
+ void
+ AddOneVariable (NameSearchContext &context,
+ Variable *var);
//------------------------------------------------------------------
/// Use the NameSearchContext to generate a Decl for the given
@@ -604,7 +636,9 @@
/// @param[in] pvar
/// The persistent variable that needs a Decl.
//------------------------------------------------------------------
- void AddOneVariable(NameSearchContext &context, ClangExpressionVariable *pvar);
+ void
+ AddOneVariable (NameSearchContext &context,
+ lldb::ClangExpressionVariableSP &pvar_sp);
//------------------------------------------------------------------
/// Use the NameSearchContext to generate a Decl for the given
@@ -622,7 +656,10 @@
/// The Symbol that corresponds to a function that needs to be
/// created with generic type (unitptr_t foo(...)).
//------------------------------------------------------------------
- void AddOneFunction(NameSearchContext &context, Function *fun, Symbol *sym);
+ void
+ AddOneFunction (NameSearchContext &context,
+ Function *fun,
+ Symbol *sym);
//------------------------------------------------------------------
/// Use the NameSearchContext to generate a Decl for the given
@@ -634,7 +671,9 @@
/// @param[in] reg_info
/// The information corresponding to that register.
//------------------------------------------------------------------
- void AddOneRegister(NameSearchContext &context, const lldb::RegisterInfo *reg_info);
+ void
+ AddOneRegister (NameSearchContext &context,
+ const lldb::RegisterInfo *reg_info);
//------------------------------------------------------------------
/// Use the NameSearchContext to generate a Decl for the given
@@ -650,9 +689,10 @@
/// True if a method with signature void $__lldb_expr(void*)
/// should be added to the C++ class type passed in
//------------------------------------------------------------------
- void AddOneType(NameSearchContext &context,
- TypeFromUser &type,
- bool add_method = false);
+ void
+ AddOneType (NameSearchContext &context,
+ TypeFromUser &type,
+ bool add_method = false);
//------------------------------------------------------------------
/// Actually do the task of materializing or dematerializing the struct.
@@ -678,15 +718,17 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool DoMaterialize (bool dematerialize,
- ExecutionContext &exe_ctx,
- ClangExpressionVariable **result,
- Error &err);
+ bool
+ DoMaterialize (bool dematerialize,
+ ExecutionContext &exe_ctx,
+ lldb::ClangExpressionVariableSP *result_sp_ptr,
+ Error &err);
//------------------------------------------------------------------
/// Clean up the state required to dematerialize the variable.
//------------------------------------------------------------------
- void DidDematerialize ();
+ void
+ DidDematerialize ();
//------------------------------------------------------------------
/// Actually do the task of materializing or dematerializing a persistent
@@ -699,8 +741,8 @@
/// @param[in] exe_ctx
/// The execution context to use.
///
- /// @param[in] name
- /// The name of the persistent variable.
+ /// @param[in] var_sp
+ /// The persistent variable to materialize
///
/// @param[in] addr
/// The address at which to materialize the variable.
@@ -712,11 +754,12 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool DoMaterializeOnePersistentVariable(bool dematerialize,
- ExecutionContext &exe_ctx,
- const ConstString &name,
- lldb::addr_t addr,
- Error &err);
+ bool
+ DoMaterializeOnePersistentVariable (bool dematerialize,
+ ExecutionContext &exe_ctx,
+ lldb::ClangExpressionVariableSP &var_sp,
+ lldb::addr_t addr,
+ Error &err);
//------------------------------------------------------------------
/// Actually do the task of materializing or dematerializing a
@@ -748,13 +791,14 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool DoMaterializeOneVariable(bool dematerialize,
- ExecutionContext &exe_ctx,
- const SymbolContext &sym_ctx,
- const ConstString &name,
- TypeFromUser type,
- lldb::addr_t addr,
- Error &err);
+ bool
+ DoMaterializeOneVariable (bool dematerialize,
+ ExecutionContext &exe_ctx,
+ const SymbolContext &sym_ctx,
+ const ConstString &name,
+ TypeFromUser type,
+ lldb::addr_t addr,
+ Error &err);
//------------------------------------------------------------------
/// Actually do the task of materializing or dematerializing a
@@ -783,12 +827,13 @@
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool DoMaterializeOneRegister(bool dematerialize,
- ExecutionContext &exe_ctx,
- RegisterContext ®_ctx,
- const lldb::RegisterInfo ®_info,
- lldb::addr_t addr,
- Error &err);
+ bool
+ DoMaterializeOneRegister (bool dematerialize,
+ ExecutionContext &exe_ctx,
+ RegisterContext ®_ctx,
+ const lldb::RegisterInfo ®_info,
+ lldb::addr_t addr,
+ Error &err);
//------------------------------------------------------------------
/// A wrapper for ClangASTContext::CopyType that sets a flag that
@@ -807,9 +852,10 @@
/// @return
/// The imported type.
//------------------------------------------------------------------
- void *GuardedCopyType (clang::ASTContext *dest_context,
- clang::ASTContext *source_context,
- void *clang_type);
+ void *
+ GuardedCopyType (clang::ASTContext *dest_context,
+ clang::ASTContext *source_context,
+ void *clang_type);
};
} // namespace lldb_private
Modified: lldb/trunk/include/lldb/Expression/ClangExpressionVariable.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/ClangExpressionVariable.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/ClangExpressionVariable.h (original)
+++ lldb/trunk/include/lldb/Expression/ClangExpressionVariable.h Mon Dec 13 20:59:59 2010
@@ -20,7 +20,7 @@
// Other libraries and framework includes
// Project includes
-#include "lldb/lldb-types.h"
+#include "lldb/lldb-include.h"
#include "lldb/Core/ClangForward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Symbol/TaggedASTType.h"
@@ -31,11 +31,8 @@
namespace lldb_private {
-class ClangExpressionVariableStore;
-class DataBufferHeap;
-class ExecutionContext;
-class Stream;
-class Value;
+class ClangExpressionVariableList;
+class ValueObjectConstResult;
//----------------------------------------------------------------------
/// @class ClangExpressionVariable ClangExpressionVariable.h "lldb/Expression/ClangExpressionVariable.h"
@@ -60,12 +57,13 @@
/// polymorphism, and provides necessary support methods. Its interface
/// is RTTI-neutral.
//----------------------------------------------------------------------
-struct ClangExpressionVariable
+class ClangExpressionVariable
{
- ClangExpressionVariable();
-
- ClangExpressionVariable(const ClangExpressionVariable &cev);
-
+public:
+ ClangExpressionVariable(lldb::ByteOrder byte_order, uint32_t addr_byte_size);
+
+ ClangExpressionVariable(const lldb::ValueObjectSP &valobj_sp);
+
//----------------------------------------------------------------------
/// If the variable contains its own data, make a Value point at it.
/// If \a exe_ctx in not NULL, the value will be resolved in with
@@ -85,24 +83,9 @@
PointValueAtData(Value &value, ExecutionContext *exe_ctx);
lldb::ValueObjectSP
- GetExpressionResult (ExecutionContext *exe_ctx);
+ GetValueObject();
//----------------------------------------------------------------------
- /// The following values should stay valid for the life of the variable
- //----------------------------------------------------------------------
- ConstString m_name; ///< The name of the variable
- TypeFromUser m_user_type; ///< The type of the variable according to some LLDB context;
- ///< NULL if the type hasn't yet been migrated to one
-
- const lldb::RegisterInfo *m_register_info; ///< if non-NULL, LLDB's information for the register this value is stored in. Only used for register values
-
- //----------------------------------------------------------------------
- /// The following values indicate where the variable originally came from
- //----------------------------------------------------------------------
- ClangExpressionVariableStore *m_store; ///< The store containing the variable
- uint64_t m_index; ///< The index of the variable in the store
-
- //----------------------------------------------------------------------
/// The following values should not live beyond parsing
//----------------------------------------------------------------------
struct ParserVars {
@@ -120,13 +103,12 @@
llvm::Value *m_llvm_value; ///< The IR value corresponding to this variable; usually a GlobalValue
lldb_private::Value *m_lldb_value; ///< The value found in LLDB for this variable
};
- std::auto_ptr<ParserVars> m_parser_vars;
-
//----------------------------------------------------------------------
/// Make this variable usable by the parser by allocating space for
/// parser-specific variables
//----------------------------------------------------------------------
- void EnableParserVars()
+ void
+ EnableParserVars()
{
if (!m_parser_vars.get())
m_parser_vars.reset(new struct ParserVars);
@@ -135,7 +117,8 @@
//----------------------------------------------------------------------
/// Deallocate parser-specific variables
//----------------------------------------------------------------------
- void DisableParserVars()
+ void
+ DisableParserVars()
{
m_parser_vars.reset();
}
@@ -155,13 +138,13 @@
size_t m_size; ///< The space required for the variable, in bytes
off_t m_offset; ///< The offset of the variable in the struct, in bytes
};
- std::auto_ptr<JITVars> m_jit_vars;
-
+
//----------------------------------------------------------------------
/// Make this variable usable for materializing for the JIT by allocating
/// space for JIT-specific variables
//----------------------------------------------------------------------
- void EnableJITVars()
+ void
+ EnableJITVars()
{
if (!m_jit_vars.get())
m_jit_vars.reset(new struct JITVars);
@@ -170,62 +153,100 @@
//----------------------------------------------------------------------
/// Deallocate JIT-specific variables
//----------------------------------------------------------------------
- void DisableJITVars()
+ void
+ DisableJITVars()
{
m_jit_vars.reset();
}
-
- lldb::DataBufferSP m_data_sp;
-
+
//----------------------------------------------------------------------
- /// Make this variable usable for storing its data internally by
- /// allocating data-specific variables
+ /// Return the variable's size in bytes
//----------------------------------------------------------------------
- void
- EnableDataVars();
+ size_t
+ GetByteSize ();
- //----------------------------------------------------------------------
- /// Deallocate data-specific variables
- //----------------------------------------------------------------------
- void DisableDataVars();
+ const ConstString &
+ GetName();
+
+ lldb::RegisterInfo *
+ GetRegisterInfo();
+ void
+ SetRegisterInfo (const lldb::RegisterInfo *reg_info);
+
+ lldb::clang_type_t
+ GetClangType ();
+
+ void
+ SetClangType (lldb::clang_type_t);
+
+ clang::ASTContext *
+ GetClangAST ();
+
+ void
+ SetClangAST (clang::ASTContext *ast);
+
+ TypeFromUser
+ GetTypeFromUser ();
+
+ uint8_t *
+ GetValueBytes ();
+
+ void
+ SetName (const ConstString &name);
+
+ void
+ ValueUpdated ();
+
+
+ typedef lldb::SharedPtr<ValueObjectConstResult>::Type ValueObjectConstResultSP;
+
//----------------------------------------------------------------------
- /// Return the variable's size in bytes
+ /// Members
//----------------------------------------------------------------------
- size_t Size ()
- {
- return (m_user_type.GetClangTypeBitWidth () + 7) / 8;
- }
+ std::auto_ptr<ParserVars> m_parser_vars;
+ std::auto_ptr<JITVars> m_jit_vars;
+ //ValueObjectConstResultSP m_valojb_sp;
+ lldb::ValueObjectSP m_valojb_sp;
+
+private:
+ DISALLOW_COPY_AND_ASSIGN (ClangExpressionVariable);
};
//----------------------------------------------------------------------
/// @class ClangExpressionVariableListBase ClangExpressionVariable.h "lldb/Expression/ClangExpressionVariable.h"
-/// @brief Manages variables that the expression parser uses.
+/// @brief A list of variable references.
///
-/// The expression parser uses variable lists in various contexts, as
-/// discuessed at ClangExpressionVariable. This abstract class contains
-/// the basic functions for managing a list of variables. Its subclasses
-/// store pointers to variables or variables, depending on whether they
-/// are backing stores or merely transient repositories.
+/// This class stores variables internally, acting as the permanent store.
//----------------------------------------------------------------------
-class ClangExpressionVariableListBase
+class ClangExpressionVariableList
{
public:
//----------------------------------------------------------------------
- /// Return the number of variables in the list
- //----------------------------------------------------------------------
- virtual uint64_t Size() = 0;
-
- //----------------------------------------------------------------------
- /// Return the variable at the given index in the list
+ /// Implementation of methods in ClangExpressionVariableListBase
//----------------------------------------------------------------------
- virtual ClangExpressionVariable &VariableAtIndex(uint64_t index) = 0;
+ virtual size_t
+ GetSize()
+ {
+ return m_variables.size();
+ }
- //----------------------------------------------------------------------
- /// Add a new variable and return its index
- //----------------------------------------------------------------------
- virtual uint64_t AddVariable(ClangExpressionVariable& var) = 0;
+ virtual lldb::ClangExpressionVariableSP
+ GetVariableAtIndex(size_t index)
+ {
+ lldb::ClangExpressionVariableSP var_sp;
+ if (index < m_variables.size())
+ var_sp = m_variables[index];
+ return var_sp;
+ }
+ virtual size_t
+ AddVariable (const lldb::ClangExpressionVariableSP &var_sp)
+ {
+ m_variables.push_back(var_sp);
+ return m_variables.size() - 1;
+ }
+
//----------------------------------------------------------------------
/// Finds a variable by name in the list.
///
@@ -235,15 +256,36 @@
/// @return
/// The variable requested, or NULL if that variable is not in the list.
//----------------------------------------------------------------------
- ClangExpressionVariable *GetVariable (const ConstString &name)
+ lldb::ClangExpressionVariableSP
+ GetVariable (const ConstString &name)
{
- for (uint64_t index = 0, size = Size(); index < size; ++index)
+ lldb::ClangExpressionVariableSP var_sp;
+ for (size_t index = 0, size = GetSize(); index < size; ++index)
{
- ClangExpressionVariable &candidate (VariableAtIndex(index));
- if (candidate.m_name == name)
- return &candidate;
+ var_sp = GetVariableAtIndex(index);
+ if (var_sp->GetName() == name)
+ return var_sp;
}
- return NULL;
+ var_sp.reset();
+ return var_sp;
+ }
+
+ lldb::ClangExpressionVariableSP
+ GetVariable (const char *name)
+ {
+ lldb::ClangExpressionVariableSP var_sp;
+ if (name && name[0])
+ {
+ for (size_t index = 0, size = GetSize(); index < size; ++index)
+ {
+ var_sp = GetVariableAtIndex(index);
+ const char *var_name_cstr = var_sp->GetName().GetCString();
+ if (::strcmp (var_name_cstr, name) == 0)
+ return var_sp;
+ }
+ var_sp.reset();
+ }
+ return var_sp;
}
//----------------------------------------------------------------------
@@ -255,98 +297,60 @@
/// @return
/// The variable requested, or NULL if that variable is not in the list.
//----------------------------------------------------------------------
- ClangExpressionVariable *GetVariable (const clang::NamedDecl *decl)
+ lldb::ClangExpressionVariableSP
+ GetVariable (const clang::NamedDecl *decl)
{
- for (uint64_t index = 0, size = Size(); index < size; ++index)
+ lldb::ClangExpressionVariableSP var_sp;
+ for (size_t index = 0, size = GetSize(); index < size; ++index)
{
- ClangExpressionVariable &candidate (VariableAtIndex(index));
- if (candidate.m_parser_vars.get() &&
- candidate.m_parser_vars->m_named_decl == decl)
- return &candidate;
+ var_sp = GetVariableAtIndex(index);
+ if (var_sp->m_parser_vars.get() && var_sp->m_parser_vars->m_named_decl == decl)
+ return var_sp;
}
- return NULL;
- }
-};
-
-//----------------------------------------------------------------------
-/// @class ClangExpressionVariableListBase ClangExpressionVariable.h "lldb/Expression/ClangExpressionVariable.h"
-/// @brief A list of variable references.
-///
-/// This class stores variables internally, acting as the permanent store.
-//----------------------------------------------------------------------
-class ClangExpressionVariableStore : public ClangExpressionVariableListBase
-{
-public:
- //----------------------------------------------------------------------
- /// Implementation of methods in ClangExpressionVariableListBase
- //----------------------------------------------------------------------
- uint64_t Size()
- {
- return m_variables.size();
- }
-
- ClangExpressionVariable &VariableAtIndex(uint64_t index)
- {
- return m_variables[index];
+ var_sp.reset();
+ return var_sp;
}
-
- uint64_t AddVariable(ClangExpressionVariable &var)
- {
- m_variables.push_back(var);
- return m_variables.size() - 1;
- }
-
+
//----------------------------------------------------------------------
/// Create a new variable in the list and return its index
//----------------------------------------------------------------------
- uint64_t CreateVariable()
+ lldb::ClangExpressionVariableSP
+ CreateVariable (lldb::ByteOrder byte_order, uint32_t addr_byte_size)
{
- uint64_t index = m_variables.size();
-
- m_variables.push_back(ClangExpressionVariable());
- m_variables[index].m_store = this;
- m_variables[index].m_index = index;
-
- return index;
+ lldb::ClangExpressionVariableSP var_sp(new ClangExpressionVariable(byte_order, addr_byte_size));
+ m_variables.push_back(var_sp);
+ return var_sp;
}
-private:
- std::vector <ClangExpressionVariable> m_variables;
-};
-
-//----------------------------------------------------------------------
-/// @class ClangExpressionVariableListBase ClangExpressionVariable.h "lldb/Expression/ClangExpressionVariable.h"
-/// @brief A list of variable references.
-///
-/// This class stores references to variables stored elsewhere.
-//----------------------------------------------------------------------
-class ClangExpressionVariableList : public ClangExpressionVariableListBase
-{
-public:
- //----------------------------------------------------------------------
- /// Implementation of methods in ClangExpressionVariableListBase
- //----------------------------------------------------------------------
- uint64_t Size()
+
+ lldb::ClangExpressionVariableSP
+ CreateVariable(const lldb::ValueObjectSP &valobj_sp)
{
- return m_references.size();
+ lldb::ClangExpressionVariableSP var_sp(new ClangExpressionVariable(valobj_sp));
+ m_variables.push_back(var_sp);
+ return var_sp;
}
- ClangExpressionVariable &VariableAtIndex(uint64_t index)
- {
- return m_references[index].first->VariableAtIndex(m_references[index].second);
- }
- uint64_t AddVariable(ClangExpressionVariable &var)
+
+ lldb::ClangExpressionVariableSP
+ CreateVariable (const ConstString &name,
+ const TypeFromUser& user_type,
+ lldb::ByteOrder byte_order,
+ uint32_t addr_byte_size)
{
- m_references.push_back(ClangExpressionVariableRef(var.m_store, var.m_index));
- return m_references.size() - 1;
+ lldb::ClangExpressionVariableSP var_sp(new ClangExpressionVariable(byte_order, addr_byte_size));
+ var_sp->SetName (name);
+ var_sp->SetClangType (user_type.GetOpaqueQualType());
+ var_sp->SetClangAST (user_type.GetASTContext());
+ m_variables.push_back(var_sp);
+ return var_sp;
}
-private:
- typedef std::pair <ClangExpressionVariableStore *, uint64_t>
- ClangExpressionVariableRef;
- std::vector <ClangExpressionVariableRef> m_references;
+private:
+ std::vector <lldb::ClangExpressionVariableSP> m_variables;
};
+
} // namespace lldb_private
#endif // liblldb_ClangExpressionVariable_h_
Modified: lldb/trunk/include/lldb/Expression/ClangFunction.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/ClangFunction.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/ClangFunction.h (original)
+++ lldb/trunk/include/lldb/Expression/ClangFunction.h Mon Dec 13 20:59:59 2010
@@ -264,7 +264,7 @@
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
- static Process::ExecutionResults
+ static lldb::ExecutionResults
ExecuteFunction (ExecutionContext &exe_ctx,
lldb::addr_t function_address,
lldb::addr_t &void_arg,
@@ -294,7 +294,7 @@
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
- Process::ExecutionResults
+ lldb::ExecutionResults
ExecuteFunction(ExecutionContext &exe_ctx,
Stream &errors,
Value &results);
@@ -320,7 +320,7 @@
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
- Process::ExecutionResults
+ lldb::ExecutionResults
ExecuteFunction(ExecutionContext &exe_ctx,
Stream &errors, bool stop_others,
Value &results);
@@ -350,7 +350,7 @@
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
- Process::ExecutionResults
+ lldb::ExecutionResults
ExecuteFunction(ExecutionContext &exe_ctx,
Stream &errors,
uint32_t single_thread_timeout_usec,
@@ -390,7 +390,7 @@
/// @return
/// Returns one of the ExecutionResults enum indicating function call status.
//------------------------------------------------------------------
- Process::ExecutionResults
+ lldb::ExecutionResults
ExecuteFunction(ExecutionContext &exe_ctx,
lldb::addr_t *args_addr_ptr,
Stream &errors,
@@ -555,7 +555,7 @@
/// Return the object that the parser should use when registering
/// local variables. May be NULL if the Expression doesn't care.
//------------------------------------------------------------------
- ClangExpressionVariableStore *
+ ClangExpressionVariableList *
LocalVariables ()
{
return NULL;
Modified: lldb/trunk/include/lldb/Expression/ClangPersistentVariables.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/ClangPersistentVariables.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/ClangPersistentVariables.h (original)
+++ lldb/trunk/include/lldb/Expression/ClangPersistentVariables.h Mon Dec 13 20:59:59 2010
@@ -23,29 +23,36 @@
/// ClangPersistentVariable for more discussion. Also provides an increasing,
/// 0-based counter for naming result variables.
//----------------------------------------------------------------------
-class ClangPersistentVariables : public ClangExpressionVariableStore
+class ClangPersistentVariables : public ClangExpressionVariableList
{
public:
- //----------------------------------------------------------------------
- /// Return the next entry in the sequence of strings "$0", "$1", ... for use
- /// naming result variables.
- ///
- /// @param[in] name
- /// A string to place the variable name in.
- //----------------------------------------------------------------------
- void
- GetNextResultName (ConstString &name);
//----------------------------------------------------------------------
/// Constructor
//----------------------------------------------------------------------
ClangPersistentVariables ();
- bool
- CreatePersistentVariable (const ConstString &name,
- TypeFromUser user_type);
+ lldb::ClangExpressionVariableSP
+ CreatePersistentVariable (const lldb::ValueObjectSP &valobj_sp);
+
+ lldb::ClangExpressionVariableSP
+ CreatePersistentVariable (const ConstString &name,
+ const TypeFromUser& user_type,
+ lldb::ByteOrder byte_order,
+ uint32_t addr_byte_size);
+
+ //----------------------------------------------------------------------
+ /// Return the next entry in the sequence of strings "$0", "$1", ... for
+ /// use naming persistent expression convenience variables.
+ ///
+ /// @return
+ /// A string that contains the next persistent variable name.
+ //----------------------------------------------------------------------
+ ConstString
+ GetNextPersistentVariableName ();
+
private:
- uint64_t m_result_counter; ///< The counter used by GetNextResultName().
+ uint32_t m_next_persistent_variable_id; ///< The counter used by GetNextResultName().
};
}
Modified: lldb/trunk/include/lldb/Expression/ClangUserExpression.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/ClangUserExpression.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/ClangUserExpression.h (original)
+++ lldb/trunk/include/lldb/Expression/ClangUserExpression.h Mon Dec 13 20:59:59 2010
@@ -117,12 +117,12 @@
/// @return
/// A Process::Execution results value.
//------------------------------------------------------------------
- Process::ExecutionResults
+ lldb::ExecutionResults
Execute (Stream &error_stream,
ExecutionContext &exe_ctx,
bool discard_on_error,
ClangUserExpressionSP &shared_ptr_to_me,
- ClangExpressionVariable *&result);
+ lldb::ClangExpressionVariableSP &result);
ThreadPlan *
GetThreadPlanToExecuteJITExpression (Stream &error_stream,
@@ -130,7 +130,7 @@
bool
FinalizeJITExecution (Stream &error_stream,
ExecutionContext &exe_ctx,
- ClangExpressionVariable *&result);
+ lldb::ClangExpressionVariableSP &result);
//------------------------------------------------------------------
/// Return the string that the parser should parse. Must be a full
@@ -176,7 +176,7 @@
/// Return the object that the parser should use when registering
/// local variables. May be NULL if the Expression doesn't care.
//------------------------------------------------------------------
- ClangExpressionVariableStore *
+ ClangExpressionVariableList *
LocalVariables ()
{
return m_local_variables.get();
@@ -239,7 +239,7 @@
/// @result
/// A Process::ExecutionResults value. eExecutionCompleted for success.
//------------------------------------------------------------------
- static Process::ExecutionResults
+ static lldb::ExecutionResults
Evaluate (ExecutionContext &exe_ctx,
bool discard_on_error,
const char *expr_cstr,
@@ -266,7 +266,7 @@
TypeFromUser m_desired_type; ///< The type to coerce the expression's result to. If NULL, inferred from the expression.
std::auto_ptr<ClangExpressionDeclMap> m_expr_decl_map; ///< The map to use when parsing and materializing the expression.
- std::auto_ptr<ClangExpressionVariableStore> m_local_variables; ///< The local expression variables, if the expression is DWARF.
+ std::auto_ptr<ClangExpressionVariableList> m_local_variables; ///< The local expression variables, if the expression is DWARF.
std::auto_ptr<StreamString> m_dwarf_opcodes; ///< The DWARF opcodes for the expression. May be NULL.
lldb::addr_t m_jit_addr; ///< The address of the JITted code. LLDB_INVALID_ADDRESS if invalid.
Modified: lldb/trunk/include/lldb/Expression/ClangUtilityFunction.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/ClangUtilityFunction.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/ClangUtilityFunction.h (original)
+++ lldb/trunk/include/lldb/Expression/ClangUtilityFunction.h Mon Dec 13 20:59:59 2010
@@ -136,7 +136,7 @@
/// Return the object that the parser should use when registering
/// local variables. May be NULL if the Expression doesn't care.
//------------------------------------------------------------------
- ClangExpressionVariableStore *
+ ClangExpressionVariableList *
LocalVariables ()
{
return NULL;
Modified: lldb/trunk/include/lldb/Expression/IRToDWARF.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/IRToDWARF.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/IRToDWARF.h (original)
+++ lldb/trunk/include/lldb/Expression/IRToDWARF.h Mon Dec 13 20:59:59 2010
@@ -13,19 +13,9 @@
#include "llvm/Pass.h"
#include "llvm/PassManager.h"
-namespace llvm {
- class BasicBlock;
- class Module;
-}
-
-namespace lldb_private {
- class ClangExpressionVariableStore;
- class ClangExpressionDeclMap;
- class StreamString;
-}
+#include "lldb/lldb-include.h"
class Relocator;
-
//----------------------------------------------------------------------
/// @class IRToDWARF IRToDWARF.h "lldb/Expression/IRToDWARF.h"
/// @brief Transforms the IR for a function into a DWARF location expression
@@ -64,7 +54,7 @@
/// @param[in] func_name
/// The name of the function to translate to DWARF.
//------------------------------------------------------------------
- IRToDWARF(lldb_private::ClangExpressionVariableStore &local_vars,
+ IRToDWARF(lldb_private::ClangExpressionVariableList &local_vars,
lldb_private::ClangExpressionDeclMap *decl_map,
lldb_private::StreamString &strm,
const char* func_name = "$__lldb_expr");
@@ -113,7 +103,7 @@
bool runOnBasicBlock(llvm::BasicBlock &BB, Relocator &Relocator);
std::string m_func_name; ///< The name of the function to translate
- lldb_private::ClangExpressionVariableStore &m_local_vars; ///< The list of local variables to populate while transforming
+ lldb_private::ClangExpressionVariableList &m_local_vars; ///< The list of local variables to populate while transforming
lldb_private::ClangExpressionDeclMap *m_decl_map; ///< The list of external variables
lldb_private::StreamString &m_strm; ///< The stream to write bytecode to
};
Modified: lldb/trunk/include/lldb/Symbol/ClangASTContext.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Symbol/ClangASTContext.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Symbol/ClangASTContext.h (original)
+++ lldb/trunk/include/lldb/Symbol/ClangASTContext.h Mon Dec 13 20:59:59 2010
@@ -522,6 +522,10 @@
lldb::clang_type_t
CreatePointerType (lldb::clang_type_t clang_type);
+ static lldb::clang_type_t
+ CreatePointerType (clang::ASTContext *ast,
+ lldb::clang_type_t clang_type);
+
lldb::clang_type_t
CreateLValueReferenceType (lldb::clang_type_t clang_type);
Modified: lldb/trunk/include/lldb/Target/Process.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/Process.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/Process.h (original)
+++ lldb/trunk/include/lldb/Target/Process.h Mon Dec 13 20:59:59 2010
@@ -266,17 +266,6 @@
eBroadcastInternalStateControlPause = (1<<1),
eBroadcastInternalStateControlResume = (1<<2)
};
-
- // We can execute Thread Plans on one thread with various fall-back modes (try other threads after timeout, etc.)
- // This enum gives the result of thread plan executions.
- typedef enum ExecutionResults
- {
- eExecutionSetupError,
- eExecutionCompleted,
- eExecutionDiscarded,
- eExecutionInterrupted,
- eExecutionTimedOut
- } ExecutionResults;
//------------------------------------------------------------------
/// A notification structure that can be used by clients to listen
@@ -1195,7 +1184,7 @@
lldb::StateType
GetState ();
- ExecutionResults
+ lldb::ExecutionResults
RunThreadPlan (ExecutionContext &exe_ctx,
lldb::ThreadPlanSP &thread_plan_sp,
bool stop_others,
@@ -1205,7 +1194,7 @@
Stream &errors);
static const char *
- ExecutionResultAsCString (ExecutionResults result);
+ ExecutionResultAsCString (lldb::ExecutionResults result);
protected:
friend class CommandObjectProcessLaunch;
@@ -1751,9 +1740,6 @@
lldb::ProcessSP
GetSP ();
- ClangPersistentVariables &
- GetPersistentVariables();
-
protected:
//------------------------------------------------------------------
// Member variables
@@ -1776,7 +1762,6 @@
Listener &m_listener;
BreakpointSiteList m_breakpoint_site_list; ///< This is the list of breakpoint locations we intend
///< to insert in the target.
- ClangPersistentVariables m_persistent_vars; ///< These are the persistent variables associated with this process for the expression parser.
std::auto_ptr<DynamicCheckerFunctions> m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use.
UnixSignals m_unix_signals; /// This is the current signal set for this process.
ConstString m_target_triple;
Modified: lldb/trunk/include/lldb/Target/StackFrame.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/StackFrame.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/StackFrame.h (original)
+++ lldb/trunk/include/lldb/Target/StackFrame.h Mon Dec 13 20:59:59 2010
@@ -96,6 +96,9 @@
VariableList *
GetVariableList (bool get_file_globals);
+ lldb::ValueObjectSP
+ GetValueForVariableExpressionPath (const char *var_expr);
+
bool
HasDebugInformation ();
Modified: lldb/trunk/include/lldb/Target/Target.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/Target.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Target/Target.h (original)
+++ lldb/trunk/include/lldb/Target/Target.h Mon Dec 13 20:59:59 2010
@@ -446,6 +446,25 @@
const char *
GetExpressionPrefixContentsAsCString ();
+ // Since expressions results can persist beyond the lifetime of a process,
+ // and the const expression results are available after a process is gone,
+ // we provide a way for expressions to be evaluated from the Target itself.
+ // If an expression is going to be run, then it should have a frame filled
+ // in in th execution context.
+ lldb::ExecutionResults
+ EvaluateExpression (const char *expression,
+ StackFrame *frame,
+ bool unwind_on_error,
+ lldb::ValueObjectSP &result_valobj_sp);
+
+ ClangPersistentVariables &
+ GetPersistentVariables()
+ {
+ return m_persistent_variables;
+ }
+
+
+
protected:
friend class lldb::SBTarget;
@@ -467,6 +486,8 @@
lldb::SearchFilterSP m_search_filter_sp;
PathMappingList m_image_search_paths;
std::auto_ptr<ClangASTContext> m_scratch_ast_context_ap;
+ ClangPersistentVariables m_persistent_variables; ///< These are the persistent variables associated with this process for the expression parser.
+
//------------------------------------------------------------------
// Methods.
//------------------------------------------------------------------
Modified: lldb/trunk/include/lldb/lldb-enumerations.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/lldb-enumerations.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/lldb-enumerations.h (original)
+++ lldb/trunk/include/lldb/lldb-enumerations.h Mon Dec 13 20:59:59 2010
@@ -615,6 +615,21 @@
ePathTypePythonDir // Find Python modules (PYTHONPATH) directory
} PathType;
+
+//----------------------------------------------------------------------
+// We can execute ThreadPlans on one thread with various fall-back modes
+// (try other threads after timeout, etc.) This enum gives the result of
+// thread plan executions.
+//----------------------------------------------------------------------
+typedef enum ExecutionResults
+{
+ eExecutionSetupError,
+ eExecutionCompleted,
+ eExecutionDiscarded,
+ eExecutionInterrupted,
+ eExecutionTimedOut
+} ExecutionResults;
+
} // namespace lldb
Modified: lldb/trunk/include/lldb/lldb-forward-rtti.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/lldb-forward-rtti.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/lldb-forward-rtti.h (original)
+++ lldb/trunk/include/lldb/lldb-forward-rtti.h Mon Dec 13 20:59:59 2010
@@ -29,8 +29,10 @@
typedef SharedPtr<lldb_private::BreakpointLocation>::Type BreakpointLocationSP;
typedef SharedPtr<lldb_private::BreakpointResolver>::Type BreakpointResolverSP;
typedef SharedPtr<lldb_private::Broadcaster>::Type BroadcasterSP;
+ typedef SharedPtr<lldb_private::ClangExpressionVariable>::Type ClangExpressionVariableSP;
typedef SharedPtr<lldb_private::CommandObject>::Type CommandObjectSP;
typedef SharedPtr<lldb_private::Communication>::Type CommunicationSP;
+ typedef SharedPtr<lldb_private::Connection>::Type ConnectionSP;
typedef SharedPtr<lldb_private::CompileUnit>::Type CompUnitSP;
typedef SharedPtr<lldb_private::DataBuffer>::Type DataBufferSP;
typedef SharedPtr<lldb_private::Debugger>::Type DebuggerSP;
Modified: lldb/trunk/include/lldb/lldb-forward.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/lldb-forward.h?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/include/lldb/lldb-forward.h (original)
+++ lldb/trunk/include/lldb/lldb-forward.h Mon Dec 13 20:59:59 2010
@@ -47,7 +47,7 @@
class ClangExpressionDeclMap;
class ClangExpressionVariable;
class ClangExpressionVariableList;
-class ClangExpressionVariableStore;
+class ClangExpressionVariableList;
class CommandInterpreter;
class CommandObject;
class CommandReturnObject;
Modified: lldb/trunk/source/API/SBFrame.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBFrame.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/API/SBFrame.cpp (original)
+++ lldb/trunk/source/API/SBFrame.cpp Mon Dec 13 20:59:59 2010
@@ -570,16 +570,10 @@
if (m_opaque_sp)
{
- ExecutionContext exe_ctx;
- m_opaque_sp->CalculateExecutionContext (exe_ctx);
-
- const char *prefix = NULL;
- const bool discard_on_error = true;
-
- if (exe_ctx.target)
- prefix = exe_ctx.target->GetExpressionPrefixContentsAsCString();
-
- ClangUserExpression::Evaluate (exe_ctx, discard_on_error, expr, prefix, *expr_result);
+ lldb::ExecutionResults exe_results;
+ const bool unwind_on_error = true;
+
+ exe_results = m_opaque_sp->GetThread().GetProcess().GetTarget().EvaluateExpression(expr, m_opaque_sp.get(), unwind_on_error, *expr_result);
}
if (expr_log)
Modified: lldb/trunk/source/Commands/CommandObjectExpression.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Commands/CommandObjectExpression.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Commands/CommandObjectExpression.cpp (original)
+++ lldb/trunk/source/Commands/CommandObjectExpression.cpp Mon Dec 13 20:59:59 2010
@@ -232,55 +232,55 @@
CommandReturnObject *result
)
{
- if (!m_exe_ctx.process)
- {
- error_stream.Printf ("Execution context doesn't contain a process\n");
- return false;
- }
-
- const char *prefix = NULL;
-
if (m_exe_ctx.target)
- prefix = m_exe_ctx.target->GetExpressionPrefixContentsAsCString();
-
- lldb::ValueObjectSP result_valobj_sp;
- Process::ExecutionResults execution_results = ClangUserExpression::Evaluate (m_exe_ctx, m_options.unwind_on_error, expr, prefix, result_valobj_sp);
- assert (result_valobj_sp.get());
- if (result_valobj_sp->GetError().Success())
{
- if (m_options.format != eFormatDefault)
- result_valobj_sp->SetFormat (m_options.format);
+ lldb::ValueObjectSP result_valobj_sp;
- ValueObject::DumpValueObject (output_stream,
- m_exe_ctx.GetBestExecutionContextScope(),
- result_valobj_sp.get(), // Variable object to dump
- result_valobj_sp->GetName().AsCString(),// Root object name
- 0, // Pointer depth to traverse (zero means stop at pointers)
- 0, // Current depth, this is the top most, so zero...
- UINT32_MAX, // Max depth to go when dumping concrete types, dump everything...
- m_options.show_types, // Show types when dumping?
- false, // Show locations of variables, no since this is a host address which we don't care to see
- m_options.print_object, // Print the objective C object?
- true, // Scope is already checked. Const results are always in scope.
- false); // Don't flatten output
- if (result)
- result->SetStatus (eReturnStatusSuccessFinishResult);
- }
- else
- {
- error_stream.PutCString(result_valobj_sp->GetError().AsCString());
- // If we've been interrupted, display state information.
- if (execution_results == Process::eExecutionInterrupted && !m_options.unwind_on_error)
+ lldb::ExecutionResults exe_results;
+ exe_results = m_exe_ctx.target->EvaluateExpression(expr, m_exe_ctx.frame, m_options.unwind_on_error, result_valobj_sp);
+
+ if (exe_results == eExecutionInterrupted && !m_options.unwind_on_error)
{
if (m_exe_ctx.thread)
lldb_private::DisplayThreadInfo (m_interpreter, result->GetOutputStream(), m_exe_ctx.thread, false, true);
else
- {
lldb_private::DisplayThreadsInfo (m_interpreter, &m_exe_ctx, *result, true, true);
+ }
+
+ if (result_valobj_sp)
+ {
+ if (result_valobj_sp->GetError().Success())
+ {
+ if (m_options.format != eFormatDefault)
+ result_valobj_sp->SetFormat (m_options.format);
+
+ ValueObject::DumpValueObject (output_stream,
+ m_exe_ctx.GetBestExecutionContextScope(),
+ result_valobj_sp.get(), // Variable object to dump
+ result_valobj_sp->GetName().GetCString(),// Root object name
+ 0, // Pointer depth to traverse (zero means stop at pointers)
+ 0, // Current depth, this is the top most, so zero...
+ UINT32_MAX, // Max depth to go when dumping concrete types, dump everything...
+ m_options.show_types, // Show types when dumping?
+ false, // Show locations of variables, no since this is a host address which we don't care to see
+ m_options.print_object, // Print the objective C object?
+ true, // Scope is already checked. Const results are always in scope.
+ false); // Don't flatten output
+ if (result)
+ result->SetStatus (eReturnStatusSuccessFinishResult);
+ }
+ else
+ {
+ error_stream.PutCString(result_valobj_sp->GetError().AsCString());
+ if (result)
+ result->SetStatus (eReturnStatusFailed);
}
}
- if (result)
- result->SetStatus (eReturnStatusFailed);
+ }
+ else
+ {
+ error_stream.Printf ("error: invalid execution context for expression\n");
+ return false;
}
return true;
Modified: lldb/trunk/source/Core/Communication.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Communication.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Core/Communication.cpp (original)
+++ lldb/trunk/source/Core/Communication.cpp Mon Dec 13 20:59:59 2010
@@ -27,7 +27,7 @@
//----------------------------------------------------------------------
Communication::Communication(const char *name) :
Broadcaster (name),
- m_connection_ap (),
+ m_connection_sp (),
m_read_thread (LLDB_INVALID_HOST_THREAD),
m_read_thread_enabled (false),
m_bytes(),
@@ -65,8 +65,9 @@
{
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::BytesAvailable (timeout_usec = %u)", this, timeout_usec);
- if (m_connection_ap.get())
- return m_connection_ap->BytesAvailable (timeout_usec, error_ptr);
+ lldb::ConnectionSP connection_sp (m_connection_sp);
+ if (connection_sp.get())
+ return connection_sp->BytesAvailable (timeout_usec, error_ptr);
if (error_ptr)
error_ptr->SetErrorString("Invalid connection.");
return eConnectionStatusNoConnection;
@@ -79,8 +80,9 @@
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::Connect (url = %s)", this, url);
- if (m_connection_ap.get())
- return m_connection_ap->Connect (url, error_ptr);
+ lldb::ConnectionSP connection_sp (m_connection_sp);
+ if (connection_sp.get())
+ return connection_sp->Connect (url, error_ptr);
if (error_ptr)
error_ptr->SetErrorString("Invalid connection.");
return eConnectionStatusNoConnection;
@@ -91,10 +93,11 @@
{
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::Disconnect ()", this);
- if (m_connection_ap.get())
+ lldb::ConnectionSP connection_sp (m_connection_sp);
+ if (connection_sp.get())
{
- ConnectionStatus status = m_connection_ap->Disconnect (error_ptr);
- // We currently don't protect m_connection_ap with any mutex for
+ ConnectionStatus status = connection_sp->Disconnect (error_ptr);
+ // We currently don't protect connection_sp with any mutex for
// multi-threaded environments. So lets not nuke our connection class
// without putting some multi-threaded protections in. We also probably
// don't want to pay for the overhead it might cause if every time we
@@ -103,7 +106,7 @@
// This auto_ptr will cleanup after itself when this object goes away,
// so there is no need to currently have it destroy itself immediately
// upon disconnnect.
- //m_connection_ap.reset();
+ //connection_sp.reset();
return status;
}
return eConnectionStatusNoConnection;
@@ -112,23 +115,28 @@
bool
Communication::IsConnected () const
{
- if (m_connection_ap.get())
- return m_connection_ap->IsConnected ();
+ lldb::ConnectionSP connection_sp (m_connection_sp);
+ if (connection_sp.get())
+ return connection_sp->IsConnected ();
return false;
}
bool
Communication::HasConnection () const
{
- return m_connection_ap.get() != NULL;
+ return m_connection_sp.get() != NULL;
}
size_t
Communication::Read (void *dst, size_t dst_len, uint32_t timeout_usec, ConnectionStatus &status, Error *error_ptr)
{
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
- "%p Communication::Write (dst = %p, dst_len = %zu, timeout_usec = %u) connection = %p",
- this, dst, dst_len, timeout_usec, m_connection_ap.get());
+ "%p Communication::Read (dst = %p, dst_len = %zu, timeout_usec = %u) connection = %p",
+ this,
+ dst,
+ dst_len,
+ timeout_usec,
+ m_connection_sp.get());
if (m_read_thread != LLDB_INVALID_HOST_THREAD)
{
@@ -140,7 +148,7 @@
return cached_bytes;
}
- if (m_connection_ap.get() == NULL)
+ if (m_connection_sp.get() == NULL)
{
if (error_ptr)
error_ptr->SetErrorString("Invalid connection.");
@@ -177,11 +185,12 @@
// We aren't using a read thread, just read the data synchronously in this
// thread.
- if (m_connection_ap.get())
+ lldb::ConnectionSP connection_sp (m_connection_sp);
+ if (connection_sp.get())
{
- status = m_connection_ap->BytesAvailable (timeout_usec, error_ptr);
+ status = connection_sp->BytesAvailable (timeout_usec, error_ptr);
if (status == eConnectionStatusSuccess)
- return m_connection_ap->Read (dst, dst_len, status, error_ptr);
+ return connection_sp->Read (dst, dst_len, status, error_ptr);
}
if (error_ptr)
@@ -194,12 +203,17 @@
size_t
Communication::Write (const void *src, size_t src_len, ConnectionStatus &status, Error *error_ptr)
{
+ lldb::ConnectionSP connection_sp (m_connection_sp);
+
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
- "%p Communication::Write (src = %p, src_len = %zu) connection = %p",
- this, src, src_len, m_connection_ap.get());
+ "%p Communication::Write (src = %p, src_len = %zu) connection = %p",
+ this,
+ src,
+ src_len,
+ connection_sp.get());
- if (m_connection_ap.get())
- return m_connection_ap->Write (src, src_len, status, error_ptr);
+ if (connection_sp.get())
+ return connection_sp->Write (src, src_len, status, error_ptr);
if (error_ptr)
error_ptr->SetErrorString("Invalid connection.");
@@ -294,8 +308,9 @@
size_t
Communication::ReadFromConnection (void *dst, size_t dst_len, ConnectionStatus &status, Error *error_ptr)
{
- if (m_connection_ap.get())
- return m_connection_ap->Read (dst, dst_len, status, error_ptr);
+ lldb::ConnectionSP connection_sp (m_connection_sp);
+ if (connection_sp.get())
+ return connection_sp->Read (dst, dst_len, status, error_ptr);
return 0;
}
@@ -376,7 +391,7 @@
{
StopReadThread(NULL);
Disconnect (NULL);
- m_connection_ap.reset(connection);
+ m_connection_sp.reset(connection);
}
const char *
Modified: lldb/trunk/source/Core/ModuleList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/ModuleList.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Core/ModuleList.cpp (original)
+++ lldb/trunk/source/Core/ModuleList.cpp Mon Dec 13 20:59:59 2010
@@ -13,6 +13,7 @@
// C++ Includes
// Other libraries and framework includes
// Project includes
+#include "lldb/Core/Log.h"
#include "lldb/Core/Module.h"
#include "lldb/Host/Symbols.h"
#include "lldb/Symbol/ObjectFile.h"
@@ -374,6 +375,29 @@
}
}
+void
+ModuleList::LogUUIDAndPaths (LogSP &log_sp, const char *prefix_cstr)
+{
+ if (log_sp)
+ {
+ Mutex::Locker locker(m_modules_mutex);
+ char uuid_cstr[256];
+ collection::const_iterator pos, begin = m_modules.begin(), end = m_modules.end();
+ for (pos = begin; pos != end; ++pos)
+ {
+ Module *module = pos->get();
+ module->GetUUID().GetAsCString (uuid_cstr, sizeof(uuid_cstr));
+ const FileSpec &module_file_spec = module->GetFileSpec();
+ log_sp->Printf ("%s[%u] %s (%s) \"%s/%s\"",
+ prefix_cstr ? prefix_cstr : "",
+ (uint32_t)std::distance (begin, pos),
+ uuid_cstr,
+ module->GetArchitecture().AsCString(),
+ module_file_spec.GetDirectory().GetCString(),
+ module_file_spec.GetFilename().GetCString());
+ }
+ }
+}
bool
ModuleList::ResolveFileAddress (lldb::addr_t vm_addr, Address& so_addr)
Modified: lldb/trunk/source/Core/Value.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Value.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Core/Value.cpp (original)
+++ lldb/trunk/source/Core/Value.cpp Mon Dec 13 20:59:59 2010
@@ -162,34 +162,6 @@
return NULL;
}
-//#include "clang/Lex/LiteralSupport.h"
-//#include "clang/AST/ASTContext.h"
-//#include "clang/Frontend/CompilerInstance.h"
-//
-//Value::Value (const char *data, llvm::CompilerInstance *compiler)
-//{
-// clang::NumericLiteralParser parser(data, data + strlen(data), clang::SourceLocation(),
-// compiler->getPreprocessor());
-// if (parser.had_error)
-// {
-// }
-// else if (parser.isBool)
-// {
-// APInt value;
-// parser.GetIntegerValue(value);
-// }
-// else if (parser.isLong)
-// {
-// }
-// else if (parser.isLongLong)
-// {
-// }
-// else if (parser.isFloat)
-// {
-// }
-//
-//}
-//
void
Value::Dump (Stream* strm)
{
@@ -484,6 +456,34 @@
return eFormatHex;
}
+bool
+Value::GetData (DataExtractor &data)
+{
+ switch (m_value_type)
+ {
+ default:
+ break;
+
+ case eValueTypeScalar:
+ if (m_value.GetData (data))
+ return true;
+ break;
+
+ case eValueTypeLoadAddress:
+ case eValueTypeFileAddress:
+ case eValueTypeHostAddress:
+ if (m_data_buffer.GetByteSize())
+ {
+ data.SetData(m_data_buffer.GetBytes(), m_data_buffer.GetByteSize(), data.GetByteOrder());
+ return true;
+ }
+ break;
+ }
+
+ return false;
+
+}
+
Error
Value::GetValueAsData (ExecutionContext *exe_ctx, clang::ASTContext *ast_context, DataExtractor &data, uint32_t data_offset)
{
Modified: lldb/trunk/source/Core/ValueObject.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/ValueObject.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Core/ValueObject.cpp (original)
+++ lldb/trunk/source/Core/ValueObject.cpp Mon Dec 13 20:59:59 2010
@@ -21,6 +21,7 @@
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObjectChild.h"
+#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectList.h"
#include "lldb/Symbol/ClangASTType.h"
@@ -62,7 +63,8 @@
m_value_is_valid (false),
m_value_did_change (false),
m_children_count_valid (false),
- m_old_value_valid (false)
+ m_old_value_valid (false),
+ m_pointers_point_to_load_addrs (false)
{
}
@@ -281,7 +283,7 @@
bool omit_empty_base_classes = true;
return ClangASTContext::GetIndexOfChildWithName (GetClangAST(),
GetClangType(),
- name.AsCString(),
+ name.GetCString(),
omit_empty_base_classes);
}
@@ -297,7 +299,7 @@
bool omit_empty_base_classes = true;
const size_t num_child_indexes = ClangASTContext::GetIndexOfChildMemberWithName (clang_ast,
clang_type,
- name.AsCString(),
+ name.GetCString(),
omit_empty_base_classes,
child_indexes);
ValueObjectSP child_sp;
@@ -370,7 +372,7 @@
clang_type_t clang_type = GetClangType();
clang_type_t child_clang_type;
child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (clang_ast,
- GetName().AsCString(),
+ GetName().GetCString(),
clang_type,
idx,
transparent_pointers,
@@ -399,6 +401,8 @@
child_bitfield_bit_size,
child_bitfield_bit_offset,
child_is_base_class));
+ if (m_pointers_point_to_load_addrs)
+ valobj_sp->SetPointersPointToLoadAddrs (m_pointers_point_to_load_addrs);
}
return valobj_sp;
}
@@ -418,8 +422,8 @@
StreamString sstr;
clang_type_t elem_or_pointee_clang_type;
const Flags type_flags (ClangASTContext::GetTypeInfo (clang_type,
- GetClangAST(),
- &elem_or_pointee_clang_type));
+ GetClangAST(),
+ &elem_or_pointee_clang_type));
if (type_flags.AnySet (ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer) &&
ClangASTContext::IsCharType (elem_or_pointee_clang_type))
@@ -721,6 +725,10 @@
}
break;
}
+
+ if (m_pointers_point_to_load_addrs)
+ address_type = eAddressTypeLoad;
+
return address;
}
@@ -956,7 +964,7 @@
}
else
{
- const char *name = GetName().AsCString();
+ const char *name = GetName().GetCString();
if (name)
s.PutCString(name);
}
@@ -1001,7 +1009,7 @@
// Always show the type for the top level items.
if (show_types || curr_depth == 0)
- s.Printf("(%s) ", valobj->GetTypeName().AsCString());
+ s.Printf("(%s) ", valobj->GetTypeName().AsCString("<invalid type>"));
if (flat_output)
@@ -1163,3 +1171,197 @@
}
}
+
+ValueObjectSP
+ValueObject::CreateConstantValue (ExecutionContextScope *exe_scope, const ConstString &name)
+{
+ ValueObjectSP valobj_sp;
+
+ if (UpdateValueIfNeeded(exe_scope) && m_error.Success())
+ {
+ ExecutionContext exe_ctx;
+ exe_scope->CalculateExecutionContext(exe_ctx);
+
+ clang::ASTContext *ast = GetClangAST ();
+
+ DataExtractor data;
+ data.SetByteOrder (m_data.GetByteOrder());
+ data.SetAddressByteSize(m_data.GetAddressByteSize());
+
+ m_error = m_value.GetValueAsData (&exe_ctx, ast, data, 0);
+
+ valobj_sp.reset (new ValueObjectConstResult (ast,
+ GetClangType(),
+ name,
+ data));
+ }
+ else
+ {
+ valobj_sp.reset (new ValueObjectConstResult (m_error));
+ }
+ return valobj_sp;
+}
+
+lldb::ValueObjectSP
+ValueObject::Dereference (ExecutionContextScope *exe_scope, Error *error_ptr)
+{
+ lldb::ValueObjectSP valobj_sp;
+ if (IsPointerType())
+ {
+ bool omit_empty_base_classes = true;
+
+ std::string child_name_str;
+ uint32_t child_byte_size = 0;
+ int32_t child_byte_offset = 0;
+ uint32_t child_bitfield_bit_size = 0;
+ uint32_t child_bitfield_bit_offset = 0;
+ bool child_is_base_class = false;
+ const bool transparent_pointers = false;
+ clang::ASTContext *clang_ast = GetClangAST();
+ clang_type_t clang_type = GetClangType();
+ clang_type_t child_clang_type;
+ child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (clang_ast,
+ GetName().GetCString(),
+ clang_type,
+ 0,
+ transparent_pointers,
+ omit_empty_base_classes,
+ child_name_str,
+ child_byte_size,
+ child_byte_offset,
+ child_bitfield_bit_size,
+ child_bitfield_bit_offset,
+ child_is_base_class);
+ if (child_clang_type)
+ {
+ ConstString child_name;
+ if (!child_name_str.empty())
+ child_name.SetCString (child_name_str.c_str());
+
+ valobj_sp.reset (new ValueObjectChild (this,
+ clang_ast,
+ child_clang_type,
+ child_name,
+ child_byte_size,
+ child_byte_offset,
+ child_bitfield_bit_size,
+ child_bitfield_bit_offset,
+ child_is_base_class));
+ }
+ }
+ else
+ {
+ if (error_ptr)
+ error_ptr->SetErrorString("can't dereference a non-pointer value");
+ }
+
+ return valobj_sp;
+}
+
+
+
+//lldb::ValueObjectSP
+//ValueObject::Dereference (ExecutionContextScope *exe_scope, Error *error_ptr)
+//{
+// lldb::ValueObjectSP valobj_sp;
+// if (IsPointerType())
+// {
+// UpdateValueIfNeeded(exe_scope);
+// if (m_error.Success())
+// {
+// lldb::AddressType address_type = eAddressTypeInvalid;
+// const bool scalar_is_load_address = true;
+// lldb::addr_t addr = GetPointerValue (address_type, scalar_is_load_address);
+// if (addr != LLDB_INVALID_ADDRESS)
+// {
+// switch (address_type)
+// {
+// case eAddressTypeInvalid:
+// if (error_ptr)
+// error_ptr->SetErrorString("value is not in memory");
+// break;
+// case eAddressTypeFile:
+// case eAddressTypeLoad:
+// case eAddressTypeHost:
+// {
+// clang::ASTContext *ast = GetClangAST();
+// clang_type_t clang_type = ClangASTType::GetPointeeType (GetClangType());
+// if (ast && clang_type)
+// {
+// std::string name (1, '*');
+// name.append (m_name.AsCString(""));
+// valobj_sp.reset (new ValueObjectConstResult (ast,
+// ClangASTContext::CreatePointerType (ast, clang_type),
+// ConstString (name.c_str()),
+// addr,
+// address_type,
+// m_data.GetAddressByteSize()));
+// }
+// else
+// {
+// if (error_ptr)
+// error_ptr->SetErrorString("invalid clang type info");
+// }
+// }
+// break;
+// }
+// }
+// else
+// {
+// if (error_ptr)
+// error_ptr->SetErrorString("failed to extract pointer value");
+// }
+// }
+// else
+// {
+// if (error_ptr)
+// *error_ptr = m_error;
+// }
+// }
+// else
+// {
+// if (error_ptr)
+// error_ptr->SetErrorString("can't dereference a non-pointer value");
+// }
+//
+// return valobj_sp;
+//}
+
+lldb::ValueObjectSP
+ValueObject::AddressOf ()
+{
+ lldb::ValueObjectSP valobj_sp;
+
+ lldb::AddressType address_type = eAddressTypeInvalid;
+ const bool scalar_is_load_address = false;
+ lldb::addr_t addr = GetAddressOf (address_type, scalar_is_load_address);
+ if (addr != LLDB_INVALID_ADDRESS)
+ {
+ switch (address_type)
+ {
+ case eAddressTypeInvalid:
+ break;
+ case eAddressTypeFile:
+ case eAddressTypeLoad:
+ case eAddressTypeHost:
+ {
+ clang::ASTContext *ast = GetClangAST();
+ clang_type_t clang_type = GetClangType();
+ if (ast && clang_type)
+ {
+ std::string name (1, '&');
+ name.append (m_name.AsCString(""));
+ valobj_sp.reset (new ValueObjectConstResult (ast,
+ ClangASTContext::CreatePointerType (ast, clang_type),
+ ConstString (name.c_str()),
+ addr,
+ address_type,
+ m_data.GetAddressByteSize()));
+ }
+ }
+ break;
+ }
+ }
+ return valobj_sp;
+}
+
Modified: lldb/trunk/source/Core/ValueObjectChild.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/ValueObjectChild.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Core/ValueObjectChild.cpp (original)
+++ lldb/trunk/source/Core/ValueObjectChild.cpp Mon Dec 13 20:59:59 2010
@@ -125,7 +125,8 @@
else
{
m_value.GetScalar() += m_byte_offset;
- if (value_type == Value::eValueTypeScalar ||
+ if (m_pointers_point_to_load_addrs ||
+ value_type == Value::eValueTypeScalar ||
value_type == Value::eValueTypeFileAddress)
m_value.SetValueType (Value::eValueTypeLoadAddress);
}
Modified: lldb/trunk/source/Core/ValueObjectConstResult.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/ValueObjectConstResult.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Core/ValueObjectConstResult.cpp (original)
+++ lldb/trunk/source/Core/ValueObjectConstResult.cpp Mon Dec 13 20:59:59 2010
@@ -28,6 +28,45 @@
ValueObjectConstResult::ValueObjectConstResult
(
+ ByteOrder byte_order,
+ uint32_t addr_byte_size
+) :
+ ValueObject (NULL),
+ m_clang_ast (NULL),
+ m_type_name (),
+ m_byte_size (0)
+{
+ SetIsConstant ();
+ SetValueIsValid(true);
+ m_data.SetByteOrder(byte_order);
+ m_data.SetAddressByteSize(addr_byte_size);
+ m_pointers_point_to_load_addrs = true;
+}
+
+ValueObjectConstResult::ValueObjectConstResult
+(
+ clang::ASTContext *clang_ast,
+ void *clang_type,
+ const ConstString &name,
+ const DataExtractor &data
+) :
+ ValueObject (NULL),
+ m_clang_ast (clang_ast),
+ m_type_name (),
+ m_byte_size (0)
+{
+ m_data = data;
+ m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
+ m_value.SetValueType(Value::eValueTypeHostAddress);
+ m_value.SetContext(Value::eContextTypeClangType, clang_type);
+ m_name = name;
+ SetIsConstant ();
+ SetValueIsValid(true);
+ m_pointers_point_to_load_addrs = true;
+}
+
+ValueObjectConstResult::ValueObjectConstResult
+(
clang::ASTContext *clang_ast,
void *clang_type,
const ConstString &name,
@@ -37,7 +76,8 @@
) :
ValueObject (NULL),
m_clang_ast (clang_ast),
- m_type_name ()
+ m_type_name (),
+ m_byte_size (0)
{
m_data.SetByteOrder(data_byte_order);
m_data.SetAddressByteSize(data_addr_size);
@@ -48,15 +88,51 @@
m_name = name;
SetIsConstant ();
SetValueIsValid(true);
+ m_pointers_point_to_load_addrs = true;
+}
+
+ValueObjectConstResult::ValueObjectConstResult
+(
+ clang::ASTContext *clang_ast,
+ void *clang_type,
+ const ConstString &name,
+ lldb::addr_t address,
+ lldb::AddressType address_type,
+ uint8_t addr_byte_size
+) :
+ ValueObject (NULL),
+ m_clang_ast (clang_ast),
+ m_type_name (),
+ m_byte_size (0)
+{
+ m_value.GetScalar() = address;
+ m_data.SetAddressByteSize(addr_byte_size);
+ m_value.GetScalar().GetData (m_data, addr_byte_size);
+ //m_value.SetValueType(Value::eValueTypeHostAddress);
+ switch (address_type)
+ {
+ default:
+ case eAddressTypeInvalid: m_value.SetValueType(Value::eValueTypeScalar); break;
+ case eAddressTypeFile: m_value.SetValueType(Value::eValueTypeFileAddress); break;
+ case eAddressTypeLoad: m_value.SetValueType(Value::eValueTypeLoadAddress); break;
+ case eAddressTypeHost: m_value.SetValueType(Value::eValueTypeHostAddress); break;
+ }
+ m_value.SetContext(Value::eContextTypeClangType, clang_type);
+ m_name = name;
+ SetIsConstant ();
+ SetValueIsValid(true);
+ m_pointers_point_to_load_addrs = true;
}
ValueObjectConstResult::ValueObjectConstResult (const Error& error) :
ValueObject (NULL),
m_clang_ast (NULL),
- m_type_name ()
+ m_type_name (),
+ m_byte_size (0)
{
m_error = error;
SetIsConstant ();
+ m_pointers_point_to_load_addrs = true;
}
ValueObjectConstResult::~ValueObjectConstResult()
@@ -78,8 +154,18 @@
size_t
ValueObjectConstResult::GetByteSize()
{
- // We stored all the data for this const object in our data
- return m_data.GetByteSize();
+ if (m_byte_size == 0)
+ {
+ uint64_t bit_width = ClangASTType::GetClangTypeBitWidth (GetClangAST(), GetClangType());
+ m_byte_size = (bit_width + 7 ) / 8;
+ }
+ return m_byte_size;
+}
+
+void
+ValueObjectConstResult::SetByteSize (size_t size)
+{
+ m_byte_size = size;
}
uint32_t
@@ -105,7 +191,6 @@
void
ValueObjectConstResult::UpdateValue (ExecutionContextScope *exe_scope)
{
- m_error.Clear();
// Const value is always valid
SetValueIsValid (true);
}
Modified: lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp (original)
+++ lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp Mon Dec 13 20:59:59 2010
@@ -59,7 +59,8 @@
DisableStructVars();
}
-void ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx)
+void
+ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx)
{
EnableParserVars();
m_parser_vars->m_exe_ctx = &exe_ctx;
@@ -69,32 +70,35 @@
else if (exe_ctx.thread)
m_parser_vars->m_sym_ctx = exe_ctx.thread->GetStackFrameAtIndex(0)->GetSymbolContext(lldb::eSymbolContextEverything);
- if (exe_ctx.process)
- m_parser_vars->m_persistent_vars = &exe_ctx.process->GetPersistentVariables();
+ if (exe_ctx.target)
+ m_parser_vars->m_persistent_vars = &exe_ctx.target->GetPersistentVariables();
}
-void ClangExpressionDeclMap::DidParse()
+void
+ClangExpressionDeclMap::DidParse()
{
if (m_parser_vars.get())
{
- for (uint64_t entity_index = 0, num_entities = m_found_entities.Size();
+ for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
entity_index < num_entities;
++entity_index)
{
- ClangExpressionVariable &entity(m_found_entities.VariableAtIndex(entity_index));
- if (entity.m_parser_vars.get() &&
- entity.m_parser_vars->m_lldb_value)
- delete entity.m_parser_vars->m_lldb_value;
+ ClangExpressionVariableSP var_sp(m_found_entities.GetVariableAtIndex(entity_index));
+ if (var_sp &&
+ var_sp->m_parser_vars.get() &&
+ var_sp->m_parser_vars->m_lldb_value)
+ delete var_sp->m_parser_vars->m_lldb_value;
- entity.DisableParserVars();
+ var_sp->DisableParserVars();
}
- for (uint64_t pvar_index = 0, num_pvars = m_parser_vars->m_persistent_vars->Size();
+ for (size_t pvar_index = 0, num_pvars = m_parser_vars->m_persistent_vars->GetSize();
pvar_index < num_pvars;
++pvar_index)
{
- ClangExpressionVariable &pvar(m_parser_vars->m_persistent_vars->VariableAtIndex(pvar_index));
- pvar.DisableParserVars();
+ ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
+ if (pvar_sp)
+ pvar_sp->DisableParserVars();
}
DisableParserVars();
@@ -108,10 +112,12 @@
{
assert (m_struct_vars.get());
assert (m_parser_vars.get());
-
if (!m_struct_vars->m_result_name)
- m_parser_vars->m_persistent_vars->GetNextResultName(m_struct_vars->m_result_name);
-
+ {
+ Target *target = m_parser_vars->GetTarget();
+ assert (target);
+ m_struct_vars->m_result_name = target->GetPersistentVariables().GetNextPersistentVariableName();
+ }
return m_struct_vars->m_result_name;
}
@@ -132,18 +138,21 @@
parser_type.GetOpaqueQualType()),
context);
- if (!m_parser_vars->m_persistent_vars->CreatePersistentVariable (name, user_type))
+ if (!m_parser_vars->m_persistent_vars->CreatePersistentVariable (name,
+ user_type,
+ m_parser_vars->m_exe_ctx->process->GetByteOrder(),
+ m_parser_vars->m_exe_ctx->process->GetAddressByteSize()))
return false;
- ClangExpressionVariable *var = m_parser_vars->m_persistent_vars->GetVariable(name);
+ ClangExpressionVariableSP var_sp (m_parser_vars->m_persistent_vars->GetVariable(name));
- if (!var)
+ if (!var_sp)
return false;
- var->EnableParserVars();
+ var_sp->EnableParserVars();
- var->m_parser_vars->m_named_decl = decl;
- var->m_parser_vars->m_parser_type = parser_type;
+ var_sp->m_parser_vars->m_named_decl = decl;
+ var_sp->m_parser_vars->m_parser_type = parser_type;
return true;
}
@@ -168,29 +177,29 @@
if (m_struct_members.GetVariable(decl))
return true;
- ClangExpressionVariable *var = m_found_entities.GetVariable(decl);
+ ClangExpressionVariableSP var_sp (m_found_entities.GetVariable(decl));
- if (!var)
- var = m_parser_vars->m_persistent_vars->GetVariable(decl);
+ if (!var_sp)
+ var_sp = m_parser_vars->m_persistent_vars->GetVariable(decl);
- if (!var)
+ if (!var_sp)
return false;
if (log)
log->Printf("Adding value for decl %p [%s - %s] to the structure",
decl,
name.GetCString(),
- var->m_name.GetCString());
+ var_sp->GetName().GetCString());
// We know entity->m_parser_vars is valid because we used a parser variable
// to find it
- var->m_parser_vars->m_llvm_value = value;
+ var_sp->m_parser_vars->m_llvm_value = value;
- var->EnableJITVars();
- var->m_jit_vars->m_alignment = alignment;
- var->m_jit_vars->m_size = size;
+ var_sp->EnableJITVars();
+ var_sp->m_jit_vars->m_alignment = alignment;
+ var_sp->m_jit_vars->m_size = size;
- m_struct_members.AddVariable(*var);
+ m_struct_members.AddVariable(var_sp);
return true;
}
@@ -208,23 +217,25 @@
m_struct_vars->m_struct_alignment = 0;
m_struct_vars->m_struct_size = 0;
- for (uint64_t member_index = 0, num_members = m_struct_members.Size();
+ for (size_t member_index = 0, num_members = m_struct_members.GetSize();
member_index < num_members;
++member_index)
{
- ClangExpressionVariable &member(m_struct_members.VariableAtIndex(member_index));
-
- if (!member.m_jit_vars.get())
+ ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_index));
+ if (!member_sp)
+ return false;
+
+ if (!member_sp->m_jit_vars.get())
return false;
if (member_index == 0)
- m_struct_vars->m_struct_alignment = member.m_jit_vars->m_alignment;
+ m_struct_vars->m_struct_alignment = member_sp->m_jit_vars->m_alignment;
- if (cursor % member.m_jit_vars->m_alignment)
- cursor += (member.m_jit_vars->m_alignment - (cursor % member.m_jit_vars->m_alignment));
+ if (cursor % member_sp->m_jit_vars->m_alignment)
+ cursor += (member_sp->m_jit_vars->m_alignment - (cursor % member_sp->m_jit_vars->m_alignment));
- member.m_jit_vars->m_offset = cursor;
- cursor += member.m_jit_vars->m_size;
+ member_sp->m_jit_vars->m_offset = cursor;
+ cursor += member_sp->m_jit_vars->m_size;
}
m_struct_vars->m_struct_size = cursor;
@@ -245,7 +256,7 @@
if (!m_struct_vars->m_struct_laid_out)
return false;
- num_elements = m_struct_members.Size();
+ num_elements = m_struct_members.GetSize();
size = m_struct_vars->m_struct_size;
alignment = m_struct_vars->m_struct_alignment;
@@ -267,19 +278,20 @@
if (!m_struct_vars->m_struct_laid_out)
return false;
- if (index >= m_struct_members.Size())
+ if (index >= m_struct_members.GetSize())
return false;
- ClangExpressionVariable &member(m_struct_members.VariableAtIndex(index));
+ ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
- if (!member.m_parser_vars.get() ||
- !member.m_jit_vars.get())
+ if (!member_sp ||
+ !member_sp->m_parser_vars.get() ||
+ !member_sp->m_jit_vars.get())
return false;
- decl = member.m_parser_vars->m_named_decl;
- value = member.m_parser_vars->m_llvm_value;
- offset = member.m_jit_vars->m_offset;
- name = member.m_name;
+ decl = member_sp->m_parser_vars->m_named_decl;
+ value = member_sp->m_parser_vars->m_llvm_value;
+ offset = member_sp->m_jit_vars->m_offset;
+ name = member_sp->GetName();
return true;
}
@@ -292,16 +304,16 @@
uint64_t &ptr
)
{
- ClangExpressionVariable *entity = m_found_entities.GetVariable(decl);
+ ClangExpressionVariableSP entity_sp(m_found_entities.GetVariable(decl));
- if (!entity)
+ if (!entity_sp)
return false;
// We know m_parser_vars is valid since we searched for the variable by
// its NamedDecl
- value = &entity->m_parser_vars->m_llvm_value;
- ptr = entity->m_parser_vars->m_lldb_value->GetScalar().ULongLong();
+ value = &entity_sp->m_parser_vars->m_llvm_value;
+ ptr = entity_sp->m_parser_vars->m_lldb_value->GetScalar().ULongLong();
return true;
}
@@ -453,11 +465,11 @@
ClangExpressionDeclMap::Dematerialize
(
ExecutionContext &exe_ctx,
- ClangExpressionVariable *&result,
+ ClangExpressionVariableSP &result_sp,
Error &err
)
{
- return DoMaterialize(true, exe_ctx, &result, err);
+ return DoMaterialize(true, exe_ctx, &result_sp, err);
DidDematerialize();
}
@@ -527,26 +539,29 @@
DataExtractor extractor(data, exe_ctx.process->GetByteOrder(), exe_ctx.target->GetArchitecture().GetAddressByteSize());
- for (uint64_t member_index = 0, num_members = m_struct_members.Size();
- member_index < num_members;
- ++member_index)
+ for (size_t member_idx = 0, num_members = m_struct_members.GetSize();
+ member_idx < num_members;
+ ++member_idx)
{
- ClangExpressionVariable &member (m_struct_members.VariableAtIndex(member_index));
+ ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_idx));
- s.Printf("[%s]\n", member.m_name.GetCString());
+ if (!member_sp)
+ return false;
+
+ s.Printf("[%s]\n", member_sp->GetName().GetCString());
- if (!member.m_jit_vars.get())
+ if (!member_sp->m_jit_vars.get())
return false;
- extractor.Dump(&s, // stream
- member.m_jit_vars->m_offset, // offset
- lldb::eFormatBytesWithASCII, // format
- 1, // byte size of individual entries
- member.m_jit_vars->m_size, // number of entries
- 16, // entries per line
- m_material_vars->m_materialized_location + member.m_jit_vars->m_offset, // address to print
- 0, // bit size (bitfields only; 0 means ignore)
- 0); // bit alignment (bitfields only; 0 means ignore)
+ extractor.Dump (&s, // stream
+ member_sp->m_jit_vars->m_offset, // offset
+ lldb::eFormatBytesWithASCII, // format
+ 1, // byte size of individual entries
+ member_sp->m_jit_vars->m_size, // number of entries
+ 16, // entries per line
+ m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset, // address to print
+ 0, // bit size (bitfields only; 0 means ignore)
+ 0); // bit alignment (bitfields only; 0 means ignore)
s.PutChar('\n');
}
@@ -559,10 +574,13 @@
(
bool dematerialize,
ExecutionContext &exe_ctx,
- ClangExpressionVariable **result,
+ lldb::ClangExpressionVariableSP *result_sp_ptr,
Error &err
)
{
+ if (result_sp_ptr)
+ result_sp_ptr->reset();
+
assert (m_struct_vars.get());
lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
@@ -579,7 +597,7 @@
return LLDB_INVALID_ADDRESS;
}
- ClangPersistentVariables &persistent_vars = exe_ctx.process->GetPersistentVariables();
+ ClangPersistentVariables &persistent_vars = exe_ctx.target->GetPersistentVariables();
if (!m_struct_vars->m_struct_size)
{
@@ -619,26 +637,20 @@
if (m_material_vars->m_materialized_location % m_struct_vars->m_struct_alignment)
m_material_vars->m_materialized_location += (m_struct_vars->m_struct_alignment - (m_material_vars->m_materialized_location % m_struct_vars->m_struct_alignment));
- for (uint64_t member_index = 0, num_members = m_struct_members.Size();
+ for (uint64_t member_index = 0, num_members = m_struct_members.GetSize();
member_index < num_members;
++member_index)
{
- ClangExpressionVariable &member (m_struct_members.VariableAtIndex(member_index));
-
- ClangExpressionVariable *entity = NULL;
+ ClangExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(member_index));
- /*
- if (member.m_parser_vars.get())
- entity = m_found_entities.GetVariable(member.m_parser_vars->m_named_decl);
- */
-
- entity = m_found_entities.GetVariable(member.m_name);
+ ClangExpressionVariableSP entity_sp (m_found_entities.GetVariable(member_sp->GetName()));
- ClangExpressionVariable *persistent_variable = persistent_vars.GetVariable(member.m_name);
+ ClangExpressionVariableSP persistent_var_sp (persistent_vars.GetVariable(member_sp->GetName()));
- if (entity)
+ if (entity_sp)
{
- if (entity->m_register_info)
+ RegisterInfo *reg_info = entity_sp->GetRegisterInfo ();
+ if (reg_info)
{
// This is a register variable
@@ -647,21 +659,32 @@
if (!reg_ctx)
return false;
- if (!DoMaterializeOneRegister(dematerialize, exe_ctx, *reg_ctx, *entity->m_register_info, m_material_vars->m_materialized_location + member.m_jit_vars->m_offset, err))
+ if (!DoMaterializeOneRegister (dematerialize,
+ exe_ctx,
+ *reg_ctx,
+ *reg_info,
+ m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
+ err))
return false;
}
else
{
- if (!member.m_jit_vars.get())
+ if (!member_sp->m_jit_vars.get())
return false;
- if (!DoMaterializeOneVariable(dematerialize, exe_ctx, sym_ctx, member.m_name, member.m_user_type, m_material_vars->m_materialized_location + member.m_jit_vars->m_offset, err))
+ if (!DoMaterializeOneVariable (dematerialize,
+ exe_ctx,
+ sym_ctx,
+ member_sp->GetName(),
+ member_sp->GetTypeFromUser(),
+ m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
+ err))
return false;
}
}
- else if (persistent_variable)
+ else if (persistent_var_sp)
{
- if (member.m_name == m_struct_vars->m_result_name)
+ if (member_sp->GetName() == m_struct_vars->m_result_name)
{
if (!dematerialize)
continue;
@@ -669,18 +692,23 @@
if (log)
log->PutCString("Found result member in the struct");
- *result = &member;
+ if (result_sp_ptr)
+ *result_sp_ptr = member_sp;
}
if (log)
- log->Printf("Searched for persistent variable %s and found %s", member.m_name.GetCString(), persistent_variable->m_name.GetCString());
+ log->Printf("Searched for persistent variable %s and found %s", member_sp->GetName().GetCString(), persistent_var_sp->GetName().GetCString());
- if (!DoMaterializeOnePersistentVariable(dematerialize, exe_ctx, persistent_variable->m_name, m_material_vars->m_materialized_location + member.m_jit_vars->m_offset, err))
+ if (!DoMaterializeOnePersistentVariable (dematerialize,
+ exe_ctx,
+ persistent_var_sp,
+ m_material_vars->m_materialized_location + member_sp->m_jit_vars->m_offset,
+ err))
return false;
}
else
{
- err.SetErrorStringWithFormat("Unexpected variable %s", member.m_name.GetCString());
+ err.SetErrorStringWithFormat("Unexpected variable %s", member_sp->GetName().GetCString());
return false;
}
}
@@ -693,32 +721,29 @@
(
bool dematerialize,
ExecutionContext &exe_ctx,
- const ConstString &name,
+ ClangExpressionVariableSP &var_sp,
lldb::addr_t addr,
Error &err
)
{
- ClangPersistentVariables &persistent_vars = exe_ctx.process->GetPersistentVariables();
-
- ClangExpressionVariable *pvar(persistent_vars.GetVariable(name));
-
- if (!pvar)
+ if (!var_sp)
{
- err.SetErrorStringWithFormat("Undefined persistent variable %s", name.GetCString());
+ err.SetErrorString("Invalid persistent variable");
return LLDB_INVALID_ADDRESS;
}
- size_t pvar_size = pvar->Size();
+ const size_t pvar_byte_size = var_sp->GetByteSize();
- if (!pvar->m_data_sp.get())
+ uint8_t *pvar_data = var_sp->GetValueBytes();
+ if (pvar_data == NULL)
return false;
- uint8_t *pvar_data = pvar->m_data_sp->GetBytes();
Error error;
if (dematerialize)
{
- if (exe_ctx.process->ReadMemory (addr, pvar_data, pvar_size, error) != pvar_size)
+ var_sp->ValueUpdated ();
+ if (exe_ctx.process->ReadMemory (addr, pvar_data, pvar_byte_size, error) != pvar_byte_size)
{
err.SetErrorStringWithFormat ("Couldn't read a composite type from the target: %s", error.AsCString());
return false;
@@ -726,7 +751,7 @@
}
else
{
- if (exe_ctx.process->WriteMemory (addr, pvar_data, pvar_size, error) != pvar_size)
+ if (exe_ctx.process->WriteMemory (addr, pvar_data, pvar_byte_size, error) != pvar_byte_size)
{
err.SetErrorStringWithFormat ("Couldn't write a composite type to the target: %s", error.AsCString());
return false;
@@ -1201,11 +1226,7 @@
{
clang::NamespaceDecl *clang_namespace_decl = AddNamespace(context, namespace_decl);
if (clang_namespace_decl)
- {
- // TODO: is this how we get the decl lookups to be called for
- // this namespace??
clang_namespace_decl->setHasExternalLexicalStorage();
- }
}
}
}
@@ -1312,12 +1333,12 @@
return;
}
-
- ClangExpressionVariable *pvar(m_parser_vars->m_persistent_vars->GetVariable(name));
+
+ ClangExpressionVariableSP pvar_sp(m_parser_vars->m_persistent_vars->GetVariable(name));
- if (pvar)
+ if (pvar_sp)
{
- AddOneVariable(context, pvar);
+ AddOneVariable(context, pvar_sp);
return;
}
@@ -1493,17 +1514,18 @@
return;
NamedDecl *var_decl = context.AddVarDecl(pt.GetOpaqueQualType());
-
- ClangExpressionVariable &entity(m_found_entities.VariableAtIndex(m_found_entities.CreateVariable()));
std::string decl_name(context.m_decl_name.getAsString());
- entity.m_name.SetCString (decl_name.c_str());
- entity.m_user_type = ut;
-
- entity.EnableParserVars();
- entity.m_parser_vars->m_parser_type = pt;
- entity.m_parser_vars->m_named_decl = var_decl;
- entity.m_parser_vars->m_llvm_value = NULL;
- entity.m_parser_vars->m_lldb_value = var_location;
+ ConstString entity_name(decl_name.c_str());
+ ClangExpressionVariableSP entity(m_found_entities.CreateVariable (entity_name,
+ ut,
+ m_parser_vars->m_exe_ctx->process->GetByteOrder(),
+ m_parser_vars->m_exe_ctx->process->GetAddressByteSize()));
+ assert (entity.get());
+ entity->EnableParserVars();
+ entity->m_parser_vars->m_parser_type = pt;
+ entity->m_parser_vars->m_named_decl = var_decl;
+ entity->m_parser_vars->m_llvm_value = NULL;
+ entity->m_parser_vars->m_lldb_value = var_location;
if (log)
{
@@ -1518,24 +1540,24 @@
void
ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
- ClangExpressionVariable *pvar)
+ ClangExpressionVariableSP &pvar_sp)
{
lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
- TypeFromUser user_type = pvar->m_user_type;
+ TypeFromUser user_type (pvar_sp->GetTypeFromUser());
- TypeFromParser parser_type(GuardedCopyType(context.GetASTContext(),
- user_type.GetASTContext(),
- user_type.GetOpaqueQualType()),
- context.GetASTContext());
+ TypeFromParser parser_type (GuardedCopyType(context.GetASTContext(),
+ user_type.GetASTContext(),
+ user_type.GetOpaqueQualType()),
+ context.GetASTContext());
NamedDecl *var_decl = context.AddVarDecl(parser_type.GetOpaqueQualType());
- pvar->EnableParserVars();
- pvar->m_parser_vars->m_parser_type = parser_type;
- pvar->m_parser_vars->m_named_decl = var_decl;
- pvar->m_parser_vars->m_llvm_value = NULL;
- pvar->m_parser_vars->m_lldb_value = NULL;
+ pvar_sp->EnableParserVars();
+ pvar_sp->m_parser_vars->m_parser_type = parser_type;
+ pvar_sp->m_parser_vars->m_named_decl = var_decl;
+ pvar_sp->m_parser_vars->m_llvm_value = NULL;
+ pvar_sp->m_parser_vars->m_lldb_value = NULL;
if (log)
{
@@ -1544,13 +1566,13 @@
var_decl->print(var_decl_print_stream);
var_decl_print_stream.flush();
- log->Printf("Added pvar %s, returned %s", pvar->m_name.GetCString(), var_decl_print_string.c_str());
+ log->Printf("Added pvar %s, returned %s", pvar_sp->GetName().GetCString(), var_decl_print_string.c_str());
}
}
void
-ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
- const RegisterInfo *reg_info)
+ClangExpressionDeclMap::AddOneRegister (NameSearchContext &context,
+ const RegisterInfo *reg_info)
{
lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
@@ -1564,21 +1586,22 @@
return;
}
- TypeFromParser parser_type(ast_type,
- context.GetASTContext());
+ TypeFromParser parser_type (ast_type,
+ context.GetASTContext());
NamedDecl *var_decl = context.AddVarDecl(parser_type.GetOpaqueQualType());
- ClangExpressionVariable &entity(m_found_entities.VariableAtIndex(m_found_entities.CreateVariable()));
+ ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->process->GetByteOrder(),
+ m_parser_vars->m_exe_ctx->process->GetAddressByteSize()));
+ assert (entity.get());
std::string decl_name(context.m_decl_name.getAsString());
- entity.m_name.SetCString (decl_name.c_str());
- entity.m_register_info = reg_info;
-
- entity.EnableParserVars();
- entity.m_parser_vars->m_parser_type = parser_type;
- entity.m_parser_vars->m_named_decl = var_decl;
- entity.m_parser_vars->m_llvm_value = NULL;
- entity.m_parser_vars->m_lldb_value = NULL;
+ entity->SetName (ConstString (decl_name.c_str()));
+ entity->SetRegisterInfo (reg_info);
+ entity->EnableParserVars();
+ entity->m_parser_vars->m_parser_type = parser_type;
+ entity->m_parser_vars->m_named_decl = var_decl;
+ entity->m_parser_vars->m_llvm_value = NULL;
+ entity->m_parser_vars->m_lldb_value = NULL;
if (log)
{
@@ -1666,15 +1689,18 @@
fun_location->SetValueType(Value::eValueTypeLoadAddress);
fun_location->GetScalar() = load_addr;
- ClangExpressionVariable &entity(m_found_entities.VariableAtIndex(m_found_entities.CreateVariable()));
+ ClangExpressionVariableSP entity(m_found_entities.CreateVariable (m_parser_vars->m_exe_ctx->process->GetByteOrder(),
+ m_parser_vars->m_exe_ctx->process->GetAddressByteSize()));
+ assert (entity.get());
std::string decl_name(context.m_decl_name.getAsString());
- entity.m_name.SetCString(decl_name.c_str());
- entity.m_user_type = TypeFromUser(fun_opaque_type, fun_ast_context);;
-
- entity.EnableParserVars();
- entity.m_parser_vars->m_named_decl = fun_decl;
- entity.m_parser_vars->m_llvm_value = NULL;
- entity.m_parser_vars->m_lldb_value = fun_location.release();
+ entity->SetName(ConstString(decl_name.c_str()));
+ entity->SetClangType (fun_opaque_type);
+ entity->SetClangAST (fun_ast_context);
+
+ entity->EnableParserVars();
+ entity->m_parser_vars->m_named_decl = fun_decl;
+ entity->m_parser_vars->m_llvm_value = NULL;
+ entity->m_parser_vars->m_lldb_value = fun_location.release();
if (log)
{
Modified: lldb/trunk/source/Expression/ClangExpressionParser.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/ClangExpressionParser.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Expression/ClangExpressionParser.cpp (original)
+++ lldb/trunk/source/Expression/ClangExpressionParser.cpp Mon Dec 13 20:59:59 2010
@@ -367,7 +367,7 @@
return err;
}
- ClangExpressionVariableStore *local_variables = m_expr.LocalVariables();
+ ClangExpressionVariableList *local_variables = m_expr.LocalVariables();
ClangExpressionDeclMap *decl_map = m_expr.DeclMap();
if (!local_variables)
Modified: lldb/trunk/source/Expression/ClangExpressionVariable.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/ClangExpressionVariable.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Expression/ClangExpressionVariable.cpp (original)
+++ lldb/trunk/source/Expression/ClangExpressionVariable.cpp Mon Dec 13 20:59:59 2010
@@ -25,116 +25,109 @@
using namespace lldb_private;
using namespace clang;
-ClangExpressionVariable::ClangExpressionVariable() :
- m_name(),
- m_user_type (TypeFromUser(NULL, NULL)),
- m_store (NULL),
- m_register_info (NULL),
- m_index (0),
+ClangExpressionVariable::ClangExpressionVariable(lldb::ByteOrder byte_order, uint32_t addr_byte_size) :
m_parser_vars(),
m_jit_vars (),
- m_data_sp ()
+ m_valojb_sp (new ValueObjectConstResult(byte_order, addr_byte_size))
{
}
-void
-ClangExpressionVariable::DisableDataVars()
+ClangExpressionVariable::ClangExpressionVariable (const lldb::ValueObjectSP &valobj_sp) :
+ m_parser_vars(),
+ m_jit_vars (),
+ m_valojb_sp (valobj_sp)
{
- m_data_sp.reset();
}
+//----------------------------------------------------------------------
+/// Return the variable's size in bytes
+//----------------------------------------------------------------------
+size_t
+ClangExpressionVariable::GetByteSize ()
+{
+ return m_valojb_sp->GetByteSize();
+}
-ClangExpressionVariable::ClangExpressionVariable(const ClangExpressionVariable &rhs) :
- m_name(rhs.m_name),
- m_user_type(rhs.m_user_type),
- m_store(rhs.m_store),
- m_register_info(rhs.m_register_info),
- m_index(rhs.m_index)
+const ConstString &
+ClangExpressionVariable::GetName ()
{
- if (rhs.m_parser_vars.get())
- {
- // TODO: Sean, can m_parser_vars be a shared pointer??? We are copy
- // constructing it here. That is ok if we need to, but do we really
- // need to?
- m_parser_vars.reset(new struct ParserVars);
- *m_parser_vars.get() = *rhs.m_parser_vars.get();
- }
-
- if (rhs.m_jit_vars.get())
- {
- // TODO: Sean, can m_jit_vars be a shared pointer??? We are copy
- // constructing it here. That is ok if we need to, but do we really
- // need to?
- m_jit_vars.reset(new struct JITVars);
- *m_jit_vars.get() = *rhs.m_jit_vars.get();
- }
-
- if (rhs.m_data_sp)
- {
- // TODO: Sean, does m_data_sp need to be copy constructed? Or can it
- // shared the data?
-
- m_data_sp.reset(new DataBufferHeap (rhs.m_data_sp->GetBytes(),
- rhs.m_data_sp->GetByteSize()));
- }
+ return m_valojb_sp->GetName();
+}
+
+lldb::ValueObjectSP
+ClangExpressionVariable::GetValueObject()
+{
+ return m_valojb_sp;
}
-bool
-ClangExpressionVariable::PointValueAtData(Value &value, ExecutionContext *exe_ctx)
+lldb::RegisterInfo *
+ClangExpressionVariable::GetRegisterInfo()
{
- if (m_data_sp.get() == NULL)
- return false;
-
- value.SetContext(Value::eContextTypeClangType, m_user_type.GetOpaqueQualType());
- value.SetValueType(Value::eValueTypeHostAddress);
- value.GetScalar() = (uintptr_t)m_data_sp->GetBytes();
- clang::ASTContext *ast_context = m_user_type.GetASTContext();
-
- if (exe_ctx)
- value.ResolveValue (exe_ctx, ast_context);
-
- return true;
+ return m_valojb_sp->GetValue().GetRegisterInfo();
}
-void
-ClangExpressionVariable::EnableDataVars()
+void
+ClangExpressionVariable::SetRegisterInfo (const lldb::RegisterInfo *reg_info)
{
- if (!m_data_sp.get())
- m_data_sp.reset(new DataBufferHeap);
+ return m_valojb_sp->GetValue().SetContext (Value::eContextTypeRegisterInfo, const_cast<lldb::RegisterInfo *>(reg_info));
}
-lldb::ValueObjectSP
-ClangExpressionVariable::GetExpressionResult (ExecutionContext *exe_ctx)
+lldb::clang_type_t
+ClangExpressionVariable::GetClangType()
+{
+ return m_valojb_sp->GetClangType();
+}
+
+void
+ClangExpressionVariable::SetClangType(lldb::clang_type_t clang_type)
+{
+ m_valojb_sp->GetValue().SetContext(Value::eContextTypeClangType, clang_type);
+}
+
+clang::ASTContext *
+ClangExpressionVariable::GetClangAST()
+{
+ return m_valojb_sp->GetClangAST();
+}
+
+void
+ClangExpressionVariable::SetClangAST (clang::ASTContext *ast)
+{
+ m_valojb_sp->SetClangAST (ast);
+}
+
+TypeFromUser
+ClangExpressionVariable::GetTypeFromUser()
+{
+ TypeFromUser tfu (m_valojb_sp->GetClangType(), m_valojb_sp->GetClangAST());
+ return tfu;
+}
+
+uint8_t *
+ClangExpressionVariable::GetValueBytes()
{
- lldb::ValueObjectSP result_sp;
- if (m_data_sp)
+ const size_t byte_size = m_valojb_sp->GetByteSize();
+ if (byte_size > 0)
{
- Target * target = NULL;
- Process *process = NULL;
- if (exe_ctx)
+ if (m_valojb_sp->GetDataExtractor().GetByteSize() < byte_size)
{
- target = exe_ctx->target;
- process = exe_ctx->process;
- }
-
- Value value;
- if (PointValueAtData(value, exe_ctx))
- {
- lldb::ByteOrder byte_order = lldb::eByteOrderHost;
- uint32_t addr_byte_size = 4;
- if (process)
- {
- byte_order = process->GetByteOrder();
- addr_byte_size = process->GetAddressByteSize();
- }
- result_sp.reset (new ValueObjectConstResult (m_user_type.GetASTContext(),
- m_user_type.GetOpaqueQualType(),
- m_name,
- m_data_sp,// TODO: sean can you get this to be valid?
- byte_order,
- addr_byte_size));
+ m_valojb_sp->GetValue().ResizeData(byte_size);
+ m_valojb_sp->GetValue().GetData (m_valojb_sp->GetDataExtractor());
}
+ return const_cast<uint8_t *>(m_valojb_sp->GetDataExtractor().GetDataStart());
}
- return result_sp;
+ return NULL;
+}
+
+void
+ClangExpressionVariable::SetName (const ConstString &name)
+{
+ m_valojb_sp->SetName (name);
+}
+
+void
+ClangExpressionVariable::ValueUpdated ()
+{
+ m_valojb_sp->ValueUpdated ();
}
Modified: lldb/trunk/source/Expression/ClangFunction.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/ClangFunction.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Expression/ClangFunction.cpp (original)
+++ lldb/trunk/source/Expression/ClangFunction.cpp Mon Dec 13 20:59:59 2010
@@ -275,7 +275,7 @@
Error error;
using namespace clang;
- Process::ExecutionResults return_value = Process::eExecutionSetupError;
+ lldb::ExecutionResults return_value = lldb::eExecutionSetupError;
Process *process = exe_ctx.process;
@@ -441,13 +441,13 @@
exe_ctx.process->DeallocateMemory(args_addr);
}
-Process::ExecutionResults
+lldb::ExecutionResults
ClangFunction::ExecuteFunction(ExecutionContext &exe_ctx, Stream &errors, Value &results)
{
return ExecuteFunction (exe_ctx, errors, 1000, true, results);
}
-Process::ExecutionResults
+lldb::ExecutionResults
ClangFunction::ExecuteFunction(ExecutionContext &exe_ctx, Stream &errors, bool stop_others, Value &results)
{
const bool try_all_threads = false;
@@ -455,7 +455,7 @@
return ExecuteFunction (exe_ctx, NULL, errors, stop_others, NULL, try_all_threads, discard_on_error, results);
}
-Process::ExecutionResults
+lldb::ExecutionResults
ClangFunction::ExecuteFunction(
ExecutionContext &exe_ctx,
Stream &errors,
@@ -470,7 +470,7 @@
}
// This is the static function
-Process::ExecutionResults
+lldb::ExecutionResults
ClangFunction::ExecuteFunction (
ExecutionContext &exe_ctx,
lldb::addr_t function_address,
@@ -486,7 +486,7 @@
errors, stop_others, discard_on_error,
this_arg));
if (call_plan_sp == NULL)
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
call_plan_sp->SetPrivate(true);
@@ -494,7 +494,7 @@
single_thread_timeout_usec, errors);
}
-Process::ExecutionResults
+lldb::ExecutionResults
ClangFunction::ExecuteFunction(
ExecutionContext &exe_ctx,
lldb::addr_t *args_addr_ptr,
@@ -506,7 +506,7 @@
Value &results)
{
using namespace clang;
- Process::ExecutionResults return_value = Process::eExecutionSetupError;
+ lldb::ExecutionResults return_value = lldb::eExecutionSetupError;
lldb::addr_t args_addr;
@@ -516,12 +516,12 @@
args_addr = LLDB_INVALID_ADDRESS;
if (CompileFunction(errors) != 0)
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
if (args_addr == LLDB_INVALID_ADDRESS)
{
if (!InsertFunction(exe_ctx, args_addr, errors))
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
}
return_value = ClangFunction::ExecuteFunction(exe_ctx, m_wrapper_function_addr, args_addr, stop_others,
@@ -530,7 +530,7 @@
if (args_addr_ptr != NULL)
*args_addr_ptr = args_addr;
- if (return_value != Process::eExecutionCompleted)
+ if (return_value != lldb::eExecutionCompleted)
return return_value;
FetchFunctionResults(exe_ctx, args_addr, results);
@@ -538,7 +538,7 @@
if (args_addr_ptr == NULL)
DeallocateFunctionResults(exe_ctx, args_addr);
- return Process::eExecutionCompleted;
+ return lldb::eExecutionCompleted;
}
clang::ASTConsumer *
Modified: lldb/trunk/source/Expression/ClangPersistentVariables.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/ClangPersistentVariables.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Expression/ClangPersistentVariables.cpp (original)
+++ lldb/trunk/source/Expression/ClangPersistentVariables.cpp Mon Dec 13 20:59:59 2010
@@ -13,38 +13,39 @@
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Value.h"
+using namespace lldb;
using namespace lldb_private;
ClangPersistentVariables::ClangPersistentVariables () :
- ClangExpressionVariableStore()
+ ClangExpressionVariableList(),
+ m_next_persistent_variable_id (0)
{
- m_result_counter = 0;
}
-void
-ClangPersistentVariables::GetNextResultName (ConstString &name)
+ClangExpressionVariableSP
+ClangPersistentVariables::CreatePersistentVariable (const lldb::ValueObjectSP &valobj_sp)
{
- char result_name[256];
- ::snprintf (result_name, sizeof(result_name), "$%llu", m_result_counter++);
- name.SetCString(result_name);
+ ClangExpressionVariableSP var_sp (CreateVariable(valobj_sp));
+ return var_sp;
}
-bool
-ClangPersistentVariables::CreatePersistentVariable (const ConstString &name,
- TypeFromUser user_type)
+ClangExpressionVariableSP
+ClangPersistentVariables::CreatePersistentVariable (const ConstString &name, const TypeFromUser& user_type, lldb::ByteOrder byte_order, uint32_t addr_byte_size)
{
- if (GetVariable(name))
- return false;
+ ClangExpressionVariableSP var_sp (GetVariable(name));
+
+ if (!var_sp)
+ var_sp = CreateVariable(name, user_type, byte_order, addr_byte_size);
- ClangExpressionVariable &pvar (VariableAtIndex(CreateVariable()));
+ return var_sp;
+}
- pvar.m_name = name;
- pvar.m_user_type = user_type;
- // TODO: Sean, why do we need to call this?, we can just make it below
- // and we aren't checking the result or anything... Is this cruft left
- // over from an old code re-org?
- //pvar.EnableDataVars();
- pvar.m_data_sp.reset(new DataBufferHeap(pvar.Size(), 0));
-
- return true;
-}
\ No newline at end of file
+
+ConstString
+ClangPersistentVariables::GetNextPersistentVariableName ()
+{
+ char name_cstr[256];
+ ::snprintf (name_cstr, sizeof(name_cstr), "$%u", m_next_persistent_variable_id++);
+ ConstString name(name_cstr);
+ return name;
+}
Modified: lldb/trunk/source/Expression/ClangUserExpression.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/ClangUserExpression.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Expression/ClangUserExpression.cpp (original)
+++ lldb/trunk/source/Expression/ClangUserExpression.cpp Mon Dec 13 20:59:59 2010
@@ -271,7 +271,7 @@
m_dwarf_opcodes->SetByteOrder (lldb::eByteOrderHost);
m_dwarf_opcodes->GetFlags ().Set (Stream::eBinary);
- m_local_variables.reset(new ClangExpressionVariableStore());
+ m_local_variables.reset(new ClangExpressionVariableList());
Error dwarf_error = parser.MakeDWARF ();
@@ -422,7 +422,7 @@
bool
ClangUserExpression::FinalizeJITExecution (Stream &error_stream,
ExecutionContext &exe_ctx,
- ClangExpressionVariable *&result)
+ lldb::ClangExpressionVariableSP &result)
{
Error expr_error;
@@ -454,12 +454,12 @@
return true;
}
-Process::ExecutionResults
+lldb::ExecutionResults
ClangUserExpression::Execute (Stream &error_stream,
ExecutionContext &exe_ctx,
bool discard_on_error,
ClangUserExpression::ClangUserExpressionSP &shared_ptr_to_me,
- ClangExpressionVariable *&result)
+ lldb::ClangExpressionVariableSP &result)
{
lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
@@ -469,7 +469,7 @@
error_stream.Printf("We don't currently support executing DWARF expressions");
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
}
else if (m_jit_addr != LLDB_INVALID_ADDRESS)
{
@@ -479,7 +479,7 @@
lldb::addr_t cmd_ptr = NULL;
if (!PrepareToExecuteJITExpression (error_stream, exe_ctx, struct_address, object_ptr, cmd_ptr))
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
const bool stop_others = true;
const bool try_all_threads = true;
@@ -495,7 +495,7 @@
shared_ptr_to_me));
if (call_plan_sp == NULL || !call_plan_sp->ValidatePlan (NULL))
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
call_plan_sp->SetPrivate(true);
@@ -504,14 +504,18 @@
if (log)
log->Printf("-- [ClangUserExpression::Execute] Execution of expression begins --");
- Process::ExecutionResults execution_result =
- exe_ctx.process->RunThreadPlan (exe_ctx, call_plan_sp, stop_others, try_all_threads, discard_on_error,
- single_thread_timeout_usec, error_stream);
+ lldb::ExecutionResults execution_result = exe_ctx.process->RunThreadPlan (exe_ctx,
+ call_plan_sp,
+ stop_others,
+ try_all_threads,
+ discard_on_error,
+ single_thread_timeout_usec,
+ error_stream);
if (log)
log->Printf("-- [ClangUserExpression::Execute] Execution of expression completed --");
- if (execution_result == Process::eExecutionInterrupted)
+ if (execution_result == lldb::eExecutionInterrupted)
{
if (discard_on_error)
error_stream.Printf ("Expression execution was interrupted. The process has been returned to the state before execution.");
@@ -520,21 +524,21 @@
return execution_result;
}
- else if (execution_result != Process::eExecutionCompleted)
+ else if (execution_result != lldb::eExecutionCompleted)
{
error_stream.Printf ("Couldn't execute function; result was %s\n", Process::ExecutionResultAsCString (execution_result));
return execution_result;
}
if (FinalizeJITExecution (error_stream, exe_ctx, result))
- return Process::eExecutionCompleted;
+ return lldb::eExecutionCompleted;
else
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
}
else
{
error_stream.Printf("Expression can't be run; neither DWARF nor a JIT compiled function is present");
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
}
}
@@ -547,7 +551,7 @@
return *m_dwarf_opcodes.get();
}
-Process::ExecutionResults
+lldb::ExecutionResults
ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
bool discard_on_error,
const char *expr_cstr,
@@ -557,14 +561,14 @@
lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Error error;
- Process::ExecutionResults execution_results = Process::eExecutionSetupError;
+ lldb::ExecutionResults execution_results = lldb::eExecutionSetupError;
if (exe_ctx.process == NULL)
{
error.SetErrorString ("Must have a process to evaluate expressions.");
result_valobj_sp.reset (new ValueObjectConstResult (error));
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
}
if (!exe_ctx.process->GetDynamicCheckers())
@@ -584,7 +588,7 @@
error.SetErrorString (install_errors.GetString().c_str());
result_valobj_sp.reset (new ValueObjectConstResult (error));
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
}
exe_ctx.process->SetDynamicCheckers(dynamic_checkers);
@@ -609,7 +613,7 @@
}
else
{
- ClangExpressionVariable *expr_result = NULL;
+ lldb::ClangExpressionVariableSP expr_result;
error_stream.GetString().clear();
@@ -621,7 +625,7 @@
discard_on_error,
user_expression_sp,
expr_result);
- if (execution_results != Process::eExecutionCompleted)
+ if (execution_results != lldb::eExecutionCompleted)
{
if (log)
log->Printf("== [ClangUserExpression::Evaluate] Execution completed abnormally ==");
@@ -633,14 +637,9 @@
}
else
{
- // TODO: seems weird to get a pointer to a result object back from
- // a function. Do we own it? Feels like we do, but from looking at the
- // code we don't. Might be best to make this a reference and state
- // explicitly that we don't own it when we get a reference back from
- // the execute?
if (expr_result)
{
- result_valobj_sp = expr_result->GetExpressionResult (&exe_ctx);
+ result_valobj_sp = expr_result->GetValueObject();
if (log)
log->Printf("== [ClangUserExpression::Evaluate] Execution completed normally with result %s ==", result_valobj_sp->GetValueAsCString(exe_ctx.GetBestExecutionContextScope()));
Modified: lldb/trunk/source/Expression/IRToDWARF.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/IRToDWARF.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Expression/IRToDWARF.cpp (original)
+++ lldb/trunk/source/Expression/IRToDWARF.cpp Mon Dec 13 20:59:59 2010
@@ -26,7 +26,7 @@
static char ID;
-IRToDWARF::IRToDWARF(lldb_private::ClangExpressionVariableStore &local_vars,
+IRToDWARF::IRToDWARF(lldb_private::ClangExpressionVariableList &local_vars,
lldb_private::ClangExpressionDeclMap *decl_map,
lldb_private::StreamString &strm,
const char *func_name) :
Modified: lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp (original)
+++ lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp Mon Dec 13 20:59:59 2010
@@ -642,9 +642,6 @@
}
}
- if (log)
- log->PutCString("Unloaded:");
-
for (old_idx = 0; old_idx < old_dyld_all_image_infos.size(); ++old_idx)
{
if (old_dyld_all_image_infos[old_idx].address != LLDB_INVALID_ADDRESS)
@@ -662,7 +659,14 @@
}
if (unloaded_module_list.GetSize() > 0)
+ {
+ if (log)
+ {
+ log->PutCString("Unloaded:");
+ unloaded_module_list.LogUUIDAndPaths (log, "DynamicLoaderMacOSXDYLD::ModulesDidUnload");
+ }
m_process->GetTarget().ModulesDidUnload (unloaded_module_list);
+ }
}
else
{
@@ -752,6 +756,8 @@
}
}
}
+ if (log)
+ loaded_module_list.LogUUIDAndPaths (log, "DynamicLoaderMacOSXDYLD::ModulesDidLoad");
m_process->GetTarget().ModulesDidLoad (loaded_module_list);
}
}
Modified: lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp (original)
+++ lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp Mon Dec 13 20:59:59 2010
@@ -122,9 +122,15 @@
bool try_all_threads = true;
bool stop_others = true;
- Process::ExecutionResults results
- = func.ExecuteFunction(exe_ctx, &wrapper_struct_addr, error_stream, stop_others, 1000000, try_all_threads, unwind_on_error, ret);
- if (results != Process::eExecutionCompleted)
+ ExecutionResults results = func.ExecuteFunction (exe_ctx,
+ &wrapper_struct_addr,
+ error_stream,
+ stop_others,
+ 1000000,
+ try_all_threads,
+ unwind_on_error,
+ ret);
+ if (results != lldb::eExecutionCompleted)
{
str.Printf("Error evaluating Print Object function: %d.\n", results);
return false;
Modified: lldb/trunk/source/Symbol/ClangASTContext.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Symbol/ClangASTContext.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Symbol/ClangASTContext.cpp (original)
+++ lldb/trunk/source/Symbol/ClangASTContext.cpp Mon Dec 13 20:59:59 2010
@@ -870,16 +870,17 @@
return false;
#define OPERATOR_PREFIX "operator"
+#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
const char *post_op_name = NULL;
bool no_space = true;
- if (!::strncmp(name, OPERATOR_PREFIX, sizeof(OPERATOR_PREFIX) - 1))
- post_op_name = name + sizeof(OPERATOR_PREFIX) - 1;
- else
+ if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
return false;
+ post_op_name = name + OPERATOR_PREFIX_LENGTH;
+
if (post_op_name[0] == ' ')
{
post_op_name++;
@@ -887,6 +888,7 @@
}
#undef OPERATOR_PREFIX
+#undef OPERATOR_PREFIX_LENGTH
// This is an operator, set the overloaded operator kind to invalid
// in case this is a conversion operator...
@@ -3488,7 +3490,13 @@
clang_type_t
ClangASTContext::CreatePointerType (clang_type_t clang_type)
{
- if (clang_type)
+ return CreatePointerType (getASTContext(), clang_type);
+}
+
+clang_type_t
+ClangASTContext::CreatePointerType (clang::ASTContext *ast, clang_type_t clang_type)
+{
+ if (ast && clang_type)
{
QualType qual_type (QualType::getFromOpaquePtr(clang_type));
@@ -3497,10 +3505,10 @@
{
case clang::Type::ObjCObject:
case clang::Type::ObjCInterface:
- return getASTContext()->getObjCObjectPointerType(qual_type).getAsOpaquePtr();
+ return ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr();
default:
- return getASTContext()->getPointerType(qual_type).getAsOpaquePtr();
+ return ast->getPointerType(qual_type).getAsOpaquePtr();
}
}
return NULL;
Modified: lldb/trunk/source/Symbol/ClangASTType.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Symbol/ClangASTType.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Symbol/ClangASTType.cpp (original)
+++ lldb/trunk/source/Symbol/ClangASTType.cpp Mon Dec 13 20:59:59 2010
@@ -161,6 +161,7 @@
case clang::BuiltinType::Double:
case clang::BuiltinType::LongDouble: return lldb::eEncodingIEEE754;
+ case clang::BuiltinType::ObjCClass:
case clang::BuiltinType::ObjCId:
case clang::BuiltinType::ObjCSel: return lldb::eEncodingUint;
Modified: lldb/trunk/source/Target/Process.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Process.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Target/Process.cpp (original)
+++ lldb/trunk/source/Target/Process.cpp Mon Dec 13 20:59:59 2010
@@ -88,7 +88,6 @@
m_image_tokens (),
m_listener (listener),
m_breakpoint_site_list (),
- m_persistent_vars (),
m_dynamic_checkers_ap (),
m_unix_signals (),
m_target_triple (),
@@ -2157,12 +2156,6 @@
return GetTarget().GetProcessSP();
}
-ClangPersistentVariables &
-Process::GetPersistentVariables()
-{
- return m_persistent_vars;
-}
-
uint32_t
Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
{
@@ -2334,7 +2327,7 @@
}
}
-Process::ExecutionResults
+ExecutionResults
Process::RunThreadPlan (ExecutionContext &exe_ctx,
lldb::ThreadPlanSP &thread_plan_sp,
bool stop_others,
@@ -2375,7 +2368,7 @@
{
errors.Printf("Error resuming inferior: \"%s\".\n", resume_error.AsCString());
exe_ctx.process->RestoreProcessEvents();
- return Process::eExecutionSetupError;
+ return lldb::eExecutionSetupError;
}
// We need to call the function synchronously, so spin waiting for it to return.
@@ -2440,7 +2433,7 @@
{
if (log)
log->Printf ("Even though we timed out, the call plan was done. Exiting wait loop.");
- return_value = Process::eExecutionCompleted;
+ return_value = lldb::eExecutionCompleted;
break;
}
@@ -2458,7 +2451,7 @@
else
{
exe_ctx.process->RestoreProcessEvents ();
- return Process::eExecutionInterrupted;
+ return lldb::eExecutionInterrupted;
}
}
}
@@ -2473,12 +2466,12 @@
if (exe_ctx.thread->IsThreadPlanDone (thread_plan_sp.get()))
{
- return_value = Process::eExecutionCompleted;
+ return_value = lldb::eExecutionCompleted;
break;
}
else if (exe_ctx.thread->WasThreadPlanDiscarded (thread_plan_sp.get()))
{
- return_value = Process::eExecutionDiscarded;
+ return_value = lldb::eExecutionDiscarded;
break;
}
else
@@ -2557,7 +2550,7 @@
{
exe_ctx.thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
}
- return_value = Process::eExecutionInterrupted;
+ return_value = lldb::eExecutionInterrupted;
break;
}
}
@@ -2593,19 +2586,19 @@
switch (result)
{
- case Process::eExecutionCompleted:
+ case lldb::eExecutionCompleted:
result_name = "eExecutionCompleted";
break;
- case Process::eExecutionDiscarded:
+ case lldb::eExecutionDiscarded:
result_name = "eExecutionDiscarded";
break;
- case Process::eExecutionInterrupted:
+ case lldb::eExecutionInterrupted:
result_name = "eExecutionInterrupted";
break;
- case Process::eExecutionSetupError:
+ case lldb::eExecutionSetupError:
result_name = "eExecutionSetupError";
break;
- case Process::eExecutionTimedOut:
+ case lldb::eExecutionTimedOut:
result_name = "eExecutionTimedOut";
break;
}
Modified: lldb/trunk/source/Target/SectionLoadList.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/SectionLoadList.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Target/SectionLoadList.cpp (original)
+++ lldb/trunk/source/Target/SectionLoadList.cpp Mon Dec 13 20:59:59 2010
@@ -68,12 +68,17 @@
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
if (log)
- log->Printf ("SectionLoadList::%s (section = %p (%s.%s), load_addr = 0x%16.16llx)",
+ {
+ const FileSpec &module_file_spec (section->GetModule()->GetFileSpec());
+ log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s), load_addr = 0x%16.16llx)",
__FUNCTION__,
section,
- section->GetModule()->GetFileSpec().GetFilename().AsCString(),
+ module_file_spec.GetDirectory().AsCString(),
+ module_file_spec.GetDirectory() ? "/" : "",
+ module_file_spec.GetFilename().AsCString(),
section->GetName().AsCString(),
load_addr);
+ }
Mutex::Locker locker(m_mutex);
collection::iterator pos = m_collection.find(load_addr);
@@ -97,11 +102,16 @@
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
if (log)
- log->Printf ("SectionLoadList::%s (section = %p (%s.%s))",
+ {
+ const FileSpec &module_file_spec (section->GetModule()->GetFileSpec());
+ log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s))",
__FUNCTION__,
section,
- section->GetModule()->GetFileSpec().GetFilename().AsCString(),
+ module_file_spec.GetDirectory().AsCString(),
+ module_file_spec.GetDirectory() ? "/" : "",
+ module_file_spec.GetFilename().AsCString(),
section->GetName().AsCString());
+ }
size_t unload_count = 0;
Mutex::Locker locker(m_mutex);
@@ -128,12 +138,17 @@
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
if (log)
- log->Printf ("SectionLoadList::%s (section = %p (%s.%s), load_addr = 0x%16.16llx)",
+ {
+ const FileSpec &module_file_spec (section->GetModule()->GetFileSpec());
+ log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s), load_addr = 0x%16.16llx)",
__FUNCTION__,
section,
- section->GetModule()->GetFileSpec().GetFilename().AsCString(),
+ module_file_spec.GetDirectory().AsCString(),
+ module_file_spec.GetDirectory() ? "/" : "",
+ module_file_spec.GetFilename().AsCString(),
section->GetName().AsCString(),
load_addr);
+ }
Mutex::Locker locker(m_mutex);
return m_collection.erase (load_addr) != 0;
}
Modified: lldb/trunk/source/Target/StackFrame.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/StackFrame.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Target/StackFrame.cpp (original)
+++ lldb/trunk/source/Target/StackFrame.cpp Mon Dec 13 20:59:59 2010
@@ -478,6 +478,159 @@
return m_variable_list_sp.get();
}
+ValueObjectSP
+StackFrame::GetValueForVariableExpressionPath (const char *var_expr)
+{
+ bool deref = false;
+ bool address_of = false;
+ ValueObjectSP valobj_sp;
+ const bool get_file_globals = true;
+ VariableList *variable_list = GetVariableList (get_file_globals);
+
+ if (variable_list)
+ {
+ // If first character is a '*', then show pointer contents
+ if (var_expr[0] == '*')
+ {
+ deref = true;
+ var_expr++; // Skip the '*'
+ }
+ else if (var_expr[0] == '&')
+ {
+ address_of = true;
+ var_expr++; // Skip the '&'
+ }
+
+ std::string var_path (var_expr);
+ size_t separator_idx = var_path.find_first_of(".-[");
+
+ ConstString name_const_string;
+ if (separator_idx == std::string::npos)
+ name_const_string.SetCString (var_path.c_str());
+ else
+ name_const_string.SetCStringWithLength (var_path.c_str(), separator_idx);
+
+ VariableSP var_sp (variable_list->FindVariable(name_const_string));
+ if (var_sp)
+ {
+ valobj_sp = GetValueObjectForFrameVariable (var_sp);
+
+ var_path.erase (0, name_const_string.GetLength ());
+ // We are dumping at least one child
+ while (separator_idx != std::string::npos)
+ {
+ // Calculate the next separator index ahead of time
+ ValueObjectSP child_valobj_sp;
+ const char separator_type = var_path[0];
+ switch (separator_type)
+ {
+
+ case '-':
+ if (var_path.size() >= 2 && var_path[1] != '>')
+ return ValueObjectSP();
+
+ var_path.erase (0, 1); // Remove the '-'
+ // Fall through
+ case '.':
+ {
+ // We either have a pointer type and need to verify
+ // valobj_sp is a pointer, or we have a member of a
+ // class/union/struct being accessed with the . syntax
+ // and need to verify we don't have a pointer.
+ const bool is_ptr = var_path[0] == '>';
+
+ if (valobj_sp->IsPointerType () != is_ptr)
+ {
+ // Incorrect use of "." with a pointer, or "->" with
+ // a class/union/struct instance or reference.
+ return ValueObjectSP();
+ }
+
+ var_path.erase (0, 1); // Remove the '.' or '>'
+ separator_idx = var_path.find_first_of(".-[");
+ ConstString child_name;
+ if (separator_idx == std::string::npos)
+ child_name.SetCString (var_path.c_str());
+ else
+ child_name.SetCStringWithLength(var_path.c_str(), separator_idx);
+
+ child_valobj_sp = valobj_sp->GetChildMemberWithName (child_name, true);
+ if (!child_valobj_sp)
+ {
+ // No child member with name "child_name"
+ return ValueObjectSP();
+ }
+ // Remove the child name from the path
+ var_path.erase(0, child_name.GetLength());
+ }
+ break;
+
+ case '[':
+ // 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;
+ int32_t child_index = ::strtol (&var_path[1], &end, 0);
+ if (end && *end == ']')
+ {
+
+ if (valobj_sp->IsPointerType ())
+ {
+ child_valobj_sp = valobj_sp->GetSyntheticArrayMemberFromPointer (child_index, true);
+ }
+ else
+ {
+ child_valobj_sp = valobj_sp->GetChildAtIndex (child_index, true);
+ }
+
+ if (!child_valobj_sp)
+ {
+ // Invalid array index...
+ return ValueObjectSP();
+ }
+
+ // Erase the array member specification '[%i]' where
+ // %i is the array index
+ var_path.erase(0, (end - var_path.c_str()) + 1);
+ separator_idx = var_path.find_first_of(".-[");
+
+ // Break out early from the switch since we were
+ // able to find the child member
+ break;
+ }
+ }
+ return ValueObjectSP();
+
+ default:
+ // Failure...
+ return ValueObjectSP();
+ }
+
+ if (child_valobj_sp)
+ valobj_sp = child_valobj_sp;
+
+ if (var_path.empty())
+ break;
+
+ }
+ if (valobj_sp)
+ {
+ if (deref)
+ {
+ ValueObjectSP deref_valobj_sp (valobj_sp->Dereference(this, NULL));
+ valobj_sp = deref_valobj_sp;
+ }
+ else if (address_of)
+ {
+ ValueObjectSP address_of_valobj_sp (valobj_sp->AddressOf());
+ valobj_sp = address_of_valobj_sp;
+ }
+ }
+ return valobj_sp;
+ }
+ }
+ return ValueObjectSP();
+}
bool
StackFrame::GetFrameBaseValue (Scalar &frame_base, Error *error_ptr)
Modified: lldb/trunk/source/Target/Target.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Target.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Target/Target.cpp (original)
+++ lldb/trunk/source/Target/Target.cpp Mon Dec 13 20:59:59 2010
@@ -18,15 +18,17 @@
#include "lldb/Breakpoint/BreakpointResolverFileLine.h"
#include "lldb/Breakpoint/BreakpointResolverName.h"
#include "lldb/Core/DataBufferMemoryMap.h"
+#include "lldb/Core/Debugger.h"
#include "lldb/Core/Event.h"
#include "lldb/Core/Log.h"
-#include "lldb/Core/Timer.h"
#include "lldb/Core/StreamString.h"
+#include "lldb/Core/Timer.h"
+#include "lldb/Core/ValueObject.h"
#include "lldb/Host/Host.h"
#include "lldb/lldb-private-log.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Process.h"
-#include "lldb/Core/Debugger.h"
+#include "lldb/Target/StackFrame.h"
using namespace lldb;
using namespace lldb_private;
@@ -46,7 +48,8 @@
m_triple(),
m_search_filter_sp(),
m_image_search_paths (ImageSearchPathsChanged, this),
- m_scratch_ast_context_ap(NULL)
+ m_scratch_ast_context_ap (NULL),
+ m_persistent_variables ()
{
SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed");
SetEventName (eBroadcastBitModulesLoaded, "modules-loaded");
@@ -866,6 +869,81 @@
return m_expr_prefix_contents.c_str();
}
+ExecutionResults
+Target::EvaluateExpression
+(
+ const char *expr_cstr,
+ StackFrame *frame,
+ bool unwind_on_error,
+ lldb::ValueObjectSP &result_valobj_sp
+)
+{
+ ExecutionResults execution_results = eExecutionSetupError;
+
+ result_valobj_sp.reset();
+
+ ExecutionContext exe_ctx;
+ if (frame)
+ {
+ frame->CalculateExecutionContext(exe_ctx);
+ result_valobj_sp = frame->GetValueForVariableExpressionPath (expr_cstr);
+ }
+ 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);
+
+ result_valobj_sp = const_valobj_sp;
+
+ ClangExpressionVariableSP clang_expr_variable_sp(m_persistent_variables.CreatePersistentVariable(result_valobj_sp));
+ assert (clang_expr_variable_sp.get());
+ }
+ else
+ {
+ // Make sure we aren't just trying to see the value of a persistent
+ // variable (something like "$0")
+ lldb::ClangExpressionVariableSP 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,
+ expr_cstr,
+ prefix,
+ result_valobj_sp);
+ }
+ }
+ return execution_results;
+}
+
//--------------------------------------------------------------
// class Target::SettingsController
//--------------------------------------------------------------
Modified: lldb/trunk/source/Target/ThreadPlanTestCondition.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanTestCondition.cpp?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanTestCondition.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanTestCondition.cpp Mon Dec 13 20:59:59 2010
@@ -76,11 +76,11 @@
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
if (m_thread.IsThreadPlanDone(m_expression_plan_sp.get()))
{
- ClangExpressionVariable *expr_result = NULL;
+ lldb::ClangExpressionVariableSP expr_result;
StreamString error_stream;
m_expression->FinalizeJITExecution(error_stream, m_exe_ctx, expr_result);
- ValueObjectSP result_sp (expr_result->GetExpressionResult(&m_exe_ctx));
+ ValueObjectSP result_sp (expr_result->GetValueObject());
if (result_sp)
{
// FIXME: This is not the right answer, we should have a "GetValueAsBoolean..."
Modified: lldb/trunk/test/load_unload/Makefile
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/load_unload/Makefile?rev=121745&r1=121744&r2=121745&view=diff
==============================================================================
--- lldb/trunk/test/load_unload/Makefile (original)
+++ lldb/trunk/test/load_unload/Makefile Mon Dec 13 20:59:59 2010
@@ -1,9 +1,10 @@
-all: a.out liba.dylib libb.dylib libc.dylib
+all: a.out liba.dylib libb.dylib libc.dylib libd.dylib
CFLAGS ?=-arch x86_64 -gdwarf-2 -O0
+CWD := $(shell pwd)
-a.out: main.o
- gcc $(CFLAGS) -o a.out main.o
+a.out: main.o libd.dylib
+ gcc $(CFLAGS) -o a.out main.o -L. -ld
main.o: main.c
gcc $(CFLAGS) -c main.c
@@ -29,5 +30,12 @@
c.o: c.c
gcc $(CFLAGS) -c c.c
+libd.dylib: d.o
+ gcc $(CFLAGS) -dynamiclib -install_name "$(CWD)/libd.dylib" -o libd.dylib d.o
+ dsymutil libd.dylib
+
+d.o: d.c
+ gcc $(CFLAGS) -c d.c
+
clean:
rm -rf *.o *~ *.dylib a.out *.dSYM
Added: lldb/trunk/test/load_unload/d.c
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/load_unload/d.c?rev=121745&view=auto
==============================================================================
--- lldb/trunk/test/load_unload/d.c (added)
+++ lldb/trunk/test/load_unload/d.c Mon Dec 13 20:59:59 2010
@@ -0,0 +1,13 @@
+//===-- c.c -----------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+int
+d_function ()
+{
+ return 700;
+}
More information about the lldb-commits
mailing list