[Lldb-commits] [lldb] r111049 - in /lldb/trunk: include/lldb/Expression/ClangExpressionDeclMap.h source/Expression/ClangExpressionDeclMap.cpp source/Expression/IRForTarget.cpp

Sean Callanan scallanan at apple.com
Fri Aug 13 15:29:55 PDT 2010


Author: spyffe
Date: Fri Aug 13 17:29:54 2010
New Revision: 111049

URL: http://llvm.org/viewvc/llvm-project?rev=111049&view=rev
Log:
Added documentation to ClangExpressionDeclMap.
Also cleaned up its API a tiny bit (but not the
extensive amount that is actually needed.  That's
still coming.)

Modified:
    lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h
    lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp
    lldb/trunk/source/Expression/IRForTarget.cpp

Modified: lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h?rev=111049&r1=111048&r2=111049&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h (original)
+++ lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h Fri Aug 13 17:29:54 2010
@@ -36,80 +36,339 @@
 class Function;
 class NameSearchContext;
 class Variable;
-    
+
+//----------------------------------------------------------------------
+/// @class ClangExpressionDeclMap ClangExpressionDeclMap.h "lldb/Expression/ClangExpressionDeclMap.h"
+/// @brief Manages named entities that are defined in LLDB's debug information.
+///
+/// The Clang parser uses the ClangASTSource as an interface to request named
+/// entities from outside an expression.  The ClangASTSource reports back, listing
+/// all possible objects corresponding to a particular name.  But it in turn
+/// relies on ClangExpressionDeclMap, which performs several important functions.
+///
+/// First, it records what variables and functions were looked up and what Decls
+/// were returned for them.
+///
+/// Second, it constructs a struct on behalf of IRForTarget, recording which 
+/// variables should be placed where and relaying this information back so that 
+/// IRForTarget can generate context-independent code.
+///
+/// Third, it "materializes" this struct on behalf of the expression command,
+/// finding the current values of each variable and placing them into the
+/// struct so that it can be passed to the JITted version of the IR.
+///
+/// Fourth and finally, it "dematerializes" the struct after the JITted code has
+/// has executed, placing the new values back where it found the old ones.
+//----------------------------------------------------------------------
 class ClangExpressionDeclMap
 {
 public:
+    //------------------------------------------------------------------
+    /// Constructor
+    ///
+    /// Initializes class variabes.
+    ///
+    /// @param[in] exe_ctx
+    ///     The execution context to use when finding types for variables.
+    ///     Also used to find a "scratch" AST context to store result types.
+    //------------------------------------------------------------------
     ClangExpressionDeclMap(ExecutionContext *exe_ctx);
-    ~ClangExpressionDeclMap();
     
-    // Interface for ClangStmtVisitor
-    bool GetIndexForDecl (uint32_t &index,
-                          const clang::Decl *decl);
+    //------------------------------------------------------------------
+    /// Destructor
+    //------------------------------------------------------------------
+    ~ClangExpressionDeclMap();
     
-    // Interface for IRForTarget
+    //------------------------------------------------------------------
+    /// [Used by IRForTarget] Get a new result variable name of the form
+    ///     $n, where n is a natural number starting with 0.
+    ///
+    /// @param[in] name
+    ///     The std::string to place the name into.
+    //------------------------------------------------------------------
     void GetPersistentResultName (std::string &name);
+    
+    //------------------------------------------------------------------
+    /// [Used by IRForTarget] Add a variable to the list of persistent
+    ///     variables for the process.
+    ///
+    /// @param[in] name
+    ///     The name of the persistent variable, usually $something.
+    ///
+    /// @param[in] type
+    ///     The type of the variable, in the Clang parser's context.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool AddPersistentVariable (const char *name, TypeFromParser type);
+    
+    //------------------------------------------------------------------
+    /// [Used by IRForTarget] Add a variable to the struct that needs to
+    ///     be materialized each time the expression runs.
+    ///
+    /// @param[in] value
+    ///     The LLVM IR value for this variable.
+    ///
+    /// @param[in] decl
+    ///     The Clang declaration for the variable.
+    ///
+    /// @param[in] name
+    ///     The name of the variable.
+    ///
+    /// @param[in] type
+    ///     The type of the variable.
+    ///
+    /// @param[in] size
+    ///     The size of the variable in bytes.
+    ///
+    /// @param[in] alignment
+    ///     The required alignment of the variable in bytes.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool AddValueToStruct (llvm::Value *value,
                            const clang::NamedDecl *decl,
                            std::string &name,
-                           void *type,
-                           clang::ASTContext *ast_context,
+                           TypeFromParser type,
                            size_t size,
                            off_t alignment);
