This is an archive of the discontinued LLVM Phabricator instance.

Differential D13102

Rename clang_type -> compiler_type for variables.
ClosedPublic

Authored by brucem on Sep 23 2015, 8:38 AM.

Details

Reviewers
clayborg
Commits
rG3ad353f3f44e: Rename clang_type -> compiler_type for variables.
rLLDB248461: Rename clang_type -> compiler_type for variables.
rL248461: Rename clang_type -> compiler_type for variables.

Diff Detail

Repository
rL LLVM

Event Timeline

brucem updated this revision to Diff 35509.Sep 23 2015, 8:38 AM
brucem retitled this revision from to Rename clang_type -> compiler_type for variables..
brucem updated this object.
brucem added a reviewer: clayborg.
brucem added a subscriber: lldb-commits.
brucem added a comment.Sep 23 2015, 8:39 AM

This doesn't cover files with Clang in their name. But it should cover just about everything else.

clayborg accepted this revision.Sep 23 2015, 10:41 AM
clayborg edited edge metadata.

Looks good.

This revision is now accepted and ready to land.Sep 23 2015, 10:41 AM
Closed by commit rL248461: Rename clang_type -> compiler_type for variables. (authored by brucem). · Explain WhySep 23 2015, 10:30 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lldb/
trunk/
include/
lldb/
Core/
4 lines
4 lines
6 lines
14 lines
2 lines
4 lines
2 lines
2 lines
2 lines
Expression/
2 lines
6 lines
4 lines
Symbol/
14 lines
4 lines
2 lines
2 lines
4 lines
72 lines
2 lines
Target/
2 lines
2 lines
source/
API/
6 lines
Commands/
10 lines
Core/
32 lines
152 lines
6 lines
12 lines
32 lines
4 lines
8 lines
36 lines
26 lines
10 lines
8 lines
Expression/
4 lines
10 lines
Plugins/
ABI/
MacOSX-arm/
32 lines
MacOSX-arm64/
18 lines
MacOSX-i386/
34 lines
SysV-arm/
44 lines
SysV-arm64/
18 lines
SysV-hexagon/
4 lines
SysV-i386/
46 lines
SysV-mips/
28 lines
SysV-mips64/
44 lines
SysV-ppc/
70 lines
SysV-ppc64/
70 lines
SysV-x86_64/
72 lines
Language/
CPlusPlus/
6 lines
ObjC/
22 lines
LanguageRuntime/
ObjC/
AppleObjCRuntime/
18 lines
SymbolFile/
DWARF/
2 lines
6 lines
2 lines
60 lines
4 lines
26 lines
2 lines
8 lines
Symtab/
2 lines
2 lines
Symbol/
18 lines
18 lines
114 lines
52 lines
Target/
6 lines
6 lines
test/
lang/
objc/
foundation/
4 lines
www/
2 lines

Diff 35586

lldb/trunk/include/lldb/Core/Value.h

Show First 20 Lines • Show All 130 Lines • ▼ Show 20 Linespublic:
Value & Value &
operator=(const Value &rhs); operator=(const Value &rhs);
const CompilerType & const CompilerType &
GetCompilerType(); GetCompilerType();
void void
SetCompilerType (const CompilerType &clang_type); SetCompilerType (const CompilerType &compiler_type);
ValueType ValueType
GetValueType() const; GetValueType() const;
AddressType AddressType
GetValueAddressType () const; GetValueAddressType () const;
ContextType ContextType
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Linespublic:
GetData (DataExtractor &data); GetData (DataExtractor &data);
void void
Clear(); Clear();
protected: protected:
Scalar m_value; Scalar m_value;
Vector m_vector; Vector m_vector;
CompilerType m_clang_type; CompilerType m_compiler_type;
void * m_context; void * m_context;
ValueType m_value_type; ValueType m_value_type;
ContextType m_context_type; ContextType m_context_type;
DataBufferHeap m_data_buffer; DataBufferHeap m_data_buffer;
}; };
class ValueList class ValueList
{ {
Show All 32 Lines

lldb/trunk/include/lldb/Core/ValueObject.h

Show First 20 Lines • Show All 402 Lines • ▼ Show 20 Lines// SetContext (ExecutionContextScope *exe_scope);
virtual ConstString virtual ConstString
GetQualifiedTypeName(); GetQualifiedTypeName();
virtual lldb::LanguageType virtual lldb::LanguageType
GetObjectRuntimeLanguage(); GetObjectRuntimeLanguage();
virtual uint32_t virtual uint32_t
GetTypeInfo (CompilerType *pointee_or_element_clang_type = NULL); GetTypeInfo (CompilerType *pointee_or_element_compiler_type = NULL);
virtual bool virtual bool
IsPointerType (); IsPointerType ();
virtual bool virtual bool
IsArrayType (); IsArrayType ();
virtual bool virtual bool
▲ Show 20 Lines • Show All 321 Lines • ▼ Show 20 Lines// SetContext (ExecutionContextScope *exe_scope);
{ {
} }
// Find the address of the C++ vtable pointer // Find the address of the C++ vtable pointer
virtual lldb::addr_t virtual lldb::addr_t
GetCPPVTableAddress(AddressType &address_type); GetCPPVTableAddress(AddressType &address_type);
virtual lldb::ValueObjectSP virtual lldb::ValueObjectSP
Cast (const CompilerType &clang_ast_type); Cast (const CompilerType &compiler_type);
virtual lldb::ValueObjectSP virtual lldb::ValueObjectSP
CastPointerType (const char *name, CastPointerType (const char *name,
CompilerType &ast_type); CompilerType &ast_type);
virtual lldb::ValueObjectSP virtual lldb::ValueObjectSP
CastPointerType (const char *name, CastPointerType (const char *name,
lldb::TypeSP &type_sp); lldb::TypeSP &type_sp);
▲ Show 20 Lines • Show All 524 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/ValueObjectChild.h

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Linesprotected:
UpdateValue (); UpdateValue ();
virtual LazyBool virtual LazyBool
CanUpdateWithInvalidExecutionContext (); CanUpdateWithInvalidExecutionContext ();
virtual CompilerType virtual CompilerType
GetCompilerTypeImpl () GetCompilerTypeImpl ()
{ {
return m_clang_type; return m_compiler_type;
} }
CompilerType m_clang_type; CompilerType m_compiler_type;
ConstString m_type_name; ConstString m_type_name;
uint64_t m_byte_size; uint64_t m_byte_size;
int32_t m_byte_offset; int32_t m_byte_offset;
uint8_t m_bitfield_bit_size; uint8_t m_bitfield_bit_size;
uint8_t m_bitfield_bit_offset; uint8_t m_bitfield_bit_offset;
bool m_is_base_class; bool m_is_base_class;
bool m_is_deref_of_parent; bool m_is_deref_of_parent;
llvm::Optional<LazyBool> m_can_update_with_invalid_exe_ctx; llvm::Optional<LazyBool> m_can_update_with_invalid_exe_ctx;
// //
// void // void
// ReadValueFromMemory (ValueObject* parent, lldb::addr_t address); // ReadValueFromMemory (ValueObject* parent, lldb::addr_t address);
protected: protected:
friend class ValueObject; friend class ValueObject;
friend class ValueObjectConstResult; friend class ValueObjectConstResult;
friend class ValueObjectConstResultImpl; friend class ValueObjectConstResultImpl;
ValueObjectChild (ValueObject &parent, ValueObjectChild (ValueObject &parent,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
uint64_t byte_size, uint64_t byte_size,
int32_t byte_offset, int32_t byte_offset,
uint32_t bitfield_bit_size, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, uint32_t bitfield_bit_offset,
bool is_base_class, bool is_base_class,
bool is_deref_of_parent, bool is_deref_of_parent,
AddressType child_ptr_or_ref_addr_type); AddressType child_ptr_or_ref_addr_type);
DISALLOW_COPY_AND_ASSIGN (ValueObjectChild); DISALLOW_COPY_AND_ASSIGN (ValueObjectChild);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_ValueObjectChild_h_ #endif // liblldb_ValueObjectChild_h_

lldb/trunk/include/lldb/Core/ValueObjectConstResult.h

Show All 28 Linespublic:
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create (ExecutionContextScope *exe_scope, Create (ExecutionContextScope *exe_scope,
lldb::ByteOrder byte_order, lldb::ByteOrder byte_order,
uint32_t addr_byte_size, uint32_t addr_byte_size,
lldb::addr_t address = LLDB_INVALID_ADDRESS); lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create (ExecutionContextScope *exe_scope, Create (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
const DataExtractor &data, const DataExtractor &data,
lldb::addr_t address = LLDB_INVALID_ADDRESS); lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create (ExecutionContextScope *exe_scope, Create (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
const lldb::DataBufferSP &result_data_sp, const lldb::DataBufferSP &result_data_sp,
lldb::ByteOrder byte_order, lldb::ByteOrder byte_order,
uint32_t addr_size, uint32_t addr_size,
lldb::addr_t address = LLDB_INVALID_ADDRESS); lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create (ExecutionContextScope *exe_scope, Create (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
lldb::addr_t address, lldb::addr_t address,
AddressType address_type, AddressType address_type,
uint32_t addr_byte_size); uint32_t addr_byte_size);
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create (ExecutionContextScope *exe_scope, Create (ExecutionContextScope *exe_scope,
Value &value, Value &value,
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linespublic:
virtual lldb::ValueObjectSP virtual lldb::ValueObjectSP
GetDynamicValue (lldb::DynamicValueType valueType); GetDynamicValue (lldb::DynamicValueType valueType);
virtual lldb::LanguageType virtual lldb::LanguageType
GetPreferredDisplayLanguage (); GetPreferredDisplayLanguage ();
virtual lldb::ValueObjectSP virtual lldb::ValueObjectSP
Cast (const CompilerType &clang_ast_type); Cast (const CompilerType &compiler_type);
protected: protected:
virtual bool virtual bool
UpdateValue (); UpdateValue ();
virtual CompilerType virtual CompilerType
GetCompilerTypeImpl (); GetCompilerTypeImpl ();
ConstString m_type_name; ConstString m_type_name;
uint64_t m_byte_size; uint64_t m_byte_size;
ValueObjectConstResultImpl m_impl; ValueObjectConstResultImpl m_impl;
private: private:
friend class ValueObjectConstResultImpl; friend class ValueObjectConstResultImpl;
ValueObjectConstResult (ExecutionContextScope *exe_scope, ValueObjectConstResult (ExecutionContextScope *exe_scope,
lldb::ByteOrder byte_order, lldb::ByteOrder byte_order,
uint32_t addr_byte_size, uint32_t addr_byte_size,
lldb::addr_t address); lldb::addr_t address);
ValueObjectConstResult (ExecutionContextScope *exe_scope, ValueObjectConstResult (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
const DataExtractor &data, const DataExtractor &data,
lldb::addr_t address); lldb::addr_t address);
ValueObjectConstResult (ExecutionContextScope *exe_scope, ValueObjectConstResult (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
const lldb::DataBufferSP &result_data_sp, const lldb::DataBufferSP &result_data_sp,
lldb::ByteOrder byte_order, lldb::ByteOrder byte_order,
uint32_t addr_size, uint32_t addr_size,
lldb::addr_t address); lldb::addr_t address);
ValueObjectConstResult (ExecutionContextScope *exe_scope, ValueObjectConstResult (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
lldb::addr_t address, lldb::addr_t address,
AddressType address_type, AddressType address_type,
uint32_t addr_byte_size); uint32_t addr_byte_size);
ValueObjectConstResult (ExecutionContextScope *exe_scope, ValueObjectConstResult (ExecutionContextScope *exe_scope,
const Value &value, const Value &value,
const ConstString &name, const ConstString &name,
Show All 11 Lines

lldb/trunk/include/lldb/Core/ValueObjectConstResultCast.h

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Linespublic:
AddressOf (Error &error) override; AddressOf (Error &error) override;
size_t size_t
GetPointeeData (DataExtractor& data, GetPointeeData (DataExtractor& data,
uint32_t item_idx = 0, uint32_t item_idx = 0,
uint32_t item_count = 1) override; uint32_t item_count = 1) override;
lldb::ValueObjectSP lldb::ValueObjectSP
Cast (const CompilerType &clang_ast_type) override; Cast (const CompilerType &compiler_type) override;
protected: protected:
ValueObjectConstResultImpl m_impl; ValueObjectConstResultImpl m_impl;
private: private:
friend class ValueObject; friend class ValueObject;
friend class ValueObjectConstResult; friend class ValueObjectConstResult;
friend class ValueObjectConstResultImpl; friend class ValueObjectConstResultImpl;
DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResultCast); DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResultCast);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_ValueObjectConstResultCast_h_ #endif // liblldb_ValueObjectConstResultCast_h_

lldb/trunk/include/lldb/Core/ValueObjectConstResultChild.h

Show All 21 Lines
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// A child of a ValueObjectConstResult. // A child of a ValueObjectConstResult.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
class ValueObjectConstResultChild : public ValueObjectChild class ValueObjectConstResultChild : public ValueObjectChild
{ {
public: public:
ValueObjectConstResultChild (ValueObject &parent, ValueObjectConstResultChild (ValueObject &parent,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
uint32_t byte_size, uint32_t byte_size,
int32_t byte_offset, int32_t byte_offset,
uint32_t bitfield_bit_size, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, uint32_t bitfield_bit_offset,
bool is_base_class, bool is_base_class,
bool is_deref_of_parent, bool is_deref_of_parent,
lldb::addr_t live_address = LLDB_INVALID_ADDRESS); lldb::addr_t live_address = LLDB_INVALID_ADDRESS);
Show All 19 Linespublic:
AddressOf (Error &error) override; AddressOf (Error &error) override;
size_t size_t
GetPointeeData (DataExtractor& data, GetPointeeData (DataExtractor& data,
uint32_t item_idx = 0, uint32_t item_idx = 0,
uint32_t item_count = 1) override; uint32_t item_count = 1) override;
lldb::ValueObjectSP lldb::ValueObjectSP
Cast (const CompilerType &clang_ast_type) override; Cast (const CompilerType &compiler_type) override;
protected: protected:
ValueObjectConstResultImpl m_impl; ValueObjectConstResultImpl m_impl;
private: private:
friend class ValueObject; friend class ValueObject;
friend class ValueObjectConstResult; friend class ValueObjectConstResult;
friend class ValueObjectConstResultImpl; friend class ValueObjectConstResultImpl;
DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResultChild); DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResultChild);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_ValueObjectConstResultChild_h_ #endif // liblldb_ValueObjectConstResultChild_h_

lldb/trunk/include/lldb/Core/ValueObjectConstResultImpl.h

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linespublic:
lldb::addr_t lldb::addr_t
GetLiveAddress() GetLiveAddress()
{ {
return m_live_address; return m_live_address;
} }
lldb::ValueObjectSP lldb::ValueObjectSP
Cast (const CompilerType &clang_ast_type); Cast (const CompilerType &compiler_type);
void void
SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS, SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS,
AddressType address_type = eAddressTypeLoad) AddressType address_type = eAddressTypeLoad)
{ {
m_live_address = addr; m_live_address = addr;
m_live_address_type = address_type; m_live_address_type = address_type;
} }
Show All 24 Lines

lldb/trunk/include/lldb/Core/ValueObjectMemory.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesprotected:
virtual bool virtual bool
UpdateValue (); UpdateValue ();
virtual CompilerType virtual CompilerType
GetCompilerTypeImpl (); GetCompilerTypeImpl ();
Address m_address; ///< The variable that this value object is based upon Address m_address; ///< The variable that this value object is based upon
lldb::TypeSP m_type_sp; lldb::TypeSP m_type_sp;
CompilerType m_clang_type; CompilerType m_compiler_type;
private: private:
ValueObjectMemory (ExecutionContextScope *exe_scope, ValueObjectMemory (ExecutionContextScope *exe_scope,
const char *name, const char *name,
const Address &address, const Address &address,
lldb::TypeSP &type_sp); lldb::TypeSP &type_sp);
ValueObjectMemory (ExecutionContextScope *exe_scope, ValueObjectMemory (ExecutionContextScope *exe_scope,
Show All 12 Lines

lldb/trunk/include/lldb/Core/ValueObjectRegister.h

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Linesprotected:
virtual CompilerType virtual CompilerType
GetCompilerTypeImpl (); GetCompilerTypeImpl ();
lldb::RegisterContextSP m_reg_ctx_sp; lldb::RegisterContextSP m_reg_ctx_sp;
RegisterInfo m_reg_info; RegisterInfo m_reg_info;
RegisterValue m_reg_value; RegisterValue m_reg_value;
ConstString m_type_name; ConstString m_type_name;
CompilerType m_clang_type; CompilerType m_compiler_type;
private: private:
void void
ConstructObject (uint32_t reg_num); ConstructObject (uint32_t reg_num);
friend class ValueObjectRegisterSet; friend class ValueObjectRegisterSet;
ValueObjectRegister (ValueObject &parent, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num); ValueObjectRegister (ValueObject &parent, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num);
ValueObjectRegister (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num); ValueObjectRegister (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num);
Show All 10 Lines

lldb/trunk/include/lldb/Expression/ASTDumper.h

Show All 21 Lines
class ASTDumper class ASTDumper
{ {
public: public:
ASTDumper (clang::Decl *decl); ASTDumper (clang::Decl *decl);
ASTDumper (clang::DeclContext *decl_ctx); ASTDumper (clang::DeclContext *decl_ctx);
ASTDumper (const clang::Type *type); ASTDumper (const clang::Type *type);
ASTDumper (clang::QualType type); ASTDumper (clang::QualType type);
ASTDumper (lldb::opaque_compiler_type_t type); ASTDumper (lldb::opaque_compiler_type_t type);
ASTDumper (const CompilerType &clang_type); ASTDumper (const CompilerType &compiler_type);
const char *GetCString(); const char *GetCString();
void ToSTDERR(); void ToSTDERR();
void ToLog(Log *log, const char *prefix); void ToLog(Log *log, const char *prefix);
void ToStream(lldb::StreamSP &stream); void ToStream(lldb::StreamSP &stream);
private: private:
std::string m_dump; std::string m_dump;
}; };
} // namespace lldb_private } // namespace lldb_private
#endif #endif

lldb/trunk/include/lldb/Expression/ClangASTSource.h

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Linesprotected:
/// ///
/// @param[in] dest_context /// @param[in] dest_context
/// The target AST context, typically the parser's AST context. /// The target AST context, typically the parser's AST context.
/// ///
/// @param[in] source_context /// @param[in] source_context
/// The source AST context, typically the AST context of whatever /// The source AST context, typically the AST context of whatever
/// symbol file the type was found in. /// symbol file the type was found in.
/// ///
/// @param[in] clang_type /// @param[in] src_type
/// The source type. /// The source type.
/// ///
/// @return /// @return
/// The imported type. /// The imported type.
//------------------------------------------------------------------ //------------------------------------------------------------------
CompilerType CompilerType
GuardedCopyType (const CompilerType &src_type); GuardedCopyType (const CompilerType &src_type);
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Linesstruct NameSearchContext {
/// right places. /// right places.
//------------------------------------------------------------------ //------------------------------------------------------------------
clang::NamedDecl *AddGenericFunDecl(); clang::NamedDecl *AddGenericFunDecl();
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Create a TypeDecl with the name being searched for and the provided /// Create a TypeDecl with the name being searched for and the provided
/// type and register it in the right places. /// type and register it in the right places.
/// ///
/// @param[in] type /// @param[in] compiler_type
/// The opaque QualType for the TypeDecl being registered. /// The opaque QualType for the TypeDecl being registered.
//------------------------------------------------------------------ //------------------------------------------------------------------
clang::NamedDecl *AddTypeDecl(const CompilerType &clang_type); clang::NamedDecl *AddTypeDecl(const CompilerType &compiler_type);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Add Decls from the provided DeclContextLookupResult to the list /// Add Decls from the provided DeclContextLookupResult to the list
/// of results. /// of results.
/// ///
/// @param[in] result /// @param[in] result
/// The DeclContextLookupResult, usually returned as the result /// The DeclContextLookupResult, usually returned as the result
Show All 17 Lines

lldb/trunk/include/lldb/Expression/ExpressionVariable.h

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Linespublic:
CompilerType CompilerType
GetCompilerType() GetCompilerType()
{ {
return m_frozen_sp->GetCompilerType(); return m_frozen_sp->GetCompilerType();
} }
void void
SetCompilerType(const CompilerType &clang_type) SetCompilerType(const CompilerType &compiler_type)
{ {
m_frozen_sp->GetValue().SetCompilerType(clang_type); m_frozen_sp->GetValue().SetCompilerType(compiler_type);
} }
void void
SetName (const ConstString &name) SetName (const ConstString &name)
{ {
m_frozen_sp->SetName (name); m_frozen_sp->SetName (name);
} }
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/ClangASTContext.h

Show First 20 Lines • Show All 247 Lines • ▼ Show 20 Linespublic:
static CompilerType static CompilerType
GetTypeForDecl (clang::ObjCInterfaceDecl *objc_decl); GetTypeForDecl (clang::ObjCInterfaceDecl *objc_decl);
template <typename RecordDeclType> template <typename RecordDeclType>
CompilerType CompilerType
GetTypeForIdentifier (const ConstString &type_name) GetTypeForIdentifier (const ConstString &type_name)
{ {
CompilerType clang_type; CompilerType compiler_type;
if (type_name.GetLength()) if (type_name.GetLength())
{ {
clang::ASTContext *ast = getASTContext(); clang::ASTContext *ast = getASTContext();
if (ast) if (ast)
{ {
clang::IdentifierInfo &myIdent = ast->Idents.get(type_name.GetCString()); clang::IdentifierInfo &myIdent = ast->Idents.get(type_name.GetCString());
clang::DeclarationName myName = ast->DeclarationNames.getIdentifier(&myIdent); clang::DeclarationName myName = ast->DeclarationNames.getIdentifier(&myIdent);
clang::DeclContext::lookup_result result = ast->getTranslationUnitDecl()->lookup(myName); clang::DeclContext::lookup_result result = ast->getTranslationUnitDecl()->lookup(myName);
if (!result.empty()) if (!result.empty())
{ {
clang::NamedDecl *named_decl = result[0]; clang::NamedDecl *named_decl = result[0];
if (const RecordDeclType *record_decl = llvm::dyn_cast<RecordDeclType>(named_decl)) if (const RecordDeclType *record_decl = llvm::dyn_cast<RecordDeclType>(named_decl))
clang_type.SetCompilerType(ast, clang::QualType(record_decl->getTypeForDecl(), 0)); compiler_type.SetCompilerType(ast, clang::QualType(record_decl->getTypeForDecl(), 0));
} }
} }
} }
return clang_type; return compiler_type;
} }
CompilerType CompilerType
GetOrCreateStructForIdentifier (const ConstString &type_name, GetOrCreateStructForIdentifier (const ConstString &type_name,
const std::initializer_list< std::pair < const char *, CompilerType > >& type_fields, const std::initializer_list< std::pair < const char *, CompilerType > >& type_fields,
bool packed = false); bool packed = false);
//------------------------------------------------------------------ //------------------------------------------------------------------
▲ Show 20 Lines • Show All 416 Lines • ▼ Show 20 Linespublic:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Accessors // Accessors
//---------------------------------------------------------------------- //----------------------------------------------------------------------
ConstString ConstString
GetTypeName (lldb::opaque_compiler_type_t type) override; GetTypeName (lldb::opaque_compiler_type_t type) override;
uint32_t uint32_t
GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) override; GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type) override;
lldb::LanguageType lldb::LanguageType
GetMinimumLanguage (lldb::opaque_compiler_type_t type) override; GetMinimumLanguage (lldb::opaque_compiler_type_t type) override;
lldb::TypeClass lldb::TypeClass
GetTypeClass (lldb::opaque_compiler_type_t type) override; GetTypeClass (lldb::opaque_compiler_type_t type) override;
unsigned unsigned
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 Linespublic:
bool bool
SetBaseClassesForClassType (lldb::opaque_compiler_type_t type, SetBaseClassesForClassType (lldb::opaque_compiler_type_t type,
clang::CXXBaseSpecifier const * const *base_classes, clang::CXXBaseSpecifier const * const *base_classes,
unsigned num_base_classes); unsigned num_base_classes);
static bool static bool
SetObjCSuperClass (const CompilerType& type, SetObjCSuperClass (const CompilerType& type,
const CompilerType &superclass_clang_type); const CompilerType &superclass_compiler_type);
static bool static bool
AddObjCClassProperty (const CompilerType& type, AddObjCClassProperty (const CompilerType& type,
const char *property_name, const char *property_name,
const CompilerType &property_clang_type, const CompilerType &property_compiler_type,
clang::ObjCIvarDecl *ivar_decl, clang::ObjCIvarDecl *ivar_decl,
const char *property_setter_name, const char *property_setter_name,
const char *property_getter_name, const char *property_getter_name,
uint32_t property_attributes, uint32_t property_attributes,
ClangASTMetadata *metadata); ClangASTMetadata *metadata);
static clang::ObjCMethodDecl * static clang::ObjCMethodDecl *
AddMethodToObjCObjectType (const CompilerType& type, AddMethodToObjCObjectType (const CompilerType& type,
const char *name, // the full symbol name as seen in the symbol table (lldb::opaque_compiler_type_t type, "-[NString stringWithCString:]") const char *name, // the full symbol name as seen in the symbol table (lldb::opaque_compiler_type_t type, "-[NString stringWithCString:]")
const CompilerType &method_clang_type, const CompilerType &method_compiler_type,
lldb::AccessType access, lldb::AccessType access,
bool is_artificial); bool is_artificial);
bool bool
SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern); SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern);
//------------------------------------------------------------------ //------------------------------------------------------------------
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/CompilerType.h

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Linespublic:
ConstString ConstString
GetTypeName () const; GetTypeName () const;
ConstString ConstString
GetDisplayTypeName () const; GetDisplayTypeName () const;
uint32_t uint32_t
GetTypeInfo (CompilerType *pointee_or_element_clang_type = NULL) const; GetTypeInfo (CompilerType *pointee_or_element_compiler_type = NULL) const;
lldb::LanguageType lldb::LanguageType
GetMinimumLanguage (); GetMinimumLanguage ();
lldb::opaque_compiler_type_t lldb::opaque_compiler_type_t
GetOpaqueQualType() const GetOpaqueQualType() const
{ {
return m_type; return m_type;
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Lines GetDirectBaseClassAtIndex (size_t idx,
uint32_t *bit_offset_ptr) const; uint32_t *bit_offset_ptr) const;
CompilerType CompilerType
GetVirtualBaseClassAtIndex (size_t idx, GetVirtualBaseClassAtIndex (size_t idx,
uint32_t *bit_offset_ptr) const; uint32_t *bit_offset_ptr) const;
uint32_t uint32_t
GetIndexOfFieldWithName (const char* name, GetIndexOfFieldWithName (const char* name,
CompilerType* field_clang_type = NULL, CompilerType* field_compiler_type = NULL,
uint64_t *bit_offset_ptr = NULL, uint64_t *bit_offset_ptr = NULL,
uint32_t *bitfield_bit_size_ptr = NULL, uint32_t *bitfield_bit_size_ptr = NULL,
bool *is_bitfield_ptr = NULL) const; bool *is_bitfield_ptr = NULL) const;
CompilerType CompilerType
GetChildCompilerTypeAtIndex (ExecutionContext *exe_ctx, GetChildCompilerTypeAtIndex (ExecutionContext *exe_ctx,
size_t idx, size_t idx,
bool transparent_pointers, bool transparent_pointers,
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/GoASTContext.h

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Lines public:
virtual uint32_t GetPointerByteSize() override; virtual uint32_t GetPointerByteSize() override;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Accessors // Accessors
//---------------------------------------------------------------------- //----------------------------------------------------------------------
virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type) override; virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type) override;
virtual uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type = NULL) override; virtual uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type = NULL) override;
virtual lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type) override; virtual lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type) override;
virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override; virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Creating related types // Creating related types
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/SymbolFile.h

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 Linespublic:
virtual size_t ParseCompileUnitFunctions (const SymbolContext& sc) = 0; virtual size_t ParseCompileUnitFunctions (const SymbolContext& sc) = 0;
virtual bool ParseCompileUnitLineTable (const SymbolContext& sc) = 0; virtual bool ParseCompileUnitLineTable (const SymbolContext& sc) = 0;
virtual bool ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files) = 0; virtual bool ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files) = 0;
virtual bool ParseImportedModules (const SymbolContext &sc, std::vector<ConstString> &imported_modules) = 0; virtual bool ParseImportedModules (const SymbolContext &sc, std::vector<ConstString> &imported_modules) = 0;
virtual size_t ParseFunctionBlocks (const SymbolContext& sc) = 0; virtual size_t ParseFunctionBlocks (const SymbolContext& sc) = 0;
virtual size_t ParseTypes (const SymbolContext& sc) = 0; virtual size_t ParseTypes (const SymbolContext& sc) = 0;
virtual size_t ParseVariablesForContext (const SymbolContext& sc) = 0; virtual size_t ParseVariablesForContext (const SymbolContext& sc) = 0;
virtual Type* ResolveTypeUID (lldb::user_id_t type_uid) = 0; virtual Type* ResolveTypeUID (lldb::user_id_t type_uid) = 0;
virtual bool CompleteType (CompilerType &clang_type) = 0; virtual bool CompleteType (CompilerType &compiler_type) = 0;
virtual void ParseDeclsForContext (CompilerDeclContext decl_ctx) {} virtual void ParseDeclsForContext (CompilerDeclContext decl_ctx) {}
virtual CompilerDecl GetDeclForUID (lldb::user_id_t uid) { return CompilerDecl(); } virtual CompilerDecl GetDeclForUID (lldb::user_id_t uid) { return CompilerDecl(); }
virtual CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) { return CompilerDeclContext(); } virtual CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) { return CompilerDeclContext(); }
virtual CompilerDeclContext GetDeclContextContainingUID (lldb::user_id_t uid) { return CompilerDeclContext(); } virtual CompilerDeclContext GetDeclContextContainingUID (lldb::user_id_t uid) { return CompilerDeclContext(); }
virtual uint32_t ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) = 0; virtual uint32_t ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) = 0;
virtual uint32_t ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list); virtual uint32_t ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list);
virtual uint32_t FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables); virtual uint32_t FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables);
virtual uint32_t FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables); virtual uint32_t FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/TaggedASTType.h

Show All 14 Lines
namespace lldb_private namespace lldb_private
{ {
// For cases in which there are multiple classes of types that are not // For cases in which there are multiple classes of types that are not
// interchangeable, to allow static type checking. // interchangeable, to allow static type checking.
template <unsigned int C> class TaggedASTType : public CompilerType template <unsigned int C> class TaggedASTType : public CompilerType
{ {
public: public:
TaggedASTType (const CompilerType &clang_type) : TaggedASTType (const CompilerType &compiler_type) :
CompilerType(clang_type) CompilerType(compiler_type)
{ {
} }
TaggedASTType (lldb::opaque_compiler_type_t type, TypeSystem * type_system) : TaggedASTType (lldb::opaque_compiler_type_t type, TypeSystem * type_system) :
CompilerType(type_system, type) CompilerType(type_system, type)
{ {
} }
Show All 29 Lines

lldb/trunk/include/lldb/Symbol/Type.h

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Linespublic:
Type (lldb::user_id_t uid, Type (lldb::user_id_t uid,
SymbolFile* symbol_file, SymbolFile* symbol_file,
const ConstString &name, const ConstString &name,
uint64_t byte_size, uint64_t byte_size,
SymbolContextScope *context, SymbolContextScope *context,
lldb::user_id_t encoding_uid, lldb::user_id_t encoding_uid,
EncodingDataType encoding_uid_type, EncodingDataType encoding_uid_type,
const Declaration& decl, const Declaration& decl,
const CompilerType &clang_qual_type, const CompilerType &compiler_qual_type,
ResolveState clang_type_resolve_state); ResolveState compiler_type_resolve_state);
// This makes an invalid type. Used for functions that return a Type when they // This makes an invalid type. Used for functions that return a Type when they
// get an error. // get an error.
Type(); Type();
Type (const Type &rhs); Type (const Type &rhs);
const Type& const Type&
▲ Show 20 Lines • Show All 183 Lines • ▼ Show 20 Linesprotected:
ConstString m_name; ConstString m_name;
SymbolFile *m_symbol_file; SymbolFile *m_symbol_file;
SymbolContextScope *m_context; // The symbol context in which this type is defined SymbolContextScope *m_context; // The symbol context in which this type is defined
Type *m_encoding_type; Type *m_encoding_type;
lldb::user_id_t m_encoding_uid; lldb::user_id_t m_encoding_uid;
EncodingDataType m_encoding_uid_type; EncodingDataType m_encoding_uid_type;
uint64_t m_byte_size; uint64_t m_byte_size;
Declaration m_decl; Declaration m_decl;
CompilerType m_clang_type; CompilerType m_compiler_type;
struct Flags { struct Flags {
#ifdef __GNUC__ #ifdef __GNUC__
// using unsigned type here to work around a very noisy gcc warning // using unsigned type here to work around a very noisy gcc warning
unsigned clang_type_resolve_state : 2; unsigned compiler_type_resolve_state : 2;
#else #else
ResolveState clang_type_resolve_state : 2; ResolveState compiler_type_resolve_state : 2;
#endif #endif
bool is_complete_objc_class : 1; bool is_complete_objc_class : 1;
} m_flags; } m_flags;
Type * Type *
GetEncodingType (); GetEncodingType ();
bool bool
ResolveClangType (ResolveState clang_type_resolve_state); ResolveClangType (ResolveState compiler_type_resolve_state);
}; };
// these classes are used to back the SBType* objects // these classes are used to back the SBType* objects
class TypePair class TypePair
{ {
public: public:
TypePair () : TypePair () :
clang_type(), compiler_type(),
type_sp() type_sp()
{ {
} }
TypePair (CompilerType type) : TypePair (CompilerType type) :
clang_type(type), compiler_type(type),
type_sp() type_sp()
{ {
} }
TypePair (lldb::TypeSP type) : TypePair (lldb::TypeSP type) :
clang_type(), compiler_type(),
type_sp(type) type_sp(type)
{ {
clang_type = type_sp->GetForwardCompilerType (); compiler_type = type_sp->GetForwardCompilerType ();
} }
bool bool
IsValid () const IsValid () const
{ {
return clang_type.IsValid() || (type_sp.get() != nullptr); return compiler_type.IsValid() || (type_sp.get() != nullptr);
} }
explicit operator bool () const explicit operator bool () const
{ {
return IsValid(); return IsValid();
} }
bool bool
operator == (const TypePair& rhs) const operator == (const TypePair& rhs) const
{ {
return clang_type == rhs.clang_type && return compiler_type == rhs.compiler_type &&
type_sp.get() == rhs.type_sp.get(); type_sp.get() == rhs.type_sp.get();
} }
bool bool
operator != (const TypePair& rhs) const operator != (const TypePair& rhs) const
{ {
return clang_type != rhs.clang_type || return compiler_type != rhs.compiler_type ||
type_sp.get() != rhs.type_sp.get(); type_sp.get() != rhs.type_sp.get();
} }
void void
Clear () Clear ()
{ {
clang_type.Clear(); compiler_type.Clear();
type_sp.reset(); type_sp.reset();
} }
ConstString ConstString
GetName () const GetName () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetName(); return type_sp->GetName();
if (clang_type) if (compiler_type)
return clang_type.GetTypeName(); return compiler_type.GetTypeName();
return ConstString (); return ConstString ();
} }
ConstString ConstString
GetDisplayTypeName () const GetDisplayTypeName () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType ().GetDisplayTypeName(); return type_sp->GetForwardCompilerType ().GetDisplayTypeName();
if (clang_type) if (compiler_type)
return clang_type.GetDisplayTypeName(); return compiler_type.GetDisplayTypeName();
return ConstString(); return ConstString();
} }
void void
SetType (CompilerType type) SetType (CompilerType type)
{ {
type_sp.reset(); type_sp.reset();
clang_type = type; compiler_type = type;
} }
void void
SetType (lldb::TypeSP type) SetType (lldb::TypeSP type)
{ {
type_sp = type; type_sp = type;
clang_type = type_sp->GetForwardCompilerType (); compiler_type = type_sp->GetForwardCompilerType ();
} }
lldb::TypeSP lldb::TypeSP
GetTypeSP () const GetTypeSP () const
{ {
return type_sp; return type_sp;
} }
CompilerType CompilerType
GetCompilerType () const GetCompilerType () const
{ {
return clang_type; return compiler_type;
} }
CompilerType CompilerType
GetPointerType () const GetPointerType () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType().GetPointerType(); return type_sp->GetForwardCompilerType().GetPointerType();
return clang_type.GetPointerType(); return compiler_type.GetPointerType();
} }
CompilerType CompilerType
GetPointeeType () const GetPointeeType () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType ().GetPointeeType(); return type_sp->GetForwardCompilerType ().GetPointeeType();
return clang_type.GetPointeeType(); return compiler_type.GetPointeeType();
} }
CompilerType CompilerType
GetReferenceType () const GetReferenceType () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType ().GetLValueReferenceType(); return type_sp->GetForwardCompilerType ().GetLValueReferenceType();
else else
return clang_type.GetLValueReferenceType(); return compiler_type.GetLValueReferenceType();
} }
CompilerType CompilerType
GetTypedefedType () const GetTypedefedType () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType ().GetTypedefedType(); return type_sp->GetForwardCompilerType ().GetTypedefedType();
else else
return clang_type.GetTypedefedType(); return compiler_type.GetTypedefedType();
} }
CompilerType CompilerType
GetDereferencedType () const GetDereferencedType () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType ().GetNonReferenceType(); return type_sp->GetForwardCompilerType ().GetNonReferenceType();
else else
return clang_type.GetNonReferenceType(); return compiler_type.GetNonReferenceType();
} }
CompilerType CompilerType
GetUnqualifiedType () const GetUnqualifiedType () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType ().GetFullyUnqualifiedType(); return type_sp->GetForwardCompilerType ().GetFullyUnqualifiedType();
else else
return clang_type.GetFullyUnqualifiedType(); return compiler_type.GetFullyUnqualifiedType();
} }
CompilerType CompilerType
GetCanonicalType () const GetCanonicalType () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType ().GetCanonicalType(); return type_sp->GetForwardCompilerType ().GetCanonicalType();
return clang_type.GetCanonicalType(); return compiler_type.GetCanonicalType();
} }
TypeSystem * TypeSystem *
GetTypeSystem () const GetTypeSystem () const
{ {
return clang_type.GetTypeSystem(); return compiler_type.GetTypeSystem();
} }
lldb::ModuleSP lldb::ModuleSP
GetModule () const GetModule () const
{ {
if (type_sp) if (type_sp)
return type_sp->GetModule(); return type_sp->GetModule();
return lldb::ModuleSP(); return lldb::ModuleSP();
} }
protected: protected:
CompilerType clang_type; CompilerType compiler_type;
lldb::TypeSP type_sp; lldb::TypeSP type_sp;
}; };
class TypeImpl class TypeImpl
{ {
public: public:
TypeImpl(); TypeImpl();
~TypeImpl () {} ~TypeImpl () {}
TypeImpl(const TypeImpl& rhs); TypeImpl(const TypeImpl& rhs);
TypeImpl (const lldb::TypeSP &type_sp); TypeImpl (const lldb::TypeSP &type_sp);
TypeImpl (const CompilerType &clang_type); TypeImpl (const CompilerType &compiler_type);
TypeImpl (const lldb::TypeSP &type_sp, const CompilerType &dynamic); TypeImpl (const lldb::TypeSP &type_sp, const CompilerType &dynamic);
TypeImpl (const CompilerType &clang_type, const CompilerType &dynamic); TypeImpl (const CompilerType &compiler_type, const CompilerType &dynamic);
TypeImpl (const TypePair &pair, const CompilerType &dynamic); TypeImpl (const TypePair &pair, const CompilerType &dynamic);
void void
SetType (const lldb::TypeSP &type_sp); SetType (const lldb::TypeSP &type_sp);
void void
SetType (const CompilerType &clang_type); SetType (const CompilerType &compiler_type);
void void
SetType (const lldb::TypeSP &type_sp, const CompilerType &dynamic); SetType (const lldb::TypeSP &type_sp, const CompilerType &dynamic);
void void
SetType (const CompilerType &clang_type, const CompilerType &dynamic); SetType (const CompilerType &compiler_type, const CompilerType &dynamic);
void void
SetType (const TypePair &pair, const CompilerType &dynamic); SetType (const TypePair &pair, const CompilerType &dynamic);
TypeImpl& TypeImpl&
operator = (const TypeImpl& rhs); operator = (const TypeImpl& rhs);
bool bool
▲ Show 20 Lines • Show All 206 Lines • ▼ Show 20 Lines
/// purposes. /// purposes.
/// ///
class TypeAndOrName class TypeAndOrName
{ {
public: public:
TypeAndOrName (); TypeAndOrName ();
TypeAndOrName (lldb::TypeSP &type_sp); TypeAndOrName (lldb::TypeSP &type_sp);
TypeAndOrName (const CompilerType &clang_type); TypeAndOrName (const CompilerType &compiler_type);
TypeAndOrName (const char *type_str); TypeAndOrName (const char *type_str);
TypeAndOrName (const TypeAndOrName &rhs); TypeAndOrName (const TypeAndOrName &rhs);
TypeAndOrName (ConstString &type_const_string); TypeAndOrName (ConstString &type_const_string);
TypeAndOrName & TypeAndOrName &
operator= (const TypeAndOrName &rhs); operator= (const TypeAndOrName &rhs);
bool bool
Show All 21 Linespublic:
void void
SetName (const char *type_name_cstr); SetName (const char *type_name_cstr);
void void
SetTypeSP (lldb::TypeSP type_sp); SetTypeSP (lldb::TypeSP type_sp);
void void
SetCompilerType (CompilerType clang_type); SetCompilerType (CompilerType compiler_type);
bool bool
IsEmpty () const; IsEmpty () const;
bool bool
HasName () const; HasName () const;
bool bool
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/TypeSystem.h

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 Linespublic:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Accessors // Accessors
//---------------------------------------------------------------------- //----------------------------------------------------------------------
virtual ConstString virtual ConstString
GetTypeName (lldb::opaque_compiler_type_t type) = 0; GetTypeName (lldb::opaque_compiler_type_t type) = 0;
virtual uint32_t virtual uint32_t
GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) = 0; GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type) = 0;
virtual lldb::LanguageType virtual lldb::LanguageType
GetMinimumLanguage (lldb::opaque_compiler_type_t type) = 0; GetMinimumLanguage (lldb::opaque_compiler_type_t type) = 0;
virtual lldb::TypeClass virtual lldb::TypeClass
GetTypeClass (lldb::opaque_compiler_type_t type) = 0; GetTypeClass (lldb::opaque_compiler_type_t type) = 0;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
▲ Show 20 Lines • Show All 299 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/LanguageRuntime.h

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Linespublic:
virtual lldb::BreakpointResolverSP virtual lldb::BreakpointResolverSP
CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp) = 0; CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp) = 0;
virtual lldb::SearchFilterSP virtual lldb::SearchFilterSP
CreateExceptionSearchFilter (); CreateExceptionSearchFilter ();
virtual bool virtual bool
GetTypeBitSize (const CompilerType& clang_type, GetTypeBitSize (const CompilerType& compiler_type,
uint64_t &size) uint64_t &size)
{ {
return false; return false;
} }
virtual bool virtual bool
IsRuntimeSupportValue (ValueObject& valobj) IsRuntimeSupportValue (ValueObject& valobj)
{ {
Show All 23 Lines

lldb/trunk/include/lldb/Target/ObjCLanguageRuntime.h

Show First 20 Lines • Show All 371 Lines • ▼ Show 20 Linespublic:
virtual void virtual void
SymbolsDidLoad (const ModuleList& module_list) SymbolsDidLoad (const ModuleList& module_list)
{ {
m_negative_complete_class_cache.clear(); m_negative_complete_class_cache.clear();
} }
bool bool
GetTypeBitSize (const CompilerType& clang_type, GetTypeBitSize (const CompilerType& compiler_type,
uint64_t &size) override; uint64_t &size) override;
protected: protected:
//------------------------------------------------------------------ //------------------------------------------------------------------
// Classes that inherit from ObjCLanguageRuntime can see and modify these // Classes that inherit from ObjCLanguageRuntime can see and modify these
//------------------------------------------------------------------ //------------------------------------------------------------------
ObjCLanguageRuntime(Process *process); ObjCLanguageRuntime(Process *process);
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBType.cpp

Show First 20 Lines • Show All 263 Lines • ▼ Show 20 LinesSBType::IsTypedefType ()
return m_opaque_sp->GetCompilerType(true).IsTypedefType(); return m_opaque_sp->GetCompilerType(true).IsTypedefType();
} }
lldb::SBType lldb::SBType
SBType::GetFunctionReturnType () SBType::GetFunctionReturnType ()
{ {
if (IsValid()) if (IsValid())
{ {
CompilerType return_clang_type (m_opaque_sp->GetCompilerType(true).GetFunctionReturnType()); CompilerType return_type (m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
if (return_clang_type.IsValid()) if (return_type.IsValid())
return SBType(return_clang_type); return SBType(return_type);
} }
return lldb::SBType(); return lldb::SBType();
} }
lldb::SBTypeList lldb::SBTypeList
SBType::GetFunctionArgumentTypes () SBType::GetFunctionArgumentTypes ()
{ {
SBTypeList sb_type_list; SBTypeList sb_type_list;
▲ Show 20 Lines • Show All 577 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

Show First 20 Lines • Show All 1,042 Lines • ▼ Show 20 Lines DoExecute (Args& command, CommandReturnObject &result)
target, target,
variable_list, variable_list,
valobj_list)); valobj_list));
if (valobj_list.GetSize()) if (valobj_list.GetSize())
valobj_sp = valobj_list.GetValueObjectAtIndex(0); valobj_sp = valobj_list.GetValueObjectAtIndex(0);
} }
CompilerType clang_type; CompilerType compiler_type;
if (valobj_sp) if (valobj_sp)
{ {
AddressType addr_type; AddressType addr_type;
addr = valobj_sp->GetAddressOf(false, &addr_type); addr = valobj_sp->GetAddressOf(false, &addr_type);
if (addr_type == eAddressTypeLoad) if (addr_type == eAddressTypeLoad)
{ {
// We're in business. // We're in business.
// Find out the size of this variable. // Find out the size of this variable.
size = m_option_watchpoint.watch_size == 0 ? valobj_sp->GetByteSize() size = m_option_watchpoint.watch_size == 0 ? valobj_sp->GetByteSize()
: m_option_watchpoint.watch_size; : m_option_watchpoint.watch_size;
} }
clang_type = valobj_sp->GetCompilerType(); compiler_type = valobj_sp->GetCompilerType();
} }
else else
{ {
const char *error_cstr = error.AsCString(NULL); const char *error_cstr = error.AsCString(NULL);
if (error_cstr) if (error_cstr)
result.GetErrorStream().Printf("error: %s\n", error_cstr); result.GetErrorStream().Printf("error: %s\n", error_cstr);
else else
result.GetErrorStream().Printf ("error: unable to find any variable expression path that matches '%s'\n", result.GetErrorStream().Printf ("error: unable to find any variable expression path that matches '%s'\n",
command.GetArgumentAtIndex(0)); command.GetArgumentAtIndex(0));
return false; return false;
} }
// Now it's time to create the watchpoint. // Now it's time to create the watchpoint.
uint32_t watch_type = m_option_watchpoint.watch_type; uint32_t watch_type = m_option_watchpoint.watch_type;
error.Clear(); error.Clear();
Watchpoint *wp = target->CreateWatchpoint(addr, size, &clang_type, watch_type, error).get(); Watchpoint *wp = target->CreateWatchpoint(addr, size, &compiler_type, watch_type, error).get();
if (wp) if (wp)
{ {
wp->SetWatchSpec(command.GetArgumentAtIndex(0)); wp->SetWatchSpec(command.GetArgumentAtIndex(0));
wp->SetWatchVariable(true); wp->SetWatchVariable(true);
if (var_sp && var_sp->GetDeclaration().GetFile()) if (var_sp && var_sp->GetDeclaration().GetFile())
{ {
StreamString ss; StreamString ss;
// True to show fullpath for declaration file. // True to show fullpath for declaration file.
▲ Show 20 Lines • Show All 200 Lines • ▼ Show 20 Lines DoExecute (const char *raw_command, CommandReturnObject &result)
else else
size = target->GetArchitecture().GetAddressByteSize(); size = target->GetArchitecture().GetAddressByteSize();
// Now it's time to create the watchpoint. // Now it's time to create the watchpoint.
uint32_t watch_type = m_option_watchpoint.watch_type; uint32_t watch_type = m_option_watchpoint.watch_type;
// Fetch the type from the value object, the type of the watched object is the pointee type // Fetch the type from the value object, the type of the watched object is the pointee type
/// of the expression, so convert to that if we found a valid type. /// of the expression, so convert to that if we found a valid type.
CompilerType clang_type(valobj_sp->GetCompilerType()); CompilerType compiler_type(valobj_sp->GetCompilerType());
Error error; Error error;
Watchpoint *wp = target->CreateWatchpoint(addr, size, &clang_type, watch_type, error).get(); Watchpoint *wp = target->CreateWatchpoint(addr, size, &compiler_type, watch_type, error).get();
if (wp) if (wp)
{ {
Stream &output_stream = result.GetOutputStream(); Stream &output_stream = result.GetOutputStream();
output_stream.Printf("Watchpoint created: "); output_stream.Printf("Watchpoint created: ");
wp->GetDescription(&output_stream, lldb::eDescriptionLevelFull); wp->GetDescription(&output_stream, lldb::eDescriptionLevelFull);
output_stream.EOL(); output_stream.EOL();
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
} }
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Value.cpp

Show All 29 Lines
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Value::Value() : Value::Value() :
m_value (), m_value (),
m_vector (), m_vector (),
m_clang_type (), m_compiler_type (),
m_context (NULL), m_context (NULL),
m_value_type (eValueTypeScalar), m_value_type (eValueTypeScalar),
m_context_type (eContextTypeInvalid), m_context_type (eContextTypeInvalid),
m_data_buffer () m_data_buffer ()
{ {
} }
Value::Value(const Scalar& scalar) : Value::Value(const Scalar& scalar) :
m_value (scalar), m_value (scalar),
m_vector (), m_vector (),
m_clang_type (), m_compiler_type (),
m_context (NULL), m_context (NULL),
m_value_type (eValueTypeScalar), m_value_type (eValueTypeScalar),
m_context_type (eContextTypeInvalid), m_context_type (eContextTypeInvalid),
m_data_buffer () m_data_buffer ()
{ {
} }
Value::Value(const void *bytes, int len) : Value::Value(const void *bytes, int len) :
m_value (), m_value (),
m_vector (), m_vector (),
m_clang_type (), m_compiler_type (),
m_context (NULL), m_context (NULL),
m_value_type (eValueTypeHostAddress), m_value_type (eValueTypeHostAddress),
m_context_type (eContextTypeInvalid), m_context_type (eContextTypeInvalid),
m_data_buffer () m_data_buffer ()
{ {
SetBytes(bytes, len); SetBytes(bytes, len);
} }
Value::Value(const Value &v) : Value::Value(const Value &v) :
m_value (v.m_value), m_value (v.m_value),
m_vector (v.m_vector), m_vector (v.m_vector),
m_clang_type (v.m_clang_type), m_compiler_type (v.m_compiler_type),
m_context (v.m_context), m_context (v.m_context),
m_value_type (v.m_value_type), m_value_type (v.m_value_type),
m_context_type (v.m_context_type), m_context_type (v.m_context_type),
m_data_buffer () m_data_buffer ()
{ {
const uintptr_t rhs_value = (uintptr_t)v.m_value.ULongLong(LLDB_INVALID_ADDRESS); const uintptr_t rhs_value = (uintptr_t)v.m_value.ULongLong(LLDB_INVALID_ADDRESS);
if ((rhs_value != 0) && (rhs_value == (uintptr_t)v.m_data_buffer.GetBytes())) if ((rhs_value != 0) && (rhs_value == (uintptr_t)v.m_data_buffer.GetBytes()))
{ {
m_data_buffer.CopyData(v.m_data_buffer.GetBytes(), m_data_buffer.CopyData(v.m_data_buffer.GetBytes(),
v.m_data_buffer.GetByteSize()); v.m_data_buffer.GetByteSize());
m_value = (uintptr_t)m_data_buffer.GetBytes(); m_value = (uintptr_t)m_data_buffer.GetBytes();
} }
} }
Value & Value &
Value::operator=(const Value &rhs) Value::operator=(const Value &rhs)
{ {
if (this != &rhs) if (this != &rhs)
{ {
m_value = rhs.m_value; m_value = rhs.m_value;
m_vector = rhs.m_vector; m_vector = rhs.m_vector;
m_clang_type = rhs.m_clang_type; m_compiler_type = rhs.m_compiler_type;
m_context = rhs.m_context; m_context = rhs.m_context;
m_value_type = rhs.m_value_type; m_value_type = rhs.m_value_type;
m_context_type = rhs.m_context_type; m_context_type = rhs.m_context_type;
const uintptr_t rhs_value = (uintptr_t)rhs.m_value.ULongLong(LLDB_INVALID_ADDRESS); const uintptr_t rhs_value = (uintptr_t)rhs.m_value.ULongLong(LLDB_INVALID_ADDRESS);
if ((rhs_value != 0) && (rhs_value == (uintptr_t)rhs.m_data_buffer.GetBytes())) if ((rhs_value != 0) && (rhs_value == (uintptr_t)rhs.m_data_buffer.GetBytes()))
{ {
m_data_buffer.CopyData(rhs.m_data_buffer.GetBytes(), m_data_buffer.CopyData(rhs.m_data_buffer.GetBytes(),
rhs.m_data_buffer.GetByteSize()); rhs.m_data_buffer.GetByteSize());
▲ Show 20 Lines • Show All 190 Lines • ▼ Show 20 Lines if (error_ptr)
} }
} }
return byte_size; return byte_size;
} }
const CompilerType & const CompilerType &
Value::GetCompilerType () Value::GetCompilerType ()
{ {
if (!m_clang_type.IsValid()) if (!m_compiler_type.IsValid())
{ {
switch (m_context_type) switch (m_context_type)
{ {
case eContextTypeInvalid: case eContextTypeInvalid:
break; break;
case eContextTypeRegisterInfo: case eContextTypeRegisterInfo:
break; // TODO: Eventually convert into a clang type? break; // TODO: Eventually convert into a compiler type?
case eContextTypeLLDBType: case eContextTypeLLDBType:
{ {
Type *lldb_type = GetType(); Type *lldb_type = GetType();
if (lldb_type) if (lldb_type)
m_clang_type = lldb_type->GetForwardCompilerType (); m_compiler_type = lldb_type->GetForwardCompilerType ();
} }
break; break;
case eContextTypeVariable: case eContextTypeVariable:
{ {
Variable *variable = GetVariable(); Variable *variable = GetVariable();
if (variable) if (variable)
{ {
Type *variable_type = variable->GetType(); Type *variable_type = variable->GetType();
if (variable_type) if (variable_type)
m_clang_type = variable_type->GetForwardCompilerType (); m_compiler_type = variable_type->GetForwardCompilerType ();
} }
} }
break; break;
} }
} }
return m_clang_type; return m_compiler_type;
} }
void void
Value::SetCompilerType (const CompilerType &clang_type) Value::SetCompilerType (const CompilerType &compiler_type)
{ {
m_clang_type = clang_type; m_compiler_type = compiler_type;
} }
lldb::Format lldb::Format
Value::GetValueDefaultFormat () Value::GetValueDefaultFormat ()
{ {
switch (m_context_type) switch (m_context_type)
{ {
case eContextTypeRegisterInfo: case eContextTypeRegisterInfo:
▲ Show 20 Lines • Show All 366 Lines • ▼ Show 20 Lines// }
} }
return error; return error;
} }
Scalar & Scalar &
Value::ResolveValue(ExecutionContext *exe_ctx) Value::ResolveValue(ExecutionContext *exe_ctx)
{ {
const CompilerType &clang_type = GetCompilerType(); const CompilerType &compiler_type = GetCompilerType();
if (clang_type.IsValid()) if (compiler_type.IsValid())
{ {
switch (m_value_type) switch (m_value_type)
{ {
case eValueTypeScalar: // raw scalar value case eValueTypeScalar: // raw scalar value
break; break;
default: default:
case eValueTypeFileAddress: case eValueTypeFileAddress:
case eValueTypeLoadAddress: // load address value case eValueTypeLoadAddress: // load address value
case eValueTypeHostAddress: // host address value (for memory in the process that is using liblldb) case eValueTypeHostAddress: // host address value (for memory in the process that is using liblldb)
{ {
DataExtractor data; DataExtractor data;
lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS); lldb::addr_t addr = m_value.ULongLong(LLDB_INVALID_ADDRESS);
Error error (GetValueAsData (exe_ctx, data, 0, NULL)); Error error (GetValueAsData (exe_ctx, data, 0, NULL));
if (error.Success()) if (error.Success())
{ {
Scalar scalar; Scalar scalar;
if (clang_type.GetValueAsScalar (data, 0, data.GetByteSize(), scalar)) if (compiler_type.GetValueAsScalar (data, 0, data.GetByteSize(), scalar))
{ {
m_value = scalar; m_value = scalar;
m_value_type = eValueTypeScalar; m_value_type = eValueTypeScalar;
} }
else else
{ {
if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes()) if ((uintptr_t)addr != (uintptr_t)m_data_buffer.GetBytes())
{ {
Show All 25 LinesValue::GetVariable()
return NULL; return NULL;
} }
void void
Value::Clear() Value::Clear()
{ {
m_value.Clear(); m_value.Clear();
m_vector.Clear(); m_vector.Clear();
m_clang_type.Clear(); m_compiler_type.Clear();
m_value_type = eValueTypeScalar; m_value_type = eValueTypeScalar;
m_context = NULL; m_context = NULL;
m_context_type = eContextTypeInvalid; m_context_type = eContextTypeInvalid;
m_data_buffer.Clear(); m_data_buffer.Clear();
} }
const char * const char *
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObject.cpp

Show First 20 Lines • Show All 318 Lines • ▼ Show 20 LinesValueObject::ClearDynamicTypeInformation ()
SetValueFormat(lldb::TypeFormatImplSP()); SetValueFormat(lldb::TypeFormatImplSP());
SetSummaryFormat(lldb::TypeSummaryImplSP()); SetSummaryFormat(lldb::TypeSummaryImplSP());
SetSyntheticChildren(lldb::SyntheticChildrenSP()); SetSyntheticChildren(lldb::SyntheticChildrenSP());
} }
CompilerType CompilerType
ValueObject::MaybeCalculateCompleteType () ValueObject::MaybeCalculateCompleteType ()
{ {
CompilerType clang_type(GetCompilerTypeImpl()); CompilerType compiler_type(GetCompilerTypeImpl());
if (m_did_calculate_complete_objc_class_type) if (m_did_calculate_complete_objc_class_type)
{ {
if (m_override_type.IsValid()) if (m_override_type.IsValid())
return m_override_type; return m_override_type;
else else
return clang_type; return compiler_type;
} }
CompilerType class_type; CompilerType class_type;
bool is_pointer_type = false; bool is_pointer_type = false;
if (ClangASTContext::IsObjCObjectPointerType(clang_type, &class_type)) if (ClangASTContext::IsObjCObjectPointerType(compiler_type, &class_type))
{ {
is_pointer_type = true; is_pointer_type = true;
} }
else if (ClangASTContext::IsObjCObjectOrInterfaceType(clang_type)) else if (ClangASTContext::IsObjCObjectOrInterfaceType(compiler_type))
{ {
class_type = clang_type; class_type = compiler_type;
} }
else else
{ {
return clang_type; return compiler_type;
} }
m_did_calculate_complete_objc_class_type = true; m_did_calculate_complete_objc_class_type = true;
if (class_type) if (class_type)
{ {
ConstString class_name (class_type.GetConstTypeName()); ConstString class_name (class_type.GetConstTypeName());
Show All 27 Lines if (class_type)
if (m_override_type.IsValid()) if (m_override_type.IsValid())
return m_override_type; return m_override_type;
} }
} }
} }
} }
} }
} }
return clang_type; return compiler_type;
} }
CompilerType CompilerType
ValueObject::GetCompilerType () ValueObject::GetCompilerType ()
{ {
return MaybeCalculateCompleteType(); return MaybeCalculateCompleteType();
} }
▲ Show 20 Lines • Show All 528 Lines • ▼ Show 20 LinesValueObject::GetSummaryAsCString (std::string& destination,
return GetSummaryAsCString(GetSummaryFormat().get(), return GetSummaryAsCString(GetSummaryFormat().get(),
destination, destination,
options); options);
} }
bool bool
ValueObject::IsCStringContainer(bool check_pointer) ValueObject::IsCStringContainer(bool check_pointer)
{ {
CompilerType pointee_or_element_clang_type; CompilerType pointee_or_element_compiler_type;
const Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type)); const Flags type_flags (GetTypeInfo (&pointee_or_element_compiler_type));
bool is_char_arr_ptr (type_flags.AnySet (eTypeIsArray | eTypeIsPointer) && bool is_char_arr_ptr (type_flags.AnySet (eTypeIsArray | eTypeIsPointer) &&
pointee_or_element_clang_type.IsCharType ()); pointee_or_element_compiler_type.IsCharType ());
if (!is_char_arr_ptr) if (!is_char_arr_ptr)
return false; return false;
if (!check_pointer) if (!check_pointer)
return true; return true;
if (type_flags.Test(eTypeIsArray)) if (type_flags.Test(eTypeIsArray))
return true; return true;
addr_t cstr_address = LLDB_INVALID_ADDRESS; addr_t cstr_address = LLDB_INVALID_ADDRESS;
AddressType cstr_address_type = eAddressTypeInvalid; AddressType cstr_address_type = eAddressTypeInvalid;
cstr_address = GetAddressOf (true, &cstr_address_type); cstr_address = GetAddressOf (true, &cstr_address_type);
return (cstr_address != LLDB_INVALID_ADDRESS); return (cstr_address != LLDB_INVALID_ADDRESS);
} }
size_t size_t
ValueObject::GetPointeeData (DataExtractor& data, ValueObject::GetPointeeData (DataExtractor& data,
uint32_t item_idx, uint32_t item_idx,
uint32_t item_count) uint32_t item_count)
{ {
CompilerType pointee_or_element_clang_type; CompilerType pointee_or_element_compiler_type;
const uint32_t type_info = GetTypeInfo (&pointee_or_element_clang_type); const uint32_t type_info = GetTypeInfo (&pointee_or_element_compiler_type);
const bool is_pointer_type = type_info & eTypeIsPointer; const bool is_pointer_type = type_info & eTypeIsPointer;
const bool is_array_type = type_info & eTypeIsArray; const bool is_array_type = type_info & eTypeIsArray;
if (!(is_pointer_type || is_array_type)) if (!(is_pointer_type || is_array_type))
return 0; return 0;
if (item_count == 0) if (item_count == 0)
return 0; return 0;
ExecutionContext exe_ctx (GetExecutionContextRef()); ExecutionContext exe_ctx (GetExecutionContextRef());
const uint64_t item_type_size = pointee_or_element_clang_type.GetByteSize(exe_ctx.GetBestExecutionContextScope()); const uint64_t item_type_size = pointee_or_element_compiler_type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
const uint64_t bytes = item_count * item_type_size; const uint64_t bytes = item_count * item_type_size;
const uint64_t offset = item_idx * item_type_size; const uint64_t offset = item_idx * item_type_size;
if (item_idx == 0 && item_count == 1) // simply a deref if (item_idx == 0 && item_count == 1) // simply a deref
{ {
if (is_pointer_type) if (is_pointer_type)
{ {
Error error; Error error;
▲ Show 20 Lines • Show All 239 Lines • ▼ Show 20 LinesValueObject::ReadPointedString (lldb::DataBufferSP& buffer_sp,
} }
if (max_length == 0) if (max_length == 0)
max_length = target->GetMaximumSizeOfStringSummary(); max_length = target->GetMaximumSizeOfStringSummary();
size_t bytes_read = 0; size_t bytes_read = 0;
size_t total_bytes_read = 0; size_t total_bytes_read = 0;
CompilerType clang_type = GetCompilerType(); CompilerType compiler_type = GetCompilerType();
CompilerType elem_or_pointee_clang_type; CompilerType elem_or_pointee_compiler_type;
const Flags type_flags (GetTypeInfo (&elem_or_pointee_clang_type)); const Flags type_flags (GetTypeInfo (&elem_or_pointee_compiler_type));
if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer) && if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer) &&
elem_or_pointee_clang_type.IsCharType ()) elem_or_pointee_compiler_type.IsCharType ())
{ {
addr_t cstr_address = LLDB_INVALID_ADDRESS; addr_t cstr_address = LLDB_INVALID_ADDRESS;
AddressType cstr_address_type = eAddressTypeInvalid; AddressType cstr_address_type = eAddressTypeInvalid;
size_t cstr_len = 0; size_t cstr_len = 0;
bool capped_data = false; bool capped_data = false;
if (type_flags.Test (eTypeIsArray)) if (type_flags.Test (eTypeIsArray))
{ {
// We have an array // We have an array
uint64_t array_size = 0; uint64_t array_size = 0;
if (clang_type.IsArrayType(NULL, &array_size, NULL)) if (compiler_type.IsArrayType(NULL, &array_size, NULL))
{ {
cstr_len = array_size; cstr_len = array_size;
if (cstr_len > max_length) if (cstr_len > max_length)
{ {
capped_data = true; capped_data = true;
cstr_len = max_length; cstr_len = max_length;
} }
} }
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 LinesValueObject::GetObjectDescription ()
StreamString s; StreamString s;
LanguageType language = GetObjectRuntimeLanguage(); LanguageType language = GetObjectRuntimeLanguage();
LanguageRuntime *runtime = process->GetLanguageRuntime(language); LanguageRuntime *runtime = process->GetLanguageRuntime(language);
if (runtime == NULL) if (runtime == NULL)
{ {
// Aw, hell, if the things a pointer, or even just an integer, let's try ObjC anyway... // Aw, hell, if the things a pointer, or even just an integer, let's try ObjC anyway...
CompilerType clang_type = GetCompilerType(); CompilerType compiler_type = GetCompilerType();
if (clang_type) if (compiler_type)
{ {
bool is_signed; bool is_signed;
if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType ()) if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType ())
{ {
runtime = process->GetLanguageRuntime(eLanguageTypeObjC); runtime = process->GetLanguageRuntime(eLanguageTypeObjC);
} }
} }
} }
if (runtime && runtime->GetObjectDescription(s, *this)) if (runtime && runtime->GetObjectDescription(s, *this))
{ {
▲ Show 20 Lines • Show All 617 Lines • ▼ Show 20 LinesValueObject::GetSyntheticChild (const ConstString &key) const
ValueObjectSP synthetic_child_sp; ValueObjectSP synthetic_child_sp;
std::map<ConstString, ValueObject *>::const_iterator pos = m_synthetic_children.find (key); std::map<ConstString, ValueObject *>::const_iterator pos = m_synthetic_children.find (key);
if (pos != m_synthetic_children.end()) if (pos != m_synthetic_children.end())
synthetic_child_sp = pos->second->GetSP(); synthetic_child_sp = pos->second->GetSP();
return synthetic_child_sp; return synthetic_child_sp;
} }
uint32_t uint32_t
ValueObject::GetTypeInfo (CompilerType *pointee_or_element_clang_type) ValueObject::GetTypeInfo (CompilerType *pointee_or_element_compiler_type)
{ {
return GetCompilerType().GetTypeInfo (pointee_or_element_clang_type); return GetCompilerType().GetTypeInfo (pointee_or_element_compiler_type);
} }
bool bool
ValueObject::IsPointerType () ValueObject::IsPointerType ()
{ {
return GetCompilerType().IsPointerType(); return GetCompilerType().IsPointerType();
} }
▲ Show 20 Lines • Show All 375 Lines • ▼ Show 20 Lines
} }
bool bool
ValueObject::GetBaseClassPath (Stream &s) ValueObject::GetBaseClassPath (Stream &s)
{ {
if (IsBaseClass()) if (IsBaseClass())
{ {
bool parent_had_base_class = GetParent() && GetParent()->GetBaseClassPath (s); bool parent_had_base_class = GetParent() && GetParent()->GetBaseClassPath (s);
CompilerType clang_type = GetCompilerType(); CompilerType compiler_type = GetCompilerType();
std::string cxx_class_name; std::string cxx_class_name;
bool this_had_base_class = ClangASTContext::GetCXXClassName (clang_type, cxx_class_name); bool this_had_base_class = ClangASTContext::GetCXXClassName (compiler_type, cxx_class_name);
if (this_had_base_class) if (this_had_base_class)
{ {
if (parent_had_base_class) if (parent_had_base_class)
s.PutCString("::"); s.PutCString("::");
s.PutCString(cxx_class_name.c_str()); s.PutCString(cxx_class_name.c_str());
} }
return parent_had_base_class || this_had_base_class; return parent_had_base_class || this_had_base_class;
} }
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 LinesValueObject::GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat epformat)
if (!IsBaseClass()) if (!IsBaseClass())
{ {
if (!is_deref_of_parent) if (!is_deref_of_parent)
{ {
ValueObject *non_base_class_parent = GetNonBaseClassParent(); ValueObject *non_base_class_parent = GetNonBaseClassParent();
if (non_base_class_parent) if (non_base_class_parent)
{ {
CompilerType non_base_class_parent_clang_type = non_base_class_parent->GetCompilerType(); CompilerType non_base_class_parent_compiler_type = non_base_class_parent->GetCompilerType();
if (non_base_class_parent_clang_type) if (non_base_class_parent_compiler_type)
{ {
if (parent && parent->IsDereferenceOfParent() && epformat == eGetExpressionPathFormatHonorPointers) if (parent && parent->IsDereferenceOfParent() && epformat == eGetExpressionPathFormatHonorPointers)
{ {
s.PutCString("->"); s.PutCString("->");
} }
else else
{ {
const uint32_t non_base_class_parent_type_info = non_base_class_parent_clang_type.GetTypeInfo(); const uint32_t non_base_class_parent_type_info = non_base_class_parent_compiler_type.GetTypeInfo();
if (non_base_class_parent_type_info & eTypeIsPointer) if (non_base_class_parent_type_info & eTypeIsPointer)
{ {
s.PutCString("->"); s.PutCString("->");
} }
else if ((non_base_class_parent_type_info & eTypeHasChildren) && else if ((non_base_class_parent_type_info & eTypeHasChildren) &&
!(non_base_class_parent_type_info & eTypeIsArray)) !(non_base_class_parent_type_info & eTypeIsArray))
{ {
▲ Show 20 Lines • Show All 195 Lines • ▼ Show 20 LinesValueObject::GetValueForExpressionPath_Impl(const char* expression_cstr,
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
while (true) while (true)
{ {
const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
CompilerType root_clang_type = root->GetCompilerType(); CompilerType root_compiler_type = root->GetCompilerType();
CompilerType pointee_clang_type; CompilerType pointee_compiler_type;
Flags pointee_clang_type_info; Flags pointee_compiler_type_info;
Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type)); Flags root_compiler_type_info(root_compiler_type.GetTypeInfo(&pointee_compiler_type));
if (pointee_clang_type) if (pointee_compiler_type)
pointee_clang_type_info.Reset(pointee_clang_type.GetTypeInfo()); pointee_compiler_type_info.Reset(pointee_compiler_type.GetTypeInfo());
if (!expression_cstr || *expression_cstr == '\0') if (!expression_cstr || *expression_cstr == '\0')
{ {
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
return root; return root;
} }
switch (*expression_cstr) switch (*expression_cstr)
{ {
case '-': case '-':
{ {
if (options.m_check_dot_vs_arrow_syntax && if (options.m_check_dot_vs_arrow_syntax &&
root_clang_type_info.Test(eTypeIsPointer) ) // if you are trying to use -> on a non-pointer and I must catch the error root_compiler_type_info.Test(eTypeIsPointer) ) // if you are trying to use -> on a non-pointer and I must catch the error
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrowInsteadOfDot; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrowInsteadOfDot;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
if (root_clang_type_info.Test(eTypeIsObjC) && // if yo are trying to extract an ObjC IVar when this is forbidden if (root_compiler_type_info.Test(eTypeIsObjC) && // if yo are trying to extract an ObjC IVar when this is forbidden
root_clang_type_info.Test(eTypeIsPointer) && root_compiler_type_info.Test(eTypeIsPointer) &&
options.m_no_fragile_ivar) options.m_no_fragile_ivar)
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonFragileIVarNotAllowed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonFragileIVarNotAllowed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
if (expression_cstr[1] != '>') if (expression_cstr[1] != '>')
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
expression_cstr++; // skip the - expression_cstr++; // skip the -
} }
case '.': // or fallthrough from -> case '.': // or fallthrough from ->
{ {
if (options.m_check_dot_vs_arrow_syntax && *expression_cstr == '.' && if (options.m_check_dot_vs_arrow_syntax && *expression_cstr == '.' &&
root_clang_type_info.Test(eTypeIsPointer)) // if you are trying to use . on a pointer and I must catch the error root_compiler_type_info.Test(eTypeIsPointer)) // if you are trying to use . on a pointer and I must catch the error
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonDotInsteadOfArrow; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDotInsteadOfArrow;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
expression_cstr++; // skip . expression_cstr++; // skip .
const char *next_separator = strpbrk(expression_cstr+1,"-.["); const char *next_separator = strpbrk(expression_cstr+1,"-.[");
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines while (true)
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
} }
break; break;
} }
case '[': case '[':
{ {
if (!root_clang_type_info.Test(eTypeIsArray) && !root_clang_type_info.Test(eTypeIsPointer) && !root_clang_type_info.Test(eTypeIsVector)) // if this is not a T[] nor a T* if (!root_compiler_type_info.Test(eTypeIsArray) && !root_compiler_type_info.Test(eTypeIsPointer) && !root_compiler_type_info.Test(eTypeIsVector)) // if this is not a T[] nor a T*
{ {
if (!root_clang_type_info.Test(eTypeIsScalar)) // if this is not even a scalar... if (!root_compiler_type_info.Test(eTypeIsScalar)) // if this is not even a scalar...
{ {
if (options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None) // ...only chance left is synthetic if (options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None) // ...only chance left is synthetic
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
} }
else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
} }
if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays
{ {
if (!root_clang_type_info.Test(eTypeIsArray)) if (!root_compiler_type_info.Test(eTypeIsArray))
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
else // even if something follows, we cannot expand unbounded ranges, just let the caller do it else // even if something follows, we cannot expand unbounded ranges, just let the caller do it
{ {
Show All 20 Lines while (true)
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays
{ {
if (root_clang_type_info.Test(eTypeIsArray)) if (root_compiler_type_info.Test(eTypeIsArray))
{ {
*first_unparsed = expression_cstr+2; *first_unparsed = expression_cstr+2;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
*final_result = ValueObject::eExpressionPathEndResultTypeUnboundedRange; *final_result = ValueObject::eExpressionPathEndResultTypeUnboundedRange;
return root; return root;
} }
else else
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
} }
// from here on we do have a valid index // from here on we do have a valid index
if (root_clang_type_info.Test(eTypeIsArray)) if (root_compiler_type_info.Test(eTypeIsArray))
{ {
ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true); ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true);
if (!child_valobj_sp) if (!child_valobj_sp)
child_valobj_sp = root->GetSyntheticArrayMember(index, true); child_valobj_sp = root->GetSyntheticArrayMember(index, true);
if (!child_valobj_sp) if (!child_valobj_sp)
if (root->HasSyntheticValue() && root->GetSyntheticValue()->GetNumChildren() > index) if (root->HasSyntheticValue() && root->GetSyntheticValue()->GetNumChildren() > index)
child_valobj_sp = root->GetSyntheticValue()->GetChildAtIndex(index, true); child_valobj_sp = root->GetSyntheticValue()->GetChildAtIndex(index, true);
if (child_valobj_sp) if (child_valobj_sp)
{ {
root = child_valobj_sp; root = child_valobj_sp;
*first_unparsed = end+1; // skip ] *first_unparsed = end+1; // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain; *final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue; continue;
} }
else else
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
} }
else if (root_clang_type_info.Test(eTypeIsPointer)) else if (root_compiler_type_info.Test(eTypeIsPointer))
{ {
if (*what_next == ValueObject::eExpressionPathAftermathDereference && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield if (*what_next == ValueObject::eExpressionPathAftermathDereference && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
pointee_clang_type_info.Test(eTypeIsScalar)) pointee_compiler_type_info.Test(eTypeIsScalar))
{ {
Error error; Error error;
root = root->Dereference(error); root = root->Dereference(error);
if (error.Fail() || !root.get()) if (error.Fail() || !root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
else else
{ {
*what_next = eExpressionPathAftermathNothing; *what_next = eExpressionPathAftermathNothing;
continue; continue;
} }
} }
else else
{ {
if (root->GetCompilerType().GetMinimumLanguage() == eLanguageTypeObjC if (root->GetCompilerType().GetMinimumLanguage() == eLanguageTypeObjC
&& pointee_clang_type_info.AllClear(eTypeIsPointer) && pointee_compiler_type_info.AllClear(eTypeIsPointer)
&& root->HasSyntheticValue() && root->HasSyntheticValue()
&& (options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::ToSynthetic || && (options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::ToSynthetic ||
options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both)) options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both))
{ {
root = root->GetSyntheticValue()->GetChildAtIndex(index, true); root = root->GetSyntheticValue()->GetChildAtIndex(index, true);
} }
else else
root = root->GetSyntheticArrayMember(index, true); root = root->GetSyntheticArrayMember(index, true);
if (!root.get()) if (!root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
else else
{ {
*first_unparsed = end+1; // skip ] *first_unparsed = end+1; // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain; *final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue; continue;
} }
} }
} }
else if (root_clang_type_info.Test(eTypeIsScalar)) else if (root_compiler_type_info.Test(eTypeIsScalar))
{ {
root = root->GetSyntheticBitFieldChild(index, index, true); root = root->GetSyntheticBitFieldChild(index, index, true);
if (!root.get()) if (!root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing
{ {
*first_unparsed = end+1; // skip ] *first_unparsed = end+1; // skip ]
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
*final_result = ValueObject::eExpressionPathEndResultTypeBitfield; *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
return root; return root;
} }
} }
else if (root_clang_type_info.Test(eTypeIsVector)) else if (root_compiler_type_info.Test(eTypeIsVector))
{ {
root = root->GetChildAtIndex(index, true); root = root->GetChildAtIndex(index, true);
if (!root.get()) if (!root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines while (true)
return ValueObjectSP(); return ValueObjectSP();
} }
if (index_lower > index_higher) // swap indices if required if (index_lower > index_higher) // swap indices if required
{ {
unsigned long temp = index_lower; unsigned long temp = index_lower;
index_lower = index_higher; index_lower = index_higher;
index_higher = temp; index_higher = temp;
} }
if (root_clang_type_info.Test(eTypeIsScalar)) // expansion only works for scalars if (root_compiler_type_info.Test(eTypeIsScalar)) // expansion only works for scalars
{ {
root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true); root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true);
if (!root.get()) if (!root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} }
else else
{ {
*first_unparsed = end+1; // skip ] *first_unparsed = end+1; // skip ]
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
*final_result = ValueObject::eExpressionPathEndResultTypeBitfield; *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
return root; return root;
} }
} }
else if (root_clang_type_info.Test(eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield else if (root_compiler_type_info.Test(eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
*what_next == ValueObject::eExpressionPathAftermathDereference && *what_next == ValueObject::eExpressionPathAftermathDereference &&
pointee_clang_type_info.Test(eTypeIsScalar)) pointee_compiler_type_info.Test(eTypeIsScalar))
{ {
Error error; Error error;
root = root->Dereference(error); root = root->Dereference(error);
if (error.Fail() || !root.get()) if (error.Fail() || !root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 LinesValueObject::ExpandArraySliceExpression(const char* expression_cstr,
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
while (true) while (true)
{ {
const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
CompilerType root_clang_type = root->GetCompilerType(); CompilerType root_compiler_type = root->GetCompilerType();
CompilerType pointee_clang_type; CompilerType pointee_compiler_type;
Flags pointee_clang_type_info; Flags pointee_compiler_type_info;
Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type)); Flags root_compiler_type_info(root_compiler_type.GetTypeInfo(&pointee_compiler_type));
if (pointee_clang_type) if (pointee_compiler_type)
pointee_clang_type_info.Reset(pointee_clang_type.GetTypeInfo()); pointee_compiler_type_info.Reset(pointee_compiler_type.GetTypeInfo());
if (!expression_cstr || *expression_cstr == '\0') if (!expression_cstr || *expression_cstr == '\0')
{ {
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
list->Append(root); list->Append(root);
return 1; return 1;
} }
switch (*expression_cstr) switch (*expression_cstr)
{ {
case '[': case '[':
{ {
if (!root_clang_type_info.Test(eTypeIsArray) && !root_clang_type_info.Test(eTypeIsPointer)) // if this is not a T[] nor a T* if (!root_compiler_type_info.Test(eTypeIsArray) && !root_compiler_type_info.Test(eTypeIsPointer)) // if this is not a T[] nor a T*
{ {
if (!root_clang_type_info.Test(eTypeIsScalar)) // if this is not even a scalar, this syntax is just plain wrong! if (!root_compiler_type_info.Test(eTypeIsScalar)) // if this is not even a scalar, this syntax is just plain wrong!
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return 0; return 0;
} }
else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return 0; return 0;
} }
} }
if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays
{ {
if (!root_clang_type_info.Test(eTypeIsArray)) if (!root_compiler_type_info.Test(eTypeIsArray))
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return 0; return 0;
} }
else // expand this into list else // expand this into list
{ {
Show All 27 Lines while (true)
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return 0; return 0;
} }
if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays
{ {
if (root_clang_type_info.Test(eTypeIsArray)) if (root_compiler_type_info.Test(eTypeIsArray))
{ {
const size_t max_index = root->GetNumChildren() - 1; const size_t max_index = root->GetNumChildren() - 1;
for (size_t index = 0; index < max_index; index++) for (size_t index = 0; index < max_index; index++)
{ {
ValueObjectSP child = ValueObjectSP child =
root->GetChildAtIndex(index, true); root->GetChildAtIndex(index, true);
list->Append(child); list->Append(child);
} }
*first_unparsed = expression_cstr+2; *first_unparsed = expression_cstr+2;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
*final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList; *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
return max_index; // tell me number of items I added to the VOList return max_index; // tell me number of items I added to the VOList
} }
else else
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return 0; return 0;
} }
} }
// from here on we do have a valid index // from here on we do have a valid index
if (root_clang_type_info.Test(eTypeIsArray)) if (root_compiler_type_info.Test(eTypeIsArray))
{ {
root = root->GetChildAtIndex(index, true); root = root->GetChildAtIndex(index, true);
if (!root.get()) if (!root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return 0; return 0;
} }
else else
{ {
list->Append(root); list->Append(root);
*first_unparsed = end+1; // skip ] *first_unparsed = end+1; // skip ]
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
*final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList; *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
return 1; return 1;
} }
} }
else if (root_clang_type_info.Test(eTypeIsPointer)) else if (root_compiler_type_info.Test(eTypeIsPointer))
{ {
if (*what_next == ValueObject::eExpressionPathAftermathDereference && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield if (*what_next == ValueObject::eExpressionPathAftermathDereference && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
pointee_clang_type_info.Test(eTypeIsScalar)) pointee_compiler_type_info.Test(eTypeIsScalar))
{ {
Error error; Error error;
root = root->Dereference(error); root = root->Dereference(error);
if (error.Fail() || !root.get()) if (error.Fail() || !root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
Show All 20 Lines while (true)
list->Append(root); list->Append(root);
*first_unparsed = end+1; // skip ] *first_unparsed = end+1; // skip ]
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
*final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList; *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
return 1; return 1;
} }
} }
} }
else /*if (ClangASTContext::IsScalarType(root_clang_type))*/ else /*if (ClangASTContext::IsScalarType(root_compiler_type))*/
{ {
root = root->GetSyntheticBitFieldChild(index, index, true); root = root->GetSyntheticBitFieldChild(index, index, true);
if (!root.get()) if (!root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return 0; return 0;
Show All 28 Lines while (true)
return 0; return 0;
} }
if (index_lower > index_higher) // swap indices if required if (index_lower > index_higher) // swap indices if required
{ {
unsigned long temp = index_lower; unsigned long temp = index_lower;
index_lower = index_higher; index_lower = index_higher;
index_higher = temp; index_higher = temp;
} }
if (root_clang_type_info.Test(eTypeIsScalar)) // expansion only works for scalars if (root_compiler_type_info.Test(eTypeIsScalar)) // expansion only works for scalars
{ {
root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true); root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true);
if (!root.get()) if (!root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return 0; return 0;
} }
else else
{ {
list->Append(root); list->Append(root);
*first_unparsed = end+1; // skip ] *first_unparsed = end+1; // skip ]
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
*final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList; *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
return 1; return 1;
} }
} }
else if (root_clang_type_info.Test(eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield else if (root_compiler_type_info.Test(eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
*what_next == ValueObject::eExpressionPathAftermathDereference && *what_next == ValueObject::eExpressionPathAftermathDereference &&
pointee_clang_type_info.Test(eTypeIsScalar)) pointee_compiler_type_info.Test(eTypeIsScalar))
{ {
Error error; Error error;
root = root->Dereference(error); root = root->Dereference(error);
if (error.Fail() || !root.get()) if (error.Fail() || !root.get())
{ {
*first_unparsed = expression_cstr; *first_unparsed = expression_cstr;
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
▲ Show 20 Lines • Show All 279 Lines • ▼ Show 20 Lines if (addr != LLDB_INVALID_ADDRESS && address_type != eAddressTypeHost)
GetExpressionPath(expr_path_strm, true); GetExpressionPath(expr_path_strm, true);
error.SetErrorStringWithFormat("'%s' is not in memory", expr_path_strm.GetString().c_str()); error.SetErrorStringWithFormat("'%s' is not in memory", expr_path_strm.GetString().c_str());
} }
break; break;
case eAddressTypeFile: case eAddressTypeFile:
case eAddressTypeLoad: case eAddressTypeLoad:
{ {
CompilerType clang_type = GetCompilerType(); CompilerType compiler_type = GetCompilerType();
if (clang_type) if (compiler_type)
{ {
std::string name (1, '&'); std::string name (1, '&');
name.append (m_name.AsCString("")); name.append (m_name.AsCString(""));
ExecutionContext exe_ctx (GetExecutionContextRef()); ExecutionContext exe_ctx (GetExecutionContextRef());
m_addr_of_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), m_addr_of_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
clang_type.GetPointerType(), compiler_type.GetPointerType(),
ConstString (name.c_str()), ConstString (name.c_str()),
addr, addr,
eAddressTypeInvalid, eAddressTypeInvalid,
m_data.GetAddressByteSize()); m_data.GetAddressByteSize());
} }
} }
break; break;
default: default:
break; break;
} }
} }
else else
{ {
StreamString expr_path_strm; StreamString expr_path_strm;
GetExpressionPath(expr_path_strm, true); GetExpressionPath(expr_path_strm, true);
error.SetErrorStringWithFormat("'%s' doesn't have a valid address", expr_path_strm.GetString().c_str()); error.SetErrorStringWithFormat("'%s' doesn't have a valid address", expr_path_strm.GetString().c_str());
} }
return m_addr_of_valobj_sp; return m_addr_of_valobj_sp;
} }
ValueObjectSP ValueObjectSP
ValueObject::Cast (const CompilerType &clang_ast_type) ValueObject::Cast (const CompilerType &compiler_type)
{ {
return ValueObjectCast::Create (*this, GetName(), clang_ast_type); return ValueObjectCast::Create (*this, GetName(), compiler_type);
} }
ValueObjectSP ValueObjectSP
ValueObject::CastPointerType (const char *name, CompilerType &clang_ast_type) ValueObject::CastPointerType (const char *name, CompilerType &compiler_type)
{ {
ValueObjectSP valobj_sp; ValueObjectSP valobj_sp;
AddressType address_type; AddressType address_type;
addr_t ptr_value = GetPointerValue (&address_type); addr_t ptr_value = GetPointerValue (&address_type);
if (ptr_value != LLDB_INVALID_ADDRESS) if (ptr_value != LLDB_INVALID_ADDRESS)
{ {
Address ptr_addr (ptr_value); Address ptr_addr (ptr_value);
ExecutionContext exe_ctx (GetExecutionContextRef()); ExecutionContext exe_ctx (GetExecutionContextRef());
valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(),
name, name,
ptr_addr, ptr_addr,
clang_ast_type); compiler_type);
} }
return valobj_sp; return valobj_sp;
} }
ValueObjectSP ValueObjectSP
ValueObject::CastPointerType (const char *name, TypeSP &type_sp) ValueObject::CastPointerType (const char *name, TypeSP &type_sp)
{ {
ValueObjectSP valobj_sp; ValueObjectSP valobj_sp;
▲ Show 20 Lines • Show All 438 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObjectCast.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 LinesValueObjectCast::UpdateValue ()
SetValueIsValid (false); SetValueIsValid (false);
m_error.Clear(); m_error.Clear();
if (m_parent->UpdateValueIfNeeded(false)) if (m_parent->UpdateValueIfNeeded(false))
{ {
Value old_value(m_value); Value old_value(m_value);
m_update_point.SetUpdated(); m_update_point.SetUpdated();
m_value = m_parent->GetValue(); m_value = m_parent->GetValue();
CompilerType clang_type (GetCompilerType()); CompilerType compiler_type (GetCompilerType());
//m_value.SetContext (Value::eContextTypeClangType, clang_type); //m_value.SetContext (Value::eContextTypeClangType, compiler_type);
m_value.SetCompilerType (clang_type); m_value.SetCompilerType (compiler_type);
SetAddressTypeOfChildren(m_parent->GetAddressTypeOfChildren()); SetAddressTypeOfChildren(m_parent->GetAddressTypeOfChildren());
if (!CanProvideValue()) if (!CanProvideValue())
{ {
// this value object represents an aggregate type whose // this value object represents an aggregate type whose
// children have values, but this object does not. So we // children have values, but this object does not. So we
// say we are changed if our location has changed. // say we are changed if our location has changed.
SetValueDidChange (m_value.GetValueType() != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar()); SetValueDidChange (m_value.GetValueType() != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar());
} }
Show All 18 Lines

lldb/trunk/source/Core/ValueObjectChild.cpp

Show All 21 Lines
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
using namespace lldb_private; using namespace lldb_private;
ValueObjectChild::ValueObjectChild ValueObjectChild::ValueObjectChild
( (
ValueObject &parent, ValueObject &parent,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
uint64_t byte_size, uint64_t byte_size,
int32_t byte_offset, int32_t byte_offset,
uint32_t bitfield_bit_size, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, uint32_t bitfield_bit_offset,
bool is_base_class, bool is_base_class,
bool is_deref_of_parent, bool is_deref_of_parent,
AddressType child_ptr_or_ref_addr_type AddressType child_ptr_or_ref_addr_type
) : ) :
ValueObject (parent), ValueObject (parent),
m_clang_type (clang_type), m_compiler_type (compiler_type),
m_byte_size (byte_size), m_byte_size (byte_size),
m_byte_offset (byte_offset), m_byte_offset (byte_offset),
m_bitfield_bit_size (bitfield_bit_size), m_bitfield_bit_size (bitfield_bit_size),
m_bitfield_bit_offset (bitfield_bit_offset), m_bitfield_bit_offset (bitfield_bit_offset),
m_is_base_class (is_base_class), m_is_base_class (is_base_class),
m_is_deref_of_parent (is_deref_of_parent), m_is_deref_of_parent (is_deref_of_parent),
m_can_update_with_invalid_exe_ctx() m_can_update_with_invalid_exe_ctx()
{ {
Show All 18 Lines
} }
static void static void
AdjustForBitfieldness(ConstString& name, AdjustForBitfieldness(ConstString& name,
uint8_t bitfield_bit_size) uint8_t bitfield_bit_size)
{ {
if (name && bitfield_bit_size) if (name && bitfield_bit_size)
{ {
const char *clang_type_name = name.AsCString(); const char *compiler_type_name = name.AsCString();
if (clang_type_name) if (compiler_type_name)
{ {
std::vector<char> bitfield_type_name (strlen(clang_type_name) + 32, 0); std::vector<char> bitfield_type_name (strlen(compiler_type_name) + 32, 0);
::snprintf (&bitfield_type_name.front(), bitfield_type_name.size(), "%s:%u", clang_type_name, bitfield_bit_size); ::snprintf (&bitfield_type_name.front(), bitfield_type_name.size(), "%s:%u", compiler_type_name, bitfield_bit_size);
name.SetCString(&bitfield_type_name.front()); name.SetCString(&bitfield_type_name.front());
} }
} }
} }
ConstString ConstString
ValueObjectChild::GetTypeName() ValueObjectChild::GetTypeName()
{ {
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObjectConstResult.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 LinesValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
m_data.SetAddressByteSize(addr_byte_size); m_data.SetAddressByteSize(addr_byte_size);
SetAddressTypeOfChildren(eAddressTypeLoad); SetAddressTypeOfChildren(eAddressTypeLoad);
} }
ValueObjectSP ValueObjectSP
ValueObjectConstResult::Create ValueObjectConstResult::Create
( (
ExecutionContextScope *exe_scope, ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
const DataExtractor &data, const DataExtractor &data,
lldb::addr_t address lldb::addr_t address
) )
{ {
return (new ValueObjectConstResult (exe_scope, return (new ValueObjectConstResult (exe_scope,
clang_type, compiler_type,
name, name,
data, data,
address))->GetSP(); address))->GetSP();
} }
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope, ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
const DataExtractor &data, const DataExtractor &data,
lldb::addr_t address) : lldb::addr_t address) :
ValueObject (exe_scope), ValueObject (exe_scope),
m_type_name (), m_type_name (),
m_byte_size (0), m_byte_size (0),
m_impl(this, address) m_impl(this, address)
{ {
m_data = data; m_data = data;
if (!m_data.GetSharedDataBuffer()) if (!m_data.GetSharedDataBuffer())
{ {
DataBufferSP shared_data_buffer(new DataBufferHeap(data.GetDataStart(), data.GetByteSize())); DataBufferSP shared_data_buffer(new DataBufferHeap(data.GetDataStart(), data.GetByteSize()));
m_data.SetData(shared_data_buffer); m_data.SetData(shared_data_buffer);
} }
m_value.GetScalar() = (uintptr_t)m_data.GetDataStart(); m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
m_value.SetValueType(Value::eValueTypeHostAddress); m_value.SetValueType(Value::eValueTypeHostAddress);
m_value.SetCompilerType(clang_type); m_value.SetCompilerType(compiler_type);
m_name = name; m_name = name;
SetIsConstant (); SetIsConstant ();
SetValueIsValid(true); SetValueIsValid(true);
SetAddressTypeOfChildren(eAddressTypeLoad); SetAddressTypeOfChildren(eAddressTypeLoad);
} }
ValueObjectSP ValueObjectSP
ValueObjectConstResult::Create (ExecutionContextScope *exe_scope, ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
const lldb::DataBufferSP &data_sp, const lldb::DataBufferSP &data_sp,
lldb::ByteOrder data_byte_order, lldb::ByteOrder data_byte_order,
uint32_t data_addr_size, uint32_t data_addr_size,
lldb::addr_t address) lldb::addr_t address)
{ {
return (new ValueObjectConstResult (exe_scope, return (new ValueObjectConstResult (exe_scope,
clang_type, compiler_type,
name, name,
data_sp, data_sp,
data_byte_order, data_byte_order,
data_addr_size, data_addr_size,
address))->GetSP(); address))->GetSP();
} }
ValueObjectSP ValueObjectSP
ValueObjectConstResult::Create (ExecutionContextScope *exe_scope, ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
Value &value, Value &value,
const ConstString &name, const ConstString &name,
Module *module) Module *module)
{ {
return (new ValueObjectConstResult (exe_scope, value, name, module))->GetSP(); return (new ValueObjectConstResult (exe_scope, value, name, module))->GetSP();
} }
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope, ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
const lldb::DataBufferSP &data_sp, const lldb::DataBufferSP &data_sp,
lldb::ByteOrder data_byte_order, lldb::ByteOrder data_byte_order,
uint32_t data_addr_size, uint32_t data_addr_size,
lldb::addr_t address) : lldb::addr_t address) :
ValueObject (exe_scope), ValueObject (exe_scope),
m_type_name (), m_type_name (),
m_byte_size (0), m_byte_size (0),
m_impl(this, address) m_impl(this, address)
{ {
m_data.SetByteOrder(data_byte_order); m_data.SetByteOrder(data_byte_order);
m_data.SetAddressByteSize(data_addr_size); m_data.SetAddressByteSize(data_addr_size);
m_data.SetData(data_sp); m_data.SetData(data_sp);
m_value.GetScalar() = (uintptr_t)data_sp->GetBytes(); m_value.GetScalar() = (uintptr_t)data_sp->GetBytes();
m_value.SetValueType(Value::eValueTypeHostAddress); m_value.SetValueType(Value::eValueTypeHostAddress);
//m_value.SetContext(Value::eContextTypeClangType, clang_type); //m_value.SetContext(Value::eContextTypeClangType, compiler_type);
m_value.SetCompilerType (clang_type); m_value.SetCompilerType (compiler_type);
m_name = name; m_name = name;
SetIsConstant (); SetIsConstant ();
SetValueIsValid(true); SetValueIsValid(true);
SetAddressTypeOfChildren(eAddressTypeLoad); SetAddressTypeOfChildren(eAddressTypeLoad);
} }
ValueObjectSP ValueObjectSP
ValueObjectConstResult::Create (ExecutionContextScope *exe_scope, ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
lldb::addr_t address, lldb::addr_t address,
AddressType address_type, AddressType address_type,
uint32_t addr_byte_size) uint32_t addr_byte_size)
{ {
return (new ValueObjectConstResult (exe_scope, return (new ValueObjectConstResult (exe_scope,
clang_type, compiler_type,
name, name,
address, address,
address_type, address_type,
addr_byte_size))->GetSP(); addr_byte_size))->GetSP();
} }
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope, ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
lldb::addr_t address, lldb::addr_t address,
AddressType address_type, AddressType address_type,
uint32_t addr_byte_size) : uint32_t addr_byte_size) :
ValueObject (exe_scope), ValueObject (exe_scope),
m_type_name (), m_type_name (),
m_byte_size (0), m_byte_size (0),
m_impl(this, address) m_impl(this, address)
{ {
m_value.GetScalar() = address; m_value.GetScalar() = address;
m_data.SetAddressByteSize(addr_byte_size); m_data.SetAddressByteSize(addr_byte_size);
m_value.GetScalar().GetData (m_data, addr_byte_size); m_value.GetScalar().GetData (m_data, addr_byte_size);
//m_value.SetValueType(Value::eValueTypeHostAddress); //m_value.SetValueType(Value::eValueTypeHostAddress);
switch (address_type) switch (address_type)
{ {
case eAddressTypeInvalid: m_value.SetValueType(Value::eValueTypeScalar); break; case eAddressTypeInvalid: m_value.SetValueType(Value::eValueTypeScalar); break;
case eAddressTypeFile: m_value.SetValueType(Value::eValueTypeFileAddress); break; case eAddressTypeFile: m_value.SetValueType(Value::eValueTypeFileAddress); break;
case eAddressTypeLoad: m_value.SetValueType(Value::eValueTypeLoadAddress); break; case eAddressTypeLoad: m_value.SetValueType(Value::eValueTypeLoadAddress); break;
case eAddressTypeHost: m_value.SetValueType(Value::eValueTypeHostAddress); break; case eAddressTypeHost: m_value.SetValueType(Value::eValueTypeHostAddress); break;
} }
// m_value.SetContext(Value::eContextTypeClangType, clang_type); // m_value.SetContext(Value::eContextTypeClangType, compiler_type);
m_value.SetCompilerType (clang_type); m_value.SetCompilerType (compiler_type);
m_name = name; m_name = name;
SetIsConstant (); SetIsConstant ();
SetValueIsValid(true); SetValueIsValid(true);
SetAddressTypeOfChildren(eAddressTypeLoad); SetAddressTypeOfChildren(eAddressTypeLoad);
} }
ValueObjectSP ValueObjectSP
ValueObjectConstResult::Create ValueObjectConstResult::Create
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines if (use_dynamic != eNoDynamicValues)
} }
if (m_dynamic_value) if (m_dynamic_value)
return m_dynamic_value->GetSP(); return m_dynamic_value->GetSP();
} }
return ValueObjectSP(); return ValueObjectSP();
} }
lldb::ValueObjectSP lldb::ValueObjectSP
ValueObjectConstResult::Cast (const CompilerType &clang_ast_type) ValueObjectConstResult::Cast (const CompilerType &compiler_type)
{ {
return m_impl.Cast(clang_ast_type); return m_impl.Cast(compiler_type);
} }
lldb::LanguageType lldb::LanguageType
ValueObjectConstResult::GetPreferredDisplayLanguage () ValueObjectConstResult::GetPreferredDisplayLanguage ()
{ {
return lldb::eLanguageTypeUnknown; return lldb::eLanguageTypeUnknown;
} }

lldb/trunk/source/Core/ValueObjectConstResultCast.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
ValueObjectConstResultCast::GetPointeeData (DataExtractor& data, ValueObjectConstResultCast::GetPointeeData (DataExtractor& data,
uint32_t item_idx, uint32_t item_idx,
uint32_t item_count) uint32_t item_count)
{ {
return m_impl.GetPointeeData(data, item_idx, item_count); return m_impl.GetPointeeData(data, item_idx, item_count);
} }
lldb::ValueObjectSP lldb::ValueObjectSP
ValueObjectConstResultCast::Cast (const CompilerType &clang_ast_type) ValueObjectConstResultCast::Cast (const CompilerType &compiler_type)
{ {
return m_impl.Cast(clang_ast_type); return m_impl.Cast(compiler_type);
} }

lldb/trunk/source/Core/ValueObjectConstResultChild.cpp

Show All 13 Lines
#include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTContext.h"
using namespace lldb_private; using namespace lldb_private;
ValueObjectConstResultChild::ValueObjectConstResultChild ValueObjectConstResultChild::ValueObjectConstResultChild
( (
ValueObject &parent, ValueObject &parent,
const CompilerType &clang_type, const CompilerType &compiler_type,
const ConstString &name, const ConstString &name,
uint32_t byte_size, uint32_t byte_size,
int32_t byte_offset, int32_t byte_offset,
uint32_t bitfield_bit_size, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, uint32_t bitfield_bit_offset,
bool is_base_class, bool is_base_class,
bool is_deref_of_parent, bool is_deref_of_parent,
lldb::addr_t live_address lldb::addr_t live_address
) : ) :
ValueObjectChild (parent, ValueObjectChild (parent,
clang_type, compiler_type,
name, name,
byte_size, byte_size,
byte_offset, byte_offset,
bitfield_bit_size, bitfield_bit_size,
bitfield_bit_offset, bitfield_bit_offset,
is_base_class, is_base_class,
is_deref_of_parent, is_deref_of_parent,
eAddressTypeLoad), eAddressTypeLoad),
Show All 34 Lines
ValueObjectConstResultChild::GetPointeeData (DataExtractor& data, ValueObjectConstResultChild::GetPointeeData (DataExtractor& data,
uint32_t item_idx, uint32_t item_idx,
uint32_t item_count) uint32_t item_count)
{ {
return m_impl.GetPointeeData(data, item_idx, item_count); return m_impl.GetPointeeData(data, item_idx, item_count);
} }
lldb::ValueObjectSP lldb::ValueObjectSP
ValueObjectConstResultChild::Cast (const CompilerType &clang_ast_type) ValueObjectConstResultChild::Cast (const CompilerType &compiler_type)
{ {
return m_impl.Cast(clang_ast_type); return m_impl.Cast(compiler_type);
} }

lldb/trunk/source/Core/ValueObjectConstResultImpl.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 LinesValueObjectConstResultImpl::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index)
uint32_t child_byte_size = 0; uint32_t child_byte_size = 0;
int32_t child_byte_offset = 0; int32_t child_byte_offset = 0;
uint32_t child_bitfield_bit_size = 0; uint32_t child_bitfield_bit_size = 0;
uint32_t child_bitfield_bit_offset = 0; uint32_t child_bitfield_bit_offset = 0;
bool child_is_base_class = false; bool child_is_base_class = false;
bool child_is_deref_of_parent = false; bool child_is_deref_of_parent = false;
const bool transparent_pointers = synthetic_array_member == false; const bool transparent_pointers = synthetic_array_member == false;
CompilerType clang_type = m_impl_backend->GetCompilerType(); CompilerType compiler_type = m_impl_backend->GetCompilerType();
CompilerType child_compiler_type; CompilerType child_compiler_type;
ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef()); ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef());
child_compiler_type = clang_type.GetChildCompilerTypeAtIndex (&exe_ctx, child_compiler_type = compiler_type.GetChildCompilerTypeAtIndex (&exe_ctx,
idx, idx,
transparent_pointers, transparent_pointers,
omit_empty_base_classes, omit_empty_base_classes,
ignore_array_bounds, ignore_array_bounds,
child_name_str, child_name_str,
child_byte_size, child_byte_size,
child_byte_offset, child_byte_offset,
child_bitfield_bit_size, child_bitfield_bit_size,
child_bitfield_bit_offset, child_bitfield_bit_offset,
child_is_base_class, child_is_base_class,
child_is_deref_of_parent, child_is_deref_of_parent,
m_impl_backend); m_impl_backend);
if (child_compiler_type && child_byte_size) if (child_compiler_type && child_byte_size)
{ {
if (synthetic_index) if (synthetic_index)
child_byte_offset += child_byte_size * synthetic_index; child_byte_offset += child_byte_size * synthetic_index;
ConstString child_name; ConstString child_name;
if (!child_name_str.empty()) if (!child_name_str.empty())
child_name.SetCString (child_name_str.c_str()); child_name.SetCString (child_name_str.c_str());
Show All 27 Lines
{ {
if (m_address_of_backend.get() != NULL) if (m_address_of_backend.get() != NULL)
return m_address_of_backend; return m_address_of_backend;
if (m_impl_backend == NULL) if (m_impl_backend == NULL)
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
if (m_live_address != LLDB_INVALID_ADDRESS) if (m_live_address != LLDB_INVALID_ADDRESS)
{ {
CompilerType clang_type(m_impl_backend->GetCompilerType()); CompilerType compiler_type(m_impl_backend->GetCompilerType());
lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&m_live_address,sizeof(lldb::addr_t))); lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&m_live_address,sizeof(lldb::addr_t)));
std::string new_name("&"); std::string new_name("&");
new_name.append(m_impl_backend->GetName().AsCString("")); new_name.append(m_impl_backend->GetName().AsCString(""));
ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef()); ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef());
m_address_of_backend = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), m_address_of_backend = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
clang_type.GetPointerType(), compiler_type.GetPointerType(),
ConstString(new_name.c_str()), ConstString(new_name.c_str()),
buffer, buffer,
lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder(),
exe_ctx.GetAddressByteSize()); exe_ctx.GetAddressByteSize());
m_address_of_backend->GetValue().SetValueType(Value::eValueTypeScalar); m_address_of_backend->GetValue().SetValueType(Value::eValueTypeScalar);
m_address_of_backend->GetValue().GetScalar() = m_live_address; m_address_of_backend->GetValue().GetScalar() = m_live_address;
return m_address_of_backend; return m_address_of_backend;
} }
else else
return m_impl_backend->ValueObject::AddressOf(error); return m_impl_backend->ValueObject::AddressOf(error);
} }
lldb::ValueObjectSP lldb::ValueObjectSP
ValueObjectConstResultImpl::Cast (const CompilerType &clang_ast_type) ValueObjectConstResultImpl::Cast (const CompilerType &compiler_type)
{ {
if (m_impl_backend == NULL) if (m_impl_backend == NULL)
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
ValueObjectConstResultCast *result_cast = new ValueObjectConstResultCast( ValueObjectConstResultCast *result_cast = new ValueObjectConstResultCast(
*m_impl_backend, m_impl_backend->GetName(), clang_ast_type, m_live_address); *m_impl_backend, m_impl_backend->GetName(), compiler_type, m_live_address);
return result_cast->GetSP(); return result_cast->GetSP();
} }
lldb::addr_t lldb::addr_t
ValueObjectConstResultImpl::GetAddressOf (bool scalar_is_load_address, ValueObjectConstResultImpl::GetAddressOf (bool scalar_is_load_address,
AddressType *address_type) AddressType *address_type)
{ {
Show All 24 Lines

lldb/trunk/source/Core/ValueObjectMemory.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope, ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope,
const char *name, const char *name,
const Address &address, const Address &address,
lldb::TypeSP &type_sp) : lldb::TypeSP &type_sp) :
ValueObject(exe_scope), ValueObject(exe_scope),
m_address (address), m_address (address),
m_type_sp(type_sp), m_type_sp(type_sp),
m_clang_type() m_compiler_type()
{ {
// Do not attempt to construct one of these objects with no variable! // Do not attempt to construct one of these objects with no variable!
assert (m_type_sp.get() != NULL); assert (m_type_sp.get() != NULL);
SetName (ConstString(name)); SetName (ConstString(name));
m_value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get()); m_value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get());
TargetSP target_sp (GetTargetSP()); TargetSP target_sp (GetTargetSP());
lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get()); lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
if (load_address != LLDB_INVALID_ADDRESS) if (load_address != LLDB_INVALID_ADDRESS)
Show All 19 Lines
ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope, ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope,
const char *name, const char *name,
const Address &address, const Address &address,
const CompilerType &ast_type) : const CompilerType &ast_type) :
ValueObject(exe_scope), ValueObject(exe_scope),
m_address (address), m_address (address),
m_type_sp(), m_type_sp(),
m_clang_type(ast_type) m_compiler_type(ast_type)
{ {
// Do not attempt to construct one of these objects with no variable! // Do not attempt to construct one of these objects with no variable!
assert (m_clang_type.GetTypeSystem()); assert (m_compiler_type.GetTypeSystem());
assert (m_clang_type.GetOpaqueQualType()); assert (m_compiler_type.GetOpaqueQualType());
TargetSP target_sp (GetTargetSP()); TargetSP target_sp (GetTargetSP());
SetName (ConstString(name)); SetName (ConstString(name));
// m_value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType()); // m_value.SetContext(Value::eContextTypeClangType, m_compiler_type.GetOpaqueQualType());
m_value.SetCompilerType(m_clang_type); m_value.SetCompilerType(m_compiler_type);
lldb::addr_t load_address = m_address.GetLoadAddress (target_sp.get()); lldb::addr_t load_address = m_address.GetLoadAddress (target_sp.get());
if (load_address != LLDB_INVALID_ADDRESS) if (load_address != LLDB_INVALID_ADDRESS)
{ {
m_value.SetValueType(Value::eValueTypeLoadAddress); m_value.SetValueType(Value::eValueTypeLoadAddress);
m_value.GetScalar() = load_address; m_value.GetScalar() = load_address;
} }
else else
{ {
Show All 15 Lines
{ {
} }
CompilerType CompilerType
ValueObjectMemory::GetCompilerTypeImpl () ValueObjectMemory::GetCompilerTypeImpl ()
{ {
if (m_type_sp) if (m_type_sp)
return m_type_sp->GetForwardCompilerType (); return m_type_sp->GetForwardCompilerType ();
return m_clang_type; return m_compiler_type;
} }
ConstString ConstString
ValueObjectMemory::GetTypeName() ValueObjectMemory::GetTypeName()
{ {
if (m_type_sp) if (m_type_sp)
return m_type_sp->GetName(); return m_type_sp->GetName();
return m_clang_type.GetConstTypeName(); return m_compiler_type.GetConstTypeName();
} }
ConstString ConstString
ValueObjectMemory::GetDisplayTypeName() ValueObjectMemory::GetDisplayTypeName()
{ {
if (m_type_sp) if (m_type_sp)
return m_type_sp->GetForwardCompilerType ().GetDisplayTypeName(); return m_type_sp->GetForwardCompilerType ().GetDisplayTypeName();
return m_clang_type.GetDisplayTypeName(); return m_compiler_type.GetDisplayTypeName();
} }
size_t size_t
ValueObjectMemory::CalculateNumChildren() ValueObjectMemory::CalculateNumChildren()
{ {
if (m_type_sp) if (m_type_sp)
return m_type_sp->GetNumChildren(true); return m_type_sp->GetNumChildren(true);
const bool omit_empty_base_classes = true; const bool omit_empty_base_classes = true;
return m_clang_type.GetNumChildren (omit_empty_base_classes); return m_compiler_type.GetNumChildren (omit_empty_base_classes);
} }
uint64_t uint64_t
ValueObjectMemory::GetByteSize() ValueObjectMemory::GetByteSize()
{ {
if (m_type_sp) if (m_type_sp)
return m_type_sp->GetByteSize(); return m_type_sp->GetByteSize();
return m_clang_type.GetByteSize (nullptr); return m_compiler_type.GetByteSize (nullptr);
} }
lldb::ValueType lldb::ValueType
ValueObjectMemory::GetValueType() const ValueObjectMemory::GetValueType() const
{ {
// RETHINK: Should this be inherited from somewhere? // RETHINK: Should this be inherited from somewhere?
return lldb::eValueTypeVariableGlobal; return lldb::eValueTypeVariableGlobal;
} }
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines if (m_address.IsValid())
{ {
// Copy the Value and set the context to use our Variable // Copy the Value and set the context to use our Variable
// so it can extract read its value into m_data appropriately // so it can extract read its value into m_data appropriately
Value value(m_value); Value value(m_value);
if (m_type_sp) if (m_type_sp)
value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get()); value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get());
else else
{ {
//value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType()); //value.SetContext(Value::eContextTypeClangType, m_compiler_type.GetOpaqueQualType());
value.SetCompilerType(m_clang_type); value.SetCompilerType(m_compiler_type);
} }
m_error = value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get()); m_error = value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get());
} }
break; break;
} }
SetValueIsValid (m_error.Success()); SetValueIsValid (m_error.Success());
Show All 22 Lines