+    
+    //------------------------------------------------------------------
+    /// [Used by IRForTarget] Finalize the struct, laying out the position 
+    /// of each object in it.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool DoStructLayout ();
+    
+    //------------------------------------------------------------------
+    /// [Used by IRForTarget] Get general information about the laid-out
+    /// struct after DoStructLayout() has been called.
+    ///
+    /// @param[out] num_elements
+    ///     The number of elements in the struct.
+    ///
+    /// @param[out] size
+    ///     The size of the struct, in bytes.
+    ///
+    /// @param[out] alignment
+    ///     The alignment of the struct, in bytes.
+    ///
+    /// @return
+    ///     True if the information could be retrieved; false otherwise.
+    //------------------------------------------------------------------
     bool GetStructInfo (uint32_t &num_elements,
                         size_t &size,
                         off_t &alignment);
+    
+    //------------------------------------------------------------------
+    /// [Used by IRForTarget] Get specific information about one field
+    /// of the laid-out struct after DoStructLayout() has been called.
+    ///
+    /// @param[out] decl
+    ///     The parsed Decl for the field, as generated by ClangASTSource
+    ///     on ClangExpressionDeclMap's behalf.  In the case of the result
+    ///     value, this will have the name ___clang_result even if the
+    ///     result value ends up having the name $1.  This is an
+    ///     implementation detail of IRForTarget.
+    ///
+    /// @param[out] value
+    ///     The IR value for the field (usually a GlobalVariable).  In
+    ///     the case of the result value, this will have the correct
+    ///     name ($1, for instance).  This is an implementation detail
+    ///     of IRForTarget.
+    ///
+    /// @param[out] offset
+    ///     The offset of the field from the beginning of the struct.
+    ///     As long as the struct is aligned according to its required
+    ///     alignment, this offset will align the field correctly.
+    ///
+    /// @param[in] index
+    ///     The index of the field about which information is requested.
+    ///
+    /// @return
+    ///     True if the information could be retrieved; false otherwise.
+    //------------------------------------------------------------------
     bool GetStructElement (const clang::NamedDecl *&decl,
                            llvm::Value *&value,
                            off_t &offset,
                            uint32_t index);
     
+    //------------------------------------------------------------------
+    /// [Used by IRForTarget] Get information about a function given its
+    /// Decl.
+    ///
+    /// @param[in] decl
+    ///     The parsed Decl for the Function, as generated by ClangASTSource
+    ///     on ClangExpressionDeclMap's behalf.
+    ///
+    /// @param[out] value
+    ///     A pointer to the address where a Value for the function's address
+    ///     can be stored.  IRForTarget typically places a ConstantExpr here.
+    ///
+    /// @param[out] ptr
+    ///     The absolute address of the function in the target.
+    ///
+    /// @return
+    ///     True if the information could be retrieved; false otherwise.
+    //------------------------------------------------------------------
     bool GetFunctionInfo (const clang::NamedDecl *decl, 
                           llvm::Value**& value, 
                           uint64_t &ptr);
+    
+    //------------------------------------------------------------------
+    /// [Used by IRForTarget] Get the address of a function given nothing
+    /// but its name.  Some functions are needed but didn't get Decls made
+    /// during parsing -- specifically, sel_registerName is never called
+    /// in the generated IR but we need to call it nonetheless.
+    ///
+    /// @param[in] name
+    ///     The name of the function.  
+    ///
+    /// @param[out] ptr
+    ///     The absolute address of the function in the target.
+    ///
+    /// @return
+    ///     True if the address could be retrieved; false otherwise.
+    //------------------------------------------------------------------
     bool GetFunctionAddress (const char *name,
                              uint64_t &ptr);
     
-    // Interface for DwarfExpression
+    //------------------------------------------------------------------
+    /// [Used by DWARFExpression] Get the LLDB value for a variable given
+    /// its unique index into the value map.
+    ///
+    /// @param[in] index
+    ///     The index of the variable into the tuple array, which keeps track
+    ///     of Decls, types, and Values.
+    ///
+    /// @return
+    ///     The LLDB value for the variable.
+    //------------------------------------------------------------------
     Value *GetValueForIndex (uint32_t index);
     
-    // Interface for CommandObjectExpression
+    //------------------------------------------------------------------
+    /// [Used by CommandObjectExpression] Materialize the entire struct
+    /// at a given address, which should be aligned as specified by 
+    /// GetStructInfo().
+    ///
+    /// @param[in] exe_ctx
+    ///     The execution context at which to dump the struct.
+    ///
+    /// @param[in] struct_address
+    ///     The address at which the struct should be written.
+    ///
+    /// @param[in] error
+    ///     An Error to populate with any messages related to
+    ///     materializing the struct.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool Materialize(ExecutionContext *exe_ctx,
                      lldb::addr_t &struct_address,
                      Error &error);
     
+    //------------------------------------------------------------------
+    /// [Used by CommandObjectExpression] Pretty-print a materialized
+    /// struct, which must have been materialized by Materialize(),
+    /// byte for byte on a given stream.
+    ///
+    /// @param[in] exe_ctx
+    ///     The execution context from which to read the struct.
+    ///
+    /// @param[in] s
+    ///     The stream on which to write the pretty-printed output.
+    ///
+    /// @param[in] error
+    ///     An Error to populate with any messages related to
+    ///     pretty-printing the struct.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool DumpMaterializedStruct(ExecutionContext *exe_ctx,
                                 Stream &s,
                                 Error &error);
     
+    //------------------------------------------------------------------
+    /// [Used by CommandObjectExpression] Deaterialize the entire struct.
+    ///
+    /// @param[in] exe_ctx
+    ///     The execution context from which to read the struct.
+    ///
+    /// @param[out] result
+    ///     A ClangPersistentVariable containing the result of the
+    ///     expression, for potential re-use.
+    ///
+    /// @param[in] error
+    ///     An Error to populate with any messages related to
+    ///     dematerializing the struct.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool Dematerialize(ExecutionContext *exe_ctx,
                        ClangPersistentVariable *&result,
                        Error &error);
     
-    // Interface for ClangASTSource
+    //------------------------------------------------------------------
+    /// [Used by ClangASTSource] Find all entities matching a given name,
+    /// using a NameSearchContext to make Decls for them.
+    ///
+    /// @param[in] context
+    ///     The NameSearchContext that can construct Decls for this name.
+    ///
+    /// @param[in] name
+    ///     The name as a plain C string.  The NameSearchContext contains 
+    ///     a DeclarationName for the name so at first the name may seem
+    ///     redundant, but ClangExpressionDeclMap operates in RTTI land so 
+    ///     it can't access DeclarationName.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     void GetDecls (NameSearchContext &context,
                    const char *name);
-private:    
+private:
+    //----------------------------------------------------------------------
+    /// @class Tuple ClangExpressionDeclMap.h "lldb/Expression/ClangExpressionDeclMap.h"
+    /// @brief A single entity that has been looked up on the behalf of the parser.
+    ///
+    /// When the Clang parser requests entities by name, ClangExpressionDeclMap
+    /// records what was looked up in a list of Tuples.
+    //----------------------------------------------------------------------
     struct Tuple
     {
-        const clang::NamedDecl  *m_decl;
-        TypeFromParser          m_parser_type;
-        TypeFromUser            m_user_type;
-        lldb_private::Value     *m_value; /* owned by ClangExpressionDeclMap */
-        llvm::Value             *m_llvm_value;
+        const clang::NamedDecl  *m_decl;        ///< The Decl generated for the entity.
+        TypeFromParser          m_parser_type;  ///< The type of the entity, as reported to the parser.
+        TypeFromUser            m_user_type;    ///< The type of the entity, as found in LLDB.
+        lldb_private::Value     *m_value;       ///< [owned by ClangExpressionDeclMap] A LLDB Value for the entity.
+        llvm::Value             *m_llvm_value;  ///< A LLVM IR Value for the entity, usually a GlobalVariable.
     };
     