lldb/trunk/source/Core/ValueObjectRegister.cpp

Show First 20 Lines • Show All 273 Lines • ▼ Show 20 Lines
} }
ValueObjectRegister::ValueObjectRegister (ValueObject &parent, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num) : ValueObjectRegister::ValueObjectRegister (ValueObject &parent, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num) :
ValueObject (parent), ValueObject (parent),
m_reg_ctx_sp (reg_ctx_sp), m_reg_ctx_sp (reg_ctx_sp),
m_reg_info (), m_reg_info (),
m_reg_value (), m_reg_value (),
m_type_name (), m_type_name (),
m_clang_type () m_compiler_type ()
{ {
assert (reg_ctx_sp.get()); assert (reg_ctx_sp.get());
ConstructObject(reg_num); ConstructObject(reg_num);
} }
ValueObjectSP ValueObjectSP
ValueObjectRegister::Create (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num) ValueObjectRegister::Create (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num)
{ {
return (new ValueObjectRegister (exe_scope, reg_ctx_sp, reg_num))->GetSP(); return (new ValueObjectRegister (exe_scope, reg_ctx_sp, reg_num))->GetSP();
} }
ValueObjectRegister::ValueObjectRegister (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx, uint32_t reg_num) : ValueObjectRegister::ValueObjectRegister (ExecutionContextScope *exe_scope, lldb::RegisterContextSP &reg_ctx, uint32_t reg_num) :
ValueObject (exe_scope), ValueObject (exe_scope),
m_reg_ctx_sp (reg_ctx), m_reg_ctx_sp (reg_ctx),
m_reg_info (), m_reg_info (),
m_reg_value (), m_reg_value (),
m_type_name (), m_type_name (),
m_clang_type () m_compiler_type ()
{ {
assert (reg_ctx); assert (reg_ctx);
ConstructObject(reg_num); ConstructObject(reg_num);
} }
ValueObjectRegister::~ValueObjectRegister() ValueObjectRegister::~ValueObjectRegister()
{ {
} }
CompilerType CompilerType
ValueObjectRegister::GetCompilerTypeImpl () ValueObjectRegister::GetCompilerTypeImpl ()
{ {
if (!m_clang_type.IsValid()) if (!m_compiler_type.IsValid())
{ {
ExecutionContext exe_ctx (GetExecutionContextRef()); ExecutionContext exe_ctx (GetExecutionContextRef());
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
if (target) if (target)
{ {
Module *exe_module = target->GetExecutableModulePointer(); Module *exe_module = target->GetExecutableModulePointer();
if (exe_module) if (exe_module)
{ {
TypeSystem *type_system = exe_module->GetTypeSystemForLanguage (eLanguageTypeC); TypeSystem *type_system = exe_module->GetTypeSystemForLanguage (eLanguageTypeC);
if (type_system) if (type_system)
m_clang_type = type_system->GetBuiltinTypeForEncodingAndBitSize (m_reg_info.encoding, m_compiler_type = type_system->GetBuiltinTypeForEncodingAndBitSize (m_reg_info.encoding,
m_reg_info.byte_size * 8); m_reg_info.byte_size * 8);
} }
} }
} }
return m_clang_type; return m_compiler_type;
} }
ConstString ConstString
ValueObjectRegister::GetTypeName() ValueObjectRegister::GetTypeName()
{ {
if (m_type_name.IsEmpty()) if (m_type_name.IsEmpty())
m_type_name = GetCompilerType().GetConstTypeName (); m_type_name = GetCompilerType().GetConstTypeName ();
return m_type_name; return m_type_name;
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObjectVariable.cpp

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines else
loclist_base_load_addr = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (target); loclist_base_load_addr = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (target);
} }
Value old_value(m_value); Value old_value(m_value);
if (expr.Evaluate (&exe_ctx, NULL, NULL, NULL, loclist_base_load_addr, NULL, m_value, &m_error)) if (expr.Evaluate (&exe_ctx, NULL, NULL, NULL, loclist_base_load_addr, NULL, m_value, &m_error))
{ {
m_resolved_value = m_value; m_resolved_value = m_value;
m_value.SetContext(Value::eContextTypeVariable, variable); m_value.SetContext(Value::eContextTypeVariable, variable);
CompilerType clang_type = GetCompilerType(); CompilerType compiler_type = GetCompilerType();
if (clang_type.IsValid()) if (compiler_type.IsValid())
m_value.SetCompilerType(clang_type); m_value.SetCompilerType(compiler_type);
Value::ValueType value_type = m_value.GetValueType(); Value::ValueType value_type = m_value.GetValueType();
Process *process = exe_ctx.GetProcessPtr(); Process *process = exe_ctx.GetProcessPtr();
const bool process_is_alive = process && process->IsAlive(); const bool process_is_alive = process && process->IsAlive();
const uint32_t type_info = clang_type.GetTypeInfo(); const uint32_t type_info = compiler_type.GetTypeInfo();
const bool is_pointer_or_ref = (type_info & (lldb::eTypeIsPointer | lldb::eTypeIsReference)) != 0; const bool is_pointer_or_ref = (type_info & (lldb::eTypeIsPointer | lldb::eTypeIsReference)) != 0;
switch (value_type) switch (value_type)
{ {
case Value::eValueTypeFileAddress: case Value::eValueTypeFileAddress:
// If this type is a pointer, then its children will be considered load addresses // If this type is a pointer, then its children will be considered load addresses
// if the pointer or reference is dereferenced, but only if the process is alive. // if the pointer or reference is dereferenced, but only if the process is alive.
// //
▲ Show 20 Lines • Show All 257 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/ASTDumper.cpp

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 LinesASTDumper::ASTDumper (clang::QualType type)
m_dump = type.getAsString(); m_dump = type.getAsString();
} }
ASTDumper::ASTDumper (lldb::opaque_compiler_type_t type) ASTDumper::ASTDumper (lldb::opaque_compiler_type_t type)
{ {
m_dump = clang::QualType::getFromOpaquePtr(type).getAsString(); m_dump = clang::QualType::getFromOpaquePtr(type).getAsString();
} }
ASTDumper::ASTDumper (const CompilerType &clang_type) ASTDumper::ASTDumper (const CompilerType &compiler_type)
{ {
m_dump = ClangASTContext::GetQualType(clang_type).getAsString(); m_dump = ClangASTContext::GetQualType(compiler_type).getAsString();
} }
const char * const char *
ASTDumper::GetCString() ASTDumper::GetCString()
{ {
return m_dump.c_str(); return m_dump.c_str();
} }
Show All 40 Lines

lldb/trunk/source/Expression/IRForTarget.cpp

Show First 20 Lines • Show All 1,503 Lines • ▼ Show 20 Lines else if (GlobalVariable *global_variable = dyn_cast<GlobalVariable>(llvm_value_ptr))
} }
std::string name (named_decl->getName().str()); std::string name (named_decl->getName().str());
clang::ValueDecl *value_decl = dyn_cast<clang::ValueDecl>(named_decl); clang::ValueDecl *value_decl = dyn_cast<clang::ValueDecl>(named_decl);
if (value_decl == NULL) if (value_decl == NULL)
return false; return false;
lldb_private::CompilerType clang_type(&value_decl->getASTContext(), value_decl->getType()); lldb_private::CompilerType compiler_type(&value_decl->getASTContext(), value_decl->getType());
const Type *value_type = NULL; const Type *value_type = NULL;
if (name[0] == '$') if (name[0] == '$')
{ {
// The $__lldb_expr_result name indicates the return value has allocated as // The $__lldb_expr_result name indicates the return value has allocated as
// a static variable. Per the comment at ASTResultSynthesizer::SynthesizeBodyResult, // a static variable. Per the comment at ASTResultSynthesizer::SynthesizeBodyResult,
// accesses to this static variable need to be redirected to the result of dereferencing // accesses to this static variable need to be redirected to the result of dereferencing
// a pointer that is passed in as one of the arguments. // a pointer that is passed in as one of the arguments.
// //
// Consequently, when reporting the size of the type, we report a pointer type pointing // Consequently, when reporting the size of the type, we report a pointer type pointing
// to the type of $__lldb_expr_result, not the type itself. // to the type of $__lldb_expr_result, not the type itself.
// //
// We also do this for any user-declared persistent variables. // We also do this for any user-declared persistent variables.
clang_type = clang_type.GetPointerType(); compiler_type = compiler_type.GetPointerType();
value_type = PointerType::get(global_variable->getType(), 0); value_type = PointerType::get(global_variable->getType(), 0);
} }
else else
{ {
value_type = global_variable->getType(); value_type = global_variable->getType();
} }
const uint64_t value_size = clang_type.GetByteSize(nullptr); const uint64_t value_size = compiler_type.GetByteSize(nullptr);
lldb::offset_t value_alignment = (clang_type.GetTypeBitAlign() + 7ull) / 8ull; lldb::offset_t value_alignment = (compiler_type.GetTypeBitAlign() + 7ull) / 8ull;
if (log) if (log)
{ {
log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64 ", align %" PRIu64 "]", log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64 ", align %" PRIu64 "]",
name.c_str(), name.c_str(),
lldb_private::ClangASTContext::GetQualType(clang_type).getAsString().c_str(), lldb_private::ClangASTContext::GetQualType(compiler_type).getAsString().c_str(),
PrintType(value_type).c_str(), PrintType(value_type).c_str(),
value_size, value_size,
value_alignment); value_alignment);
} }
if (named_decl && !m_decl_map->AddValueToStruct(named_decl, if (named_decl && !m_decl_map->AddValueToStruct(named_decl,
lldb_private::ConstString (name.c_str()), lldb_private::ConstString (name.c_str()),
▲ Show 20 Lines • Show All 1,269 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

Show First 20 Lines • Show All 326 Lines • ▼ Show 20 LinesABIMacOSX_arm::GetArgumentValues (Thread &thread,
{ {
// We currently only support extracting values with Clang QualTypes. // We currently only support extracting values with Clang QualTypes.
// Do we care about others? // Do we care about others?
Value *value = values.GetValueAtIndex(value_idx); Value *value = values.GetValueAtIndex(value_idx);
if (!value) if (!value)
return false; return false;
CompilerType clang_type = value->GetCompilerType(); CompilerType compiler_type = value->GetCompilerType();
if (clang_type) if (compiler_type)
{ {
bool is_signed = false; bool is_signed = false;
size_t bit_width = 0; size_t bit_width = 0;
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
bit_width = clang_type.GetBitSize(&thread); bit_width = compiler_type.GetBitSize(&thread);
} }
else if (clang_type.IsPointerOrReferenceType ()) else if (compiler_type.IsPointerOrReferenceType ())
{ {
bit_width = clang_type.GetBitSize(&thread); bit_width = compiler_type.GetBitSize(&thread);
} }
else else
{ {
// We only handle integer, pointer and reference types currently... // We only handle integer, pointer and reference types currently...
return false; return false;
} }
if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8))
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx)
} }
} }
} }
return true; return true;
} }
ValueObjectSP ValueObjectSP
ABIMacOSX_arm::GetReturnValueObjectImpl (Thread &thread, ABIMacOSX_arm::GetReturnValueObjectImpl (Thread &thread,
lldb_private::CompilerType &clang_type) const lldb_private::CompilerType &compiler_type) const
{ {
Value value; Value value;
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
if (!clang_type) if (!compiler_type)
return return_valobj_sp; return return_valobj_sp;
value.SetCompilerType (clang_type); value.SetCompilerType (compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
bool is_signed; bool is_signed;
// Get the pointer to the first stack argument so we have a place to start // Get the pointer to the first stack argument so we have a place to start
// when reading data // when reading data
const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0); const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
size_t bit_width = clang_type.GetBitSize(&thread); size_t bit_width = compiler_type.GetBitSize(&thread);
switch (bit_width) switch (bit_width)
{ {
default: default:
return return_valobj_sp; return return_valobj_sp;
case 64: case 64:
{ {
const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfoByName("r1", 0); const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfoByName("r1", 0);
Show All 21 Lines if (compiler_type.IsIntegerType (is_signed))
case 8: case 8:
if (is_signed) if (is_signed)
value.GetScalar() = (int8_t)(reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX); value.GetScalar() = (int8_t)(reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
else else
value.GetScalar() = (uint8_t)(reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX); value.GetScalar() = (uint8_t)(reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
break; break;
} }
} }
else if (clang_type.IsPointerType ()) else if (compiler_type.IsPointerType ())
{ {
uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX; uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
value.GetScalar() = ptr; value.GetScalar() = ptr;
} }
else else
{ {
// not handled yet // not handled yet
return return_valobj_sp; return return_valobj_sp;
Show All 12 Lines
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
bool is_signed; bool is_signed;
uint32_t count; uint32_t count;
bool is_complex; bool is_complex;
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
bool set_it_simple = false; bool set_it_simple = false;
if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType()) if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
{ {
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString()); error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
return error; return error;
Show All 23 Lines if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
} }
} }
} }
else else
{ {
error.SetErrorString("We don't support returning longer than 64 bit integer values at present."); error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
} }
} }
else if (clang_type.IsFloatingPointType (count, is_complex)) else if (compiler_type.IsFloatingPointType (count, is_complex))
{ {
if (is_complex) if (is_complex)
error.SetErrorString ("We don't support returning complex values at present"); error.SetErrorString ("We don't support returning complex values at present");
else else
error.SetErrorString ("We don't support returning float values at present"); error.SetErrorString ("We don't support returning float values at present");
} }
if (!set_it_simple) if (!set_it_simple)
▲ Show 20 Lines • Show All 303 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