+    //----------------------------------------------------------------------
+    /// @class StructMember ClangExpressionDeclMap.h "lldb/Expression/ClangExpressionDeclMap.h"
+    /// @brief An entity that needs to be materialized in order to make the
+    /// expression work.
+    ///
+    /// IRForTarget identifies those entities that actually made it into the
+    /// final IR and adds them to a list of StructMembers; this list is used
+    /// as the basis of struct layout and its fields are used for
+    /// materializing/dematerializing the struct.
+    //----------------------------------------------------------------------
     struct StructMember
     {
-        const clang::NamedDecl *m_decl;
-        llvm::Value            *m_value;
-        std::string             m_name;
-        TypeFromParser          m_parser_type;
-        off_t                   m_offset;
-        size_t                  m_size;
-        off_t                   m_alignment;
+        const clang::NamedDecl *m_decl;         ///< The Decl generated for the entity.
+        llvm::Value            *m_value;        ///< A LLVM IR Value for he entity, usually a GlobalVariable.
+        std::string             m_name;         ///< The name of the entity, for use in materialization.
+        TypeFromParser          m_parser_type;  ///< The expected type of the entity, for use in materialization.
+        off_t                   m_offset;       ///< The laid-out offset of the entity in the struct.  Only valid after DoStructLayout().
+        size_t                  m_size;         ///< The size of the entity.
+        off_t                   m_alignment;    ///< The required alignment of the entity, in bytes.
     };
     
     typedef std::vector<Tuple> TupleVector;
@@ -118,44 +377,237 @@
     typedef std::vector<StructMember> StructMemberVector;
     typedef StructMemberVector::iterator StructMemberIterator;
     
-    TupleVector                 m_tuples;
-    StructMemberVector          m_members;
-    ExecutionContext           *m_exe_ctx;
-    SymbolContext              *m_sym_ctx; /* owned by ClangExpressionDeclMap */
-    ClangPersistentVariables   *m_persistent_vars;
-    off_t                       m_struct_alignment;
-    size_t                      m_struct_size;
-    bool                        m_struct_laid_out;
-    lldb::addr_t                m_allocated_area;
-    lldb::addr_t                m_materialized_location;
-    std::string                 m_result_name;
-        
+    TupleVector                 m_tuples;                   ///< All entities that were looked up for the parser.
+    StructMemberVector          m_members;                  ///< All fields of the struct that need to be materialized.
+    ExecutionContext           *m_exe_ctx;                  ///< The execution context where this expression was first defined.  It determines types for all the external variables, even if the expression is re-used.
+    SymbolContext              *m_sym_ctx;                  ///< [owned by ClangExpressionDeclMap] The symbol context where this expression was first defined.
+    ClangPersistentVariables   *m_persistent_vars;          ///< The list of persistent variables to use when resolving symbols in the expression and when creating new ones (like the result).
+    off_t                       m_struct_alignment;         ///< The alignment of the struct in bytes.
+    size_t                      m_struct_size;              ///< The size of the struct in bytes.
+    bool                        m_struct_laid_out;          ///< True if the struct has been laid out and the layout is valid (that is, no new fields have been added since).
+    lldb::addr_t                m_allocated_area;           ///< The base of the memory allocated for the struct.  Starts on a potentially unaligned address and may therefore be larger than the struct.
+    lldb::addr_t                m_materialized_location;    ///< The address at which the struct is placed.  Falls inside the allocated area.
+    std::string                 m_result_name;              ///< The name of the result variable ($1, for example)
+    
+    //------------------------------------------------------------------
+    /// Given a symbol context, find a variable that matches the given
+    /// name and type.  We need this for expression re-use; we may not
+    /// always get the same lldb::Variable back, and we want the expression
+    /// to work wherever it can.  Returns the variable defined in the
+    /// tightest scope.
+    ///
+    /// @param[in] sym_ctx
+    ///     The SymbolContext to search for the variable.
+    ///
+    /// @param[in] name
+    ///     The name as a plain C string.
+    ///
+    /// @param[in] type
+    ///     The required type for the variable.  This function may be called
+    ///     during parsing, in which case we don't know its type; hence the
+    ///     default.
+    ///
+    /// @return
+    ///     The LLDB Variable found, or NULL if none was found.
+    //------------------------------------------------------------------
     Variable *FindVariableInScope(const SymbolContext &sym_ctx,
                                   const char *name,
                                   TypeFromUser *type = NULL);
     
+    //------------------------------------------------------------------
+    /// Get the index into the Tuple array for the given Decl.  Implements
+    /// vanilla linear search.
+    ///
+    /// @param[out] index
+    ///     The index into the Tuple array that corresponds to the Decl.
+    ///
+    /// @param[in] decl
+    ///     The Decl to be looked up.
+    ///
+    /// @return
+    ///     True if the Decl was found; false otherwise.
+    //------------------------------------------------------------------
+    bool GetIndexForDecl (uint32_t &index,
+                          const clang::Decl *decl);
+    
+    //------------------------------------------------------------------
+    /// Get the value of a variable in a given execution context and return
+    /// the associated Types if needed.
+    ///
+    /// @param[in] exe_ctx
+    ///     The execution context to look for the variable in.
+    ///
+    /// @param[in] var
+    ///     The variable to evaluate.
+    ///
+    /// @param[in] parser_ast_context
+    ///     The AST context of the parser, to store the found type in.
+    ///
+    /// @param[out] found_type
+    ///     The type of the found value, as it was found in the user process.
+    ///     This is only useful when the variable is being inspected on behalf
+    ///     of the parser, hence the default.
+    ///
+    /// @param[out] parser_type
+    ///     The type of the found value, as it was copied into the parser's
+    ///     AST context.  This is only useful when the variable is being
+    ///     inspected on behalf of the parser, hence the default.
+    ///
+    /// @param[in] decl
+    ///     The Decl to be looked up.
+    ///
+    /// @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);
     
+    //------------------------------------------------------------------
+    /// Use the NameSearchContext to generate a Decl for the given LLDB
+    /// Variable, and put it in the Tuple list.
+    ///
+    /// @param[in] context
+    ///     The NameSearchContext to use when constructing the Decl.
+    ///
+    /// @param[in] var
+    ///     The LLDB Variable that needs a Decl.
+    //------------------------------------------------------------------
     void AddOneVariable(NameSearchContext &context, Variable *var);
+    
+    //------------------------------------------------------------------
+    /// Use the NameSearchContext to generate a Decl for the given
+    /// persistent variable, and put it in the Tuple list.
+    ///
+    /// @param[in] context
+    ///     The NameSearchContext to use when constructing the Decl.
+    ///
+    /// @param[in] pvar
+    ///     The persistent variable that needs a Decl.
+    //------------------------------------------------------------------
     void AddOneVariable(NameSearchContext &context, ClangPersistentVariable *pvar);
+    
+    //------------------------------------------------------------------
+    /// Use the NameSearchContext to generate a Decl for the given
+    /// function.  (Functions are not placed in the Tuple list.)  Can
+    /// handle both fully typed functions and generic functions.
+    ///
+    /// @param[in] context
+    ///     The NameSearchContext to use when constructing the Decl.
+    ///
+    /// @param[in] fun
+    ///     The Function that needs to be created.  If non-NULL, this is
+    ///     a fully-typed function.
+    ///
+    /// @param[in] sym
+    ///     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);
+    
+    //------------------------------------------------------------------
+    /// Use the NameSearchContext to generate a Decl for the given
+    /// type.  (Types are not placed in the Tuple list.)
+    ///
+    /// @param[in] context
+    ///     The NameSearchContext to use when constructing the Decl.
+    ///
+    /// @param[in] type
+    ///     The LLDB Type that needs to be created.
+    //------------------------------------------------------------------
     void AddOneType(NameSearchContext &context, Type *type);
     
+    //------------------------------------------------------------------
+    /// Actually do the task of materializing or dematerializing the struct.
+    /// Since both tasks are very similar, although ClangExpressionDeclMap
+    /// exposes two functions to the outside, both call DoMaterialize.
+    ///
+    /// @param[in] dematerialize
+    ///     True if the struct is to be dematerialized; false if it is to
+    ///     be materialized.
+    ///
+    /// @param[in] exe_ctx
+    ///     The execution context to use.
+    ///
+    /// @param[out] result
+    ///     If the struct is being dematerialized, a pointer into which the
+    ///     location of the result persistent variable is placed.  If not,
+    ///     NULL.
+    ///
+    /// @param[in] err
+    ///     An Error to populate with any messages related to
+    ///     (de)materializing the struct.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool DoMaterialize (bool dematerialize,
                         ExecutionContext *exe_ctx,