Show First 20 Lines • Show All 852 Lines • ▼ Show 20 LinesLoadValueFromConsecutiveGPRRegisters (ExecutionContext &exe_ctx,
data.SetByteOrder(byte_order); data.SetByteOrder(byte_order);
data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize()); data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
data.SetData(DataBufferSP (heap_data_ap.release())); data.SetData(DataBufferSP (heap_data_ap.release()));
return true; return true;
} }
ValueObjectSP ValueObjectSP
ABIMacOSX_arm64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_clang_type) const ABIMacOSX_arm64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
Value value; Value value;
ExecutionContext exe_ctx (thread.shared_from_this()); ExecutionContext exe_ctx (thread.shared_from_this());
if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL) if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL)
return return_valobj_sp; return return_valobj_sp;
//value.SetContext (Value::eContextTypeClangType, return_clang_type); //value.SetContext (Value::eContextTypeClangType, return_compiler_type);
value.SetCompilerType(return_clang_type); value.SetCompilerType(return_compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
const uint32_t type_flags = return_clang_type.GetTypeInfo (NULL); const uint32_t type_flags = return_compiler_type.GetTypeInfo (NULL);
if (type_flags & eTypeIsScalar || if (type_flags & eTypeIsScalar ||
type_flags & eTypeIsPointer) type_flags & eTypeIsPointer)
{ {
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
bool success = false; bool success = false;
if (type_flags & eTypeIsInteger || if (type_flags & eTypeIsInteger ||
type_flags & eTypeIsPointer ) type_flags & eTypeIsPointer )
Show All 30 Lines if (type_flags & eTypeIsScalar ||
if (x0_reg_value.GetAsMemoryData (x0_reg_info, heap_data_ap->GetBytes()+0, 8, byte_order, error) && if (x0_reg_value.GetAsMemoryData (x0_reg_info, heap_data_ap->GetBytes()+0, 8, byte_order, error) &&
x1_reg_value.GetAsMemoryData (x1_reg_info, heap_data_ap->GetBytes()+8, 8, byte_order, error)) x1_reg_value.GetAsMemoryData (x1_reg_info, heap_data_ap->GetBytes()+8, 8, byte_order, error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
exe_ctx.GetProcessRef().GetAddressByteSize()); exe_ctx.GetProcessRef().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
return return_valobj_sp; return return_valobj_sp;
} }
} }
} }
} }
} }
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines else if (type_flags & eTypeIsVector)
heap_data_ap->GetByteSize(), heap_data_ap->GetByteSize(),
byte_order, byte_order,
error)) error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
exe_ctx.GetProcessRef().GetAddressByteSize()); exe_ctx.GetProcessRef().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
} }
} }
} }
} }
else if (type_flags & eTypeIsStructUnion || else if (type_flags & eTypeIsStructUnion ||
type_flags & eTypeIsClass) type_flags & eTypeIsClass)
{ {
DataExtractor data; DataExtractor data;
uint32_t NGRN = 0; // Search ABI docs for NGRN uint32_t NGRN = 0; // Search ABI docs for NGRN
uint32_t NSRN = 0; // Search ABI docs for NSRN uint32_t NSRN = 0; // Search ABI docs for NSRN
const bool is_return_value = true; const bool is_return_value = true;
if (LoadValueFromConsecutiveGPRRegisters (exe_ctx, reg_ctx, return_clang_type, is_return_value, NGRN, NSRN, data)) if (LoadValueFromConsecutiveGPRRegisters (exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN, data))
{ {
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
return return_valobj_sp; return return_valobj_sp;
} }
void void
Show All 35 Lines

lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

Show First 20 Lines • Show All 300 Lines • ▼ Show 20 LinesABIMacOSX_i386::GetArgumentValues (Thread &thread,
{ {
Value *value = values.GetValueAtIndex(value_index); Value *value = values.GetValueAtIndex(value_index);
if (!value) if (!value)
return false; return false;
// We currently only support extracting values with Clang QualTypes. // We currently only support extracting values with Clang QualTypes.
// Do we care about others? // Do we care about others?
CompilerType clang_type (value->GetCompilerType()); CompilerType compiler_type (value->GetCompilerType());
if (clang_type) if (compiler_type)
{ {
bool is_signed; bool is_signed;
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
is_signed, is_signed,
thread.GetProcess().get(), thread.GetProcess().get(),
current_stack_argument); current_stack_argument);
} }
else if (clang_type.IsPointerType()) else if (compiler_type.IsPointerType())
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
false, false,
thread.GetProcess().get(), thread.GetProcess().get(),
current_stack_argument); current_stack_argument);
} }
} }
} }
return true; return true;
} }
Error Error
ABIMacOSX_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp) ABIMacOSX_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
bool is_signed; bool is_signed;
uint32_t count; uint32_t count;
bool is_complex; bool is_complex;
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
bool set_it_simple = false; bool set_it_simple = false;
if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType()) if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
{ {
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString()); error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
return error; return error;
Show All 23 Lines if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
} }
} }
} }
else else
{ {
error.SetErrorString("We don't support returning longer than 64 bit integer values at present."); error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
} }
} }
else if (clang_type.IsFloatingPointType (count, is_complex)) else if (compiler_type.IsFloatingPointType (count, is_complex))
{ {
if (is_complex) if (is_complex)
error.SetErrorString ("We don't support returning complex values at present"); error.SetErrorString ("We don't support returning complex values at present");
else else
error.SetErrorString ("We don't support returning float values at present"); error.SetErrorString ("We don't support returning float values at present");
} }
if (!set_it_simple) if (!set_it_simple)
error.SetErrorString ("We only support setting simple integer return types at present."); error.SetErrorString ("We only support setting simple integer return types at present.");
return error; return error;
} }
ValueObjectSP ValueObjectSP
ABIMacOSX_i386::GetReturnValueObjectImpl (Thread &thread, ABIMacOSX_i386::GetReturnValueObjectImpl (Thread &thread,
CompilerType &clang_type) const CompilerType &compiler_type) const
{ {
Value value; Value value;
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
if (!clang_type) if (!compiler_type)
return return_valobj_sp; return return_valobj_sp;
//value.SetContext (Value::eContextTypeClangType, clang_type.GetOpaqueQualType()); //value.SetContext (Value::eContextTypeClangType, compiler_type.GetOpaqueQualType());
value.SetCompilerType (clang_type); value.SetCompilerType (compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
bool is_signed; bool is_signed;
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
size_t bit_width = clang_type.GetBitSize(&thread); size_t bit_width = compiler_type.GetBitSize(&thread);
unsigned eax_id = reg_ctx->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB]; unsigned eax_id = reg_ctx->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB];
unsigned edx_id = reg_ctx->GetRegisterInfoByName("edx", 0)->kinds[eRegisterKindLLDB]; unsigned edx_id = reg_ctx->GetRegisterInfoByName("edx", 0)->kinds[eRegisterKindLLDB];
switch (bit_width) switch (bit_width)
{ {
default: default:
case 128: case 128:
Show All 23 Lines if (compiler_type.IsIntegerType (is_signed))
case 8: case 8:
if (is_signed) if (is_signed)
value.GetScalar() = (int8_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xff); value.GetScalar() = (int8_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xff);
else else
value.GetScalar() = (uint8_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xff); value.GetScalar() = (uint8_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xff);
break; break;
} }
} }
else if (clang_type.IsPointerType ()) else if (compiler_type.IsPointerType ())
{ {
unsigned eax_id = reg_ctx->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB]; unsigned eax_id = reg_ctx->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB];
uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff; uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff;
value.GetScalar() = ptr; value.GetScalar() = ptr;
} }
else else
{ {
// not handled yet // not handled yet
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

Show First 20 Lines • Show All 326 Lines • ▼ Show 20 LinesABISysV_arm::GetArgumentValues (Thread &thread,
{ {
// We currently only support extracting values with Clang QualTypes. // We currently only support extracting values with Clang QualTypes.
// Do we care about others? // Do we care about others?
Value *value = values.GetValueAtIndex(value_idx); Value *value = values.GetValueAtIndex(value_idx);
if (!value) if (!value)
return false; return false;
CompilerType clang_type = value->GetCompilerType(); CompilerType compiler_type = value->GetCompilerType();
if (clang_type) if (compiler_type)
{ {
bool is_signed = false; bool is_signed = false;
size_t bit_width = 0; size_t bit_width = 0;
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
bit_width = clang_type.GetBitSize(&thread); bit_width = compiler_type.GetBitSize(&thread);
} }
else if (clang_type.IsPointerOrReferenceType ()) else if (compiler_type.IsPointerOrReferenceType ())
{ {
bit_width = clang_type.GetBitSize(&thread); bit_width = compiler_type.GetBitSize(&thread);
} }
else else
{ {
// We only handle integer, pointer and reference types currently... // We only handle integer, pointer and reference types currently...
return false; return false;
} }
if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8))
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines if (error.Fail())
return false; return false;
value.SetBytes(buffer.GetBytes(), buffer.GetByteSize()); value.SetBytes(buffer.GetBytes(), buffer.GetByteSize());
return true; return true;
} }
ValueObjectSP ValueObjectSP
ABISysV_arm::GetReturnValueObjectImpl (Thread &thread, ABISysV_arm::GetReturnValueObjectImpl (Thread &thread,
lldb_private::CompilerType &clang_type) const lldb_private::CompilerType &compiler_type) const
{ {
Value value; Value value;
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
if (!clang_type) if (!compiler_type)
return return_valobj_sp; return return_valobj_sp;
//value.SetContext (Value::eContextTypeClangType, clang_type.GetOpaqueQualType()); //value.SetContext (Value::eContextTypeClangType, compiler_type.GetOpaqueQualType());
value.SetCompilerType (clang_type); value.SetCompilerType (compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
bool is_signed; bool is_signed;
bool is_complex; bool is_complex;
uint32_t float_count; uint32_t float_count;
// Get the pointer to the first stack argument so we have a place to start // Get the pointer to the first stack argument so we have a place to start
// when reading data // when reading data
const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1); const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
size_t bit_width = clang_type.GetBitSize(&thread); size_t bit_width = compiler_type.GetBitSize(&thread);
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
switch (bit_width) switch (bit_width)
{ {
default: default:
return return_valobj_sp; return return_valobj_sp;
case 64: case 64:
{ {
const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2); const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2);
Show All 21 Lines if (compiler_type.IsIntegerType (is_signed))
case 8: case 8:
if (is_signed) if (is_signed)
value.GetScalar() = (int8_t)(reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX); value.GetScalar() = (int8_t)(reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
else else
value.GetScalar() = (uint8_t)(reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX); value.GetScalar() = (uint8_t)(reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT8_MAX);
break; break;
} }
} }
else if (clang_type.IsPointerType ()) else if (compiler_type.IsPointerType ())
{ {
uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX; uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
value.GetScalar() = ptr; value.GetScalar() = ptr;
} }
else if (clang_type.IsVectorType(nullptr, nullptr)) else if (compiler_type.IsVectorType(nullptr, nullptr))
{ {
size_t byte_size = clang_type.GetByteSize(&thread); size_t byte_size = compiler_type.GetByteSize(&thread);
if (byte_size <= 16) if (byte_size <= 16)
{ {
DataBufferHeap buffer(16, 0); DataBufferHeap buffer(16, 0);
uint32_t* buffer_ptr = (uint32_t*)buffer.GetBytes(); uint32_t* buffer_ptr = (uint32_t*)buffer.GetBytes();
for (uint32_t i = 0; 4*i < byte_size; ++i) for (uint32_t i = 0; 4*i < byte_size; ++i)
{ {
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i); const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
buffer_ptr[i] = reg_ctx->ReadRegisterAsUnsigned(reg_info, 0) & UINT32_MAX; buffer_ptr[i] = reg_ctx->ReadRegisterAsUnsigned(reg_info, 0) & UINT32_MAX;
} }
value.SetBytes(buffer.GetBytes(), byte_size); value.SetBytes(buffer.GetBytes(), byte_size);
} }
else else
{ {
if (!GetReturnValuePassedInMemory(thread, reg_ctx, byte_size, value)) if (!GetReturnValuePassedInMemory(thread, reg_ctx, byte_size, value))
return return_valobj_sp; return return_valobj_sp;
} }
} }
else if (clang_type.IsFloatingPointType(float_count, is_complex)) else if (compiler_type.IsFloatingPointType(float_count, is_complex))
{ {
if (float_count == 1 && !is_complex) if (float_count == 1 && !is_complex)
{ {
switch (bit_width) switch (bit_width)
{ {
default: default:
return return_valobj_sp; return return_valobj_sp;
case 64: case 64:
Show All 17 Lines else if (compiler_type.IsFloatingPointType(float_count, is_complex))
} }
} }
else else
{ {
// not handled yet // not handled yet
return return_valobj_sp; return return_valobj_sp;
} }
} }
else if (clang_type.IsAggregateType()) else if (compiler_type.IsAggregateType())
{ {
size_t byte_size = clang_type.GetByteSize(&thread); size_t byte_size = compiler_type.GetByteSize(&thread);
if (byte_size <= 4) if (byte_size <= 4)
{ {
RegisterValue r0_reg_value; RegisterValue r0_reg_value;
uint32_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX; uint32_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
value.SetBytes(&raw_value, byte_size); value.SetBytes(&raw_value, byte_size);
} }
else else
{ {
Show All 20 Lines
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
bool is_signed; bool is_signed;
uint32_t count; uint32_t count;
bool is_complex; bool is_complex;
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
bool set_it_simple = false; bool set_it_simple = false;
if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType()) if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
{ {
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString()); error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
return error; return error;
Show All 23 Lines if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
} }
} }
} }
else else
{ {
error.SetErrorString("We don't support returning longer than 64 bit integer values at present."); error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
} }
} }
else if (clang_type.IsFloatingPointType (count, is_complex)) else if (compiler_type.IsFloatingPointType (count, is_complex))
{ {
if (is_complex) if (is_complex)
error.SetErrorString ("We don't support returning complex values at present"); error.SetErrorString ("We don't support returning complex values at present");
else else
error.SetErrorString ("We don't support returning float values at present"); error.SetErrorString ("We don't support returning float values at present");
} }
if (!set_it_simple) if (!set_it_simple)
▲ Show 20 Lines • Show All 295 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

Show First 20 Lines • Show All 822 Lines • ▼ Show 20 LinesLoadValueFromConsecutiveGPRRegisters (ExecutionContext &exe_ctx,
data.SetByteOrder(byte_order); data.SetByteOrder(byte_order);
data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize()); data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
data.SetData(DataBufferSP (heap_data_ap.release())); data.SetData(DataBufferSP (heap_data_ap.release()));
return true; return true;
} }
ValueObjectSP ValueObjectSP
ABISysV_arm64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_clang_type) const ABISysV_arm64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
Value value; Value value;
ExecutionContext exe_ctx (thread.shared_from_this()); ExecutionContext exe_ctx (thread.shared_from_this());
if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL) if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL)
return return_valobj_sp; return return_valobj_sp;
//value.SetContext (Value::eContextTypeClangType, return_clang_type); //value.SetContext (Value::eContextTypeClangType, return_compiler_type);
value.SetCompilerType(return_clang_type); value.SetCompilerType(return_compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
const uint32_t type_flags = return_clang_type.GetTypeInfo (NULL); const uint32_t type_flags = return_compiler_type.GetTypeInfo (NULL);
if (type_flags & eTypeIsScalar || if (type_flags & eTypeIsScalar ||
type_flags & eTypeIsPointer) type_flags & eTypeIsPointer)
{ {
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
bool success = false; bool success = false;
if (type_flags & eTypeIsInteger || if (type_flags & eTypeIsInteger ||
type_flags & eTypeIsPointer ) type_flags & eTypeIsPointer )
Show All 32 Lines if (type_flags & eTypeIsScalar ||
if (x0_reg_value.GetAsMemoryData (x0_reg_info, heap_data_ap->GetBytes()+0, 8, byte_order, error) && if (x0_reg_value.GetAsMemoryData (x0_reg_info, heap_data_ap->GetBytes()+0, 8, byte_order, error) &&
x1_reg_value.GetAsMemoryData (x1_reg_info, heap_data_ap->GetBytes()+8, 8, byte_order, error)) x1_reg_value.GetAsMemoryData (x1_reg_info, heap_data_ap->GetBytes()+8, 8, byte_order, error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
exe_ctx.GetProcessRef().GetAddressByteSize()); exe_ctx.GetProcessRef().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
return return_valobj_sp; return return_valobj_sp;
} }
} }
} }
} }
} }
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines else if (type_flags & eTypeIsVector)
heap_data_ap->GetByteSize(), heap_data_ap->GetByteSize(),
byte_order, byte_order,
error)) error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
exe_ctx.GetProcessRef().GetAddressByteSize()); exe_ctx.GetProcessRef().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
} }
} }
} }
} }
else if (type_flags & eTypeIsStructUnion || else if (type_flags & eTypeIsStructUnion ||
type_flags & eTypeIsClass) type_flags & eTypeIsClass)
{ {
DataExtractor data; DataExtractor data;
uint32_t NGRN = 0; // Search ABI docs for NGRN uint32_t NGRN = 0; // Search ABI docs for NGRN
uint32_t NSRN = 0; // Search ABI docs for NSRN uint32_t NSRN = 0; // Search ABI docs for NSRN
const bool is_return_value = true; const bool is_return_value = true;
if (LoadValueFromConsecutiveGPRRegisters (exe_ctx, reg_ctx, return_clang_type, is_return_value, NGRN, NSRN, data)) if (LoadValueFromConsecutiveGPRRegisters (exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN, data))
{ {
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
return return_valobj_sp; return return_valobj_sp;
} }
void void
Show All 35 Lines

lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

Show First 20 Lines • Show All 352 Lines • ▼ Show 20 Lines
Error Error
ABISysV_hexagon::SetReturnValueObject ( lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp ) ABISysV_hexagon::SetReturnValueObject ( lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp )
{ {
Error error; Error error;
return error; return error;
} }
ValueObjectSP ValueObjectSP
ABISysV_hexagon::GetReturnValueObjectSimple ( Thread &thread, CompilerType &return_clang_type ) const ABISysV_hexagon::GetReturnValueObjectSimple ( Thread &thread, CompilerType &return_compiler_type ) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
return return_valobj_sp; return return_valobj_sp;
} }
ValueObjectSP ValueObjectSP
ABISysV_hexagon::GetReturnValueObjectImpl ( Thread &thread, CompilerType &return_clang_type ) const ABISysV_hexagon::GetReturnValueObjectImpl ( Thread &thread, CompilerType &return_compiler_type ) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
return return_valobj_sp; return return_valobj_sp;
} }
// called when we are on the first instruction of a new function // called when we are on the first instruction of a new function
// for hexagon the return address is in RA (R31) // for hexagon the return address is in RA (R31)
bool bool
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp

Show First 20 Lines • Show All 318 Lines • ▼ Show 20 Lines for (value_index = 0;
++value_index) ++value_index)
{ {
Value *value = values.GetValueAtIndex(value_index); Value *value = values.GetValueAtIndex(value_index);
if (!value) if (!value)
return false; return false;
// Currently: Support for extracting values with Clang QualTypes only. // Currently: Support for extracting values with Clang QualTypes only.
CompilerType clang_type (value->GetCompilerType()); CompilerType compiler_type (value->GetCompilerType());
if (clang_type) if (compiler_type)
{ {
bool is_signed; bool is_signed;
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
is_signed, is_signed,
thread.GetProcess().get(), thread.GetProcess().get(),
current_stack_argument); current_stack_argument);
} }
else if (clang_type.IsPointerType()) else if (compiler_type.IsPointerType())
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
false, false,
thread.GetProcess().get(), thread.GetProcess().get(),
current_stack_argument); current_stack_argument);
} }
} }
} }
return true; return true;
} }
Error Error
ABISysV_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp) ABISysV_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
const uint32_t type_flags = clang_type.GetTypeInfo (); const uint32_t type_flags = compiler_type.GetTypeInfo ();
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
bool register_write_successful = true; bool register_write_successful = true;
if (data_error.Fail()) if (data_error.Fail())
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 LinesABISysV_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
if(!register_write_successful) if(!register_write_successful)
error.SetErrorString ("Register writing failed"); error.SetErrorString ("Register writing failed");
return error; return error;
} }
ValueObjectSP ValueObjectSP
ABISysV_i386::GetReturnValueObjectSimple (Thread &thread, ABISysV_i386::GetReturnValueObjectSimple (Thread &thread,
CompilerType &return_clang_type) const CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
Value value; Value value;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
value.SetCompilerType (return_clang_type); value.SetCompilerType (return_compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
const uint32_t type_flags = return_clang_type.GetTypeInfo (); const uint32_t type_flags = return_compiler_type.GetTypeInfo ();
unsigned eax_id = reg_ctx->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB]; unsigned eax_id = reg_ctx->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB];
unsigned edx_id = reg_ctx->GetRegisterInfoByName("edx", 0)->kinds[eRegisterKindLLDB]; unsigned edx_id = reg_ctx->GetRegisterInfoByName("edx", 0)->kinds[eRegisterKindLLDB];
// Following "IF ELSE" block categorizes various 'Fundamental Data Types'. // Following "IF ELSE" block categorizes various 'Fundamental Data Types'.
// The terminology 'Fundamental Data Types' used here is adopted from // The terminology 'Fundamental Data Types' used here is adopted from
// Table 2.1 of the reference document (specified on top of this file) // Table 2.1 of the reference document (specified on top of this file)
if (type_flags & eTypeIsPointer) // 'Pointer' if (type_flags & eTypeIsPointer) // 'Pointer'
{ {
uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff ; uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff ;
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
value.GetScalar() = ptr; value.GetScalar() = ptr;
return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(), return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(),
value, value,
ConstString("")); ConstString(""));
} }
else if ((type_flags & eTypeIsScalar) || (type_flags & eTypeIsEnumeration)) //'Integral' + 'Floating Point' else if ((type_flags & eTypeIsScalar) || (type_flags & eTypeIsEnumeration)) //'Integral' + 'Floating Point'
{ {
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
bool success = false; bool success = false;
if (type_flags & eTypeIsInteger) // 'Integral' except enum if (type_flags & eTypeIsInteger) // 'Integral' except enum
{ {
const bool is_signed = ((type_flags & eTypeIsSigned) != 0); const bool is_signed = ((type_flags & eTypeIsSigned) != 0);
uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff ; uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff ;
raw_value |= (thread.GetRegisterContext()->ReadRegisterAsUnsigned(edx_id, 0) & 0xffffffff) << 32; raw_value |= (thread.GetRegisterContext()->ReadRegisterAsUnsigned(edx_id, 0) & 0xffffffff) << 32;
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines else if ((type_flags & eTypeIsScalar) || (type_flags & eTypeIsEnumeration)) //'Integral' + 'Floating Point'
ConstString("")); ConstString(""));
} }
else if(byte_size == 16) // handles __float128 else if(byte_size == 16) // handles __float128
{ {
lldb::addr_t storage_addr = (uint32_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff); lldb::addr_t storage_addr = (uint32_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff);
return_valobj_sp = ValueObjectMemory::Create (&thread, return_valobj_sp = ValueObjectMemory::Create (&thread,
"", "",
Address (storage_addr, nullptr), Address (storage_addr, nullptr),
return_clang_type); return_compiler_type);
} }
} }
else // Neither 'Integral' nor 'Floating Point' else // Neither 'Integral' nor 'Floating Point'
{ {
// If flow reaches here then check type_flags // If flow reaches here then check type_flags
// This type_flags is unhandled // This type_flags is unhandled
} }
} }
else if (type_flags & eTypeIsComplex) // 'Complex Floating Point' else if (type_flags & eTypeIsComplex) // 'Complex Floating Point'
{ {
// ToDo: Yet to be implemented // ToDo: Yet to be implemented
} }
else if (type_flags & eTypeIsVector) // 'Packed' else if (type_flags & eTypeIsVector) // 'Packed'
{ {
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
if (byte_size > 0) if (byte_size > 0)
{ {
const RegisterInfo *vec_reg = reg_ctx->GetRegisterInfoByName("xmm0", 0); const RegisterInfo *vec_reg = reg_ctx->GetRegisterInfoByName("xmm0", 0);
if (vec_reg == nullptr) if (vec_reg == nullptr)
vec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0); vec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0);
if (vec_reg) if (vec_reg)
{ {
Show All 13 Lines else if (type_flags & eTypeIsVector) // 'Packed'
heap_data_ap->GetByteSize(), heap_data_ap->GetByteSize(),
byte_order, byte_order,
error)) error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
} }
} }
else if (byte_size <= vec_reg->byte_size*2) else if (byte_size <= vec_reg->byte_size*2)
{ {
Show All 21 Lines else if (type_flags & eTypeIsVector) // 'Packed'
heap_data_ap->GetByteSize() - vec_reg->byte_size, heap_data_ap->GetByteSize() - vec_reg->byte_size,
byte_order, byte_order,
error)) error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
} }
} }
} }
} }
} }
} }
else // 'Decimal Floating Point' else // 'Decimal Floating Point'
{ {
//ToDo: Yet to be implemented //ToDo: Yet to be implemented
} }
return return_valobj_sp; return return_valobj_sp;
} }
ValueObjectSP ValueObjectSP
ABISysV_i386::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_clang_type) const ABISysV_i386::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
ExecutionContext exe_ctx (thread.shared_from_this()); ExecutionContext exe_ctx (thread.shared_from_this());
return_valobj_sp = GetReturnValueObjectSimple(thread, return_clang_type); return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
if (return_valobj_sp) if (return_valobj_sp)
return return_valobj_sp; return return_valobj_sp;
RegisterContextSP reg_ctx_sp = thread.GetRegisterContext(); RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
if (!reg_ctx_sp) if (!reg_ctx_sp)
return return_valobj_sp; return return_valobj_sp;
if (return_clang_type.IsAggregateType()) if (return_compiler_type.IsAggregateType())
{ {
unsigned eax_id = reg_ctx_sp->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB]; unsigned eax_id = reg_ctx_sp->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB];
lldb::addr_t storage_addr = (uint32_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff); lldb::addr_t storage_addr = (uint32_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff);
return_valobj_sp = ValueObjectMemory::Create (&thread, return_valobj_sp = ValueObjectMemory::Create (&thread,
"", "",
Address (storage_addr, nullptr), Address (storage_addr, nullptr),
return_clang_type); return_compiler_type);
} }
return return_valobj_sp; return return_valobj_sp;
} }
// This defines CFA as esp+4 // This defines CFA as esp+4
// The saved pc is at CFA-4 (i.e. esp+0) // The saved pc is at CFA-4 (i.e. esp+0)
// The saved esp is CFA+0 // The saved esp is CFA+0
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

Show First 20 Lines • Show All 276 Lines • ▼ Show 20 Lines
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
bool is_signed; bool is_signed;
uint32_t count; uint32_t count;
bool is_complex; bool is_complex;
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
bool set_it_simple = false; bool set_it_simple = false;
if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType()) if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
{ {
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString()); error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
return error; return error;
Show All 24 Lines if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
} }
} }
} }
else else
{ {
error.SetErrorString("We don't support returning longer than 64 bit integer values at present."); error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
} }
} }
else if (clang_type.IsFloatingPointType (count, is_complex)) else if (compiler_type.IsFloatingPointType (count, is_complex))
{ {
if (is_complex) if (is_complex)
error.SetErrorString ("We don't support returning complex values at present"); error.SetErrorString ("We don't support returning complex values at present");
else else
error.SetErrorString ("We don't support returning float values at present"); error.SetErrorString ("We don't support returning float values at present");
} }
if (!set_it_simple) if (!set_it_simple)
error.SetErrorString ("We only support setting simple integer return types at present."); error.SetErrorString ("We only support setting simple integer return types at present.");
return error; return error;
} }
ValueObjectSP ValueObjectSP
ABISysV_mips::GetReturnValueObjectSimple (Thread &thread, CompilerType &return_clang_type) const ABISysV_mips::GetReturnValueObjectSimple (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
return return_valobj_sp; return return_valobj_sp;
} }
ValueObjectSP ValueObjectSP
ABISysV_mips::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_clang_type) const ABISysV_mips::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
Value value; Value value;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
ExecutionContext exe_ctx (thread.shared_from_this()); ExecutionContext exe_ctx (thread.shared_from_this());
if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL) if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL)
return return_valobj_sp; return return_valobj_sp;
value.SetCompilerType(return_clang_type); value.SetCompilerType(return_compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
bool is_signed = false; bool is_signed = false;
bool is_complex = false; bool is_complex = false;
uint32_t count = 0; uint32_t count = 0;
// In MIPS register "r2" (v0) holds the integer function return values // In MIPS register "r2" (v0) holds the integer function return values
const RegisterInfo *r2_reg_info = reg_ctx->GetRegisterInfoByName("r2", 0); const RegisterInfo *r2_reg_info = reg_ctx->GetRegisterInfoByName("r2", 0);
size_t bit_width = return_clang_type.GetBitSize(&thread); size_t bit_width = return_compiler_type.GetBitSize(&thread);
if (return_clang_type.IsIntegerType (is_signed)) if (return_compiler_type.IsIntegerType (is_signed))
{ {
switch (bit_width) switch (bit_width)
{ {
default: default:
return return_valobj_sp; return return_valobj_sp;
case 64: case 64:
{ {
const RegisterInfo *r3_reg_info = reg_ctx->GetRegisterInfoByName("r3", 0); const RegisterInfo *r3_reg_info = reg_ctx->GetRegisterInfoByName("r3", 0);
Show All 21 Lines if (return_compiler_type.IsIntegerType (is_signed))
case 8: case 8:
if (is_signed) if (is_signed)
value.GetScalar() = (int8_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX); value.GetScalar() = (int8_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX);
else else
value.GetScalar() = (uint8_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX); value.GetScalar() = (uint8_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX);
break; break;
} }
} }
else if (return_clang_type.IsPointerType ()) else if (return_compiler_type.IsPointerType ())
{ {
uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX; uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX;
value.GetScalar() = ptr; value.GetScalar() = ptr;
} }
else if (return_clang_type.IsAggregateType ()) else if (return_compiler_type.IsAggregateType ())
{ {
// Structure/Vector is always passed in memory and pointer to that memory is passed in r2. // Structure/Vector is always passed in memory and pointer to that memory is passed in r2.
uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r2", 0), 0); uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r2", 0), 0);
// We have got the address. Create a memory object out of it // We have got the address. Create a memory object out of it
return_valobj_sp = ValueObjectMemory::Create (&thread, return_valobj_sp = ValueObjectMemory::Create (&thread,
"", "",
Address (mem_address, NULL), Address (mem_address, NULL),
return_clang_type); return_compiler_type);
return return_valobj_sp; return return_valobj_sp;
} }
else if (return_clang_type.IsFloatingPointType (count, is_complex)) else if (return_compiler_type.IsFloatingPointType (count, is_complex))
{ {
const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0); const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0); const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
if (count == 1 && !is_complex) if (count == 1 && !is_complex)
{ {
switch (bit_width) switch (bit_width)
{ {
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

Show First 20 Lines • Show All 241 Lines • ▼ Show 20 Lines
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
error.SetErrorString("no registers are available"); error.SetErrorString("no registers are available");
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString()); error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
return error; return error;
} }
const uint32_t type_flags = clang_type.GetTypeInfo (NULL); const uint32_t type_flags = compiler_type.GetTypeInfo (NULL);
if (type_flags & eTypeIsScalar || if (type_flags & eTypeIsScalar ||
type_flags & eTypeIsPointer) type_flags & eTypeIsPointer)
{ {
if (type_flags & eTypeIsInteger || if (type_flags & eTypeIsInteger ||
type_flags & eTypeIsPointer ) type_flags & eTypeIsPointer )
{ {
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
Show All 38 Lines else if (type_flags & eTypeIsVector)
error.SetErrorString("returning vector values are not supported"); error.SetErrorString("returning vector values are not supported");
} }
return error; return error;
} }
ValueObjectSP ValueObjectSP
ABISysV_mips64::GetReturnValueObjectSimple (Thread &thread, CompilerType &return_clang_type) const ABISysV_mips64::GetReturnValueObjectSimple (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
return return_valobj_sp; return return_valobj_sp;
} }
ValueObjectSP ValueObjectSP
ABISysV_mips64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_clang_type) const ABISysV_mips64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
Value value; Value value;
Error error; Error error;
ExecutionContext exe_ctx (thread.shared_from_this()); ExecutionContext exe_ctx (thread.shared_from_this());
if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL) if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL)
return return_valobj_sp; return return_valobj_sp;
value.SetCompilerType(return_clang_type); value.SetCompilerType(return_compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder(); ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
const uint32_t type_flags = return_clang_type.GetTypeInfo (NULL); const uint32_t type_flags = return_compiler_type.GetTypeInfo (NULL);
const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0); const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0); const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
if (type_flags & eTypeIsScalar || if (type_flags & eTypeIsScalar ||
type_flags & eTypeIsPointer) type_flags & eTypeIsPointer)
{ {
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines if (type_flags & eTypeIsScalar ||
copy_from_extractor->CopyByteOrderedData (0, copy_from_extractor->CopyByteOrderedData (0,
byte_size, byte_size,
data_sp->GetBytes(), data_sp->GetBytes(),
byte_size, byte_size,
target_byte_order); target_byte_order);
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
return_ext); return_ext);
return return_valobj_sp; return return_valobj_sp;
} }
} }
} }
} }
Show All 21 Lines else if (type_flags & eTypeIsStructUnion ||
bool use_fp_regs = 0; // True if return values are in FP return registers. bool use_fp_regs = 0; // True if return values are in FP return registers.
bool found_non_fp_field = 0; // True if we found any non floating point field in structure. bool found_non_fp_field = 0; // True if we found any non floating point field in structure.
bool use_r2 = 0; // True if return values are in r2 register. bool use_r2 = 0; // True if return values are in r2 register.
bool use_r3 = 0; // True if return values are in r3 register. bool use_r3 = 0; // True if return values are in r3 register.
bool sucess = 0; // True if the result is copied into our data buffer bool sucess = 0; // True if the result is copied into our data buffer
std::string name; std::string name;
bool is_complex; bool is_complex;
uint32_t count; uint32_t count;
const uint32_t num_children = return_clang_type.GetNumFields (); const uint32_t num_children = return_compiler_type.GetNumFields ();
// A structure consisting of one or two FP values (and nothing else) will be // A structure consisting of one or two FP values (and nothing else) will be
// returned in the two FP return-value registers i.e fp0 and fp2. // returned in the two FP return-value registers i.e fp0 and fp2.
if (num_children <= 2) if (num_children <= 2)
{ {
uint64_t field_bit_offset = 0; uint64_t field_bit_offset = 0;
// Check if this structure contains only floating point fields // Check if this structure contains only floating point fields
for (uint32_t idx = 0; idx < num_children; idx++) for (uint32_t idx = 0; idx < num_children; idx++)
{ {
CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL);
if (field_clang_type.IsFloatingPointType (count, is_complex)) if (field_compiler_type.IsFloatingPointType (count, is_complex))
use_fp_regs = 1; use_fp_regs = 1;
else else
found_non_fp_field = 1; found_non_fp_field = 1;
} }
if (use_fp_regs && !found_non_fp_field) if (use_fp_regs && !found_non_fp_field)
{ {
// We have one or two FP-only values in this structure. Get it from f0/f2 registers. // We have one or two FP-only values in this structure. Get it from f0/f2 registers.
DataExtractor f0_data, f1_data, f2_data; DataExtractor f0_data, f1_data, f2_data;
const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0); const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0); const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
const RegisterInfo *f2_info = reg_ctx->GetRegisterInfoByName("f2", 0); const RegisterInfo *f2_info = reg_ctx->GetRegisterInfoByName("f2", 0);
reg_ctx->ReadRegister (f0_info, f0_value); reg_ctx->ReadRegister (f0_info, f0_value);
reg_ctx->ReadRegister (f2_info, f2_value); reg_ctx->ReadRegister (f2_info, f2_value);
f0_value.GetData(f0_data); f0_value.GetData(f0_data);
f2_value.GetData(f2_data); f2_value.GetData(f2_data);
for (uint32_t idx = 0; idx < num_children; idx++) for (uint32_t idx = 0; idx < num_children; idx++)
{ {
CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL);
const size_t field_byte_width = field_clang_type.GetByteSize(nullptr); const size_t field_byte_width = field_compiler_type.GetByteSize(nullptr);
DataExtractor *copy_from_extractor = NULL; DataExtractor *copy_from_extractor = NULL;
if (idx == 0) if (idx == 0)
{ {
if (field_byte_width == 16) // This case is for long double type. if (field_byte_width == 16) // This case is for long double type.
{ {
// If structure contains long double type, then it is returned in fp0/fp1 registers. // If structure contains long double type, then it is returned in fp0/fp1 registers.
Show All 26 Lines else if (type_flags & eTypeIsStructUnion ||
field_byte_width, field_byte_width,
data_sp->GetBytes() + (field_bit_offset/8), data_sp->GetBytes() + (field_bit_offset/8),
field_byte_width, field_byte_width,
target_byte_order); target_byte_order);
} }
// The result is in our data buffer. Create a variable object out of it // The result is in our data buffer. Create a variable object out of it
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
return_ext); return_ext);
return return_valobj_sp; return return_valobj_sp;
} }
} }
// If we reach here, it means this structure either contains more than two fields or // If we reach here, it means this structure either contains more than two fields or
// it contains at least one non floating point type. // it contains at least one non floating point type.
// In that case, all fields are returned in GP return registers. // In that case, all fields are returned in GP return registers.
for (uint32_t idx = 0; idx < num_children; idx++) for (uint32_t idx = 0; idx < num_children; idx++)
{ {
uint64_t field_bit_offset = 0; uint64_t field_bit_offset = 0;
bool is_signed; bool is_signed;
uint32_t padding; uint32_t padding;
CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL);
const size_t field_byte_width = field_clang_type.GetByteSize(nullptr); const size_t field_byte_width = field_compiler_type.GetByteSize(nullptr);
// if we don't know the size of the field (e.g. invalid type), just bail out // if we don't know the size of the field (e.g. invalid type), just bail out
if (field_byte_width == 0) if (field_byte_width == 0)
break; break;
uint32_t field_byte_offset = field_bit_offset/8; uint32_t field_byte_offset = field_bit_offset/8;
if (field_clang_type.IsIntegerType (is_signed) if (field_compiler_type.IsIntegerType (is_signed)
|| field_clang_type.IsPointerType () || field_compiler_type.IsPointerType ()
|| field_clang_type.IsFloatingPointType (count, is_complex)) || field_compiler_type.IsFloatingPointType (count, is_complex))
{ {
padding = field_byte_offset - integer_bytes; padding = field_byte_offset - integer_bytes;
if (integer_bytes < 8) if (integer_bytes < 8)
{ {
// We have not yet consumed r2 completely. // We have not yet consumed r2 completely.
if (integer_bytes + field_byte_width + padding <= 8) if (integer_bytes + field_byte_width + padding <= 8)
{ {
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines else if (type_flags & eTypeIsStructUnion ||
if (bytes_copied != r3_info->byte_size) if (bytes_copied != r3_info->byte_size)
return return_valobj_sp; return return_valobj_sp;
sucess = 1; sucess = 1;
} }
if (sucess) if (sucess)
{ {
// The result is in our data buffer. Create a variable object out of it // The result is in our data buffer. Create a variable object out of it
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
return_ext); return_ext);
} }
return return_valobj_sp; return return_valobj_sp;
} }
// Any structure/vector greater than 16 bytes in size is returned in memory. // Any structure/vector greater than 16 bytes in size is returned in memory.
// The pointer to that memory is returned in r2. // The pointer to that memory is returned in r2.
uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r2", 0), 0); uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r2", 0), 0);
// We have got the address. Create a memory object out of it // We have got the address. Create a memory object out of it
return_valobj_sp = ValueObjectMemory::Create (&thread, return_valobj_sp = ValueObjectMemory::Create (&thread,
"", "",
Address (mem_address, NULL), Address (mem_address, NULL),
return_clang_type); return_compiler_type);
} }
return return_valobj_sp; return return_valobj_sp;
} }
bool bool
ABISysV_mips64::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan) ABISysV_mips64::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
{ {
unwind_plan.Clear(); unwind_plan.Clear();
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

Show First 20 Lines • Show All 387 Lines • ▼ Show 20 LinesABISysV_ppc::GetArgumentValues (Thread &thread,
{ {
Value *value = values.GetValueAtIndex(value_index); Value *value = values.GetValueAtIndex(value_index);
if (!value) if (!value)
return false; return false;
// We currently only support extracting values with Clang QualTypes. // We currently only support extracting values with Clang QualTypes.
// Do we care about others? // Do we care about others?
CompilerType clang_type = value->GetCompilerType(); CompilerType compiler_type = value->GetCompilerType();
if (!clang_type) if (!compiler_type)
return false; return false;
bool is_signed; bool is_signed;
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
is_signed, is_signed,
thread, thread,
argument_register_ids, argument_register_ids,
current_argument_register, current_argument_register,
current_stack_argument); current_stack_argument);
} }
else if (clang_type.IsPointerType ()) else if (compiler_type.IsPointerType ())
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
false, false,
thread, thread,
argument_register_ids, argument_register_ids,
current_argument_register, current_argument_register,
current_stack_argument); current_stack_argument);
} }
} }
return true; return true;
} }
Error Error
ABISysV_ppc::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp) ABISysV_ppc::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
bool is_signed; bool is_signed;
uint32_t count; uint32_t count;
bool is_complex; bool is_complex;
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
bool set_it_simple = false; bool set_it_simple = false;
if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType()) if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
{ {
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("r3", 0); const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("r3", 0);
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
Show All 9 Lines if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
set_it_simple = true; set_it_simple = true;
} }
else else
{ {
error.SetErrorString("We don't support returning longer than 64 bit integer values at present."); error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
} }
} }
else if (clang_type.IsFloatingPointType (count, is_complex)) else if (compiler_type.IsFloatingPointType (count, is_complex))
{ {
if (is_complex) if (is_complex)
error.SetErrorString ("We don't support returning complex values at present"); error.SetErrorString ("We don't support returning complex values at present");
else else
{ {
size_t bit_width = clang_type.GetBitSize(frame_sp.get()); size_t bit_width = compiler_type.GetBitSize(frame_sp.get());
if (bit_width <= 64) if (bit_width <= 64)
{ {
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString()); error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
Show All 22 LinesABISysV_ppc::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
} }
return error; return error;
} }
ValueObjectSP ValueObjectSP
ABISysV_ppc::GetReturnValueObjectSimple (Thread &thread, ABISysV_ppc::GetReturnValueObjectSimple (Thread &thread,
CompilerType &return_clang_type) const CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
Value value; Value value;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
//value.SetContext (Value::eContextTypeClangType, return_value_type); //value.SetContext (Value::eContextTypeClangType, return_value_type);
value.SetCompilerType (return_clang_type); value.SetCompilerType (return_compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
const uint32_t type_flags = return_clang_type.GetTypeInfo (); const uint32_t type_flags = return_compiler_type.GetTypeInfo ();
if (type_flags & eTypeIsScalar) if (type_flags & eTypeIsScalar)
{ {
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
bool success = false; bool success = false;
if (type_flags & eTypeIsInteger) if (type_flags & eTypeIsInteger)
{ {
// Extract the register context so we can read arguments from registers // Extract the register context so we can read arguments from registers
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r3", 0), 0); uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r3", 0), 0);
const bool is_signed = (type_flags & eTypeIsSigned) != 0; const bool is_signed = (type_flags & eTypeIsSigned) != 0;
switch (byte_size) switch (byte_size)
{ {
default: default:
break; break;
case sizeof(uint64_t): case sizeof(uint64_t):
Show All 32 Lines if (type_flags & eTypeIsScalar)
else if (type_flags & eTypeIsFloat) else if (type_flags & eTypeIsFloat)
{ {
if (type_flags & eTypeIsComplex) if (type_flags & eTypeIsComplex)
{ {
// Don't handle complex yet. // Don't handle complex yet.
} }
else else
{ {
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
if (byte_size <= sizeof(long double)) if (byte_size <= sizeof(long double))
{ {
const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0); const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
RegisterValue f1_value; RegisterValue f1_value;
if (reg_ctx->ReadRegister (f1_info, f1_value)) if (reg_ctx->ReadRegister (f1_info, f1_value))
{ {
DataExtractor data; DataExtractor data;
if (f1_value.GetData(data)) if (f1_value.GetData(data))
Show All 27 Lines else if (type_flags & eTypeIsPointer)
value.GetScalar() = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0); value.GetScalar() = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0);
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(), return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(),
value, value,
ConstString("")); ConstString(""));
} }
else if (type_flags & eTypeIsVector) else if (type_flags & eTypeIsVector)
{ {
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
if (byte_size > 0) if (byte_size > 0)
{ {
const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("v2", 0); const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("v2", 0);
if (altivec_reg) if (altivec_reg)
{ {
if (byte_size <= altivec_reg->byte_size) if (byte_size <= altivec_reg->byte_size)
{ {
Show All 11 Lines else if (type_flags & eTypeIsVector)
heap_data_ap->GetByteSize(), heap_data_ap->GetByteSize(),
byte_order, byte_order,
error)) error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
} }
} }
} }
} }
} }
return return_valobj_sp; return return_valobj_sp;
} }
ValueObjectSP ValueObjectSP
ABISysV_ppc::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_clang_type) const ABISysV_ppc::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
ExecutionContext exe_ctx (thread.shared_from_this()); ExecutionContext exe_ctx (thread.shared_from_this());
return_valobj_sp = GetReturnValueObjectSimple(thread, return_clang_type); return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
if (return_valobj_sp) if (return_valobj_sp)
return return_valobj_sp; return return_valobj_sp;
RegisterContextSP reg_ctx_sp = thread.GetRegisterContext(); RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
if (!reg_ctx_sp) if (!reg_ctx_sp)
return return_valobj_sp; return return_valobj_sp;
const size_t bit_width = return_clang_type.GetBitSize(&thread); const size_t bit_width = return_compiler_type.GetBitSize(&thread);
if (return_clang_type.IsAggregateType()) if (return_compiler_type.IsAggregateType())
{ {
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
bool is_memory = true; bool is_memory = true;
if (bit_width <= 128) if (bit_width <= 128)
{ {
ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder(); ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
DataBufferSP data_sp (new DataBufferHeap(16, 0)); DataBufferSP data_sp (new DataBufferHeap(16, 0));
DataExtractor return_ext (data_sp, DataExtractor return_ext (data_sp,
Show All 10 Lines if (return_compiler_type.IsAggregateType())
DataExtractor r3_data, rdx_data; DataExtractor r3_data, rdx_data;
r3_value.GetData(r3_data); r3_value.GetData(r3_data);
rdx_value.GetData(rdx_data); rdx_value.GetData(rdx_data);
uint32_t fp_bytes = 0; // Tracks how much of the xmm registers we've consumed so far uint32_t fp_bytes = 0; // Tracks how much of the xmm registers we've consumed so far
uint32_t integer_bytes = 0; // Tracks how much of the r3/rds registers we've consumed so far uint32_t integer_bytes = 0; // Tracks how much of the r3/rds registers we've consumed so far
const uint32_t num_children = return_clang_type.GetNumFields (); const uint32_t num_children = return_compiler_type.GetNumFields ();
// Since we are in the small struct regime, assume we are not in memory. // Since we are in the small struct regime, assume we are not in memory.
is_memory = false; is_memory = false;
for (uint32_t idx = 0; idx < num_children; idx++) for (uint32_t idx = 0; idx < num_children; idx++)
{ {
std::string name; std::string name;
uint64_t field_bit_offset = 0; uint64_t field_bit_offset = 0;
bool is_signed; bool is_signed;
bool is_complex; bool is_complex;
uint32_t count; uint32_t count;
CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL);
const size_t field_bit_width = field_clang_type.GetBitSize(&thread); const size_t field_bit_width = field_compiler_type.GetBitSize(&thread);
// If there are any unaligned fields, this is stored in memory. // If there are any unaligned fields, this is stored in memory.
if (field_bit_offset % field_bit_width != 0) if (field_bit_offset % field_bit_width != 0)
{ {
is_memory = true; is_memory = true;
break; break;
} }
uint32_t field_byte_width = field_bit_width/8; uint32_t field_byte_width = field_bit_width/8;
uint32_t field_byte_offset = field_bit_offset/8; uint32_t field_byte_offset = field_bit_offset/8;
DataExtractor *copy_from_extractor = NULL; DataExtractor *copy_from_extractor = NULL;
uint32_t copy_from_offset = 0; uint32_t copy_from_offset = 0;
if (field_clang_type.IsIntegerType (is_signed) || field_clang_type.IsPointerType ()) if (field_compiler_type.IsIntegerType (is_signed) || field_compiler_type.IsPointerType ())
{ {
if (integer_bytes < 8) if (integer_bytes < 8)
{ {
if (integer_bytes + field_byte_width <= 8) if (integer_bytes + field_byte_width <= 8)
{ {
// This is in RAX, copy from register to our result structure: // This is in RAX, copy from register to our result structure:
copy_from_extractor = &r3_data; copy_from_extractor = &r3_data;
copy_from_offset = integer_bytes; copy_from_offset = integer_bytes;
Show All 16 Lines if (return_compiler_type.IsAggregateType())
} }
else else
{ {
// The last field didn't fit. I can't see how that would happen w/o the overall size being // The last field didn't fit. I can't see how that would happen w/o the overall size being
// greater than 16 bytes. For now, return a NULL return value object. // greater than 16 bytes. For now, return a NULL return value object.
return return_valobj_sp; return return_valobj_sp;
} }
} }
else if (field_clang_type.IsFloatingPointType (count, is_complex)) else if (field_compiler_type.IsFloatingPointType (count, is_complex))
{ {
// Structs with long doubles are always passed in memory. // Structs with long doubles are always passed in memory.
if (field_bit_width == 128) if (field_bit_width == 128)
{ {
is_memory = true; is_memory = true;
break; break;
} }
else if (field_bit_width == 64) else if (field_bit_width == 64)
Show All 10 Lines if (return_compiler_type.IsAggregateType())
if (field_byte_offset % 8 == 0) if (field_byte_offset % 8 == 0)
{ {
// We are at the beginning of one of the eightbytes, so check the next element (if any) // We are at the beginning of one of the eightbytes, so check the next element (if any)
if (idx == num_children - 1) if (idx == num_children - 1)
in_gpr = false; in_gpr = false;
else else
{ {
uint64_t next_field_bit_offset = 0; uint64_t next_field_bit_offset = 0;
CompilerType next_field_clang_type = return_clang_type.GetFieldAtIndex (idx + 1, CompilerType next_field_compiler_type = return_compiler_type.GetFieldAtIndex (idx + 1,
name, name,
&next_field_bit_offset, &next_field_bit_offset,
NULL, NULL,
NULL); NULL);
if (next_field_clang_type.IsIntegerType (is_signed)) if (next_field_compiler_type.IsIntegerType (is_signed))
in_gpr = true; in_gpr = true;
else else
{ {
copy_from_offset = 0; copy_from_offset = 0;
in_gpr = false; in_gpr = false;
} }
} }
} }
else if (field_byte_offset % 4 == 0) else if (field_byte_offset % 4 == 0)
{ {
// We are inside of an eightbyte, so see if the field before us is floating point: // We are inside of an eightbyte, so see if the field before us is floating point:
// This could happen if somebody put padding in the structure. // This could happen if somebody put padding in the structure.
if (idx == 0) if (idx == 0)
in_gpr = false; in_gpr = false;
else else
{ {
uint64_t prev_field_bit_offset = 0; uint64_t prev_field_bit_offset = 0;
CompilerType prev_field_clang_type = return_clang_type.GetFieldAtIndex (idx - 1, CompilerType prev_field_compiler_type = return_compiler_type.GetFieldAtIndex (idx - 1,
name, name,
&prev_field_bit_offset, &prev_field_bit_offset,
NULL, NULL,
NULL); NULL);
if (prev_field_clang_type.IsIntegerType (is_signed)) if (prev_field_compiler_type.IsIntegerType (is_signed))
in_gpr = true; in_gpr = true;
else else
{ {
copy_from_offset = 4; copy_from_offset = 4;
in_gpr = false; in_gpr = false;
} }
} }
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines if (return_compiler_type.IsAggregateType())
field_byte_width, field_byte_width,
target_byte_order); target_byte_order);
} }
if (!is_memory) if (!is_memory)
{ {
// The result is in our data buffer. Let's make a variable object out of it: // The result is in our data buffer. Let's make a variable object out of it:
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
return_ext); return_ext);
} }
} }
// FIXME: This is just taking a guess, r3 may very well no longer hold the return storage location. // FIXME: This is just taking a guess, r3 may very well no longer hold the return storage location.
// If we are going to do this right, when we make a new frame we should check to see if it uses a memory // If we are going to do this right, when we make a new frame we should check to see if it uses a memory
// return, and if we are at the first instruction and if so stash away the return location. Then we would // return, and if we are at the first instruction and if so stash away the return location. Then we would
// only return the memory return value if we know it is valid. // only return the memory return value if we know it is valid.
if (is_memory) if (is_memory)
{ {
unsigned r3_id = reg_ctx_sp->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB]; unsigned r3_id = reg_ctx_sp->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB];
lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0); lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0);
return_valobj_sp = ValueObjectMemory::Create (&thread, return_valobj_sp = ValueObjectMemory::Create (&thread,
"", "",
Address (storage_addr, NULL), Address (storage_addr, NULL),
return_clang_type); return_compiler_type);
} }
} }
return return_valobj_sp; return return_valobj_sp;
} }
bool bool
ABISysV_ppc::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan) ABISysV_ppc::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