-                        ClangPersistentVariable **result, /* must be non-NULL if D is set */
+                        ClangPersistentVariable **result,
                         Error &err);
 
+    //------------------------------------------------------------------
+    /// Actually do the task of materializing or dematerializing a persistent
+    /// variable.
+    ///
+    /// @param[in] dematerialize
+    ///     True if the variable is to be dematerialized; false if it is to
+    ///     be materialized.
+    ///
+    /// @param[in] exe_ctx
+    ///     The execution context to use.
+    ///
+    /// @param[in] name
+    ///     The name of the persistent variable.
+    ///
+    /// @param[in] addr
+    ///     The address at which to materialize the variable.
+    ///
+    /// @param[in] err
+    ///     An Error to populate with any messages related to
+    ///     (de)materializing the persistent variable.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool DoMaterializeOnePersistentVariable(bool dematerialize,
                                             ExecutionContext &exe_ctx,
                                             const char *name,
                                             lldb::addr_t addr,
                                             Error &err);
     
+    //------------------------------------------------------------------
+    /// Actually do the task of materializing or dematerializing a 
+    /// variable.
+    ///
+    /// @param[in] dematerialize
+    ///     True if the variable is to be dematerialized; false if it is to
+    ///     be materialized.
+    ///
+    /// @param[in] exe_ctx
+    ///     The execution context to use.
+    ///
+    /// @param[in] sym_ctx
+    ///     The symbol context to use (for looking the variable up).
+    ///
+    /// @param[in] name
+    ///     The name of the variable (for looking the variable up).
+    ///
+    /// @param[in] type
+    ///     The required type of the variable (for looking the variable up).
+    ///
+    /// @param[in] addr
+    ///     The address at which to materialize the variable.
+    ///
+    /// @param[in] err
+    ///     An Error to populate with any messages related to
+    ///     (de)materializing the persistent variable.
+    ///
+    /// @return
+    ///     True on success; false otherwise.
+    //------------------------------------------------------------------
     bool DoMaterializeOneVariable(bool dematerialize,
                                   ExecutionContext &exe_ctx,
                                   const SymbolContext &sym_ctx,

Modified: lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp?rev=111049&r1=111048&r2=111049&view=diff
==============================================================================
--- lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp (original)
+++ lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp Fri Aug 13 17:29:54 2010
@@ -115,8 +115,7 @@
 ClangExpressionDeclMap::AddValueToStruct (llvm::Value *value,
                                           const clang::NamedDecl *decl,
                                           std::string &name,
-                                          void *parser_type,
-                                          clang::ASTContext *parser_ast_context,
+                                          TypeFromParser type,
                                           size_t size,
                                           off_t alignment)
 {
@@ -137,7 +136,7 @@
     member.m_value          = value;
     member.m_decl           = decl;
     member.m_name           = name;
-    member.m_parser_type    = TypeFromParser(parser_type, parser_ast_context);
+    member.m_parser_type    = type;
     member.m_offset         = 0;
     member.m_size           = size;
     member.m_alignment      = alignment;

Modified: lldb/trunk/source/Expression/IRForTarget.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/IRForTarget.cpp?rev=111049&r1=111048&r2=111049&view=diff
==============================================================================
--- lldb/trunk/source/Expression/IRForTarget.cpp (original)
+++ lldb/trunk/source/Expression/IRForTarget.cpp Fri Aug 13 17:29:54 2010
@@ -528,8 +528,7 @@
         if (named_decl && !m_decl_map->AddValueToStruct(V, 
                                                         named_decl,
                                                         name,
-                                                        qual_type,
-                                                        ast_context,
+                                                        lldb_private::TypeFromParser(qual_type, ast_context),
                                                         value_size, 
                                                         value_alignment))
             return false;





More information about the lldb-commits mailing list