Show First 20 Lines • Show All 388 Lines • ▼ Show 20 LinesABISysV_ppc64::GetArgumentValues (Thread &thread,
{ {
Value *value = values.GetValueAtIndex(value_index); Value *value = values.GetValueAtIndex(value_index);
if (!value) if (!value)
return false; return false;
// We currently only support extracting values with Clang QualTypes. // We currently only support extracting values with Clang QualTypes.
// Do we care about others? // Do we care about others?
CompilerType clang_type = value->GetCompilerType(); CompilerType compiler_type = value->GetCompilerType();
if (!clang_type) if (!compiler_type)
return false; return false;
bool is_signed; bool is_signed;
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
is_signed, is_signed,
thread, thread,
argument_register_ids, argument_register_ids,
current_argument_register, current_argument_register,
current_stack_argument); current_stack_argument);
} }
else if (clang_type.IsPointerType ()) else if (compiler_type.IsPointerType ())
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
false, false,
thread, thread,
argument_register_ids, argument_register_ids,
current_argument_register, current_argument_register,
current_stack_argument); current_stack_argument);
} }
} }
return true; return true;
} }
Error Error
ABISysV_ppc64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp) ABISysV_ppc64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
bool is_signed; bool is_signed;
uint32_t count; uint32_t count;
bool is_complex; bool is_complex;
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
bool set_it_simple = false; bool set_it_simple = false;
if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType()) if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
{ {
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("r3", 0); const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("r3", 0);
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
Show All 9 Lines if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
set_it_simple = true; set_it_simple = true;
} }
else else
{ {
error.SetErrorString("We don't support returning longer than 64 bit integer values at present."); error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
} }
} }
else if (clang_type.IsFloatingPointType (count, is_complex)) else if (compiler_type.IsFloatingPointType (count, is_complex))
{ {
if (is_complex) if (is_complex)
error.SetErrorString ("We don't support returning complex values at present"); error.SetErrorString ("We don't support returning complex values at present");
else else
{ {
size_t bit_width = clang_type.GetBitSize(frame_sp.get()); size_t bit_width = compiler_type.GetBitSize(frame_sp.get());
if (bit_width <= 64) if (bit_width <= 64)
{ {
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString()); error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
Show All 22 LinesABISysV_ppc64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
} }
return error; return error;
} }
ValueObjectSP ValueObjectSP
ABISysV_ppc64::GetReturnValueObjectSimple (Thread &thread, ABISysV_ppc64::GetReturnValueObjectSimple (Thread &thread,
CompilerType &return_clang_type) const CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
Value value; Value value;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
//value.SetContext (Value::eContextTypeClangType, return_value_type); //value.SetContext (Value::eContextTypeClangType, return_value_type);
value.SetCompilerType (return_clang_type); value.SetCompilerType (return_compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
const uint32_t type_flags = return_clang_type.GetTypeInfo (); const uint32_t type_flags = return_compiler_type.GetTypeInfo ();
if (type_flags & eTypeIsScalar) if (type_flags & eTypeIsScalar)
{ {
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
bool success = false; bool success = false;
if (type_flags & eTypeIsInteger) if (type_flags & eTypeIsInteger)
{ {
// Extract the register context so we can read arguments from registers // Extract the register context so we can read arguments from registers
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r3", 0), 0); uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r3", 0), 0);
const bool is_signed = (type_flags & eTypeIsSigned) != 0; const bool is_signed = (type_flags & eTypeIsSigned) != 0;
switch (byte_size) switch (byte_size)
{ {
default: default:
break; break;
case sizeof(uint64_t): case sizeof(uint64_t):
Show All 32 Lines if (type_flags & eTypeIsScalar)
else if (type_flags & eTypeIsFloat) else if (type_flags & eTypeIsFloat)
{ {
if (type_flags & eTypeIsComplex) if (type_flags & eTypeIsComplex)
{ {
// Don't handle complex yet. // Don't handle complex yet.
} }
else else
{ {
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
if (byte_size <= sizeof(long double)) if (byte_size <= sizeof(long double))
{ {
const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0); const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
RegisterValue f1_value; RegisterValue f1_value;
if (reg_ctx->ReadRegister (f1_info, f1_value)) if (reg_ctx->ReadRegister (f1_info, f1_value))
{ {
DataExtractor data; DataExtractor data;
if (f1_value.GetData(data)) if (f1_value.GetData(data))
Show All 27 Lines else if (type_flags & eTypeIsPointer)
value.GetScalar() = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0); value.GetScalar() = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0);
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(), return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(),
value, value,
ConstString("")); ConstString(""));
} }
else if (type_flags & eTypeIsVector) else if (type_flags & eTypeIsVector)
{ {
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
if (byte_size > 0) if (byte_size > 0)
{ {
const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("v2", 0); const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("v2", 0);
if (altivec_reg) if (altivec_reg)
{ {
if (byte_size <= altivec_reg->byte_size) if (byte_size <= altivec_reg->byte_size)
{ {
Show All 11 Lines else if (type_flags & eTypeIsVector)
heap_data_ap->GetByteSize(), heap_data_ap->GetByteSize(),
byte_order, byte_order,
error)) error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
} }
} }
} }
} }
} }
return return_valobj_sp; return return_valobj_sp;
} }
ValueObjectSP ValueObjectSP
ABISysV_ppc64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_clang_type) const ABISysV_ppc64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
ExecutionContext exe_ctx (thread.shared_from_this()); ExecutionContext exe_ctx (thread.shared_from_this());
return_valobj_sp = GetReturnValueObjectSimple(thread, return_clang_type); return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
if (return_valobj_sp) if (return_valobj_sp)
return return_valobj_sp; return return_valobj_sp;
RegisterContextSP reg_ctx_sp = thread.GetRegisterContext(); RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
if (!reg_ctx_sp) if (!reg_ctx_sp)
return return_valobj_sp; return return_valobj_sp;
const size_t bit_width = return_clang_type.GetBitSize(&thread); const size_t bit_width = return_compiler_type.GetBitSize(&thread);
if (return_clang_type.IsAggregateType()) if (return_compiler_type.IsAggregateType())
{ {
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
bool is_memory = true; bool is_memory = true;
if (bit_width <= 128) if (bit_width <= 128)
{ {
ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder(); ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
DataBufferSP data_sp (new DataBufferHeap(16, 0)); DataBufferSP data_sp (new DataBufferHeap(16, 0));
DataExtractor return_ext (data_sp, DataExtractor return_ext (data_sp,
Show All 10 Lines if (return_compiler_type.IsAggregateType())
DataExtractor r3_data, rdx_data; DataExtractor r3_data, rdx_data;
r3_value.GetData(r3_data); r3_value.GetData(r3_data);
rdx_value.GetData(rdx_data); rdx_value.GetData(rdx_data);
uint32_t fp_bytes = 0; // Tracks how much of the xmm registers we've consumed so far uint32_t fp_bytes = 0; // Tracks how much of the xmm registers we've consumed so far
uint32_t integer_bytes = 0; // Tracks how much of the r3/rds registers we've consumed so far uint32_t integer_bytes = 0; // Tracks how much of the r3/rds registers we've consumed so far
const uint32_t num_children = return_clang_type.GetNumFields (); const uint32_t num_children = return_compiler_type.GetNumFields ();
// Since we are in the small struct regime, assume we are not in memory. // Since we are in the small struct regime, assume we are not in memory.
is_memory = false; is_memory = false;
for (uint32_t idx = 0; idx < num_children; idx++) for (uint32_t idx = 0; idx < num_children; idx++)
{ {
std::string name; std::string name;
uint64_t field_bit_offset = 0; uint64_t field_bit_offset = 0;
bool is_signed; bool is_signed;
bool is_complex; bool is_complex;
uint32_t count; uint32_t count;
CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL);
const size_t field_bit_width = field_clang_type.GetBitSize(&thread); const size_t field_bit_width = field_compiler_type.GetBitSize(&thread);
// If there are any unaligned fields, this is stored in memory. // If there are any unaligned fields, this is stored in memory.
if (field_bit_offset % field_bit_width != 0) if (field_bit_offset % field_bit_width != 0)
{ {
is_memory = true; is_memory = true;
break; break;
} }
uint32_t field_byte_width = field_bit_width/8; uint32_t field_byte_width = field_bit_width/8;
uint32_t field_byte_offset = field_bit_offset/8; uint32_t field_byte_offset = field_bit_offset/8;
DataExtractor *copy_from_extractor = NULL; DataExtractor *copy_from_extractor = NULL;
uint32_t copy_from_offset = 0; uint32_t copy_from_offset = 0;
if (field_clang_type.IsIntegerType (is_signed) || field_clang_type.IsPointerType ()) if (field_compiler_type.IsIntegerType (is_signed) || field_compiler_type.IsPointerType ())
{ {
if (integer_bytes < 8) if (integer_bytes < 8)
{ {
if (integer_bytes + field_byte_width <= 8) if (integer_bytes + field_byte_width <= 8)
{ {
// This is in RAX, copy from register to our result structure: // This is in RAX, copy from register to our result structure:
copy_from_extractor = &r3_data; copy_from_extractor = &r3_data;
copy_from_offset = integer_bytes; copy_from_offset = integer_bytes;
Show All 16 Lines if (return_compiler_type.IsAggregateType())
} }
else else
{ {
// The last field didn't fit. I can't see how that would happen w/o the overall size being // The last field didn't fit. I can't see how that would happen w/o the overall size being
// greater than 16 bytes. For now, return a NULL return value object. // greater than 16 bytes. For now, return a NULL return value object.
return return_valobj_sp; return return_valobj_sp;
} }
} }
else if (field_clang_type.IsFloatingPointType (count, is_complex)) else if (field_compiler_type.IsFloatingPointType (count, is_complex))
{ {
// Structs with long doubles are always passed in memory. // Structs with long doubles are always passed in memory.
if (field_bit_width == 128) if (field_bit_width == 128)
{ {
is_memory = true; is_memory = true;
break; break;
} }
else if (field_bit_width == 64) else if (field_bit_width == 64)
Show All 10 Lines if (return_compiler_type.IsAggregateType())
if (field_byte_offset % 8 == 0) if (field_byte_offset % 8 == 0)
{ {
// We are at the beginning of one of the eightbytes, so check the next element (if any) // We are at the beginning of one of the eightbytes, so check the next element (if any)
if (idx == num_children - 1) if (idx == num_children - 1)
in_gpr = false; in_gpr = false;
else else
{ {
uint64_t next_field_bit_offset = 0; uint64_t next_field_bit_offset = 0;
CompilerType next_field_clang_type = return_clang_type.GetFieldAtIndex (idx + 1, CompilerType next_field_compiler_type = return_compiler_type.GetFieldAtIndex (idx + 1,
name, name,
&next_field_bit_offset, &next_field_bit_offset,
NULL, NULL,
NULL); NULL);
if (next_field_clang_type.IsIntegerType (is_signed)) if (next_field_compiler_type.IsIntegerType (is_signed))
in_gpr = true; in_gpr = true;
else else
{ {
copy_from_offset = 0; copy_from_offset = 0;
in_gpr = false; in_gpr = false;
} }
} }
} }
else if (field_byte_offset % 4 == 0) else if (field_byte_offset % 4 == 0)
{ {
// We are inside of an eightbyte, so see if the field before us is floating point: // We are inside of an eightbyte, so see if the field before us is floating point:
// This could happen if somebody put padding in the structure. // This could happen if somebody put padding in the structure.
if (idx == 0) if (idx == 0)
in_gpr = false; in_gpr = false;
else else
{ {
uint64_t prev_field_bit_offset = 0; uint64_t prev_field_bit_offset = 0;
CompilerType prev_field_clang_type = return_clang_type.GetFieldAtIndex (idx - 1, CompilerType prev_field_compiler_type = return_compiler_type.GetFieldAtIndex (idx - 1,
name, name,
&prev_field_bit_offset, &prev_field_bit_offset,
NULL, NULL,
NULL); NULL);
if (prev_field_clang_type.IsIntegerType (is_signed)) if (prev_field_compiler_type.IsIntegerType (is_signed))
in_gpr = true; in_gpr = true;
else else
{ {
copy_from_offset = 4; copy_from_offset = 4;
in_gpr = false; in_gpr = false;
} }
} }
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines if (return_compiler_type.IsAggregateType())
field_byte_width, field_byte_width,
target_byte_order); target_byte_order);
} }
if (!is_memory) if (!is_memory)
{ {
// The result is in our data buffer. Let's make a variable object out of it: // The result is in our data buffer. Let's make a variable object out of it:
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
return_ext); return_ext);
} }
} }
// FIXME: This is just taking a guess, r3 may very well no longer hold the return storage location. // FIXME: This is just taking a guess, r3 may very well no longer hold the return storage location.
// If we are going to do this right, when we make a new frame we should check to see if it uses a memory // If we are going to do this right, when we make a new frame we should check to see if it uses a memory
// return, and if we are at the first instruction and if so stash away the return location. Then we would // return, and if we are at the first instruction and if so stash away the return location. Then we would
// only return the memory return value if we know it is valid. // only return the memory return value if we know it is valid.
if (is_memory) if (is_memory)
{ {
unsigned r3_id = reg_ctx_sp->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB]; unsigned r3_id = reg_ctx_sp->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB];
lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0); lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0);
return_valobj_sp = ValueObjectMemory::Create (&thread, return_valobj_sp = ValueObjectMemory::Create (&thread,
"", "",
Address (storage_addr, NULL), Address (storage_addr, NULL),
return_clang_type); return_compiler_type);
} }
} }
return return_valobj_sp; return return_valobj_sp;
} }
bool bool
ABISysV_ppc64::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan) ABISysV_ppc64::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

Show First 20 Lines • Show All 417 Lines • ▼ Show 20 LinesABISysV_x86_64::GetArgumentValues (Thread &thread,
{ {
Value *value = values.GetValueAtIndex(value_index); Value *value = values.GetValueAtIndex(value_index);
if (!value) if (!value)
return false; return false;
// We currently only support extracting values with Clang QualTypes. // We currently only support extracting values with Clang QualTypes.
// Do we care about others? // Do we care about others?
CompilerType clang_type = value->GetCompilerType(); CompilerType compiler_type = value->GetCompilerType();
if (!clang_type) if (!compiler_type)
return false; return false;
bool is_signed; bool is_signed;
if (clang_type.IsIntegerType (is_signed)) if (compiler_type.IsIntegerType (is_signed))
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
is_signed, is_signed,
thread, thread,
argument_register_ids, argument_register_ids,
current_argument_register, current_argument_register,
current_stack_argument); current_stack_argument);
} }
else if (clang_type.IsPointerType ()) else if (compiler_type.IsPointerType ())
{ {
ReadIntegerArgument(value->GetScalar(), ReadIntegerArgument(value->GetScalar(),
clang_type.GetBitSize(&thread), compiler_type.GetBitSize(&thread),
false, false,
thread, thread,
argument_register_ids, argument_register_ids,
current_argument_register, current_argument_register,
current_stack_argument); current_stack_argument);
} }
} }
return true; return true;
} }
Error Error
ABISysV_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp) ABISysV_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
{ {
Error error; Error error;
if (!new_value_sp) if (!new_value_sp)
{ {
error.SetErrorString("Empty value object for return value."); error.SetErrorString("Empty value object for return value.");
return error; return error;
} }
CompilerType clang_type = new_value_sp->GetCompilerType(); CompilerType compiler_type = new_value_sp->GetCompilerType();
if (!clang_type) if (!compiler_type)
{ {
error.SetErrorString ("Null clang type for return value."); error.SetErrorString ("Null clang type for return value.");
return error; return error;
} }
Thread *thread = frame_sp->GetThread().get(); Thread *thread = frame_sp->GetThread().get();
bool is_signed; bool is_signed;
uint32_t count; uint32_t count;
bool is_complex; bool is_complex;
RegisterContext *reg_ctx = thread->GetRegisterContext().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get();
bool set_it_simple = false; bool set_it_simple = false;
if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType()) if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
{ {
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("rax", 0); const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("rax", 0);
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
{ {
Show All 9 Lines if (compiler_type.IsIntegerType (is_signed) || compiler_type.IsPointerType())
set_it_simple = true; set_it_simple = true;
} }
else else
{ {
error.SetErrorString("We don't support returning longer than 64 bit integer values at present."); error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
} }
} }
else if (clang_type.IsFloatingPointType (count, is_complex)) else if (compiler_type.IsFloatingPointType (count, is_complex))
{ {
if (is_complex) if (is_complex)
error.SetErrorString ("We don't support returning complex values at present"); error.SetErrorString ("We don't support returning complex values at present");
else else
{ {
size_t bit_width = clang_type.GetBitSize(frame_sp.get()); size_t bit_width = compiler_type.GetBitSize(frame_sp.get());
if (bit_width <= 64) if (bit_width <= 64)
{ {
const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0); const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0);
RegisterValue xmm0_value; RegisterValue xmm0_value;
DataExtractor data; DataExtractor data;
Error data_error; Error data_error;
size_t num_bytes = new_value_sp->GetData(data, data_error); size_t num_bytes = new_value_sp->GetData(data, data_error);
if (data_error.Fail()) if (data_error.Fail())
Show All 26 LinesABISysV_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
} }
return error; return error;
} }
ValueObjectSP ValueObjectSP
ABISysV_x86_64::GetReturnValueObjectSimple (Thread &thread, ABISysV_x86_64::GetReturnValueObjectSimple (Thread &thread,
CompilerType &return_clang_type) const CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
Value value; Value value;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
//value.SetContext (Value::eContextTypeClangType, return_value_type); //value.SetContext (Value::eContextTypeClangType, return_value_type);
value.SetCompilerType (return_clang_type); value.SetCompilerType (return_compiler_type);
RegisterContext *reg_ctx = thread.GetRegisterContext().get(); RegisterContext *reg_ctx = thread.GetRegisterContext().get();
if (!reg_ctx) if (!reg_ctx)
return return_valobj_sp; return return_valobj_sp;
const uint32_t type_flags = return_clang_type.GetTypeInfo (); const uint32_t type_flags = return_compiler_type.GetTypeInfo ();
if (type_flags & eTypeIsScalar) if (type_flags & eTypeIsScalar)
{ {
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
bool success = false; bool success = false;
if (type_flags & eTypeIsInteger) if (type_flags & eTypeIsInteger)
{ {
// Extract the register context so we can read arguments from registers // Extract the register context so we can read arguments from registers
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("rax", 0), 0); uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("rax", 0), 0);
const bool is_signed = (type_flags & eTypeIsSigned) != 0; const bool is_signed = (type_flags & eTypeIsSigned) != 0;
switch (byte_size) switch (byte_size)
{ {
default: default:
break; break;
case sizeof(uint64_t): case sizeof(uint64_t):
Show All 32 Lines if (type_flags & eTypeIsScalar)
else if (type_flags & eTypeIsFloat) else if (type_flags & eTypeIsFloat)
{ {
if (type_flags & eTypeIsComplex) if (type_flags & eTypeIsComplex)
{ {
// Don't handle complex yet. // Don't handle complex yet.
} }
else else
{ {
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
if (byte_size <= sizeof(long double)) if (byte_size <= sizeof(long double))
{ {
const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0); const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0);
RegisterValue xmm0_value; RegisterValue xmm0_value;
if (reg_ctx->ReadRegister (xmm0_info, xmm0_value)) if (reg_ctx->ReadRegister (xmm0_info, xmm0_value))
{ {
DataExtractor data; DataExtractor data;
if (xmm0_value.GetData(data)) if (xmm0_value.GetData(data))
Show All 31 Lines else if (type_flags & eTypeIsPointer)
value.GetScalar() = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id, 0); value.GetScalar() = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id, 0);
value.SetValueType(Value::eValueTypeScalar); value.SetValueType(Value::eValueTypeScalar);
return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(), return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(),
value, value,
ConstString("")); ConstString(""));
} }
else if (type_flags & eTypeIsVector) else if (type_flags & eTypeIsVector)
{ {
const size_t byte_size = return_clang_type.GetByteSize(nullptr); const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
if (byte_size > 0) if (byte_size > 0)
{ {
const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("xmm0", 0); const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("xmm0", 0);
if (altivec_reg == nullptr) if (altivec_reg == nullptr)
altivec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0); altivec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0);
if (altivec_reg) if (altivec_reg)
{ {
Show All 13 Lines else if (type_flags & eTypeIsVector)
heap_data_ap->GetByteSize(), heap_data_ap->GetByteSize(),
byte_order, byte_order,
error)) error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
} }
} }
else if (byte_size <= altivec_reg->byte_size*2) else if (byte_size <= altivec_reg->byte_size*2)
{ {
Show All 21 Lines else if (type_flags & eTypeIsVector)
heap_data_ap->GetByteSize() - altivec_reg->byte_size, heap_data_ap->GetByteSize() - altivec_reg->byte_size,
byte_order, byte_order,
error)) error))
{ {
DataExtractor data (DataBufferSP (heap_data_ap.release()), DataExtractor data (DataBufferSP (heap_data_ap.release()),
byte_order, byte_order,
process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
data); data);
} }
} }
} }
} }
} }
} }
} }
} }
return return_valobj_sp; return return_valobj_sp;
} }
ValueObjectSP ValueObjectSP
ABISysV_x86_64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_clang_type) const ABISysV_x86_64::GetReturnValueObjectImpl (Thread &thread, CompilerType &return_compiler_type) const
{ {
ValueObjectSP return_valobj_sp; ValueObjectSP return_valobj_sp;
if (!return_clang_type) if (!return_compiler_type)
return return_valobj_sp; return return_valobj_sp;
ExecutionContext exe_ctx (thread.shared_from_this()); ExecutionContext exe_ctx (thread.shared_from_this());
return_valobj_sp = GetReturnValueObjectSimple(thread, return_clang_type); return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
if (return_valobj_sp) if (return_valobj_sp)
return return_valobj_sp; return return_valobj_sp;
RegisterContextSP reg_ctx_sp = thread.GetRegisterContext(); RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
if (!reg_ctx_sp) if (!reg_ctx_sp)
return return_valobj_sp; return return_valobj_sp;
const size_t bit_width = return_clang_type.GetBitSize(&thread); const size_t bit_width = return_compiler_type.GetBitSize(&thread);
if (return_clang_type.IsAggregateType()) if (return_compiler_type.IsAggregateType())
{ {
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
bool is_memory = true; bool is_memory = true;
if (bit_width <= 128) if (bit_width <= 128)
{ {
ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder(); ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
DataBufferSP data_sp (new DataBufferHeap(16, 0)); DataBufferSP data_sp (new DataBufferHeap(16, 0));
DataExtractor return_ext (data_sp, DataExtractor return_ext (data_sp,
Show All 16 Lines if (return_compiler_type.IsAggregateType())
rax_value.GetData(rax_data); rax_value.GetData(rax_data);
rdx_value.GetData(rdx_data); rdx_value.GetData(rdx_data);
xmm0_value.GetData(xmm0_data); xmm0_value.GetData(xmm0_data);
xmm1_value.GetData(xmm1_data); xmm1_value.GetData(xmm1_data);
uint32_t fp_bytes = 0; // Tracks how much of the xmm registers we've consumed so far uint32_t fp_bytes = 0; // Tracks how much of the xmm registers we've consumed so far
uint32_t integer_bytes = 0; // Tracks how much of the rax/rds registers we've consumed so far uint32_t integer_bytes = 0; // Tracks how much of the rax/rds registers we've consumed so far
const uint32_t num_children = return_clang_type.GetNumFields (); const uint32_t num_children = return_compiler_type.GetNumFields ();
// Since we are in the small struct regime, assume we are not in memory. // Since we are in the small struct regime, assume we are not in memory.
is_memory = false; is_memory = false;
for (uint32_t idx = 0; idx < num_children; idx++) for (uint32_t idx = 0; idx < num_children; idx++)
{ {
std::string name; std::string name;
uint64_t field_bit_offset = 0; uint64_t field_bit_offset = 0;
bool is_signed; bool is_signed;
bool is_complex; bool is_complex;
uint32_t count; uint32_t count;
CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL);
const size_t field_bit_width = field_clang_type.GetBitSize(&thread); const size_t field_bit_width = field_compiler_type.GetBitSize(&thread);
// if we don't know the size of the field (e.g. invalid type), just bail out // if we don't know the size of the field (e.g. invalid type), just bail out
if (field_bit_width == 0) if (field_bit_width == 0)
break; break;
// If there are any unaligned fields, this is stored in memory. // If there are any unaligned fields, this is stored in memory.
if (field_bit_offset % field_bit_width != 0) if (field_bit_offset % field_bit_width != 0)
{ {
is_memory = true; is_memory = true;
break; break;
} }
uint32_t field_byte_width = field_bit_width/8; uint32_t field_byte_width = field_bit_width/8;
uint32_t field_byte_offset = field_bit_offset/8; uint32_t field_byte_offset = field_bit_offset/8;
DataExtractor *copy_from_extractor = NULL; DataExtractor *copy_from_extractor = NULL;
uint32_t copy_from_offset = 0; uint32_t copy_from_offset = 0;
if (field_clang_type.IsIntegerType (is_signed) || field_clang_type.IsPointerType ()) if (field_compiler_type.IsIntegerType (is_signed) || field_compiler_type.IsPointerType ())
{ {
if (integer_bytes < 8) if (integer_bytes < 8)
{ {
if (integer_bytes + field_byte_width <= 8) if (integer_bytes + field_byte_width <= 8)
{ {
// This is in RAX, copy from register to our result structure: // This is in RAX, copy from register to our result structure:
copy_from_extractor = &rax_data; copy_from_extractor = &rax_data;
copy_from_offset = integer_bytes; copy_from_offset = integer_bytes;
Show All 16 Lines if (return_compiler_type.IsAggregateType())
} }
else else
{ {
// The last field didn't fit. I can't see how that would happen w/o the overall size being // The last field didn't fit. I can't see how that would happen w/o the overall size being
// greater than 16 bytes. For now, return a NULL return value object. // greater than 16 bytes. For now, return a NULL return value object.
return return_valobj_sp; return return_valobj_sp;
} }
} }
else if (field_clang_type.IsFloatingPointType (count, is_complex)) else if (field_compiler_type.IsFloatingPointType (count, is_complex))
{ {
// Structs with long doubles are always passed in memory. // Structs with long doubles are always passed in memory.
if (field_bit_width == 128) if (field_bit_width == 128)
{ {
is_memory = true; is_memory = true;
break; break;
} }
else if (field_bit_width == 64) else if (field_bit_width == 64)
Show All 16 Lines if (return_compiler_type.IsAggregateType())
if (field_byte_offset % 8 == 0) if (field_byte_offset % 8 == 0)
{ {
// We are at the beginning of one of the eightbytes, so check the next element (if any) // We are at the beginning of one of the eightbytes, so check the next element (if any)
if (idx == num_children - 1) if (idx == num_children - 1)
in_gpr = false; in_gpr = false;
else else
{ {
uint64_t next_field_bit_offset = 0; uint64_t next_field_bit_offset = 0;
CompilerType next_field_clang_type = return_clang_type.GetFieldAtIndex (idx + 1, CompilerType next_field_compiler_type = return_compiler_type.GetFieldAtIndex (idx + 1,
name, name,
&next_field_bit_offset, &next_field_bit_offset,
NULL, NULL,
NULL); NULL);
if (next_field_clang_type.IsIntegerType (is_signed)) if (next_field_compiler_type.IsIntegerType (is_signed))
in_gpr = true; in_gpr = true;
else else
{ {
copy_from_offset = 0; copy_from_offset = 0;
in_gpr = false; in_gpr = false;
} }
} }
} }
else if (field_byte_offset % 4 == 0) else if (field_byte_offset % 4 == 0)
{ {
// We are inside of an eightbyte, so see if the field before us is floating point: // We are inside of an eightbyte, so see if the field before us is floating point:
// This could happen if somebody put padding in the structure. // This could happen if somebody put padding in the structure.
if (idx == 0) if (idx == 0)
in_gpr = false; in_gpr = false;
else else
{ {
uint64_t prev_field_bit_offset = 0; uint64_t prev_field_bit_offset = 0;
CompilerType prev_field_clang_type = return_clang_type.GetFieldAtIndex (idx - 1, CompilerType prev_field_compiler_type = return_compiler_type.GetFieldAtIndex (idx - 1,
name, name,
&prev_field_bit_offset, &prev_field_bit_offset,
NULL, NULL,
NULL); NULL);
if (prev_field_clang_type.IsIntegerType (is_signed)) if (prev_field_compiler_type.IsIntegerType (is_signed))
in_gpr = true; in_gpr = true;
else else
{ {
copy_from_offset = 4; copy_from_offset = 4;
in_gpr = false; in_gpr = false;
} }
} }
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines if (return_compiler_type.IsAggregateType())
field_byte_width, field_byte_width,
target_byte_order); target_byte_order);
} }
if (!is_memory) if (!is_memory)
{ {
// The result is in our data buffer. Let's make a variable object out of it: // The result is in our data buffer. Let's make a variable object out of it:
return_valobj_sp = ValueObjectConstResult::Create (&thread, return_valobj_sp = ValueObjectConstResult::Create (&thread,
return_clang_type, return_compiler_type,
ConstString(""), ConstString(""),
return_ext); return_ext);
} }
} }
// FIXME: This is just taking a guess, rax may very well no longer hold the return storage location. // FIXME: This is just taking a guess, rax may very well no longer hold the return storage location.
// If we are going to do this right, when we make a new frame we should check to see if it uses a memory // If we are going to do this right, when we make a new frame we should check to see if it uses a memory
// return, and if we are at the first instruction and if so stash away the return location. Then we would // return, and if we are at the first instruction and if so stash away the return location. Then we would
// only return the memory return value if we know it is valid. // only return the memory return value if we know it is valid.
if (is_memory) if (is_memory)
{ {
unsigned rax_id = reg_ctx_sp->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB]; unsigned rax_id = reg_ctx_sp->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id, 0); lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id, 0);
return_valobj_sp = ValueObjectMemory::Create (&thread, return_valobj_sp = ValueObjectMemory::Create (&thread,
"", "",
Address (storage_addr, NULL), Address (storage_addr, NULL),
return_clang_type); return_compiler_type);
} }
} }
return return_valobj_sp; return return_valobj_sp;
} }
// This defines the CFA as rsp+8 // This defines the CFA as rsp+8
// the saved pc is at CFA-8 (i.e. rsp+0) // the saved pc is at CFA-8 (i.e. rsp+0)
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines if (valobj.IsPointerType())
data_addr = valobj.GetValueAsUnsigned(0); data_addr = valobj.GetValueAsUnsigned(0);
else if (valobj.IsArrayType()) else if (valobj.IsArrayType())
data_addr = valobj.GetAddressOf(); data_addr = valobj.GetAddressOf();
if (data_addr == 0 || data_addr == LLDB_INVALID_ADDRESS) if (data_addr == 0 || data_addr == LLDB_INVALID_ADDRESS)
return false; return false;
// Get a wchar_t basic type from the current type system // Get a wchar_t basic type from the current type system
CompilerType wchar_clang_type = valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar); CompilerType wchar_compiler_type = valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar);
if (!wchar_clang_type) if (!wchar_compiler_type)
return false; return false;
const uint32_t wchar_size = wchar_clang_type.GetBitSize(nullptr); // Safe to pass NULL for exe_scope here const uint32_t wchar_size = wchar_compiler_type.GetBitSize(nullptr); // Safe to pass NULL for exe_scope here
StringPrinter::ReadStringAndDumpToStreamOptions options(valobj); StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
options.SetLocation(data_addr); options.SetLocation(data_addr);
options.SetProcessSP(process_sp); options.SetProcessSP(process_sp);
options.SetStream(&stream); options.SetStream(&stream);
options.SetPrefixToken('L'); options.SetPrefixToken('L');
switch (wchar_size) switch (wchar_size)
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.cpp

Show All 23 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::formatters; using namespace lldb_private::formatters;
static CompilerType static CompilerType
GetLLDBNSPairType (TargetSP target_sp) GetLLDBNSPairType (TargetSP target_sp)
{ {
CompilerType clang_type; CompilerType compiler_type;
ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext(); ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext();
if (target_ast_context) if (target_ast_context)
{ {
ConstString g___lldb_autogen_nspair("__lldb_autogen_nspair"); ConstString g___lldb_autogen_nspair("__lldb_autogen_nspair");
clang_type = target_ast_context->GetTypeForIdentifier<clang::CXXRecordDecl>(g___lldb_autogen_nspair); compiler_type = target_ast_context->GetTypeForIdentifier<clang::CXXRecordDecl>(g___lldb_autogen_nspair);
if (!clang_type) if (!compiler_type)
{ {
clang_type = target_ast_context->CreateRecordType(NULL, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC); compiler_type = target_ast_context->CreateRecordType(NULL, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC);
if (clang_type) if (compiler_type)
{ {
ClangASTContext::StartTagDeclarationDefinition(clang_type); ClangASTContext::StartTagDeclarationDefinition(compiler_type);
CompilerType id_clang_type = target_ast_context->GetBasicType (eBasicTypeObjCID); CompilerType id_compiler_type = target_ast_context->GetBasicType (eBasicTypeObjCID);
ClangASTContext::AddFieldToRecordType(clang_type, "key", id_clang_type, lldb::eAccessPublic, 0); ClangASTContext::AddFieldToRecordType(compiler_type, "key", id_compiler_type, lldb::eAccessPublic, 0);
ClangASTContext::AddFieldToRecordType(clang_type, "value", id_clang_type, lldb::eAccessPublic, 0); ClangASTContext::AddFieldToRecordType(compiler_type, "value", id_compiler_type, lldb::eAccessPublic, 0);
ClangASTContext::CompleteTagDeclarationDefinition(clang_type); ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
} }
} }
} }
return clang_type; return compiler_type;
} }
namespace lldb_private { namespace lldb_private {
namespace formatters { namespace formatters {
class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd
{ {
private: private:
struct DataDescriptor_32 struct DataDescriptor_32
▲ Show 20 Lines • Show All 639 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 LinesAppleObjCRuntime::AppleObjCRuntime(Process *process) :
m_Foundation_major() m_Foundation_major()
{ {
ReadObjCLibraryIfNeeded (process->GetTarget().GetImages()); ReadObjCLibraryIfNeeded (process->GetTarget().GetImages());
} }
bool bool
AppleObjCRuntime::GetObjectDescription (Stream &str, ValueObject &valobj) AppleObjCRuntime::GetObjectDescription (Stream &str, ValueObject &valobj)
{ {
CompilerType clang_type(valobj.GetCompilerType()); CompilerType compiler_type(valobj.GetCompilerType());
bool is_signed; bool is_signed;
// ObjC objects can only be pointers (or numbers that actually represents pointers // ObjC objects can only be pointers (or numbers that actually represents pointers
// but haven't been typecast, because reasons..) // but haven't been typecast, because reasons..)
if (!clang_type.IsIntegerType (is_signed) && !clang_type.IsPointerType ()) if (!compiler_type.IsIntegerType (is_signed) && !compiler_type.IsPointerType ())
return false; return false;
// Make the argument list: we pass one arg, the address of our pointer, to the print function. // Make the argument list: we pass one arg, the address of our pointer, to the print function.
Value val; Value val;
if (!valobj.ResolveValue(val.GetScalar())) if (!valobj.ResolveValue(val.GetScalar()))
return false; return false;
Show All 17 LinesAppleObjCRuntime::GetObjectDescription (Stream &strm, Value &value, ExecutionContextScope *exe_scope)
assert (m_process == process); assert (m_process == process);
// Get the function address for the print function. // Get the function address for the print function.
const Address *function_address = GetPrintForDebuggerAddr(); const Address *function_address = GetPrintForDebuggerAddr();
if (!function_address) if (!function_address)
return false; return false;
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
CompilerType clang_type = value.GetCompilerType(); CompilerType compiler_type = value.GetCompilerType();
if (clang_type) if (compiler_type)
{ {
if (!ClangASTContext::IsObjCObjectPointerType(clang_type)) if (!ClangASTContext::IsObjCObjectPointerType(compiler_type))
{ {
strm.Printf ("Value doesn't point to an ObjC object.\n"); strm.Printf ("Value doesn't point to an ObjC object.\n");
return false; return false;
} }
} }
else else
{ {
// If it is not a pointer, see if we can make it into a pointer. // If it is not a pointer, see if we can make it into a pointer.
ClangASTContext *ast_context = target->GetScratchClangASTContext(); ClangASTContext *ast_context = target->GetScratchClangASTContext();
CompilerType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID); CompilerType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID);
if (!opaque_type) if (!opaque_type)
opaque_type = ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); opaque_type = ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
//value.SetContext(Value::eContextTypeClangType, opaque_type_ptr); //value.SetContext(Value::eContextTypeClangType, opaque_type_ptr);
value.SetCompilerType (opaque_type); value.SetCompilerType (opaque_type);
} }
ValueList arg_value_list; ValueList arg_value_list;
arg_value_list.PushValue(value); arg_value_list.PushValue(value);
// This is the return value: // This is the return value:
ClangASTContext *ast_context = target->GetScratchClangASTContext(); ClangASTContext *ast_context = target->GetScratchClangASTContext();
CompilerType return_clang_type = ast_context->GetCStringType(true); CompilerType return_compiler_type = ast_context->GetCStringType(true);
Value ret; Value ret;
// ret.SetContext(Value::eContextTypeClangType, return_clang_type); // ret.SetContext(Value::eContextTypeClangType, return_compiler_type);
ret.SetCompilerType (return_clang_type); ret.SetCompilerType (return_compiler_type);
if (exe_ctx.GetFramePtr() == NULL) if (exe_ctx.GetFramePtr() == NULL)
{ {
Thread *thread = exe_ctx.GetThreadPtr(); Thread *thread = exe_ctx.GetThreadPtr();
if (thread == NULL) if (thread == NULL)
{ {
exe_ctx.SetThreadSP(process->GetThreadList().GetSelectedThread()); exe_ctx.SetThreadSP(process->GetThreadList().GetSelectedThread());
thread = exe_ctx.GetThreadPtr(); thread = exe_ctx.GetThreadPtr();
} }
if (thread) if (thread)
{ {
exe_ctx.SetFrameSP(thread->GetSelectedFrame()); exe_ctx.SetFrameSP(thread->GetSelectedFrame());
} }
} }
// Now we're ready to call the function: // Now we're ready to call the function:
StreamString error_stream; StreamString error_stream;
lldb::addr_t wrapper_struct_addr = LLDB_INVALID_ADDRESS; lldb::addr_t wrapper_struct_addr = LLDB_INVALID_ADDRESS;
if (!m_print_object_caller_up) if (!m_print_object_caller_up)
{ {
Error error; Error error;
m_print_object_caller_up.reset(exe_scope->CalculateTarget()->GetFunctionCallerForLanguage (eLanguageTypeObjC, m_print_object_caller_up.reset(exe_scope->CalculateTarget()->GetFunctionCallerForLanguage (eLanguageTypeObjC,
return_clang_type, return_compiler_type,
*function_address, *function_address,
arg_value_list, arg_value_list,
"objc-object-description", "objc-object-description",
error)); error));
if (error.Fail()) if (error.Fail())
{ {
m_print_object_caller_up.reset(); m_print_object_caller_up.reset();
strm.Printf("Could not get function runner to call print for debugger function: %s.", error.AsCString()); strm.Printf("Could not get function runner to call print for debugger function: %s.", error.AsCString());
▲ Show 20 Lines • Show All 379 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

Show All 29 Linespublic:
virtual lldb_private::Function * virtual lldb_private::Function *
ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc, ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc,
const DWARFDIE &die) = 0; const DWARFDIE &die) = 0;
virtual bool virtual bool
CompleteTypeFromDWARF (const DWARFDIE &die, CompleteTypeFromDWARF (const DWARFDIE &die,
lldb_private::Type *type, lldb_private::Type *type,
lldb_private::CompilerType &clang_type) = 0; lldb_private::CompilerType &compiler_type) = 0;
virtual lldb_private::CompilerDecl virtual lldb_private::CompilerDecl
GetDeclForUIDFromDWARF (const DWARFDIE &die) = 0; GetDeclForUIDFromDWARF (const DWARFDIE &die) = 0;
virtual lldb_private::CompilerDeclContext virtual lldb_private::CompilerDeclContext
GetDeclContextForUIDFromDWARF (const DWARFDIE &die) = 0; GetDeclContextForUIDFromDWARF (const DWARFDIE &die) = 0;
virtual lldb_private::CompilerDeclContext virtual lldb_private::CompilerDeclContext
GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) = 0; GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) = 0;
virtual std::vector<DWARFDIE> virtual std::vector<DWARFDIE>
GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) = 0; GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) = 0;
}; };
#endif // SymbolFileDWARF_DWARFASTParser_h_ #endif // SymbolFileDWARF_DWARFASTParser_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

Show All 40 Linespublic:
virtual lldb_private::Function * virtual lldb_private::Function *
ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc, ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc,
const DWARFDIE &die) override; const DWARFDIE &die) override;
virtual bool virtual bool
CompleteTypeFromDWARF (const DWARFDIE &die, CompleteTypeFromDWARF (const DWARFDIE &die,
lldb_private::Type *type, lldb_private::Type *type,
lldb_private::CompilerType &clang_type) override; lldb_private::CompilerType &compiler_type) override;
virtual lldb_private::CompilerDecl virtual lldb_private::CompilerDecl
GetDeclForUIDFromDWARF (const DWARFDIE &die) override; GetDeclForUIDFromDWARF (const DWARFDIE &die) override;
virtual std::vector<DWARFDIE> virtual std::vector<DWARFDIE>
GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) override; GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) override;
virtual lldb_private::CompilerDeclContext virtual lldb_private::CompilerDeclContext
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines ParseTemplateDIE (const DWARFDIE &die,
lldb_private::ClangASTContext::TemplateParameterInfos &template_param_infos); lldb_private::ClangASTContext::TemplateParameterInfos &template_param_infos);
bool bool
ParseTemplateParameterInfos (const DWARFDIE &parent_die, ParseTemplateParameterInfos (const DWARFDIE &parent_die,
lldb_private::ClangASTContext::TemplateParameterInfos &template_param_infos); lldb_private::ClangASTContext::TemplateParameterInfos &template_param_infos);
bool bool
ParseChildMembers (const lldb_private::SymbolContext& sc, ParseChildMembers (const lldb_private::SymbolContext& sc,
const DWARFDIE &die, const DWARFDIE &die,
lldb_private::CompilerType &class_clang_type, lldb_private::CompilerType &class_compiler_type,
const lldb::LanguageType class_language, const lldb::LanguageType class_language,
std::vector<clang::CXXBaseSpecifier *>& base_classes, std::vector<clang::CXXBaseSpecifier *>& base_classes,
std::vector<int>& member_accessibilities, std::vector<int>& member_accessibilities,
DWARFDIECollection& member_function_dies, DWARFDIECollection& member_function_dies,
DelayedPropertyList& delayed_properties, DelayedPropertyList& delayed_properties,
lldb::AccessType &default_accessibility, lldb::AccessType &default_accessibility,
bool &is_a_class, bool &is_a_class,
LayoutInfo &layout_info); LayoutInfo &layout_info);
Show All 16 Lines ParseChildArrayInfo (const lldb_private::SymbolContext& sc,
int64_t& first_index, int64_t& first_index,
std::vector<uint64_t>& element_orders, std::vector<uint64_t>& element_orders,
uint32_t& byte_stride, uint32_t& byte_stride,
uint32_t& bit_stride); uint32_t& bit_stride);
size_t size_t
ParseChildEnumerators (const lldb_private::SymbolContext& sc, ParseChildEnumerators (const lldb_private::SymbolContext& sc,
lldb_private::CompilerType &clang_type, lldb_private::CompilerType &compiler_type,
bool is_signed, bool is_signed,
uint32_t enumerator_byte_size, uint32_t enumerator_byte_size,
const DWARFDIE &parent_die); const DWARFDIE &parent_die);
lldb_private::Type * lldb_private::Type *
GetTypeForDIE (const DWARFDIE &die); GetTypeForDIE (const DWARFDIE &die);
clang::Decl * clang::Decl *
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesclass DWARFASTParserGo : public DWARFASTParser
private: private:
size_t ParseChildParameters(const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die, bool &is_variadic, size_t ParseChildParameters(const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die, bool &is_variadic,
std::vector<lldb_private::CompilerType> &function_param_types); std::vector<lldb_private::CompilerType> &function_param_types);
void ParseChildArrayInfo(const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die, int64_t &first_index, void ParseChildArrayInfo(const lldb_private::SymbolContext &sc, const DWARFDIE &parent_die, int64_t &first_index,
std::vector<uint64_t> &element_orders, uint32_t &byte_stride, uint32_t &bit_stride); std::vector<uint64_t> &element_orders, uint32_t &byte_stride, uint32_t &bit_stride);
size_t ParseChildMembers(const lldb_private::SymbolContext &sc, const DWARFDIE &die, size_t ParseChildMembers(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
lldb_private::CompilerType &class_clang_type); lldb_private::CompilerType &class_compiler_type);
lldb_private::GoASTContext &m_ast; lldb_private::GoASTContext &m_ast;
}; };
#endif // SymbolFileDWARF_DWARFASTParserGo_h_ #endif // SymbolFileDWARF_DWARFASTParserGo_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines if (die)
const char *type_name_cstr = NULL; const char *type_name_cstr = NULL;
ConstString type_name_const_str; ConstString type_name_const_str;
Type::ResolveState resolve_state = Type::eResolveStateUnresolved; Type::ResolveState resolve_state = Type::eResolveStateUnresolved;
uint64_t byte_size = 0; uint64_t byte_size = 0;
uint64_t go_kind = 0; uint64_t go_kind = 0;
Declaration decl; Declaration decl;
Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID; Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
CompilerType clang_type; CompilerType compiler_type;
DWARFFormValue form_value; DWARFFormValue form_value;
dw_attr_t attr; dw_attr_t attr;
switch (tag) switch (tag)
{ {
case DW_TAG_base_type: case DW_TAG_base_type:
case DW_TAG_pointer_type: case DW_TAG_pointer_type:
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines if (die)
switch (tag) switch (tag)
{ {
default: default:
break; break;
case DW_TAG_unspecified_type: case DW_TAG_unspecified_type:
resolve_state = Type::eResolveStateFull; resolve_state = Type::eResolveStateFull;
clang_type = m_ast.CreateVoidType(type_name_const_str); compiler_type = m_ast.CreateVoidType(type_name_const_str);
break; break;
case DW_TAG_base_type: case DW_TAG_base_type:
resolve_state = Type::eResolveStateFull; resolve_state = Type::eResolveStateFull;
clang_type = m_ast.CreateBaseType(go_kind, type_name_const_str, byte_size); compiler_type = m_ast.CreateBaseType(go_kind, type_name_const_str, byte_size);
break; break;
case DW_TAG_pointer_type: case DW_TAG_pointer_type:
encoding_data_type = Type::eEncodingIsPointerUID; encoding_data_type = Type::eEncodingIsPointerUID;
break; break;
case DW_TAG_typedef: case DW_TAG_typedef:
encoding_data_type = Type::eEncodingIsTypedefUID; encoding_data_type = Type::eEncodingIsTypedefUID;
CompilerType impl; CompilerType impl;
Type *type = dwarf->ResolveTypeUID(encoding_uid); Type *type = dwarf->ResolveTypeUID(encoding_uid);
if (type) if (type)
{ {
if (go_kind == 0 && type->GetName() == type_name_const_str) if (go_kind == 0 && type->GetName() == type_name_const_str)
{ {
// Go emits extra typedefs as a forward declaration. Ignore these. // Go emits extra typedefs as a forward declaration. Ignore these.
dwarf->m_die_to_type[die.GetDIE()] = type; dwarf->m_die_to_type[die.GetDIE()] = type;
return type->shared_from_this(); return type->shared_from_this();
} }
impl = type->GetForwardCompilerType(); impl = type->GetForwardCompilerType();
clang_type = m_ast.CreateTypedefType (go_kind, type_name_const_str, impl); compiler_type = m_ast.CreateTypedefType (go_kind, type_name_const_str, impl);
} }
break; break;
} }
type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, byte_size, type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, byte_size,
NULL, encoding_uid, encoding_data_type, &decl, clang_type, resolve_state)); NULL, encoding_uid, encoding_data_type, &decl, compiler_type, resolve_state));
dwarf->m_die_to_type[die.GetDIE()] = type_sp.get(); dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
} }
break; break;
case DW_TAG_structure_type: case DW_TAG_structure_type:
{ {
// Set a bit that lets us know that we are currently parsing this // Set a bit that lets us know that we are currently parsing this
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines if (die)
dwarf->m_die_to_type[die.GetDIE()] = type_sp.get(); dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
return type_sp; return type_sp;
} }
} }
DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", dwarf->MakeUserID(die.GetOffset()), DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", dwarf->MakeUserID(die.GetOffset()),
DW_TAG_value_to_name(tag), type_name_cstr); DW_TAG_value_to_name(tag), type_name_cstr);
bool clang_type_was_created = false; bool compiler_type_was_created = false;
clang_type.SetCompilerType(&m_ast, dwarf->m_forward_decl_die_to_clang_type.lookup(die.GetDIE())); compiler_type.SetCompilerType(&m_ast, dwarf->m_forward_decl_die_to_clang_type.lookup(die.GetDIE()));
if (!clang_type) if (!compiler_type)
{ {
clang_type_was_created = true; compiler_type_was_created = true;
clang_type = m_ast.CreateStructType(go_kind, type_name_const_str, byte_size); compiler_type = m_ast.CreateStructType(go_kind, type_name_const_str, byte_size);
} }
type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, byte_size, type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, byte_size,
NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, clang_type, NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, compiler_type,
Type::eResolveStateForward)); Type::eResolveStateForward));
// Add our type to the unique type map so we don't // Add our type to the unique type map so we don't
// end up creating many copies of the same type over // end up creating many copies of the same type over
// and over in the ASTContext for our module // and over in the ASTContext for our module
unique_ast_entry_ap->m_type_sp = type_sp; unique_ast_entry_ap->m_type_sp = type_sp;
unique_ast_entry_ap->m_die = die; unique_ast_entry_ap->m_die = die;
unique_ast_entry_ap->m_declaration = decl; unique_ast_entry_ap->m_declaration = decl;
unique_ast_entry_ap->m_byte_size = byte_size; unique_ast_entry_ap->m_byte_size = byte_size;
dwarf->GetUniqueDWARFASTTypeMap().Insert(type_name_const_str, *unique_ast_entry_ap); dwarf->GetUniqueDWARFASTTypeMap().Insert(type_name_const_str, *unique_ast_entry_ap);
if (!is_forward_declaration) if (!is_forward_declaration)
{ {
// Always start the definition for a class type so that // Always start the definition for a class type so that
// if the class has child classes or types that require // if the class has child classes or types that require
// the class to be created for use as their decl contexts // the class to be created for use as their decl contexts
// the class will be ready to accept these child definitions. // the class will be ready to accept these child definitions.
if (die.HasChildren() == false) if (die.HasChildren() == false)
{ {
// No children for this struct/union/class, lets finish it // No children for this struct/union/class, lets finish it
m_ast.CompleteStructType(clang_type); m_ast.CompleteStructType(compiler_type);
} }
else if (clang_type_was_created) else if (compiler_type_was_created)
{ {
// Leave this as a forward declaration until we need // Leave this as a forward declaration until we need
// to know the details of the type. lldb_private::Type // to know the details of the type. lldb_private::Type
// will automatically call the SymbolFile virtual function // will automatically call the SymbolFile virtual function
// "SymbolFileDWARF::CompleteType(Type *)" // "SymbolFileDWARF::CompleteType(Type *)"
// When the definition needs to be defined. // When the definition needs to be defined.
dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] = clang_type.GetOpaqueQualType(); dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] = compiler_type.GetOpaqueQualType();
dwarf->m_forward_decl_clang_type_to_die[clang_type.GetOpaqueQualType()] = die.GetDIERef(); dwarf->m_forward_decl_clang_type_to_die[compiler_type.GetOpaqueQualType()] = die.GetDIERef();
// SetHasExternalStorage (clang_type.GetOpaqueQualType(), true); // SetHasExternalStorage (compiler_type.GetOpaqueQualType(), true);
} }
} }
} }
break; break;
case DW_TAG_subprogram: case DW_TAG_subprogram:
case DW_TAG_subroutine_type: case DW_TAG_subroutine_type:
{ {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines if (die)
// Parse the function children for the parameters // Parse the function children for the parameters
if (die.HasChildren()) if (die.HasChildren())
{ {
ParseChildParameters(sc, die, is_variadic, function_param_types); ParseChildParameters(sc, die, is_variadic, function_param_types);
} }
// clang_type will get the function prototype clang type after this call // compiler_type will get the function prototype clang type after this call
clang_type = m_ast.CreateFunctionType(type_name_const_str, function_param_types.data(), compiler_type = m_ast.CreateFunctionType(type_name_const_str, function_param_types.data(),
function_param_types.size(), is_variadic); function_param_types.size(), is_variadic);
type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, 0, NULL, type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, 0, NULL,
LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, clang_type, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, compiler_type,
Type::eResolveStateFull)); Type::eResolveStateFull));
assert(type_sp.get()); assert(type_sp.get());
} }
break; break;
case DW_TAG_array_type: case DW_TAG_array_type:
{ {
// Set a bit that lets us know that we are currently parsing this // Set a bit that lets us know that we are currently parsing this
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines if (die)
ParseChildArrayInfo(sc, die, first_index, element_orders, byte_stride, bit_stride); ParseChildArrayInfo(sc, die, first_index, element_orders, byte_stride, bit_stride);
if (byte_stride == 0) if (byte_stride == 0)
byte_stride = element_type->GetByteSize(); byte_stride = element_type->GetByteSize();
CompilerType array_element_type = element_type->GetForwardCompilerType(); CompilerType array_element_type = element_type->GetForwardCompilerType();
if (element_orders.size() > 0) if (element_orders.size() > 0)
{ {
if (element_orders.size() > 1) if (element_orders.size() > 1)
printf("golang: unsupported multi-dimensional array %s\n", type_name_cstr); printf("golang: unsupported multi-dimensional array %s\n", type_name_cstr);
clang_type = compiler_type =
m_ast.CreateArrayType(type_name_const_str, array_element_type, element_orders[0]); m_ast.CreateArrayType(type_name_const_str, array_element_type, element_orders[0]);
} }
else else
{ {
clang_type = m_ast.CreateArrayType(type_name_const_str, array_element_type, 0); compiler_type = m_ast.CreateArrayType(type_name_const_str, array_element_type, 0);
} }
type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str, type_sp.reset(new Type(dwarf->MakeUserID(die.GetOffset()), dwarf, type_name_const_str,
byte_stride, NULL, type_die_offset, Type::eEncodingIsUID, &decl, byte_stride, NULL, type_die_offset, Type::eEncodingIsUID, &decl,
clang_type, Type::eResolveStateFull)); compiler_type, Type::eResolveStateFull));
type_sp->SetEncodingType(element_type); type_sp->SetEncodingType(element_type);
} }
} }
} }
break; break;
default: default:
dwarf->GetObjectFile()->GetModule()->ReportError("{0x%8.8x}: unhandled type tag 0x%4.4x (%s), " dwarf->GetObjectFile()->GetModule()->ReportError("{0x%8.8x}: unhandled type tag 0x%4.4x (%s), "
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
} }
} }
break; break;
} }
} }
} }
bool bool
DWARFASTParserGo::CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type, CompilerType &clang_type) DWARFASTParserGo::CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type, CompilerType &compiler_type)
{ {
if (!die) if (!die)
return false; return false;
const dw_tag_t tag = die.Tag(); const dw_tag_t tag = die.Tag();
SymbolFileDWARF *dwarf = die.GetDWARF(); SymbolFileDWARF *dwarf = die.GetDWARF();
Log *log = nullptr; // (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION)); Log *log = nullptr; // (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
if (log) if (log)
dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace( dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...", dwarf->MakeUserID(die.GetOffset()), log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...", dwarf->MakeUserID(die.GetOffset()),
DW_TAG_value_to_name(tag), type->GetName().AsCString()); DW_TAG_value_to_name(tag), type->GetName().AsCString());
assert(clang_type); assert(compiler_type);
DWARFAttributes attributes; DWARFAttributes attributes;
switch (tag) switch (tag)
{ {
case DW_TAG_structure_type: case DW_TAG_structure_type:
{ {
{ {
if (die.HasChildren()) if (die.HasChildren())
{ {
SymbolContext sc(die.GetLLDBCompileUnit()); SymbolContext sc(die.GetLLDBCompileUnit());
ParseChildMembers(sc, die, clang_type); ParseChildMembers(sc, die, compiler_type);
} }
} }
m_ast.CompleteStructType(clang_type); m_ast.CompleteStructType(compiler_type);
return (bool)clang_type; return (bool)compiler_type;
} }
default: default:
assert(false && "not a forward go type decl!"); assert(false && "not a forward go type decl!");
break; break;
} }
return false; return false;
} }
size_t size_t
DWARFASTParserGo::ParseChildMembers(const SymbolContext &sc, const DWARFDIE &parent_die, CompilerType &class_clang_type) DWARFASTParserGo::ParseChildMembers(const SymbolContext &sc, const DWARFDIE &parent_die, CompilerType &class_compiler_type)
{ {
size_t count = 0; size_t count = 0;
uint32_t member_idx = 0; uint32_t member_idx = 0;
ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
GoASTContext *ast = llvm::dyn_cast_or_null<GoASTContext>(class_clang_type.GetTypeSystem()); GoASTContext *ast = llvm::dyn_cast_or_null<GoASTContext>(class_compiler_type.GetTypeSystem());
if (ast == nullptr) if (ast == nullptr)
return 0; return 0;
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling()) for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
{ {
dw_tag_t tag = die.Tag(); dw_tag_t tag = die.Tag();
switch (tag) switch (tag)
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
} }
} }
Type *member_type = die.ResolveTypeUID(encoding_uid); Type *member_type = die.ResolveTypeUID(encoding_uid);
if (member_type) if (member_type)
{ {
CompilerType member_go_type = member_type->GetFullCompilerType(); CompilerType member_go_type = member_type->GetFullCompilerType();
ConstString name_const_str(name); ConstString name_const_str(name);
m_ast.AddFieldToStruct(class_clang_type, name_const_str, member_go_type, member_byte_offset); m_ast.AddFieldToStruct(class_compiler_type, name_const_str, member_go_type, member_byte_offset);
} }
} }
++member_idx; ++member_idx;
} }
break; break;
default: default:
break; break;
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Linespublic:
size_t size_t
ParseVariablesForContext (const lldb_private::SymbolContext& sc) override; ParseVariablesForContext (const lldb_private::SymbolContext& sc) override;
lldb_private::Type * lldb_private::Type *
ResolveTypeUID(lldb::user_id_t type_uid) override; ResolveTypeUID(lldb::user_id_t type_uid) override;
bool bool
CompleteType (lldb_private::CompilerType& clang_type) override; CompleteType (lldb_private::CompilerType& compiler_type) override;
lldb_private::Type * lldb_private::Type *
ResolveType (const DWARFDIE &die, ResolveType (const DWARFDIE &die,
bool assert_not_being_parsed = true); bool assert_not_being_parsed = true);
lldb_private::CompilerDecl lldb_private::CompilerDecl
GetDeclForUID (lldb::user_id_t uid) override; GetDeclForUID (lldb::user_id_t uid) override;
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Linespublic:
const lldb_private::Flags& const lldb_private::Flags&
GetFlags () const GetFlags () const
{ {
return m_flags; return m_flags;
} }
bool bool
HasForwardDeclForClangType (const lldb_private::CompilerType &clang_type); HasForwardDeclForClangType (const lldb_private::CompilerType &compiler_type);
lldb_private::CompileUnit* lldb_private::CompileUnit*
GetCompUnitForDWARFCompUnit(DWARFCompileUnit* dwarf_cu, GetCompUnitForDWARFCompUnit(DWARFCompileUnit* dwarf_cu,
uint32_t cu_idx = UINT32_MAX); uint32_t cu_idx = UINT32_MAX);
lldb::user_id_t lldb::user_id_t
MakeUserID (dw_offset_t die_offset) const MakeUserID (dw_offset_t die_offset) const
{ {
▲ Show 20 Lines • Show All 291 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Show First 20 Lines • Show All 376 Lines • ▼ Show 20 Lines else
UINT32_MAX, UINT32_MAX,
type_mask, type_mask,
type_set); type_set);
} }
} }
} }
} }
std::set<CompilerType> clang_type_set; std::set<CompilerType> compiler_type_set;
size_t num_types_added = 0; size_t num_types_added = 0;
for (Type *type : type_set) for (Type *type : type_set)
{ {
CompilerType clang_type = type->GetForwardCompilerType (); CompilerType compiler_type = type->GetForwardCompilerType ();
if (clang_type_set.find(clang_type) == clang_type_set.end()) if (compiler_type_set.find(compiler_type) == compiler_type_set.end())
{ {
clang_type_set.insert(clang_type); compiler_type_set.insert(compiler_type);
type_list.Insert (type->shared_from_this()); type_list.Insert (type->shared_from_this());
++num_types_added; ++num_types_added;
} }
} }
return num_types_added; return num_types_added;
} }
▲ Show 20 Lines • Show All 1,124 Lines • ▼ Show 20 Lines if (die)
} }
return ResolveType (die); return ResolveType (die);
} }
return NULL; return NULL;
} }
// This function is used when SymbolFileDWARFDebugMap owns a bunch of // This function is used when SymbolFileDWARFDebugMap owns a bunch of
// SymbolFileDWARF objects to detect if this DWARF file is the one that // SymbolFileDWARF objects to detect if this DWARF file is the one that
// can resolve a clang_type. // can resolve a compiler_type.
bool bool
SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &clang_type) SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &compiler_type)
{ {
CompilerType clang_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(clang_type); CompilerType compiler_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(compiler_type);
return GetForwardDeclClangTypeToDie().count (clang_type_no_qualifiers.GetOpaqueQualType()); return GetForwardDeclClangTypeToDie().count (compiler_type_no_qualifiers.GetOpaqueQualType());
} }
bool bool
SymbolFileDWARF::CompleteType (CompilerType &clang_type) SymbolFileDWARF::CompleteType (CompilerType &compiler_type)
{ {
// We have a struct/union/class/enum that needs to be fully resolved. // We have a struct/union/class/enum that needs to be fully resolved.
CompilerType clang_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(clang_type); CompilerType compiler_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(compiler_type);
auto die_it = GetForwardDeclClangTypeToDie().find (clang_type_no_qualifiers.GetOpaqueQualType()); auto die_it = GetForwardDeclClangTypeToDie().find (compiler_type_no_qualifiers.GetOpaqueQualType());
if (die_it == GetForwardDeclClangTypeToDie().end()) if (die_it == GetForwardDeclClangTypeToDie().end())
{ {
// We have already resolved this type... // We have already resolved this type...
return true; return true;
} }
DWARFDebugInfo* debug_info = DebugInfo(); DWARFDebugInfo* debug_info = DebugInfo();
DWARFDIE dwarf_die = debug_info->GetDIE(die_it->getSecond()); DWARFDIE dwarf_die = debug_info->GetDIE(die_it->getSecond());
// Once we start resolving this type, remove it from the forward declaration // Once we start resolving this type, remove it from the forward declaration
// map in case anyone child members or other types require this type to get resolved. // map in case anyone child members or other types require this type to get resolved.
// The type will get resolved when all of the calls to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition // The type will get resolved when all of the calls to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition
// are done. // are done.
GetForwardDeclClangTypeToDie().erase (die_it); GetForwardDeclClangTypeToDie().erase (die_it);
Type *type = GetDIEToType().lookup (dwarf_die.GetDIE()); Type *type = GetDIEToType().lookup (dwarf_die.GetDIE());
Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION)); Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
if (log) if (log)
GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log, GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log,
"0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...", "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
dwarf_die.GetID(), dwarf_die.GetID(),
dwarf_die.GetTagAsCString(), dwarf_die.GetTagAsCString(),
type->GetName().AsCString()); type->GetName().AsCString());
assert (clang_type); assert (compiler_type);
DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser(); DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
if (dwarf_ast) if (dwarf_ast)
return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, clang_type); return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, compiler_type);
return false; return false;
} }
Type* Type*
SymbolFileDWARF::ResolveType (const DWARFDIE &die, bool assert_not_being_parsed) SymbolFileDWARF::ResolveType (const DWARFDIE &die, bool assert_not_being_parsed)
{ {
if (die) if (die)
{ {
▲ Show 20 Lines • Show All 2,773 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linespublic:
bool ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules) override; bool ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules) override;
size_t ParseFunctionBlocks (const lldb_private::SymbolContext& sc) override; size_t ParseFunctionBlocks (const lldb_private::SymbolContext& sc) override;
size_t ParseTypes (const lldb_private::SymbolContext& sc) override; size_t ParseTypes (const lldb_private::SymbolContext& sc) override;
size_t ParseVariablesForContext (const lldb_private::SymbolContext& sc) override; size_t ParseVariablesForContext (const lldb_private::SymbolContext& sc) override;
lldb_private::Type* ResolveTypeUID (lldb::user_id_t type_uid) override; lldb_private::Type* ResolveTypeUID (lldb::user_id_t type_uid) override;
lldb_private::CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) override; lldb_private::CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) override;
lldb_private::CompilerDeclContext GetDeclContextContainingUID (lldb::user_id_t uid) override; lldb_private::CompilerDeclContext GetDeclContextContainingUID (lldb::user_id_t uid) override;
bool CompleteType (lldb_private::CompilerType& clang_type) override; bool CompleteType (lldb_private::CompilerType& compiler_type) override;
uint32_t ResolveSymbolContext (const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc) override; uint32_t ResolveSymbolContext (const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc) override;
uint32_t ResolveSymbolContext (const lldb_private::FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, lldb_private::SymbolContextList& sc_list) override; uint32_t ResolveSymbolContext (const lldb_private::FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, lldb_private::SymbolContextList& sc_list) override;
uint32_t FindGlobalVariables (const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::VariableList& variables) override; uint32_t FindGlobalVariables (const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::VariableList& variables) override;
uint32_t FindGlobalVariables (const lldb_private::RegularExpression& regex, bool append, uint32_t max_matches, lldb_private::VariableList& variables) override; uint32_t FindGlobalVariables (const lldb_private::RegularExpression& regex, bool append, uint32_t max_matches, lldb_private::VariableList& variables) override;
uint32_t FindFunctions (const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, lldb_private::SymbolContextList& sc_list) override; uint32_t FindFunctions (const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, lldb_private::SymbolContextList& sc_list) override;
uint32_t FindFunctions (const lldb_private::RegularExpression& regex, bool include_inlines, bool append, lldb_private::SymbolContextList& sc_list) override; uint32_t FindFunctions (const lldb_private::RegularExpression& regex, bool include_inlines, bool append, lldb_private::SymbolContextList& sc_list) override;
uint32_t FindTypes (const lldb_private::SymbolContext& sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::TypeList& types) override; uint32_t FindTypes (const lldb_private::SymbolContext& sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::TypeList& types) override;
lldb_private::CompilerDeclContext lldb_private::CompilerDeclContext
▲ Show 20 Lines • Show All 330 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

Show First 20 Lines • Show All 772 Lines • ▼ Show 20 LinesSymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid)
const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid); const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid);
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx); SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
if (oso_dwarf) if (oso_dwarf)
return oso_dwarf->ResolveTypeUID (type_uid); return oso_dwarf->ResolveTypeUID (type_uid);
return NULL; return NULL;
} }
bool bool
SymbolFileDWARFDebugMap::CompleteType (CompilerType& clang_type) SymbolFileDWARFDebugMap::CompleteType (CompilerType& compiler_type)
{ {
bool success = false; bool success = false;
if (clang_type) if (compiler_type)
{ {
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
if (oso_dwarf->HasForwardDeclForClangType (clang_type)) if (oso_dwarf->HasForwardDeclForClangType (compiler_type))
{ {
oso_dwarf->CompleteType (clang_type); oso_dwarf->CompleteType (compiler_type);
success = true; success = true;
return true; return true;
} }
return false; return false;
}); });
} }
return success; return success;
} }
▲ Show 20 Lines • Show All 785 Lines • Show Last 20 Lines

lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Linespublic:
virtual size_t virtual size_t
ParseVariablesForContext (const lldb_private::SymbolContext& sc); ParseVariablesForContext (const lldb_private::SymbolContext& sc);
virtual lldb_private::Type* virtual lldb_private::Type*
ResolveTypeUID(lldb::user_id_t type_uid); ResolveTypeUID(lldb::user_id_t type_uid);
virtual bool virtual bool
CompleteType (lldb_private::CompilerType& clang_type); CompleteType (lldb_private::CompilerType& compiler_type);
virtual uint32_t virtual uint32_t
ResolveSymbolContext (const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc); ResolveSymbolContext (const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc);
virtual size_t virtual size_t
GetTypes (lldb_private::SymbolContextScope *sc_scope, GetTypes (lldb_private::SymbolContextScope *sc_scope,
uint32_t type_mask, uint32_t type_mask,
lldb_private::TypeList &type_list); lldb_private::TypeList &type_list);
Show All 26 Lines

lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

Show First 20 Lines • Show All 285 Lines • ▼ Show 20 Lines
Type* Type*
SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid)
{ {
return NULL; return NULL;
} }
bool bool
SymbolFileSymtab::CompleteType (lldb_private::CompilerType& clang_opaque_type) SymbolFileSymtab::CompleteType (lldb_private::CompilerType& compiler_type)
{ {
return false; return false;
} }
uint32_t uint32_t
SymbolFileSymtab::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) SymbolFileSymtab::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc)
{ {
if (m_obj_file->GetSymtab() == NULL) if (m_obj_file->GetSymtab() == NULL)
Show All 26 Lines

lldb/trunk/source/Symbol/CompilerType.cpp

Show First 20 Lines • Show All 363 Lines • ▼ Show 20 Lines
ConstString ConstString
CompilerType::GetDisplayTypeName () const CompilerType::GetDisplayTypeName () const
{ {
return GetTypeName(); return GetTypeName();
} }
uint32_t uint32_t
CompilerType::GetTypeInfo (CompilerType *pointee_or_element_clang_type) const CompilerType::GetTypeInfo (CompilerType *pointee_or_element_compiler_type) const
{ {
if (!IsValid()) if (!IsValid())
return 0; return 0;
return m_type_system->GetTypeInfo(m_type, pointee_or_element_clang_type); return m_type_system->GetTypeInfo(m_type, pointee_or_element_compiler_type);
} }
lldb::LanguageType lldb::LanguageType
CompilerType::GetMinimumLanguage () CompilerType::GetMinimumLanguage ()
{ {
if (!IsValid()) if (!IsValid())
▲ Show 20 Lines • Show All 339 Lines • ▼ Show 20 Lines
{ {
if (IsValid()) if (IsValid())
return m_type_system->GetVirtualBaseClassAtIndex (m_type, idx, bit_offset_ptr); return m_type_system->GetVirtualBaseClassAtIndex (m_type, idx, bit_offset_ptr);
return CompilerType(); return CompilerType();
} }
uint32_t uint32_t
CompilerType::GetIndexOfFieldWithName (const char* name, CompilerType::GetIndexOfFieldWithName (const char* name,
CompilerType* field_clang_type_ptr, CompilerType* field_compiler_type_ptr,
uint64_t *bit_offset_ptr, uint64_t *bit_offset_ptr,
uint32_t *bitfield_bit_size_ptr, uint32_t *bitfield_bit_size_ptr,
bool *is_bitfield_ptr) const bool *is_bitfield_ptr) const
{ {
unsigned count = GetNumFields(); unsigned count = GetNumFields();
std::string field_name; std::string field_name;
for (unsigned index = 0; index < count; index++) for (unsigned index = 0; index < count; index++)
{ {
CompilerType field_clang_type (GetFieldAtIndex(index, field_name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); CompilerType field_compiler_type (GetFieldAtIndex(index, field_name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
if (strcmp(field_name.c_str(), name) == 0) if (strcmp(field_name.c_str(), name) == 0)
{ {
if (field_clang_type_ptr) if (field_compiler_type_ptr)
*field_clang_type_ptr = field_clang_type; *field_compiler_type_ptr = field_compiler_type;
return index; return index;
} }
} }
return UINT32_MAX; return UINT32_MAX;
} }
CompilerType CompilerType
▲ Show 20 Lines • Show All 510 Lines • ▼ Show 20 Lines if (byte_size > 0)
return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size; return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size;
} }
} }
} }
return false; return false;
} }
//clang::CXXRecordDecl * //clang::CXXRecordDecl *
//CompilerType::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t opaque_clang_qual_type) //CompilerType::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t opaque_compiler_qual_type)
//{ //{
// if (opaque_clang_qual_type) // if (opaque_compiler_qual_type)
// return clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl(); // return clang::QualType::getFromOpaquePtr(opaque_compiler_qual_type)->getAsCXXRecordDecl();
// return NULL; // return NULL;
//} //}
bool bool
lldb_private::operator == (const lldb_private::CompilerType &lhs, const lldb_private::CompilerType &rhs) lldb_private::operator == (const lldb_private::CompilerType &lhs, const lldb_private::CompilerType &rhs)
{ {
return lhs.GetTypeSystem() == rhs.GetTypeSystem() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType(); return lhs.GetTypeSystem() == rhs.GetTypeSystem() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType();
} }
Show All 10 Lines

lldb/trunk/source/Symbol/GoASTContext.cpp

Show First 20 Lines • Show All 650 Lines • ▼ Show 20 Lines
GoASTContext::GetTypeName(lldb::opaque_compiler_type_t type) GoASTContext::GetTypeName(lldb::opaque_compiler_type_t type)
{ {
if (type) if (type)
return static_cast<GoType *>(type)->GetName(); return static_cast<GoType *>(type)->GetName();
return ConstString(); return ConstString();
} }
uint32_t uint32_t
GoASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) GoASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type)
{ {
if (pointee_or_element_clang_type) if (pointee_or_element_compiler_type)
pointee_or_element_clang_type->Clear(); pointee_or_element_compiler_type->Clear();
if (!type) if (!type)
return 0; return 0;
GoType *t = static_cast<GoType *>(type); GoType *t = static_cast<GoType *>(type);
if (pointee_or_element_clang_type) if (pointee_or_element_compiler_type)
*pointee_or_element_clang_type = t->GetElementType(); *pointee_or_element_compiler_type = t->GetElementType();
int kind = t->GetGoKind(); int kind = t->GetGoKind();
if (kind == GoType::KIND_ARRAY) if (kind == GoType::KIND_ARRAY)
return eTypeHasChildren | eTypeIsArray; return eTypeHasChildren | eTypeIsArray;
if (kind < GoType::KIND_ARRAY) if (kind < GoType::KIND_ARRAY)
{ {
uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue; uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
if (kind < GoType::KIND_FLOAT32) if (kind < GoType::KIND_FLOAT32)
{ {
▲ Show 20 Lines • Show All 573 Lines • ▼ Show 20 LinesGoASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data,
{ {
return false; return false;
} }
else else
{ {
GoType *t = static_cast<GoType *>(type); GoType *t = static_cast<GoType *>(type);
if (t->IsTypedef()) if (t->IsTypedef())
{ {
CompilerType typedef_clang_type = t->GetElementType(); CompilerType typedef_compiler_type = t->GetElementType();
if (format == eFormatDefault) if (format == eFormatDefault)
format = typedef_clang_type.GetFormat(); format = typedef_compiler_type.GetFormat();
uint64_t typedef_byte_size = typedef_clang_type.GetByteSize(exe_scope); uint64_t typedef_byte_size = typedef_compiler_type.GetByteSize(exe_scope);
return typedef_clang_type.DumpTypeValue( return typedef_compiler_type.DumpTypeValue(
s, s,
format, // The format with which to display the element format, // The format with which to display the element
data, // Data buffer containing all bytes for this type data, // Data buffer containing all bytes for this type
byte_offset, // Offset into "data" where to grab value from byte_offset, // Offset into "data" where to grab value from
typedef_byte_size, // Size of this type in bytes typedef_byte_size, // Size of this type in bytes
bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield
bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_size != 0 bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_size != 0
exe_scope); exe_scope);
▲ Show 20 Lines • Show All 200 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Type.cpp

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines(
lldb::user_id_t uid, lldb::user_id_t uid,
SymbolFile* symbol_file, SymbolFile* symbol_file,
const ConstString &name, const ConstString &name,
uint64_t byte_size, uint64_t byte_size,
SymbolContextScope *context, SymbolContextScope *context,
user_id_t encoding_uid, user_id_t encoding_uid,
EncodingDataType encoding_uid_type, EncodingDataType encoding_uid_type,
const Declaration& decl, const Declaration& decl,
const CompilerType &clang_type, const CompilerType &compiler_type,
ResolveState clang_type_resolve_state ResolveState compiler_type_resolve_state
) : ) :
std::enable_shared_from_this<Type> (), std::enable_shared_from_this<Type> (),
UserID (uid), UserID (uid),
m_name (name), m_name (name),
m_symbol_file (symbol_file), m_symbol_file (symbol_file),
m_context (context), m_context (context),
m_encoding_type (nullptr), m_encoding_type (nullptr),
m_encoding_uid (encoding_uid), m_encoding_uid (encoding_uid),
m_encoding_uid_type (encoding_uid_type), m_encoding_uid_type (encoding_uid_type),
m_byte_size (byte_size), m_byte_size (byte_size),
m_decl (decl), m_decl (decl),
m_clang_type (clang_type) m_compiler_type (compiler_type)
{ {
m_flags.clang_type_resolve_state = (clang_type ? clang_type_resolve_state : eResolveStateUnresolved); m_flags.compiler_type_resolve_state = (compiler_type ? compiler_type_resolve_state : eResolveStateUnresolved);
m_flags.is_complete_objc_class = false; m_flags.is_complete_objc_class = false;
} }
Type::Type () : Type::Type () :
std::enable_shared_from_this<Type> (), std::enable_shared_from_this<Type> (),
UserID (0), UserID (0),
m_name ("<INVALID TYPE>"), m_name ("<INVALID TYPE>"),
m_symbol_file (nullptr), m_symbol_file (nullptr),
m_context (nullptr), m_context (nullptr),
m_encoding_type (nullptr), m_encoding_type (nullptr),
m_encoding_uid (LLDB_INVALID_UID), m_encoding_uid (LLDB_INVALID_UID),
m_encoding_uid_type (eEncodingInvalid), m_encoding_uid_type (eEncodingInvalid),
m_byte_size (0), m_byte_size (0),
m_decl (), m_decl (),
m_clang_type () m_compiler_type ()
{ {
m_flags.clang_type_resolve_state = eResolveStateUnresolved; m_flags.compiler_type_resolve_state = eResolveStateUnresolved;
m_flags.is_complete_objc_class = false; m_flags.is_complete_objc_class = false;
} }
Type::Type (const Type &rhs) : Type::Type (const Type &rhs) :
std::enable_shared_from_this<Type> (rhs), std::enable_shared_from_this<Type> (rhs),
UserID (rhs), UserID (rhs),
m_name (rhs.m_name), m_name (rhs.m_name),
m_symbol_file (rhs.m_symbol_file), m_symbol_file (rhs.m_symbol_file),
m_context (rhs.m_context), m_context (rhs.m_context),
m_encoding_type (rhs.m_encoding_type), m_encoding_type (rhs.m_encoding_type),
m_encoding_uid (rhs.m_encoding_uid), m_encoding_uid (rhs.m_encoding_uid),
m_encoding_uid_type (rhs.m_encoding_uid_type), m_encoding_uid_type (rhs.m_encoding_uid_type),
m_byte_size (rhs.m_byte_size), m_byte_size (rhs.m_byte_size),
m_decl (rhs.m_decl), m_decl (rhs.m_decl),
m_clang_type (rhs.m_clang_type), m_compiler_type (rhs.m_compiler_type),
m_flags (rhs.m_flags) m_flags (rhs.m_flags)
{ {
} }
const Type& const Type&
Type::operator= (const Type& rhs) Type::operator= (const Type& rhs)
{ {
if (this != &rhs) if (this != &rhs)
Show All 24 LinesType::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name)
} }
// Call the get byte size accesor so we resolve our byte size // Call the get byte size accesor so we resolve our byte size
if (GetByteSize()) if (GetByteSize())
s->Printf(", byte-size = %" PRIu64, m_byte_size); s->Printf(", byte-size = %" PRIu64, m_byte_size);
bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose); bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose);
m_decl.Dump(s, show_fullpaths); m_decl.Dump(s, show_fullpaths);
if (m_clang_type.IsValid()) if (m_compiler_type.IsValid())
{ {
*s << ", clang_type = \""; *s << ", compiler_type = \"";
GetForwardCompilerType ().DumpTypeDescription(s); GetForwardCompilerType ().DumpTypeDescription(s);
*s << '"'; *s << '"';
} }
else if (m_encoding_uid != LLDB_INVALID_UID) else if (m_encoding_uid != LLDB_INVALID_UID)
{ {
s->Printf(", type_uid = 0x%8.8" PRIx64, m_encoding_uid); s->Printf(", type_uid = 0x%8.8" PRIx64, m_encoding_uid);
switch (m_encoding_uid_type) switch (m_encoding_uid_type)
{ {
Show All 29 Lines if (show_context && m_context != nullptr)
s->PutCString(", context = ( "); s->PutCString(", context = ( ");
m_context->DumpSymbolContext(s); m_context->DumpSymbolContext(s);
s->PutCString(" )"); s->PutCString(" )");
} }
bool show_fullpaths = false; bool show_fullpaths = false;
m_decl.Dump (s,show_fullpaths); m_decl.Dump (s,show_fullpaths);
if (m_clang_type.IsValid()) if (m_compiler_type.IsValid())
{ {
*s << ", clang_type = " << m_clang_type.GetOpaqueQualType() << ' '; *s << ", compiler_type = " << m_compiler_type.GetOpaqueQualType() << ' ';
GetForwardCompilerType ().DumpTypeDescription (s); GetForwardCompilerType ().DumpTypeDescription (s);
} }
else if (m_encoding_uid != LLDB_INVALID_UID) else if (m_encoding_uid != LLDB_INVALID_UID)
{ {
*s << ", type_data = " << (uint64_t)m_encoding_uid; *s << ", type_data = " << (uint64_t)m_encoding_uid;
switch (m_encoding_uid_type) switch (m_encoding_uid_type)
{ {
case eEncodingInvalid: break; case eEncodingInvalid: break;
▲ Show 20 Lines • Show All 251 Lines • ▼ Show 20 Lines
const Declaration & const Declaration &
Type::GetDeclaration () const Type::GetDeclaration () const
{ {
return m_decl; return m_decl;
} }
bool bool
Type::ResolveClangType (ResolveState clang_type_resolve_state) Type::ResolveClangType (ResolveState compiler_type_resolve_state)
{ {
// TODO: This needs to consider the correct type system to use. // TODO: This needs to consider the correct type system to use.
Type *encoding_type = nullptr; Type *encoding_type = nullptr;
if (!m_clang_type.IsValid()) if (!m_compiler_type.IsValid())
{ {
encoding_type = GetEncodingType(); encoding_type = GetEncodingType();
if (encoding_type) if (encoding_type)
{ {
switch (m_encoding_uid_type) switch (m_encoding_uid_type)
{ {
case eEncodingIsUID: case eEncodingIsUID:
{ {
CompilerType encoding_clang_type = encoding_type->GetForwardCompilerType (); CompilerType encoding_compiler_type = encoding_type->GetForwardCompilerType ();
if (encoding_clang_type.IsValid()) if (encoding_compiler_type.IsValid())
{ {
m_clang_type = encoding_clang_type; m_compiler_type = encoding_compiler_type;
m_flags.clang_type_resolve_state = encoding_type->m_flags.clang_type_resolve_state; m_flags.compiler_type_resolve_state = encoding_type->m_flags.compiler_type_resolve_state;
} }
} }
break; break;
case eEncodingIsConstUID: case eEncodingIsConstUID:
m_clang_type = encoding_type->GetForwardCompilerType ().AddConstModifier(); m_compiler_type = encoding_type->GetForwardCompilerType ().AddConstModifier();
break; break;
case eEncodingIsRestrictUID: case eEncodingIsRestrictUID:
m_clang_type = encoding_type->GetForwardCompilerType ().AddRestrictModifier(); m_compiler_type = encoding_type->GetForwardCompilerType ().AddRestrictModifier();
break; break;
case eEncodingIsVolatileUID: case eEncodingIsVolatileUID:
m_clang_type = encoding_type->GetForwardCompilerType ().AddVolatileModifier(); m_compiler_type = encoding_type->GetForwardCompilerType ().AddVolatileModifier();
break; break;
case eEncodingIsTypedefUID: case eEncodingIsTypedefUID:
m_clang_type = encoding_type->GetForwardCompilerType ().CreateTypedef(GetName().AsCString(), m_compiler_type = encoding_type->GetForwardCompilerType ().CreateTypedef(GetName().AsCString(),
GetSymbolFile()->GetDeclContextContainingUID(GetID())); GetSymbolFile()->GetDeclContextContainingUID(GetID()));
m_name.Clear(); m_name.Clear();
break; break;
case eEncodingIsPointerUID: case eEncodingIsPointerUID:
m_clang_type = encoding_type->GetForwardCompilerType ().GetPointerType(); m_compiler_type = encoding_type->GetForwardCompilerType ().GetPointerType();
break; break;
case eEncodingIsLValueReferenceUID: case eEncodingIsLValueReferenceUID:
m_clang_type = encoding_type->GetForwardCompilerType ().GetLValueReferenceType(); m_compiler_type = encoding_type->GetForwardCompilerType ().GetLValueReferenceType();
break; break;
case eEncodingIsRValueReferenceUID: case eEncodingIsRValueReferenceUID:
m_clang_type = encoding_type->GetForwardCompilerType ().GetRValueReferenceType(); m_compiler_type = encoding_type->GetForwardCompilerType ().GetRValueReferenceType();
break; break;
default: default:
assert(!"Unhandled encoding_data_type."); assert(!"Unhandled encoding_data_type.");
break; break;
} }
} }
else else
{ {
// We have no encoding type, return void? // We have no encoding type, return void?
TypeSystem *type_system = m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC); TypeSystem *type_system = m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC);
CompilerType void_clang_type = type_system->GetBasicTypeFromAST(eBasicTypeVoid); CompilerType void_compiler_type = type_system->GetBasicTypeFromAST(eBasicTypeVoid);
switch (m_encoding_uid_type) switch (m_encoding_uid_type)
{ {
case eEncodingIsUID: case eEncodingIsUID:
m_clang_type = void_clang_type; m_compiler_type = void_compiler_type;
break; break;
case eEncodingIsConstUID: case eEncodingIsConstUID:
m_clang_type = void_clang_type.AddConstModifier(); m_compiler_type = void_compiler_type.AddConstModifier();
break; break;
case eEncodingIsRestrictUID: case eEncodingIsRestrictUID:
m_clang_type = void_clang_type.AddRestrictModifier(); m_compiler_type = void_compiler_type.AddRestrictModifier();
break; break;
case eEncodingIsVolatileUID: case eEncodingIsVolatileUID:
m_clang_type = void_clang_type.AddVolatileModifier(); m_compiler_type = void_compiler_type.AddVolatileModifier();
break; break;
case eEncodingIsTypedefUID: case eEncodingIsTypedefUID:
m_clang_type = void_clang_type.CreateTypedef(GetName().AsCString(), m_compiler_type = void_compiler_type.CreateTypedef(GetName().AsCString(),
GetSymbolFile()->GetDeclContextContainingUID(GetID())); GetSymbolFile()->GetDeclContextContainingUID(GetID()));
break; break;
case eEncodingIsPointerUID: case eEncodingIsPointerUID:
m_clang_type = void_clang_type.GetPointerType (); m_compiler_type = void_compiler_type.GetPointerType ();
break; break;
case eEncodingIsLValueReferenceUID: case eEncodingIsLValueReferenceUID:
m_clang_type = void_clang_type.GetLValueReferenceType(); m_compiler_type = void_compiler_type.GetLValueReferenceType();
break; break;
case eEncodingIsRValueReferenceUID: case eEncodingIsRValueReferenceUID:
m_clang_type = void_clang_type.GetRValueReferenceType(); m_compiler_type = void_compiler_type.GetRValueReferenceType();
break; break;
default: default:
assert(!"Unhandled encoding_data_type."); assert(!"Unhandled encoding_data_type.");
break; break;
} }
} }
// When we have a EncodingUID, our "m_flags.clang_type_resolve_state" is set to eResolveStateUnresolved // When we have a EncodingUID, our "m_flags.compiler_type_resolve_state" is set to eResolveStateUnresolved
// so we need to update it to say that we now have a forward declaration since that is what we created // so we need to update it to say that we now have a forward declaration since that is what we created
// above. // above.
if (m_clang_type.IsValid()) if (m_compiler_type.IsValid())
m_flags.clang_type_resolve_state = eResolveStateForward; m_flags.compiler_type_resolve_state = eResolveStateForward;
} }
// Check if we have a forward reference to a class/struct/union/enum? // Check if we have a forward reference to a class/struct/union/enum?
if (clang_type_resolve_state == eResolveStateLayout || clang_type_resolve_state == eResolveStateFull) if (compiler_type_resolve_state == eResolveStateLayout || compiler_type_resolve_state == eResolveStateFull)
{ {
// Check if we have a forward reference to a class/struct/union/enum? // Check if we have a forward reference to a class/struct/union/enum?
if (m_clang_type.IsValid() && m_flags.clang_type_resolve_state < clang_type_resolve_state) if (m_compiler_type.IsValid() && m_flags.compiler_type_resolve_state < compiler_type_resolve_state)
{ {
m_flags.clang_type_resolve_state = eResolveStateFull; m_flags.compiler_type_resolve_state = eResolveStateFull;
if (!m_clang_type.IsDefined ()) if (!m_compiler_type.IsDefined ())
{ {
// We have a forward declaration, we need to resolve it to a complete definition. // We have a forward declaration, we need to resolve it to a complete definition.
m_symbol_file->CompleteType (m_clang_type); m_symbol_file->CompleteType (m_compiler_type);
} }
} }
} }
// If we have an encoding type, then we need to make sure it is // If we have an encoding type, then we need to make sure it is
// resolved appropriately. // resolved appropriately.
if (m_encoding_uid != LLDB_INVALID_UID) if (m_encoding_uid != LLDB_INVALID_UID)
{ {
if (encoding_type == nullptr) if (encoding_type == nullptr)
encoding_type = GetEncodingType(); encoding_type = GetEncodingType();
if (encoding_type) if (encoding_type)
{ {
ResolveState encoding_clang_type_resolve_state = clang_type_resolve_state; ResolveState encoding_compiler_type_resolve_state = compiler_type_resolve_state;
if (clang_type_resolve_state == eResolveStateLayout) if (compiler_type_resolve_state == eResolveStateLayout)
{ {
switch (m_encoding_uid_type) switch (m_encoding_uid_type)
{ {
case eEncodingIsPointerUID: case eEncodingIsPointerUID:
case eEncodingIsLValueReferenceUID: case eEncodingIsLValueReferenceUID:
case eEncodingIsRValueReferenceUID: case eEncodingIsRValueReferenceUID:
encoding_clang_type_resolve_state = eResolveStateForward; encoding_compiler_type_resolve_state = eResolveStateForward;
break; break;
default: default:
break; break;
} }
} }
encoding_type->ResolveClangType (encoding_clang_type_resolve_state); encoding_type->ResolveClangType (encoding_compiler_type_resolve_state);
} }
} }
return m_clang_type.IsValid(); return m_compiler_type.IsValid();
} }
uint32_t uint32_t
Type::GetEncodingMask () Type::GetEncodingMask ()
{ {
uint32_t encoding_mask = 1u << m_encoding_uid_type; uint32_t encoding_mask = 1u << m_encoding_uid_type;
Type *encoding_type = GetEncodingType(); Type *encoding_type = GetEncodingType();
assert (encoding_type != this); assert (encoding_type != this);
if (encoding_type) if (encoding_type)
encoding_mask |= encoding_type->GetEncodingMask (); encoding_mask |= encoding_type->GetEncodingMask ();
return encoding_mask; return encoding_mask;
} }
CompilerType CompilerType
Type::GetFullCompilerType () Type::GetFullCompilerType ()
{ {
ResolveClangType(eResolveStateFull); ResolveClangType(eResolveStateFull);
return m_clang_type; return m_compiler_type;
} }
CompilerType CompilerType
Type::GetLayoutCompilerType () Type::GetLayoutCompilerType ()
{ {
ResolveClangType(eResolveStateLayout); ResolveClangType(eResolveStateLayout);
return m_clang_type; return m_compiler_type;
} }
CompilerType CompilerType
Type::GetForwardCompilerType () Type::GetForwardCompilerType ()
{ {
ResolveClangType (eResolveStateForward); ResolveClangType (eResolveStateForward);
return m_clang_type; return m_compiler_type;
} }
int int
Type::Compare(const Type &a, const Type &b) Type::Compare(const Type &a, const Type &b)
{ {
// Just compare the UID values for now... // Just compare the UID values for now...
lldb::user_id_t a_uid = a.GetID(); lldb::user_id_t a_uid = a.GetID();
lldb::user_id_t b_uid = b.GetID(); lldb::user_id_t b_uid = b.GetID();
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
TypeAndOrName::SetTypeSP (lldb::TypeSP type_sp) TypeAndOrName::SetTypeSP (lldb::TypeSP type_sp)
{ {
m_type_pair.SetType(type_sp); m_type_pair.SetType(type_sp);
if (m_type_pair) if (m_type_pair)
m_type_name = m_type_pair.GetName(); m_type_name = m_type_pair.GetName();
} }
void void
TypeAndOrName::SetCompilerType (CompilerType clang_type) TypeAndOrName::SetCompilerType (CompilerType compiler_type)
{ {
m_type_pair.SetType(clang_type); m_type_pair.SetType(compiler_type);
if (m_type_pair) if (m_type_pair)
m_type_name = m_type_pair.GetName(); m_type_name = m_type_pair.GetName();
} }
bool bool
TypeAndOrName::IsEmpty() const TypeAndOrName::IsEmpty() const
{ {
if ((bool)m_type_name || (bool)m_type_pair) if ((bool)m_type_name || (bool)m_type_pair)
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
TypeImpl::TypeImpl (const lldb::TypeSP &type_sp) : TypeImpl::TypeImpl (const lldb::TypeSP &type_sp) :
m_module_wp (), m_module_wp (),
m_static_type(), m_static_type(),
m_dynamic_type() m_dynamic_type()
{ {
SetType (type_sp); SetType (type_sp);
} }
TypeImpl::TypeImpl (const CompilerType &clang_type) : TypeImpl::TypeImpl (const CompilerType &compiler_type) :
m_module_wp (), m_module_wp (),
m_static_type(), m_static_type(),
m_dynamic_type() m_dynamic_type()
{ {
SetType (clang_type); SetType (compiler_type);
} }
TypeImpl::TypeImpl (const lldb::TypeSP &type_sp, const CompilerType &dynamic) : TypeImpl::TypeImpl (const lldb::TypeSP &type_sp, const CompilerType &dynamic) :
m_module_wp (), m_module_wp (),
m_static_type (type_sp), m_static_type (type_sp),
m_dynamic_type(dynamic) m_dynamic_type(dynamic)
{ {
SetType (type_sp, dynamic); SetType (type_sp, dynamic);
Show All 21 LinesTypeImpl::SetType (const lldb::TypeSP &type_sp)
m_static_type.SetType(type_sp); m_static_type.SetType(type_sp);
if (type_sp) if (type_sp)
m_module_wp = type_sp->GetModule(); m_module_wp = type_sp->GetModule();
else else
m_module_wp = lldb::ModuleWP(); m_module_wp = lldb::ModuleWP();
} }
void void
TypeImpl::SetType (const CompilerType &clang_type) TypeImpl::SetType (const CompilerType &compiler_type)
{ {
m_module_wp = lldb::ModuleWP(); m_module_wp = lldb::ModuleWP();
m_static_type.SetType (clang_type); m_static_type.SetType (compiler_type);
} }
void void
TypeImpl::SetType (const lldb::TypeSP &type_sp, const CompilerType &dynamic) TypeImpl::SetType (const lldb::TypeSP &type_sp, const CompilerType &dynamic)
{ {
SetType (type_sp); SetType (type_sp);
m_dynamic_type = dynamic; m_dynamic_type = dynamic;
} }
void void
TypeImpl::SetType (const CompilerType &clang_type, const CompilerType &dynamic) TypeImpl::SetType (const CompilerType &compiler_type, const CompilerType &dynamic)
{ {
m_module_wp = lldb::ModuleWP(); m_module_wp = lldb::ModuleWP();
m_static_type.SetType (clang_type); m_static_type.SetType (compiler_type);
m_dynamic_type = dynamic; m_dynamic_type = dynamic;
} }
void void
TypeImpl::SetType (const TypePair &pair, const CompilerType &dynamic) TypeImpl::SetType (const TypePair &pair, const CompilerType &dynamic)
{ {
m_module_wp = pair.GetModule(); m_module_wp = pair.GetModule();
m_static_type = pair; m_static_type = pair;
▲ Show 20 Lines • Show All 386 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Variable.cpp

Show First 20 Lines • Show All 578 Lines • ▼ Show 20 LinesVariable::DumpLocationForAddress (Stream *s, const Address &address)
return false; return false;
} }
static void static void
PrivateAutoComplete (StackFrame *frame, PrivateAutoComplete (StackFrame *frame,
const std::string &partial_path, const std::string &partial_path,
const std::string &prefix_path, // Anything that has been resolved already will be in here const std::string &prefix_path, // Anything that has been resolved already will be in here
const CompilerType& clang_type, const CompilerType& compiler_type,
StringList &matches, StringList &matches,
bool &word_complete); bool &word_complete);
static void static void
PrivateAutoCompleteMembers (StackFrame *frame, PrivateAutoCompleteMembers (StackFrame *frame,
const std::string &partial_member_name, const std::string &partial_member_name,
const std::string &partial_path, const std::string &partial_path,
const std::string &prefix_path, // Anything that has been resolved already will be in here const std::string &prefix_path, // Anything that has been resolved already will be in here
const CompilerType& clang_type, const CompilerType& compiler_type,
StringList &matches, StringList &matches,
bool &word_complete); bool &word_complete);
static void static void
PrivateAutoCompleteMembers (StackFrame *frame, PrivateAutoCompleteMembers (StackFrame *frame,
const std::string &partial_member_name, const std::string &partial_member_name,
const std::string &partial_path, const std::string &partial_path,
const std::string &prefix_path, // Anything that has been resolved already will be in here const std::string &prefix_path, // Anything that has been resolved already will be in here
const CompilerType& clang_type, const CompilerType& compiler_type,
StringList &matches, StringList &matches,
bool &word_complete) bool &word_complete)
{ {
// We are in a type parsing child members // We are in a type parsing child members
const uint32_t num_bases = clang_type.GetNumDirectBaseClasses(); const uint32_t num_bases = compiler_type.GetNumDirectBaseClasses();
if (num_bases > 0) if (num_bases > 0)
{ {
for (uint32_t i = 0; i < num_bases; ++i) for (uint32_t i = 0; i < num_bases; ++i)
{ {
CompilerType base_class_type = clang_type.GetDirectBaseClassAtIndex(i, nullptr); CompilerType base_class_type = compiler_type.GetDirectBaseClassAtIndex(i, nullptr);
PrivateAutoCompleteMembers (frame, PrivateAutoCompleteMembers (frame,
partial_member_name, partial_member_name,
partial_path, partial_path,
prefix_path, prefix_path,
base_class_type.GetCanonicalType(), base_class_type.GetCanonicalType(),
matches, matches,
word_complete); word_complete);
} }
} }
const uint32_t num_vbases = clang_type.GetNumVirtualBaseClasses(); const uint32_t num_vbases = compiler_type.GetNumVirtualBaseClasses();
if (num_vbases > 0) if (num_vbases > 0)
{ {
for (uint32_t i = 0; i < num_vbases; ++i) for (uint32_t i = 0; i < num_vbases; ++i)
{ {
CompilerType vbase_class_type = clang_type.GetVirtualBaseClassAtIndex(i,nullptr); CompilerType vbase_class_type = compiler_type.GetVirtualBaseClassAtIndex(i,nullptr);
PrivateAutoCompleteMembers (frame, PrivateAutoCompleteMembers (frame,
partial_member_name, partial_member_name,
partial_path, partial_path,
prefix_path, prefix_path,
vbase_class_type.GetCanonicalType(), vbase_class_type.GetCanonicalType(),
matches, matches,
word_complete); word_complete);
} }
} }
// We are in a type parsing child members // We are in a type parsing child members
const uint32_t num_fields = clang_type.GetNumFields(); const uint32_t num_fields = compiler_type.GetNumFields();
if (num_fields > 0) if (num_fields > 0)
{ {
for (uint32_t i = 0; i < num_fields; ++i) for (uint32_t i = 0; i < num_fields; ++i)
{ {
std::string member_name; std::string member_name;
CompilerType member_clang_type = clang_type.GetFieldAtIndex (i, member_name, nullptr, nullptr, nullptr); CompilerType member_compiler_type = compiler_type.GetFieldAtIndex (i, member_name, nullptr, nullptr, nullptr);
if (partial_member_name.empty() || if (partial_member_name.empty() ||
member_name.find(partial_member_name) == 0) member_name.find(partial_member_name) == 0)
{ {
if (member_name == partial_member_name) if (member_name == partial_member_name)
{ {
PrivateAutoComplete (frame, PrivateAutoComplete (frame,
partial_path, partial_path,
prefix_path + member_name, // Anything that has been resolved already will be in here prefix_path + member_name, // Anything that has been resolved already will be in here
member_clang_type.GetCanonicalType(), member_compiler_type.GetCanonicalType(),
matches, matches,
word_complete); word_complete);
} }
else else
{ {
matches.AppendString (prefix_path + member_name); matches.AppendString (prefix_path + member_name);
} }
} }
} }
} }
} }
static void static void
PrivateAutoComplete (StackFrame *frame, PrivateAutoComplete (StackFrame *frame,
const std::string &partial_path, const std::string &partial_path,
const std::string &prefix_path, // Anything that has been resolved already will be in here const std::string &prefix_path, // Anything that has been resolved already will be in here
const CompilerType& clang_type, const CompilerType& compiler_type,
StringList &matches, StringList &matches,
bool &word_complete) bool &word_complete)
{ {
// printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path = '%s'\n", prefix_path.c_str(), partial_path.c_str()); // printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path = '%s'\n", prefix_path.c_str(), partial_path.c_str());
std::string remaining_partial_path; std::string remaining_partial_path;
const lldb::TypeClass type_class = clang_type.GetTypeClass(); const lldb::TypeClass type_class = compiler_type.GetTypeClass();
if (partial_path.empty()) if (partial_path.empty())
{ {
if (clang_type.IsValid()) if (compiler_type.IsValid())
{ {
switch (type_class) switch (type_class)
{ {
default: default:
case eTypeClassArray: case eTypeClassArray:
case eTypeClassBlockPointer: case eTypeClassBlockPointer:
case eTypeClassBuiltin: case eTypeClassBuiltin:
case eTypeClassComplexFloat: case eTypeClassComplexFloat:
Show All 19 Lines if (partial_path.empty())
case eTypeClassObjCObject: case eTypeClassObjCObject:
case eTypeClassObjCInterface: case eTypeClassObjCInterface:
break; break;
case eTypeClassObjCObjectPointer: case eTypeClassObjCObjectPointer:
case eTypeClassPointer: case eTypeClassPointer:
{ {
bool omit_empty_base_classes = true; bool omit_empty_base_classes = true;
if (clang_type.GetNumChildren (omit_empty_base_classes) > 0) if (compiler_type.GetNumChildren (omit_empty_base_classes) > 0)
matches.AppendString (prefix_path + "->"); matches.AppendString (prefix_path + "->");
else else
{ {
matches.AppendString (prefix_path); matches.AppendString (prefix_path);
word_complete = true; word_complete = true;
} }
} }
break; break;
Show All 25 Lines else
switch (ch) switch (ch)
{ {
case '*': case '*':
if (prefix_path.empty()) if (prefix_path.empty())
{ {
PrivateAutoComplete (frame, PrivateAutoComplete (frame,
partial_path.substr(1), partial_path.substr(1),
std::string("*"), std::string("*"),
clang_type, compiler_type,
matches, matches,
word_complete); word_complete);
} }
break; break;
case '&': case '&':
if (prefix_path.empty()) if (prefix_path.empty())
{ {
PrivateAutoComplete (frame, PrivateAutoComplete (frame,
partial_path.substr(1), partial_path.substr(1),
std::string("&"), std::string("&"),
clang_type, compiler_type,
matches, matches,
word_complete); word_complete);
} }
break; break;
case '-': case '-':
if (partial_path[1] == '>' && !prefix_path.empty()) if (partial_path[1] == '>' && !prefix_path.empty())
{ {
switch (type_class) switch (type_class)
{ {
case lldb::eTypeClassPointer: case lldb::eTypeClassPointer:
{ {
CompilerType pointee_type(clang_type.GetPointeeType()); CompilerType pointee_type(compiler_type.GetPointeeType());
if (partial_path[2]) if (partial_path[2])
{ {
// If there is more after the "->", then search deeper // If there is more after the "->", then search deeper
PrivateAutoComplete (frame, PrivateAutoComplete (frame,
partial_path.substr(2), partial_path.substr(2),
prefix_path + "->", prefix_path + "->",
pointee_type.GetCanonicalType(), pointee_type.GetCanonicalType(),
matches, matches,
Show All 13 Lines else
} }
default: default:
break; break;
} }
} }
break; break;
case '.': case '.':
if (clang_type.IsValid()) if (compiler_type.IsValid())
{ {
switch (type_class) switch (type_class)
{ {
case lldb::eTypeClassUnion: case lldb::eTypeClassUnion:
case lldb::eTypeClassStruct: case lldb::eTypeClassStruct:
case lldb::eTypeClassClass: case lldb::eTypeClassClass:
if (partial_path[1]) if (partial_path[1])
{ {
// If there is more after the ".", then search deeper // If there is more after the ".", then search deeper
PrivateAutoComplete (frame, PrivateAutoComplete (frame,
partial_path.substr(1), partial_path.substr(1),
prefix_path + ".", prefix_path + ".",
clang_type, compiler_type,
matches, matches,
word_complete); word_complete);
} }
else else
{ {
// Nothing after the ".", so list all members // Nothing after the ".", so list all members
PrivateAutoCompleteMembers (frame, PrivateAutoCompleteMembers (frame,
std::string(), std::string(),
partial_path, partial_path,
prefix_path + ".", prefix_path + ".",
clang_type, compiler_type,
matches, matches,
word_complete); word_complete);
} }
default: default:
break; break;
} }
} }
break; break;
Show All 11 Lines else
continue; continue;
} }
break; break;
} }
std::string token(partial_path, 0, pos); std::string token(partial_path, 0, pos);
remaining_partial_path = partial_path.substr(pos); remaining_partial_path = partial_path.substr(pos);
if (clang_type.IsValid()) if (compiler_type.IsValid())
{ {
PrivateAutoCompleteMembers (frame, PrivateAutoCompleteMembers (frame,
token, token,
remaining_partial_path, remaining_partial_path,
prefix_path, prefix_path,
clang_type, compiler_type,
matches, matches,
word_complete); word_complete);
} }
else if (frame) else if (frame)
{ {
// We haven't found our variable yet // We haven't found our variable yet
const bool get_file_globals = true; const bool get_file_globals = true;
Show All 13 Lines else
const char *variable_name = variable->GetName().AsCString(); const char *variable_name = variable->GetName().AsCString();
if (strstr(variable_name, token.c_str()) == variable_name) if (strstr(variable_name, token.c_str()) == variable_name)
{ {
if (strcmp (variable_name, token.c_str()) == 0) if (strcmp (variable_name, token.c_str()) == 0)
{ {
Type *variable_type = variable->GetType(); Type *variable_type = variable->GetType();
if (variable_type) if (variable_type)
{ {
CompilerType variable_clang_type (variable_type->GetForwardCompilerType ()); CompilerType variable_compiler_type (variable_type->GetForwardCompilerType ());
PrivateAutoComplete (frame, PrivateAutoComplete (frame,
remaining_partial_path, remaining_partial_path,
prefix_path + token, // Anything that has been resolved already will be in here prefix_path + token, // Anything that has been resolved already will be in here
variable_clang_type.GetCanonicalType(), variable_compiler_type.GetCanonicalType(),
matches, matches,
word_complete); word_complete);
} }
else else
{ {
matches.AppendString (prefix_path + variable_name); matches.AppendString (prefix_path + variable_name);
} }
} }
Show All 16 Lines
Variable::AutoComplete (const ExecutionContext &exe_ctx, Variable::AutoComplete (const ExecutionContext &exe_ctx,
const char *partial_path_cstr, const char *partial_path_cstr,
StringList &matches, StringList &matches,
bool &word_complete) bool &word_complete)
{ {
word_complete = false; word_complete = false;
std::string partial_path; std::string partial_path;
std::string prefix_path; std::string prefix_path;
CompilerType clang_type; CompilerType compiler_type;
if (partial_path_cstr && partial_path_cstr[0]) if (partial_path_cstr && partial_path_cstr[0])
partial_path = partial_path_cstr; partial_path = partial_path_cstr;
PrivateAutoComplete (exe_ctx.GetFramePtr(), PrivateAutoComplete (exe_ctx.GetFramePtr(),
partial_path, partial_path,
prefix_path, prefix_path,
clang_type, compiler_type,
matches, matches,
word_complete); word_complete);
return matches.GetSize(); return matches.GetSize();
} }

lldb/trunk/source/Target/ObjCLanguageRuntime.cpp

Show First 20 Lines • Show All 362 Lines • ▼ Show 20 Lines
ObjCLanguageRuntime::EncodingToTypeSP ObjCLanguageRuntime::EncodingToTypeSP
ObjCLanguageRuntime::GetEncodingToType () ObjCLanguageRuntime::GetEncodingToType ()
{ {
return nullptr; return nullptr;
} }
bool bool
ObjCLanguageRuntime::GetTypeBitSize (const CompilerType& clang_type, ObjCLanguageRuntime::GetTypeBitSize (const CompilerType& compiler_type,
uint64_t &size) uint64_t &size)
{ {
void *opaque_ptr = clang_type.GetOpaqueQualType(); void *opaque_ptr = compiler_type.GetOpaqueQualType();
size = m_type_size_cache.Lookup(opaque_ptr); size = m_type_size_cache.Lookup(opaque_ptr);
// an ObjC object will at least have an ISA, so 0 is definitely not OK // an ObjC object will at least have an ISA, so 0 is definitely not OK
if (size > 0) if (size > 0)
return true; return true;
ClassDescriptorSP class_descriptor_sp = GetClassDescriptorFromClassName(clang_type.GetTypeName()); ClassDescriptorSP class_descriptor_sp = GetClassDescriptorFromClassName(compiler_type.GetTypeName());
if (!class_descriptor_sp) if (!class_descriptor_sp)
return false; return false;
int32_t max_offset = INT32_MIN; int32_t max_offset = INT32_MIN;
uint64_t sizeof_max = 0; uint64_t sizeof_max = 0;
bool found = false; bool found = false;
for (size_t idx = 0; for (size_t idx = 0;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ThreadPlanStepOut.cpp

Show First 20 Lines • Show All 527 Lines • ▼ Show 20 Lines
void void
ThreadPlanStepOut::CalculateReturnValue () ThreadPlanStepOut::CalculateReturnValue ()
{ {
if (m_return_valobj_sp) if (m_return_valobj_sp)
return; return;
if (m_immediate_step_from_function != NULL) if (m_immediate_step_from_function != NULL)
{ {
CompilerType return_clang_type = m_immediate_step_from_function->GetCompilerType().GetFunctionReturnType(); CompilerType return_compiler_type = m_immediate_step_from_function->GetCompilerType().GetFunctionReturnType();
if (return_clang_type) if (return_compiler_type)
{ {
lldb::ABISP abi_sp = m_thread.GetProcess()->GetABI(); lldb::ABISP abi_sp = m_thread.GetProcess()->GetABI();
if (abi_sp) if (abi_sp)
m_return_valobj_sp = abi_sp->GetReturnValueObject(m_thread, return_clang_type); m_return_valobj_sp = abi_sp->GetReturnValueObject(m_thread, return_compiler_type);
} }
} }
} }
bool bool
ThreadPlanStepOut::IsPlanStale() ThreadPlanStepOut::IsPlanStale()
{ {
// If we are still lower on the stack than the frame we are returning to, then // If we are still lower on the stack than the frame we are returning to, then
// there's something for us to do. Otherwise, we're stale. // there's something for us to do. Otherwise, we're stale.
StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID(); StackID frame_zero_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
if (frame_zero_id < m_step_out_to_id) if (frame_zero_id < m_step_out_to_id)
return false; return false;
else else
return true; return true;
} }

lldb/trunk/test/lang/objc/foundation/TestObjCMethods.py

Show First 20 Lines • Show All 183 Lines • ▼ Show 20 Lines# startstr = "Breakpoint created: 1: name = '-[MyString description]', locations = 1")
# The backtrace should show we stop at -[MyString description]. # The backtrace should show we stop at -[MyString description].
self.expect("thread backtrace", "Stop at -[MyString description]", self.expect("thread backtrace", "Stop at -[MyString description]",
substrs = ["a.out`-[MyString description]"]) substrs = ["a.out`-[MyString description]"])
# Lookup objc data type MyString and evaluate some expressions. # Lookup objc data type MyString and evaluate some expressions.
self.expect("image lookup -t NSString", DATA_TYPES_DISPLAYED_CORRECTLY, self.expect("image lookup -t NSString", DATA_TYPES_DISPLAYED_CORRECTLY,
substrs = ['name = "NSString"', substrs = ['name = "NSString"',
'clang_type = "@interface NSString']) 'compiler_type = "@interface NSString'])
self.expect("image lookup -t MyString", DATA_TYPES_DISPLAYED_CORRECTLY, self.expect("image lookup -t MyString", DATA_TYPES_DISPLAYED_CORRECTLY,
substrs = ['name = "MyString"', substrs = ['name = "MyString"',
'clang_type = "@interface MyString', 'compiler_type = "@interface MyString',
'NSString * str;', 'NSString * str;',
'NSDate * date;']) 'NSDate * date;'])
self.expect("frame variable --show-types --scope", VARIABLES_DISPLAYED_CORRECTLY, self.expect("frame variable --show-types --scope", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["ARG: (MyString *) self"], substrs = ["ARG: (MyString *) self"],
patterns = ["ARG: \(.*\) _cmd", patterns = ["ARG: \(.*\) _cmd",
"(objc_selector *)|(SEL)"]) "(objc_selector *)|(SEL)"])
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

lldb/trunk/www/symbolication.html

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines</tt></pre></code>
you can get verbose information which can often include the locations you can get verbose information which can often include the locations
of some of your local variables: of some of your local variables:
<code><pre><tt>><b>(lldb)</b> image lookup --address 0x100123aa3 --verbose <code><pre><tt>><b>(lldb)</b> image lookup --address 0x100123aa3 --verbose
Address: a.out[0x0000000100000aa3] (a.out.__TEXT.__text + 110) Address: a.out[0x0000000100000aa3] (a.out.__TEXT.__text + 110)
Summary: a.out`main + 50 at main.c:13 Summary: a.out`main + 50 at main.c:13
Module: file = "/tmp/a.out", arch = "x86_64" Module: file = "/tmp/a.out", arch = "x86_64"
CompileUnit: id = {0x00000000}, file = "/tmp/main.c", language = "ISO C:1999" CompileUnit: id = {0x00000000}, file = "/tmp/main.c", language = "ISO C:1999"
Function: id = {0x0000004f}, name = "main", range = [0x0000000100000bc0-0x0000000100000dc9) Function: id = {0x0000004f}, name = "main", range = [0x0000000100000bc0-0x0000000100000dc9)
FuncType: id = {0x0000004f}, decl = main.c:9, clang_type = "int (int, const char **, const char **, const char **)" FuncType: id = {0x0000004f}, decl = main.c:9, compiler_type = "int (int, const char **, const char **, const char **)"
Blocks: id = {0x0000004f}, range = [0x100000bc0-0x100000dc9) Blocks: id = {0x0000004f}, range = [0x100000bc0-0x100000dc9)
id = {0x000000ae}, range = [0x100000bf2-0x100000dc4) id = {0x000000ae}, range = [0x100000bf2-0x100000dc4)
LineEntry: [0x0000000100000bf2-0x0000000100000bfa): /tmp/main.c:13:23 LineEntry: [0x0000000100000bf2-0x0000000100000bfa): /tmp/main.c:13:23
Symbol: id = {0x00000004}, range = [0x0000000100000bc0-0x0000000100000dc9), name="main" Symbol: id = {0x00000004}, range = [0x0000000100000bc0-0x0000000100000dc9), name="main"
Variable: id = {0x000000bf}, name = "path", type= "char [1024]", location = DW_OP_fbreg(-1072), decl = main.c:28 Variable: id = {0x000000bf}, name = "path", type= "char [1024]", location = DW_OP_fbreg(-1072), decl = main.c:28
Variable: id = {0x00000072}, name = "argc", type= "int", <b>location = r13</b>, decl = main.c:8 Variable: id = {0x00000072}, name = "argc", type= "int", <b>location = r13</b>, decl = main.c:8
Variable: id = {0x00000081}, name = "argv", type= "const char **", <b>location = r12</b>, decl = main.c:8 Variable: id = {0x00000081}, name = "argv", type= "const char **", <b>location = r12</b>, decl = main.c:8
Variable: id = {0x00000090}, name = "envp", type= "const char **", <b>location = r15</b>, decl = main.c:8 Variable: id = {0x00000090}, name = "envp", type= "const char **", <b>location = r15</b>, decl = main.c:8
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines