Index: lldb/trunk/include/lldb/Symbol/ClangASTContext.h =================================================================== --- lldb/trunk/include/lldb/Symbol/ClangASTContext.h +++ lldb/trunk/include/lldb/Symbol/ClangASTContext.h @@ -586,60 +586,60 @@ //---------------------------------------------------------------------- bool - IsArrayType (void *type, + IsArrayType (lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) override; bool - IsVectorType (void *type, + IsVectorType (lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) override; bool - IsAggregateType (void *type) override; + IsAggregateType (lldb::opaque_compiler_type_t type) override; bool - IsBeingDefined (void *type) override; + IsBeingDefined (lldb::opaque_compiler_type_t type) override; bool - IsCharType (void *type) override; + IsCharType (lldb::opaque_compiler_type_t type) override; bool - IsCompleteType (void *type) override; + IsCompleteType (lldb::opaque_compiler_type_t type) override; bool - IsConst(void *type) override; + IsConst(lldb::opaque_compiler_type_t type) override; bool - IsCStringType (void *type, uint32_t &length) override; + IsCStringType (lldb::opaque_compiler_type_t type, uint32_t &length) override; static bool IsCXXClassType (const CompilerType& type); bool - IsDefined(void *type) override; + IsDefined(lldb::opaque_compiler_type_t type) override; bool - IsFloatingPointType (void *type, uint32_t &count, bool &is_complex) override; + IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) override; bool - IsFunctionType (void *type, bool *is_variadic_ptr) override; + IsFunctionType (lldb::opaque_compiler_type_t type, bool *is_variadic_ptr) override; uint32_t - IsHomogeneousAggregate (void *type, CompilerType* base_type_ptr) override; + IsHomogeneousAggregate (lldb::opaque_compiler_type_t type, CompilerType* base_type_ptr) override; size_t - GetNumberOfFunctionArguments (void *type) override; + GetNumberOfFunctionArguments (lldb::opaque_compiler_type_t type) override; CompilerType - GetFunctionArgumentAtIndex (void *type, const size_t index) override; + GetFunctionArgumentAtIndex (lldb::opaque_compiler_type_t type, const size_t index) override; bool - IsFunctionPointerType (void *type) override; + IsFunctionPointerType (lldb::opaque_compiler_type_t type) override; bool - IsIntegerType (void *type, bool &is_signed) override; + IsIntegerType (lldb::opaque_compiler_type_t type, bool &is_signed) override; static bool IsObjCClassType (const CompilerType& type); @@ -654,34 +654,34 @@ IsObjCObjectPointerType (const CompilerType& type, CompilerType *target_type = NULL); bool - IsPolymorphicClass (void *type) override; + IsPolymorphicClass (lldb::opaque_compiler_type_t type) override; bool - IsPossibleDynamicType (void *type, + IsPossibleDynamicType (lldb::opaque_compiler_type_t type, CompilerType *target_type, // Can pass NULL bool check_cplusplus, bool check_objc) override; bool - IsRuntimeGeneratedType (void *type) override; + IsRuntimeGeneratedType (lldb::opaque_compiler_type_t type) override; bool - IsPointerType (void *type, CompilerType *pointee_type) override; + IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) override; bool - IsPointerOrReferenceType (void *type, CompilerType *pointee_type) override; + IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) override; bool - IsReferenceType (void *type, CompilerType *pointee_type, bool* is_rvalue) override; + IsReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool* is_rvalue) override; bool - IsScalarType (void *type) override; + IsScalarType (lldb::opaque_compiler_type_t type) override; bool - IsTypedefType (void *type) override; + IsTypedefType (lldb::opaque_compiler_type_t type) override; bool - IsVoidType (void *type) override; + IsVoidType (lldb::opaque_compiler_type_t type) override; bool SupportsLanguage (lldb::LanguageType language) override; @@ -697,26 +697,26 @@ //---------------------------------------------------------------------- bool - GetCompleteType (void *type) override; + GetCompleteType (lldb::opaque_compiler_type_t type) override; //---------------------------------------------------------------------- // Accessors //---------------------------------------------------------------------- ConstString - GetTypeName (void *type) override; + GetTypeName (lldb::opaque_compiler_type_t type) override; uint32_t - GetTypeInfo (void *type, CompilerType *pointee_or_element_clang_type) override; + GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) override; lldb::LanguageType - GetMinimumLanguage (void *type) override; + GetMinimumLanguage (lldb::opaque_compiler_type_t type) override; lldb::TypeClass - GetTypeClass (void *type) override; + GetTypeClass (lldb::opaque_compiler_type_t type) override; unsigned - GetTypeQualifiers(void *type) override; + GetTypeQualifiers(lldb::opaque_compiler_type_t type) override; //---------------------------------------------------------------------- // Creating related types @@ -730,61 +730,61 @@ const CompilerDeclContext &compiler_decl_ctx); CompilerType - GetArrayElementType (void *type, uint64_t *stride) override; + GetArrayElementType (lldb::opaque_compiler_type_t type, uint64_t *stride) override; CompilerType - GetCanonicalType (void *type) override; + GetCanonicalType (lldb::opaque_compiler_type_t type) override; CompilerType - GetFullyUnqualifiedType (void *type) override; + GetFullyUnqualifiedType (lldb::opaque_compiler_type_t type) override; // Returns -1 if this isn't a function of if the function doesn't have a prototype // Returns a value >= 0 if there is a prototype. int - GetFunctionArgumentCount (void *type) override; + GetFunctionArgumentCount (lldb::opaque_compiler_type_t type) override; CompilerType - GetFunctionArgumentTypeAtIndex (void *type, size_t idx) override; + GetFunctionArgumentTypeAtIndex (lldb::opaque_compiler_type_t type, size_t idx) override; CompilerType - GetFunctionReturnType (void *type) override; + GetFunctionReturnType (lldb::opaque_compiler_type_t type) override; size_t - GetNumMemberFunctions (void *type) override; + GetNumMemberFunctions (lldb::opaque_compiler_type_t type) override; TypeMemberFunctionImpl - GetMemberFunctionAtIndex (void *type, size_t idx) override; + GetMemberFunctionAtIndex (lldb::opaque_compiler_type_t type, size_t idx) override; CompilerType - GetNonReferenceType (void *type) override; + GetNonReferenceType (lldb::opaque_compiler_type_t type) override; CompilerType - GetPointeeType (void *type) override; + GetPointeeType (lldb::opaque_compiler_type_t type) override; CompilerType - GetPointerType (void *type) override; + GetPointerType (lldb::opaque_compiler_type_t type) override; CompilerType - GetLValueReferenceType (void *type) override; + GetLValueReferenceType (lldb::opaque_compiler_type_t type) override; CompilerType - GetRValueReferenceType (void *type) override; + GetRValueReferenceType (lldb::opaque_compiler_type_t type) override; CompilerType - AddConstModifier (void *type) override; + AddConstModifier (lldb::opaque_compiler_type_t type) override; CompilerType - AddVolatileModifier (void *type) override; + AddVolatileModifier (lldb::opaque_compiler_type_t type) override; CompilerType - AddRestrictModifier (void *type) override; + AddRestrictModifier (lldb::opaque_compiler_type_t type) override; CompilerType - CreateTypedef (void *type, const char *name, const CompilerDeclContext &decl_ctx) override; + CreateTypedef (lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx) override; // If the current object represents a typedef type, get the underlying type CompilerType - GetTypedefedType (void *type) override; + GetTypedefedType (lldb::opaque_compiler_type_t type) override; static CompilerType RemoveFastQualifiers (const CompilerType& type); @@ -800,43 +800,43 @@ //---------------------------------------------------------------------- uint64_t - GetByteSize (void *type, ExecutionContextScope *exe_scope) + GetByteSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) { return (GetBitSize (type, exe_scope) + 7) / 8; } uint64_t - GetBitSize (void *type, ExecutionContextScope *exe_scope) override; + GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override; lldb::Encoding - GetEncoding (void *type, uint64_t &count) override; + GetEncoding (lldb::opaque_compiler_type_t type, uint64_t &count) override; lldb::Format - GetFormat (void *type) override; + GetFormat (lldb::opaque_compiler_type_t type) override; size_t - GetTypeBitAlign (void *type) override; + GetTypeBitAlign (lldb::opaque_compiler_type_t type) override; uint32_t - GetNumChildren (void *type, bool omit_empty_base_classes) override; + GetNumChildren (lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) override; CompilerType GetBuiltinTypeByName (const ConstString &name) override; lldb::BasicType - GetBasicTypeEnumeration (void *type) override; + GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type) override; static lldb::BasicType - GetBasicTypeEnumeration (void *type, const ConstString &name); + GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type, const ConstString &name); void - ForEachEnumerator (void *type, std::function const &callback) override; + ForEachEnumerator (lldb::opaque_compiler_type_t type, std::function const &callback) override; uint32_t - GetNumFields (void *type) override; + GetNumFields (lldb::opaque_compiler_type_t type) override; CompilerType - GetFieldAtIndex (void *type, + GetFieldAtIndex (lldb::opaque_compiler_type_t type, size_t idx, std::string& name, uint64_t *bit_offset_ptr, @@ -844,18 +844,18 @@ bool *is_bitfield_ptr) override; uint32_t - GetNumDirectBaseClasses (void *type) override; + GetNumDirectBaseClasses (lldb::opaque_compiler_type_t type) override; uint32_t - GetNumVirtualBaseClasses (void *type) override; + GetNumVirtualBaseClasses (lldb::opaque_compiler_type_t type) override; CompilerType - GetDirectBaseClassAtIndex (void *type, + GetDirectBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override; CompilerType - GetVirtualBaseClassAtIndex (void *type, + GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override; @@ -863,7 +863,7 @@ GetNumPointeeChildren (clang::QualType type); CompilerType - GetChildCompilerTypeAtIndex (void *type, + GetChildCompilerTypeAtIndex (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, @@ -881,7 +881,7 @@ // Lookup a child given a name. This function will match base class names // and member member names in "clang_type" only, not descendants. uint32_t - GetIndexOfChildWithName (void *type, + GetIndexOfChildWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) override; @@ -891,16 +891,16 @@ // TODO: Return all matches for a given name by returning a vector> // so we catch all names that match a given child name, not just the first. size_t - GetIndexOfChildMemberWithName (void *type, + GetIndexOfChildMemberWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes, std::vector& child_indexes) override; size_t - GetNumTemplateArguments (void *type) override; + GetNumTemplateArguments (lldb::opaque_compiler_type_t type) override; CompilerType - GetTemplateArgument (void *type, + GetTemplateArgument (lldb::opaque_compiler_type_t type, size_t idx, lldb::TemplateArgumentKind &kind) override; @@ -927,7 +927,7 @@ lldb::AccessType access); clang::CXXMethodDecl * - AddMethodToCXXRecordType (void *type, + AddMethodToCXXRecordType (lldb::opaque_compiler_type_t type, const char *name, const CompilerType &method_type, lldb::AccessType access, @@ -940,7 +940,7 @@ // C++ Base Classes clang::CXXBaseSpecifier * - CreateBaseClassSpecifier (void *type, + CreateBaseClassSpecifier (lldb::opaque_compiler_type_t type, lldb::AccessType access, bool is_virtual, bool base_of_class); @@ -950,7 +950,7 @@ unsigned num_base_classes); bool - SetBaseClassesForClassType (void *type, + SetBaseClassesForClassType (lldb::opaque_compiler_type_t type, clang::CXXBaseSpecifier const * const *base_classes, unsigned num_base_classes); @@ -970,13 +970,13 @@ static clang::ObjCMethodDecl * AddMethodToObjCObjectType (const CompilerType& type, - const char *name, // the full symbol name as seen in the symbol table (void *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, lldb::AccessType access, bool is_artificial); bool - SetHasExternalStorage (void *type, bool has_extern); + SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern); //------------------------------------------------------------------ @@ -992,7 +992,7 @@ // Modifying Enumeration types //---------------------------------------------------------------------- bool - AddEnumerationValueToEnumerationType (void *type, + AddEnumerationValueToEnumerationType (lldb::opaque_compiler_type_t type, const CompilerType &enumerator_qual_type, const Declaration &decl, const char *name, @@ -1002,7 +1002,7 @@ CompilerType - GetEnumerationIntegerType (void *type); + GetEnumerationIntegerType (lldb::opaque_compiler_type_t type); //------------------------------------------------------------------ // Pointers & References @@ -1017,7 +1017,7 @@ // Converts "s" to a floating point value and place resulting floating // point bytes in the "dst" buffer. size_t - ConvertStringToFloatValue (void *type, + ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) override; @@ -1025,7 +1025,7 @@ // Dumping types //---------------------------------------------------------------------- void - DumpValue (void *type, + DumpValue (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format, @@ -1040,7 +1040,7 @@ uint32_t depth) override; bool - DumpTypeValue (void *type, + DumpTypeValue (lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data, @@ -1051,7 +1051,7 @@ ExecutionContextScope *exe_scope) override; void - DumpSummary (void *type, + DumpSummary (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data, @@ -1059,10 +1059,10 @@ size_t data_byte_size) override; virtual void - DumpTypeDescription (void *type) override; // Dump to stdout + DumpTypeDescription (lldb::opaque_compiler_type_t type) override; // Dump to stdout void - DumpTypeDescription (void *type, Stream *s) override; + DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s) override; static clang::EnumDecl * GetAsEnumDecl (const CompilerType& type); @@ -1071,7 +1071,7 @@ GetAsRecordDecl (const CompilerType& type); clang::CXXRecordDecl * - GetAsCXXRecordDecl (void *type); + GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type); static clang::ObjCInterfaceDecl * GetAsObjCInterfaceDecl (const CompilerType& type); @@ -1116,7 +1116,7 @@ CreateVariableDeclaration (clang::DeclContext *decl_context, const char *name, clang::QualType type); protected: static clang::QualType - GetQualType (void *type) + GetQualType (lldb::opaque_compiler_type_t type) { if (type) return clang::QualType::getFromOpaquePtr(type); @@ -1124,7 +1124,7 @@ } static clang::QualType - GetCanonicalQualType (void *type) + GetCanonicalQualType (lldb::opaque_compiler_type_t type) { if (type) return clang::QualType::getFromOpaquePtr(type).getCanonicalType(); Index: lldb/trunk/include/lldb/Symbol/CompilerType.h =================================================================== --- lldb/trunk/include/lldb/Symbol/CompilerType.h +++ lldb/trunk/include/lldb/Symbol/CompilerType.h @@ -34,7 +34,7 @@ //---------------------------------------------------------------------- // Constructors and Destructors //---------------------------------------------------------------------- - CompilerType (TypeSystem *type_system, void *type); + CompilerType (TypeSystem *type_system, lldb::opaque_compiler_type_t type); CompilerType (clang::ASTContext *ast_context, clang::QualType qual_type); CompilerType (const CompilerType &rhs) : @@ -225,7 +225,7 @@ lldb::LanguageType GetMinimumLanguage (); - void * + lldb::opaque_compiler_type_t GetOpaqueQualType() const { return m_type; @@ -235,7 +235,7 @@ GetTypeClass () const; void - SetCompilerType (TypeSystem* type_system, void* type); + SetCompilerType (TypeSystem* type_system, lldb::opaque_compiler_type_t type); void SetCompilerType (clang::ASTContext *ast, clang::QualType qual_type); @@ -535,7 +535,7 @@ m_type_system = NULL; } private: - void* m_type; + lldb::opaque_compiler_type_t m_type; TypeSystem *m_type_system; }; Index: lldb/trunk/include/lldb/Symbol/GoASTContext.h =================================================================== --- lldb/trunk/include/lldb/Symbol/GoASTContext.h +++ lldb/trunk/include/lldb/Symbol/GoASTContext.h @@ -146,37 +146,37 @@ static bool IsDirectIface(uint8_t kind); static bool IsPointerKind(uint8_t kind); - bool IsArrayType(void *type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) override; + bool IsArrayType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) override; - bool IsAggregateType(void *type) override; + bool IsAggregateType(lldb::opaque_compiler_type_t type) override; - bool IsCharType(void *type) override; + bool IsCharType(lldb::opaque_compiler_type_t type) override; - bool IsCompleteType(void *type) override; + bool IsCompleteType(lldb::opaque_compiler_type_t type) override; - bool IsDefined(void *type) override; + bool IsDefined(lldb::opaque_compiler_type_t type) override; - bool IsFloatingPointType(void *type, uint32_t &count, bool &is_complex) override; + bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) override; - bool IsFunctionType(void *type, bool *is_variadic_ptr = NULL) override; + bool IsFunctionType(lldb::opaque_compiler_type_t type, bool *is_variadic_ptr = NULL) override; - size_t GetNumberOfFunctionArguments(void *type) override; + size_t GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override; - CompilerType GetFunctionArgumentAtIndex(void *type, const size_t index) override; + CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, const size_t index) override; - bool IsFunctionPointerType(void *type) override; + bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override; - bool IsIntegerType(void *type, bool &is_signed) override; + bool IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed) override; - bool IsPossibleDynamicType(void *type, + bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type, CompilerType *target_type, // Can pass NULL bool check_cplusplus, bool check_objc) override; - bool IsPointerType(void *type, CompilerType *pointee_type = NULL) override; + bool IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = NULL) override; - bool IsScalarType(void *type) override; + bool IsScalarType(lldb::opaque_compiler_type_t type) override; - bool IsVoidType(void *type) override; + bool IsVoidType(lldb::opaque_compiler_type_t type) override; bool SupportsLanguage (lldb::LanguageType language) override; @@ -184,7 +184,7 @@ // Type Completion //---------------------------------------------------------------------- - virtual bool GetCompleteType(void *type) override; + virtual bool GetCompleteType(lldb::opaque_compiler_type_t type) override; //---------------------------------------------------------------------- // AST related queries @@ -196,85 +196,85 @@ // Accessors //---------------------------------------------------------------------- - virtual ConstString GetTypeName(void *type) override; + virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type) override; - virtual uint32_t GetTypeInfo(void *type, CompilerType *pointee_or_element_clang_type = NULL) override; + virtual uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type = NULL) override; - virtual lldb::LanguageType GetMinimumLanguage(void *type) override; + virtual lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type) override; - virtual lldb::TypeClass GetTypeClass(void *type) override; + virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override; //---------------------------------------------------------------------- // Creating related types //---------------------------------------------------------------------- - virtual CompilerType GetArrayElementType(void *type, uint64_t *stride = nullptr) override; + virtual CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride = nullptr) override; - virtual CompilerType GetCanonicalType(void *type) override; + virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override; // Returns -1 if this isn't a function of if the function doesn't have a prototype // Returns a value >= 0 if there is a prototype. - virtual int GetFunctionArgumentCount(void *type) override; + virtual int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override; - virtual CompilerType GetFunctionArgumentTypeAtIndex(void *type, size_t idx) override; + virtual CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override; - virtual CompilerType GetFunctionReturnType(void *type) override; + virtual CompilerType GetFunctionReturnType(lldb::opaque_compiler_type_t type) override; - virtual size_t GetNumMemberFunctions(void *type) override; + virtual size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override; - virtual TypeMemberFunctionImpl GetMemberFunctionAtIndex(void *type, size_t idx) override; + virtual TypeMemberFunctionImpl GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override; - virtual CompilerType GetPointeeType(void *type) override; + virtual CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override; - virtual CompilerType GetPointerType(void *type) override; + virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override; //---------------------------------------------------------------------- // Exploring the type //---------------------------------------------------------------------- - virtual uint64_t GetBitSize(void *type, ExecutionContextScope *exe_scope) override; + virtual uint64_t GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override; - virtual lldb::Encoding GetEncoding(void *type, uint64_t &count) override; + virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count) override; - virtual lldb::Format GetFormat(void *type) override; + virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override; - virtual uint32_t GetNumChildren(void *type, bool omit_empty_base_classes) override; + virtual uint32_t GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) override; - virtual lldb::BasicType GetBasicTypeEnumeration(void *type) override; + virtual lldb::BasicType GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override; virtual CompilerType GetBuiltinTypeForEncodingAndBitSize (lldb::Encoding encoding, size_t bit_size) override; - virtual uint32_t GetNumFields(void *type) override; + virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override; - virtual CompilerType GetFieldAtIndex(void *type, size_t idx, std::string &name, uint64_t *bit_offset_ptr, + virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) override; virtual uint32_t - GetNumDirectBaseClasses(void *type) override + GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override { return 0; } virtual uint32_t - GetNumVirtualBaseClasses(void *type) override + GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override { return 0; } virtual CompilerType - GetDirectBaseClassAtIndex(void *type, size_t idx, uint32_t *bit_offset_ptr) override + GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override { return CompilerType(); } virtual CompilerType - GetVirtualBaseClassAtIndex(void *type, size_t idx, uint32_t *bit_offset_ptr) override + GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override { return CompilerType(); } - virtual CompilerType GetChildCompilerTypeAtIndex(void *type, ExecutionContext *exe_ctx, size_t idx, + virtual CompilerType GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, bool omit_empty_base_classes, bool ignore_array_bounds, std::string &child_name, uint32_t &child_byte_size, int32_t &child_byte_offset, @@ -284,24 +284,24 @@ // Lookup a child given a name. This function will match base class names // and member member names in "clang_type" only, not descendants. - virtual uint32_t GetIndexOfChildWithName(void *type, const char *name, bool omit_empty_base_classes) override; + virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) override; // Lookup a child member given a name. This function will match member names // only and will descend into "clang_type" children in search for the first // member in this class, or any base class that matches "name". // TODO: Return all matches for a given name by returning a vector> // so we catch all names that match a given child name, not just the first. - virtual size_t GetIndexOfChildMemberWithName(void *type, const char *name, bool omit_empty_base_classes, + virtual size_t GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes, std::vector &child_indexes) override; virtual size_t - GetNumTemplateArguments(void *type) override + GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override { return 0; } virtual CompilerType - GetTemplateArgument(void *type, size_t idx, lldb::TemplateArgumentKind &kind) override + GetTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, lldb::TemplateArgumentKind &kind) override { return CompilerType(); } @@ -309,66 +309,66 @@ //---------------------------------------------------------------------- // Dumping types //---------------------------------------------------------------------- - virtual void DumpValue(void *type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format, + virtual void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, bool show_summary, bool verbose, uint32_t depth) override; - virtual bool DumpTypeValue(void *type, Stream *s, lldb::Format format, const DataExtractor &data, + virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope) override; - virtual void DumpTypeDescription(void *type) override; // Dump to stdout + virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type) override; // Dump to stdout - virtual void DumpTypeDescription(void *type, Stream *s) override; + virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s) override; //---------------------------------------------------------------------- // TODO: These methods appear unused. Should they be removed? //---------------------------------------------------------------------- - virtual bool IsRuntimeGeneratedType(void *type) override; + virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override; - virtual void DumpSummary(void *type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data, + virtual void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size) override; // Converts "s" to a floating point value and place resulting floating // point bytes in the "dst" buffer. - virtual size_t ConvertStringToFloatValue(void *type, const char *s, uint8_t *dst, size_t dst_size) override; + virtual size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) override; //---------------------------------------------------------------------- // TODO: Determine if these methods should move to ClangASTContext. //---------------------------------------------------------------------- - virtual bool IsPointerOrReferenceType(void *type, CompilerType *pointee_type = NULL) override; + virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = NULL) override; - virtual unsigned GetTypeQualifiers(void *type) override; + virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override; - virtual bool IsCStringType(void *type, uint32_t &length) override; + virtual bool IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length) override; - virtual size_t GetTypeBitAlign(void *type) override; + virtual size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override; virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override; - virtual bool IsBeingDefined(void *type) override; + virtual bool IsBeingDefined(lldb::opaque_compiler_type_t type) override; - virtual bool IsConst(void *type) override; + virtual bool IsConst(lldb::opaque_compiler_type_t type) override; - virtual uint32_t IsHomogeneousAggregate(void *type, CompilerType *base_type_ptr) override; + virtual uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr) override; - virtual bool IsPolymorphicClass(void *type) override; + virtual bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override; - virtual bool IsTypedefType(void *type) override; + virtual bool IsTypedefType(lldb::opaque_compiler_type_t type) override; // If the current object represents a typedef type, get the underlying type - virtual CompilerType GetTypedefedType(void *type) override; + virtual CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override; - virtual bool IsVectorType(void *type, CompilerType *element_type, uint64_t *size) override; + virtual bool IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) override; - virtual CompilerType GetFullyUnqualifiedType(void *type) override; + virtual CompilerType GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override; - virtual CompilerType GetNonReferenceType(void *type) override; + virtual CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override; - virtual bool IsReferenceType(void *type, CompilerType *pointee_type = nullptr, bool *is_rvalue = nullptr) override; + virtual bool IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = nullptr, bool *is_rvalue = nullptr) override; private: typedef std::map> TypeMap; Index: lldb/trunk/include/lldb/Symbol/TaggedASTType.h =================================================================== --- lldb/trunk/include/lldb/Symbol/TaggedASTType.h +++ lldb/trunk/include/lldb/Symbol/TaggedASTType.h @@ -25,7 +25,7 @@ { } - TaggedASTType (void *type, TypeSystem * type_system) : + TaggedASTType (lldb::opaque_compiler_type_t type, TypeSystem * type_system) : CompilerType(type_system, type) { } Index: lldb/trunk/include/lldb/Symbol/TypeSystem.h =================================================================== --- lldb/trunk/include/lldb/Symbol/TypeSystem.h +++ lldb/trunk/include/lldb/Symbol/TypeSystem.h @@ -135,55 +135,55 @@ //---------------------------------------------------------------------- virtual bool - IsArrayType (void *type, + IsArrayType (lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) = 0; virtual bool - IsAggregateType (void *type) = 0; + IsAggregateType (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsCharType (void *type) = 0; + IsCharType (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsCompleteType (void *type) = 0; + IsCompleteType (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsDefined(void *type) = 0; + IsDefined(lldb::opaque_compiler_type_t type) = 0; virtual bool - IsFloatingPointType (void *type, uint32_t &count, bool &is_complex) = 0; + IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) = 0; virtual bool - IsFunctionType (void *type, bool *is_variadic_ptr) = 0; + IsFunctionType (lldb::opaque_compiler_type_t type, bool *is_variadic_ptr) = 0; virtual size_t - GetNumberOfFunctionArguments (void *type) = 0; + GetNumberOfFunctionArguments (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType - GetFunctionArgumentAtIndex (void *type, const size_t index) = 0; + GetFunctionArgumentAtIndex (lldb::opaque_compiler_type_t type, const size_t index) = 0; virtual bool - IsFunctionPointerType (void *type) = 0; + IsFunctionPointerType (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsIntegerType (void *type, bool &is_signed) = 0; + IsIntegerType (lldb::opaque_compiler_type_t type, bool &is_signed) = 0; virtual bool - IsPossibleDynamicType (void *type, + IsPossibleDynamicType (lldb::opaque_compiler_type_t type, CompilerType *target_type, // Can pass NULL bool check_cplusplus, bool check_objc) = 0; virtual bool - IsPointerType (void *type, CompilerType *pointee_type) = 0; + IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) = 0; virtual bool - IsScalarType (void *type) = 0; + IsScalarType (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsVoidType (void *type) = 0; + IsVoidType (lldb::opaque_compiler_type_t type) = 0; // TypeSystems can support more than one language virtual bool @@ -194,7 +194,7 @@ //---------------------------------------------------------------------- virtual bool - GetCompleteType (void *type) = 0; + GetCompleteType (lldb::opaque_compiler_type_t type) = 0; //---------------------------------------------------------------------- // AST related queries @@ -208,100 +208,100 @@ //---------------------------------------------------------------------- virtual ConstString - GetTypeName (void *type) = 0; + GetTypeName (lldb::opaque_compiler_type_t type) = 0; virtual uint32_t - GetTypeInfo (void *type, CompilerType *pointee_or_element_clang_type) = 0; + GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) = 0; virtual lldb::LanguageType - GetMinimumLanguage (void *type) = 0; + GetMinimumLanguage (lldb::opaque_compiler_type_t type) = 0; virtual lldb::TypeClass - GetTypeClass (void *type) = 0; + GetTypeClass (lldb::opaque_compiler_type_t type) = 0; //---------------------------------------------------------------------- // Creating related types //---------------------------------------------------------------------- virtual CompilerType - GetArrayElementType (void *type, uint64_t *stride) = 0; + GetArrayElementType (lldb::opaque_compiler_type_t type, uint64_t *stride) = 0; virtual CompilerType - GetCanonicalType (void *type) = 0; + GetCanonicalType (lldb::opaque_compiler_type_t type) = 0; // Returns -1 if this isn't a function of if the function doesn't have a prototype // Returns a value >= 0 if there is a prototype. virtual int - GetFunctionArgumentCount (void *type) = 0; + GetFunctionArgumentCount (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType - GetFunctionArgumentTypeAtIndex (void *type, size_t idx) = 0; + GetFunctionArgumentTypeAtIndex (lldb::opaque_compiler_type_t type, size_t idx) = 0; virtual CompilerType - GetFunctionReturnType (void *type) = 0; + GetFunctionReturnType (lldb::opaque_compiler_type_t type) = 0; virtual size_t - GetNumMemberFunctions (void *type) = 0; + GetNumMemberFunctions (lldb::opaque_compiler_type_t type) = 0; virtual TypeMemberFunctionImpl - GetMemberFunctionAtIndex (void *type, size_t idx) = 0; + GetMemberFunctionAtIndex (lldb::opaque_compiler_type_t type, size_t idx) = 0; virtual CompilerType - GetPointeeType (void *type) = 0; + GetPointeeType (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType - GetPointerType (void *type) = 0; + GetPointerType (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType - GetLValueReferenceType (void *type); + GetLValueReferenceType (lldb::opaque_compiler_type_t type); virtual CompilerType - GetRValueReferenceType (void *type); + GetRValueReferenceType (lldb::opaque_compiler_type_t type); virtual CompilerType - AddConstModifier (void *type); + AddConstModifier (lldb::opaque_compiler_type_t type); virtual CompilerType - AddVolatileModifier (void *type); + AddVolatileModifier (lldb::opaque_compiler_type_t type); virtual CompilerType - AddRestrictModifier (void *type); + AddRestrictModifier (lldb::opaque_compiler_type_t type); virtual CompilerType - CreateTypedef (void *type, const char *name, const CompilerDeclContext &decl_ctx); + CreateTypedef (lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx); //---------------------------------------------------------------------- // Exploring the type //---------------------------------------------------------------------- virtual uint64_t - GetBitSize (void *type, ExecutionContextScope *exe_scope) = 0; + GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) = 0; virtual lldb::Encoding - GetEncoding (void *type, uint64_t &count) = 0; + GetEncoding (lldb::opaque_compiler_type_t type, uint64_t &count) = 0; virtual lldb::Format - GetFormat (void *type) = 0; + GetFormat (lldb::opaque_compiler_type_t type) = 0; virtual uint32_t - GetNumChildren (void *type, bool omit_empty_base_classes) = 0; + GetNumChildren (lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) = 0; virtual CompilerType GetBuiltinTypeByName (const ConstString &name); virtual lldb::BasicType - GetBasicTypeEnumeration (void *type) = 0; + GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type) = 0; virtual void - ForEachEnumerator (void *type, std::function const &callback) + ForEachEnumerator (lldb::opaque_compiler_type_t type, std::function const &callback) { } virtual uint32_t - GetNumFields (void *type) = 0; + GetNumFields (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType - GetFieldAtIndex (void *type, + GetFieldAtIndex (lldb::opaque_compiler_type_t type, size_t idx, std::string& name, uint64_t *bit_offset_ptr, @@ -309,23 +309,23 @@ bool *is_bitfield_ptr) = 0; virtual uint32_t - GetNumDirectBaseClasses (void *type) = 0; + GetNumDirectBaseClasses (lldb::opaque_compiler_type_t type) = 0; virtual uint32_t - GetNumVirtualBaseClasses (void *type) = 0; + GetNumVirtualBaseClasses (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType - GetDirectBaseClassAtIndex (void *type, + GetDirectBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) = 0; virtual CompilerType - GetVirtualBaseClassAtIndex (void *type, + GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) = 0; virtual CompilerType - GetChildCompilerTypeAtIndex (void *type, + GetChildCompilerTypeAtIndex (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, @@ -343,7 +343,7 @@ // Lookup a child given a name. This function will match base class names // and member member names in "clang_type" only, not descendants. virtual uint32_t - GetIndexOfChildWithName (void *type, + GetIndexOfChildWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) = 0; @@ -353,16 +353,16 @@ // TODO: Return all matches for a given name by returning a vector> // so we catch all names that match a given child name, not just the first. virtual size_t - GetIndexOfChildMemberWithName (void *type, + GetIndexOfChildMemberWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes, std::vector& child_indexes) = 0; virtual size_t - GetNumTemplateArguments (void *type) = 0; + GetNumTemplateArguments (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType - GetTemplateArgument (void *type, + GetTemplateArgument (lldb::opaque_compiler_type_t type, size_t idx, lldb::TemplateArgumentKind &kind) = 0; @@ -370,7 +370,7 @@ // Dumping types //---------------------------------------------------------------------- virtual void - DumpValue (void *type, + DumpValue (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format, @@ -385,7 +385,7 @@ uint32_t depth) = 0; virtual bool - DumpTypeValue (void *type, + DumpTypeValue (lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data, @@ -396,20 +396,20 @@ ExecutionContextScope *exe_scope) = 0; virtual void - DumpTypeDescription (void *type) = 0; // Dump to stdout + DumpTypeDescription (lldb::opaque_compiler_type_t type) = 0; // Dump to stdout virtual void - DumpTypeDescription (void *type, Stream *s) = 0; + DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s) = 0; //---------------------------------------------------------------------- // TODO: These methods appear unused. Should they be removed? //---------------------------------------------------------------------- virtual bool - IsRuntimeGeneratedType (void *type) = 0; + IsRuntimeGeneratedType (lldb::opaque_compiler_type_t type) = 0; virtual void - DumpSummary (void *type, + DumpSummary (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data, @@ -419,7 +419,7 @@ // Converts "s" to a floating point value and place resulting floating // point bytes in the "dst" buffer. virtual size_t - ConvertStringToFloatValue (void *type, + ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) = 0; @@ -429,16 +429,16 @@ //---------------------------------------------------------------------- virtual bool - IsPointerOrReferenceType (void *type, CompilerType *pointee_type) = 0; + IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) = 0; virtual unsigned - GetTypeQualifiers(void *type) = 0; + GetTypeQualifiers(lldb::opaque_compiler_type_t type) = 0; virtual bool - IsCStringType (void *type, uint32_t &length) = 0; + IsCStringType (lldb::opaque_compiler_type_t type, uint32_t &length) = 0; virtual size_t - GetTypeBitAlign (void *type) = 0; + GetTypeBitAlign (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType GetBasicTypeFromAST (lldb::BasicType basic_type) = 0; @@ -448,37 +448,37 @@ size_t bit_size) = 0; virtual bool - IsBeingDefined (void *type) = 0; + IsBeingDefined (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsConst(void *type) = 0; + IsConst(lldb::opaque_compiler_type_t type) = 0; virtual uint32_t - IsHomogeneousAggregate (void *type, CompilerType* base_type_ptr) = 0; + IsHomogeneousAggregate (lldb::opaque_compiler_type_t type, CompilerType* base_type_ptr) = 0; virtual bool - IsPolymorphicClass (void *type) = 0; + IsPolymorphicClass (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsTypedefType (void *type) = 0; + IsTypedefType (lldb::opaque_compiler_type_t type) = 0; // If the current object represents a typedef type, get the underlying type virtual CompilerType - GetTypedefedType (void *type) = 0; + GetTypedefedType (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsVectorType (void *type, + IsVectorType (lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) = 0; virtual CompilerType - GetFullyUnqualifiedType (void *type) = 0; + GetFullyUnqualifiedType (lldb::opaque_compiler_type_t type) = 0; virtual CompilerType - GetNonReferenceType (void *type) = 0; + GetNonReferenceType (lldb::opaque_compiler_type_t type) = 0; virtual bool - IsReferenceType (void *type, CompilerType *pointee_type, bool* is_rvalue) = 0; + IsReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool* is_rvalue) = 0; virtual UserExpression * GetUserExpression (const char *expr, Index: lldb/trunk/source/Symbol/ClangASTContext.cpp =================================================================== --- lldb/trunk/source/Symbol/ClangASTContext.cpp +++ lldb/trunk/source/Symbol/ClangASTContext.cpp @@ -841,7 +841,7 @@ { if (ast) { - opaque_compiler_type_t clang_type = nullptr; + lldb::opaque_compiler_type_t clang_type = nullptr; switch (basic_type) { @@ -2124,7 +2124,7 @@ // so we can support remote targets. The code below also requires a patch to // llvm::APInt. //bool -//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, opaque_compiler_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str) +//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, lldb::opaque_compiler_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str) //{ // uint32_t count = 0; // bool is_complex = false; @@ -2500,7 +2500,7 @@ //---------------------------------------------------------------------- bool -ClangASTContext::IsAggregateType (void* type) +ClangASTContext::IsAggregateType (lldb::opaque_compiler_type_t type) { clang::QualType qual_type (GetCanonicalQualType(type)); @@ -2530,7 +2530,7 @@ } bool -ClangASTContext::IsArrayType (void* type, +ClangASTContext::IsArrayType (lldb::opaque_compiler_type_t type, CompilerType *element_type_ptr, uint64_t *size, bool *is_incomplete) @@ -2599,7 +2599,7 @@ } bool -ClangASTContext::IsVectorType (void* type, +ClangASTContext::IsVectorType (lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) { @@ -2640,7 +2640,7 @@ } bool -ClangASTContext::IsRuntimeGeneratedType (void* type) +ClangASTContext::IsRuntimeGeneratedType (lldb::opaque_compiler_type_t type) { clang::DeclContext* decl_ctx = ClangASTContext::GetASTContext(getASTContext())->GetDeclContextForType(GetQualType(type)); if (!decl_ctx) @@ -2658,27 +2658,27 @@ } bool -ClangASTContext::IsCharType (void* type) +ClangASTContext::IsCharType (lldb::opaque_compiler_type_t type) { return GetQualType(type).getUnqualifiedType()->isCharType(); } bool -ClangASTContext::IsCompleteType (void* type) +ClangASTContext::IsCompleteType (lldb::opaque_compiler_type_t type) { const bool allow_completion = false; return GetCompleteQualType (getASTContext(), GetQualType(type), allow_completion); } bool -ClangASTContext::IsConst(void* type) +ClangASTContext::IsConst(lldb::opaque_compiler_type_t type) { return GetQualType(type).isConstQualified(); } bool -ClangASTContext::IsCStringType (void* type, uint32_t &length) +ClangASTContext::IsCStringType (lldb::opaque_compiler_type_t type, uint32_t &length) { CompilerType pointee_or_element_clang_type; length = 0; @@ -2705,7 +2705,7 @@ } bool -ClangASTContext::IsFunctionType (void* type, bool *is_variadic_ptr) +ClangASTContext::IsFunctionType (lldb::opaque_compiler_type_t type, bool *is_variadic_ptr) { if (type) { @@ -2750,7 +2750,7 @@ // Used to detect "Homogeneous Floating-point Aggregates" uint32_t -ClangASTContext::IsHomogeneousAggregate (void* type, CompilerType* base_type_ptr) +ClangASTContext::IsHomogeneousAggregate (lldb::opaque_compiler_type_t type, CompilerType* base_type_ptr) { if (!type) return 0; @@ -2845,7 +2845,7 @@ } size_t -ClangASTContext::GetNumberOfFunctionArguments (void* type) +ClangASTContext::GetNumberOfFunctionArguments (lldb::opaque_compiler_type_t type) { if (type) { @@ -2858,7 +2858,7 @@ } CompilerType -ClangASTContext::GetFunctionArgumentAtIndex (void* type, const size_t index) +ClangASTContext::GetFunctionArgumentAtIndex (lldb::opaque_compiler_type_t type, const size_t index) { if (type) { @@ -2874,7 +2874,7 @@ } bool -ClangASTContext::IsFunctionPointerType (void* type) +ClangASTContext::IsFunctionPointerType (lldb::opaque_compiler_type_t type) { if (type) { @@ -2910,7 +2910,7 @@ } bool -ClangASTContext::IsIntegerType (void* type, bool &is_signed) +ClangASTContext::IsIntegerType (lldb::opaque_compiler_type_t type, bool &is_signed) { if (!type) return false; @@ -2931,7 +2931,7 @@ } bool -ClangASTContext::IsPointerType (void* type, CompilerType *pointee_type) +ClangASTContext::IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) { if (type) { @@ -2982,7 +2982,7 @@ bool -ClangASTContext::IsPointerOrReferenceType (void* type, CompilerType *pointee_type) +ClangASTContext::IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) { if (type) { @@ -3041,7 +3041,7 @@ bool -ClangASTContext::IsReferenceType (void* type, CompilerType *pointee_type, bool* is_rvalue) +ClangASTContext::IsReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool* is_rvalue) { if (type) { @@ -3079,7 +3079,7 @@ } bool -ClangASTContext::IsFloatingPointType (void* type, uint32_t &count, bool &is_complex) +ClangASTContext::IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) { if (type) { @@ -3121,7 +3121,7 @@ bool -ClangASTContext::IsDefined(void* type) +ClangASTContext::IsDefined(lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -3173,7 +3173,7 @@ } bool -ClangASTContext::IsPolymorphicClass (void* type) +ClangASTContext::IsPolymorphicClass (lldb::opaque_compiler_type_t type) { if (type) { @@ -3203,7 +3203,7 @@ } bool -ClangASTContext::IsPossibleDynamicType (void* type, CompilerType *dynamic_pointee_type, +ClangASTContext::IsPossibleDynamicType (lldb::opaque_compiler_type_t type, CompilerType *dynamic_pointee_type, bool check_cplusplus, bool check_objc) { @@ -3343,7 +3343,7 @@ bool -ClangASTContext::IsScalarType (void* type) +ClangASTContext::IsScalarType (lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -3352,7 +3352,7 @@ } bool -ClangASTContext::IsTypedefType (void* type) +ClangASTContext::IsTypedefType (lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -3360,7 +3360,7 @@ } bool -ClangASTContext::IsVoidType (void* type) +ClangASTContext::IsVoidType (lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -3407,7 +3407,7 @@ } bool -ClangASTContext::IsBeingDefined (void* type) +ClangASTContext::IsBeingDefined (lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -3474,7 +3474,7 @@ //---------------------------------------------------------------------- bool -ClangASTContext::GetCompleteType (void* type) +ClangASTContext::GetCompleteType (lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -3483,7 +3483,7 @@ } ConstString -ClangASTContext::GetTypeName (void* type) +ClangASTContext::GetTypeName (lldb::opaque_compiler_type_t type) { std::string type_name; if (type) @@ -3507,7 +3507,7 @@ } uint32_t -ClangASTContext::GetTypeInfo (void* type, CompilerType *pointee_or_element_clang_type) +ClangASTContext::GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) { if (!type) return 0; @@ -3685,7 +3685,7 @@ lldb::LanguageType -ClangASTContext::GetMinimumLanguage (void* type) +ClangASTContext::GetMinimumLanguage (lldb::opaque_compiler_type_t type) { if (!type) return lldb::eLanguageTypeC; @@ -3769,7 +3769,7 @@ } lldb::TypeClass -ClangASTContext::GetTypeClass (void* type) +ClangASTContext::GetTypeClass (lldb::opaque_compiler_type_t type) { if (!type) return lldb::eTypeClassInvalid; @@ -3848,7 +3848,7 @@ } unsigned -ClangASTContext::GetTypeQualifiers(void* type) +ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) { if (type) return GetQualType(type).getQualifiers().getCVRQualifiers(); @@ -3860,7 +3860,7 @@ //---------------------------------------------------------------------- CompilerType -ClangASTContext::GetArrayElementType (void* type, uint64_t *stride) +ClangASTContext::GetArrayElementType (lldb::opaque_compiler_type_t type, uint64_t *stride) { if (type) { @@ -3884,7 +3884,7 @@ } CompilerType -ClangASTContext::GetCanonicalType (void* type) +ClangASTContext::GetCanonicalType (lldb::opaque_compiler_type_t type) { if (type) return CompilerType (getASTContext(), GetCanonicalQualType(type)); @@ -3905,7 +3905,7 @@ } CompilerType -ClangASTContext::GetFullyUnqualifiedType (void* type) +ClangASTContext::GetFullyUnqualifiedType (lldb::opaque_compiler_type_t type) { if (type) return CompilerType(getASTContext(), GetFullyUnqualifiedType_Impl(getASTContext(), GetQualType(type))); @@ -3914,7 +3914,7 @@ int -ClangASTContext::GetFunctionArgumentCount (void* type) +ClangASTContext::GetFunctionArgumentCount (lldb::opaque_compiler_type_t type) { if (type) { @@ -3926,7 +3926,7 @@ } CompilerType -ClangASTContext::GetFunctionArgumentTypeAtIndex (void* type, size_t idx) +ClangASTContext::GetFunctionArgumentTypeAtIndex (lldb::opaque_compiler_type_t type, size_t idx) { if (type) { @@ -3942,7 +3942,7 @@ } CompilerType -ClangASTContext::GetFunctionReturnType (void* type) +ClangASTContext::GetFunctionReturnType (lldb::opaque_compiler_type_t type) { if (type) { @@ -3955,7 +3955,7 @@ } size_t -ClangASTContext::GetNumMemberFunctions (void* type) +ClangASTContext::GetNumMemberFunctions (lldb::opaque_compiler_type_t type) { size_t num_functions = 0; if (type) @@ -4019,7 +4019,7 @@ } TypeMemberFunctionImpl -ClangASTContext::GetMemberFunctionAtIndex (void* type, size_t idx) +ClangASTContext::GetMemberFunctionAtIndex (lldb::opaque_compiler_type_t type, size_t idx) { std::string name(""); MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown); @@ -4149,7 +4149,7 @@ } CompilerType -ClangASTContext::GetNonReferenceType (void* type) +ClangASTContext::GetNonReferenceType (lldb::opaque_compiler_type_t type) { if (type) return CompilerType(getASTContext(), GetQualType(type).getNonReferenceType()); @@ -4190,7 +4190,7 @@ } CompilerType -ClangASTContext::GetPointeeType (void* type) +ClangASTContext::GetPointeeType (lldb::opaque_compiler_type_t type) { if (type) { @@ -4201,7 +4201,7 @@ } CompilerType -ClangASTContext::GetPointerType (void* type) +ClangASTContext::GetPointerType (lldb::opaque_compiler_type_t type) { if (type) { @@ -4223,7 +4223,7 @@ CompilerType -ClangASTContext::GetLValueReferenceType (void *type) +ClangASTContext::GetLValueReferenceType (lldb::opaque_compiler_type_t type) { if (type) return CompilerType(this, getASTContext()->getLValueReferenceType(GetQualType(type)).getAsOpaquePtr()); @@ -4232,7 +4232,7 @@ } CompilerType -ClangASTContext::GetRValueReferenceType (void *type) +ClangASTContext::GetRValueReferenceType (lldb::opaque_compiler_type_t type) { if (type) return CompilerType(this, getASTContext()->getRValueReferenceType(GetQualType(type)).getAsOpaquePtr()); @@ -4241,7 +4241,7 @@ } CompilerType -ClangASTContext::AddConstModifier (void *type) +ClangASTContext::AddConstModifier (lldb::opaque_compiler_type_t type) { if (type) { @@ -4253,7 +4253,7 @@ } CompilerType -ClangASTContext::AddVolatileModifier (void *type) +ClangASTContext::AddVolatileModifier (lldb::opaque_compiler_type_t type) { if (type) { @@ -4266,7 +4266,7 @@ } CompilerType -ClangASTContext::AddRestrictModifier (void *type) +ClangASTContext::AddRestrictModifier (lldb::opaque_compiler_type_t type) { if (type) { @@ -4279,7 +4279,7 @@ } CompilerType -ClangASTContext::CreateTypedef (void *type, const char *typedef_name, const CompilerDeclContext &compiler_decl_ctx) +ClangASTContext::CreateTypedef (lldb::opaque_compiler_type_t type, const char *typedef_name, const CompilerDeclContext &compiler_decl_ctx) { if (type) { @@ -4308,7 +4308,7 @@ } CompilerType -ClangASTContext::GetTypedefedType (void* type) +ClangASTContext::GetTypedefedType (lldb::opaque_compiler_type_t type) { if (type) { @@ -4346,7 +4346,7 @@ //---------------------------------------------------------------------- uint64_t -ClangASTContext::GetBitSize (void* type, ExecutionContextScope *exe_scope) +ClangASTContext::GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) { if (GetCompleteType (type)) { @@ -4403,7 +4403,7 @@ } size_t -ClangASTContext::GetTypeBitAlign (void* type) +ClangASTContext::GetTypeBitAlign (lldb::opaque_compiler_type_t type) { if (GetCompleteType(type)) return getASTContext()->getTypeAlign(GetQualType(type)); @@ -4412,7 +4412,7 @@ lldb::Encoding -ClangASTContext::GetEncoding (void* type, uint64_t &count) +ClangASTContext::GetEncoding (lldb::opaque_compiler_type_t type, uint64_t &count) { if (!type) return lldb::eEncodingInvalid; @@ -4567,7 +4567,7 @@ } lldb::Format -ClangASTContext::GetFormat (void* type) +ClangASTContext::GetFormat (lldb::opaque_compiler_type_t type) { if (!type) return lldb::eFormatDefault; @@ -4699,7 +4699,7 @@ } uint32_t -ClangASTContext::GetNumChildren (void* type, bool omit_empty_base_classes) +ClangASTContext::GetNumChildren (lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) { if (!type) return 0; @@ -4874,7 +4874,7 @@ } lldb::BasicType -ClangASTContext::GetBasicTypeEnumeration (void* type) +ClangASTContext::GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type) { if (type) { @@ -4923,7 +4923,7 @@ } void -ClangASTContext::ForEachEnumerator (void* type, std::function const &callback) +ClangASTContext::ForEachEnumerator (lldb::opaque_compiler_type_t type, std::function const &callback) { const clang::EnumType *enum_type = llvm::dyn_cast(GetCanonicalQualType(type)); if (enum_type) @@ -4948,7 +4948,7 @@ #pragma mark Aggregate Types uint32_t -ClangASTContext::GetNumFields (void* type) +ClangASTContext::GetNumFields (lldb::opaque_compiler_type_t type) { if (!type) return 0; @@ -5024,7 +5024,7 @@ return count; } -static opaque_compiler_type_t +static lldb::opaque_compiler_type_t GetObjCFieldAtIndex (clang::ASTContext *ast, clang::ObjCInterfaceDecl *class_interface_decl, size_t idx, @@ -5084,7 +5084,7 @@ } CompilerType -ClangASTContext::GetFieldAtIndex (void* type, size_t idx, +ClangASTContext::GetFieldAtIndex (lldb::opaque_compiler_type_t type, size_t idx, std::string& name, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, @@ -5203,7 +5203,7 @@ } uint32_t -ClangASTContext::GetNumDirectBaseClasses (void *type) +ClangASTContext::GetNumDirectBaseClasses (lldb::opaque_compiler_type_t type) { uint32_t count = 0; clang::QualType qual_type(GetCanonicalQualType(type)); @@ -5270,7 +5270,7 @@ } uint32_t -ClangASTContext::GetNumVirtualBaseClasses (void *type) +ClangASTContext::GetNumVirtualBaseClasses (lldb::opaque_compiler_type_t type) { uint32_t count = 0; clang::QualType qual_type(GetCanonicalQualType(type)); @@ -5306,7 +5306,7 @@ } CompilerType -ClangASTContext::GetDirectBaseClassAtIndex (void *type, size_t idx, uint32_t *bit_offset_ptr) +ClangASTContext::GetDirectBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) { clang::QualType qual_type(GetCanonicalQualType(type)); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); @@ -5405,7 +5405,7 @@ } CompilerType -ClangASTContext::GetVirtualBaseClassAtIndex (void *type, +ClangASTContext::GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) { @@ -5567,7 +5567,7 @@ CompilerType -ClangASTContext::GetChildCompilerTypeAtIndex (void* type, +ClangASTContext::GetChildCompilerTypeAtIndex (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, @@ -6220,7 +6220,7 @@ // The second index 1 is the child index for "m_b" within class A size_t -ClangASTContext::GetIndexOfChildMemberWithName (void* type, const char *name, +ClangASTContext::GetIndexOfChildMemberWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes, std::vector& child_indexes) { @@ -6485,7 +6485,7 @@ // matches can include base class names. uint32_t -ClangASTContext::GetIndexOfChildWithName (void* type, const char *name, bool omit_empty_base_classes) +ClangASTContext::GetIndexOfChildWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) { if (type && name && name[0]) { @@ -6684,7 +6684,7 @@ size_t -ClangASTContext::GetNumTemplateArguments (void* type) +ClangASTContext::GetNumTemplateArguments (lldb::opaque_compiler_type_t type) { if (!type) return 0; @@ -6723,7 +6723,7 @@ } CompilerType -ClangASTContext::GetTemplateArgument (void* type, size_t arg_idx, lldb::TemplateArgumentKind &kind) +ClangASTContext::GetTemplateArgument (lldb::opaque_compiler_type_t type, size_t arg_idx, lldb::TemplateArgumentKind &kind) { if (!type) return CompilerType(); @@ -7036,7 +7036,7 @@ } clang::CXXRecordDecl * -ClangASTContext::GetAsCXXRecordDecl (void* type) +ClangASTContext::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type) { return GetCanonicalQualType(type)->getAsCXXRecordDecl(); } @@ -7314,7 +7314,7 @@ clang::CXXMethodDecl * -ClangASTContext::AddMethodToCXXRecordType (void* type, const char *name, +ClangASTContext::AddMethodToCXXRecordType (lldb::opaque_compiler_type_t type, const char *name, const CompilerType &method_clang_type, lldb::AccessType access, bool is_virtual, @@ -7526,7 +7526,7 @@ #pragma mark C++ Base Classes clang::CXXBaseSpecifier * -ClangASTContext::CreateBaseClassSpecifier (void* type, AccessType access, bool is_virtual, bool base_of_class) +ClangASTContext::CreateBaseClassSpecifier (lldb::opaque_compiler_type_t type, AccessType access, bool is_virtual, bool base_of_class) { if (type) return new clang::CXXBaseSpecifier (clang::SourceRange(), @@ -7549,7 +7549,7 @@ } bool -ClangASTContext::SetBaseClassesForClassType (void* type, clang::CXXBaseSpecifier const * const *base_classes, +ClangASTContext::SetBaseClassesForClassType (lldb::opaque_compiler_type_t type, clang::CXXBaseSpecifier const * const *base_classes, unsigned num_base_classes) { if (type) @@ -7790,7 +7790,7 @@ clang::ObjCMethodDecl * ClangASTContext::AddMethodToObjCObjectType (const CompilerType& type, - const char *name, // the full symbol name as seen in the symbol table (void* 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, lldb::AccessType access, bool is_artificial) @@ -7912,7 +7912,7 @@ } bool -ClangASTContext::SetHasExternalStorage (void* type, bool has_extern) +ClangASTContext::SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern) { if (!type) return false; @@ -8076,7 +8076,7 @@ } bool -ClangASTContext::AddEnumerationValueToEnumerationType (void* type, +ClangASTContext::AddEnumerationValueToEnumerationType (lldb::opaque_compiler_type_t type, const CompilerType &enumerator_clang_type, const Declaration &decl, const char *name, @@ -8124,7 +8124,7 @@ } CompilerType -ClangASTContext::GetEnumerationIntegerType (void* type) +ClangASTContext::GetEnumerationIntegerType (lldb::opaque_compiler_type_t type) { clang::QualType enum_qual_type (GetCanonicalQualType(type)); const clang::Type *clang_type = enum_qual_type.getTypePtr(); @@ -8158,7 +8158,7 @@ size_t -ClangASTContext::ConvertStringToFloatValue (void* type, const char *s, uint8_t *dst, size_t dst_size) +ClangASTContext::ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) { if (type) { @@ -8204,7 +8204,7 @@ #define DEPTH_INCREMENT 2 void -ClangASTContext::DumpValue (void* type, ExecutionContext *exe_ctx, +ClangASTContext::DumpValue (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format, const lldb_private::DataExtractor &data, @@ -8534,7 +8534,7 @@ bool -ClangASTContext::DumpTypeValue (void* type, Stream *s, +ClangASTContext::DumpTypeValue (lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const lldb_private::DataExtractor &data, lldb::offset_t byte_offset, @@ -8696,7 +8696,7 @@ void -ClangASTContext::DumpSummary (void* type, ExecutionContext *exe_ctx, +ClangASTContext::DumpSummary (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const lldb_private::DataExtractor &data, lldb::offset_t data_byte_offset, @@ -8744,7 +8744,7 @@ } void -ClangASTContext::DumpTypeDescription (void* type) +ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type) { StreamFile s (stdout, false); DumpTypeDescription (&s); @@ -8756,7 +8756,7 @@ } void -ClangASTContext::DumpTypeDescription (void* type, Stream *s) +ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s) { if (type) { Index: lldb/trunk/source/Symbol/CompilerType.cpp =================================================================== --- lldb/trunk/source/Symbol/CompilerType.cpp +++ lldb/trunk/source/Symbol/CompilerType.cpp @@ -30,7 +30,7 @@ using namespace lldb_private; CompilerType::CompilerType (TypeSystem *type_system, - void* type) : + lldb::opaque_compiler_type_t type) : m_type (type), m_type_system (type_system) { @@ -399,7 +399,7 @@ } void -CompilerType::SetCompilerType (TypeSystem* type_system, void* type) +CompilerType::SetCompilerType (TypeSystem* type_system, lldb::opaque_compiler_type_t type) { m_type_system = type_system; m_type = type; Index: lldb/trunk/source/Symbol/GoASTContext.cpp =================================================================== --- lldb/trunk/source/Symbol/GoASTContext.cpp +++ lldb/trunk/source/Symbol/GoASTContext.cpp @@ -356,7 +356,7 @@ //---------------------------------------------------------------------- bool -GoASTContext::IsArrayType(void *type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) +GoASTContext::IsArrayType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size, bool *is_incomplete) { if (element_type) element_type->Clear(); @@ -377,7 +377,7 @@ } bool -GoASTContext::IsVectorType(void *type, CompilerType *element_type, uint64_t *size) +GoASTContext::IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) { if (element_type) element_type->Clear(); @@ -387,7 +387,7 @@ } bool -GoASTContext::IsAggregateType(void *type) +GoASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) { int kind = static_cast(type)->GetGoKind(); if (kind < GoType::KIND_ARRAY) @@ -402,20 +402,20 @@ } bool -GoASTContext::IsBeingDefined(void *type) +GoASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) { return false; } bool -GoASTContext::IsCharType(void *type) +GoASTContext::IsCharType(lldb::opaque_compiler_type_t type) { // Go's DWARF doesn't distinguish between rune and int32. return false; } bool -GoASTContext::IsCompleteType(void *type) +GoASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -428,25 +428,25 @@ } bool -GoASTContext::IsConst(void *type) +GoASTContext::IsConst(lldb::opaque_compiler_type_t type) { return false; } bool -GoASTContext::IsCStringType(void *type, uint32_t &length) +GoASTContext::IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length) { return false; } bool -GoASTContext::IsDefined(void *type) +GoASTContext::IsDefined(lldb::opaque_compiler_type_t type) { return type != nullptr; } bool -GoASTContext::IsFloatingPointType(void *type, uint32_t &count, bool &is_complex) +GoASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) { int kind = static_cast(type)->GetGoKind(); if (kind >= GoType::KIND_FLOAT32 && kind <= GoType::KIND_COMPLEX128) @@ -469,7 +469,7 @@ } bool -GoASTContext::IsFunctionType(void *type, bool *is_variadic_ptr) +GoASTContext::IsFunctionType(lldb::opaque_compiler_type_t type, bool *is_variadic_ptr) { GoFunction *func = static_cast(type)->GetFunction(); if (func) @@ -484,31 +484,31 @@ } uint32_t -GoASTContext::IsHomogeneousAggregate(void *type, CompilerType *base_type_ptr) +GoASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr) { return false; } size_t -GoASTContext::GetNumberOfFunctionArguments(void *type) +GoASTContext::GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) { return 0; } CompilerType -GoASTContext::GetFunctionArgumentAtIndex(void *type, const size_t index) +GoASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, const size_t index) { return CompilerType(); } bool -GoASTContext::IsFunctionPointerType(void *type) +GoASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) { return IsFunctionType(type); } bool -GoASTContext::IsIntegerType(void *type, bool &is_signed) +GoASTContext::IsIntegerType(lldb::opaque_compiler_type_t type, bool &is_signed) { is_signed = false; // TODO: Is bool an integer? @@ -525,13 +525,13 @@ } bool -GoASTContext::IsPolymorphicClass(void *type) +GoASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) { return false; } bool -GoASTContext::IsPossibleDynamicType(void *type, +GoASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type, CompilerType *target_type, // Can pass NULL bool check_cplusplus, bool check_objc) { @@ -543,13 +543,13 @@ } bool -GoASTContext::IsRuntimeGeneratedType(void *type) +GoASTContext::IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) { return false; } bool -GoASTContext::IsPointerType(void *type, CompilerType *pointee_type) +GoASTContext::IsPointerType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type) { if (!type) return false; @@ -571,25 +571,25 @@ } bool -GoASTContext::IsPointerOrReferenceType(void *type, CompilerType *pointee_type) +GoASTContext::IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type) { return IsPointerType(type, pointee_type); } bool -GoASTContext::IsReferenceType(void *type, CompilerType *pointee_type, bool *is_rvalue) +GoASTContext::IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool *is_rvalue) { return false; } bool -GoASTContext::IsScalarType(void *type) +GoASTContext::IsScalarType(lldb::opaque_compiler_type_t type) { return !IsAggregateType(type); } bool -GoASTContext::IsTypedefType(void *type) +GoASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) { if (type) return static_cast(type)->IsTypedef(); @@ -597,7 +597,7 @@ } bool -GoASTContext::IsVoidType(void *type) +GoASTContext::IsVoidType(lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -615,7 +615,7 @@ //---------------------------------------------------------------------- bool -GoASTContext::GetCompleteType(void *type) +GoASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) { if (!type) return false; @@ -648,7 +648,7 @@ //---------------------------------------------------------------------- ConstString -GoASTContext::GetTypeName(void *type) +GoASTContext::GetTypeName(lldb::opaque_compiler_type_t type) { if (type) return static_cast(type)->GetName(); @@ -656,7 +656,7 @@ } uint32_t -GoASTContext::GetTypeInfo(void *type, CompilerType *pointee_or_element_clang_type) +GoASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) { if (pointee_or_element_clang_type) pointee_or_element_clang_type->Clear(); @@ -699,7 +699,7 @@ } lldb::TypeClass -GoASTContext::GetTypeClass(void *type) +GoASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) { if (!type) return eTypeClassInvalid; @@ -718,7 +718,7 @@ } lldb::BasicType -GoASTContext::GetBasicTypeEnumeration(void *type) +GoASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) { ConstString name = GetTypeName(type); if (name) @@ -759,13 +759,13 @@ } lldb::LanguageType -GoASTContext::GetMinimumLanguage(void *type) +GoASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) { return lldb::eLanguageTypeGo; } unsigned -GoASTContext::GetTypeQualifiers(void *type) +GoASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) { return 0; } @@ -775,7 +775,7 @@ //---------------------------------------------------------------------- CompilerType -GoASTContext::GetArrayElementType(void *type, uint64_t *stride) +GoASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride) { GoArray *array = static_cast(type)->GetArray(); if (array) @@ -790,7 +790,7 @@ } CompilerType -GoASTContext::GetCanonicalType(void *type) +GoASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) { GoType *t = static_cast(type); if (t->IsTypedef()) @@ -799,7 +799,7 @@ } CompilerType -GoASTContext::GetFullyUnqualifiedType(void *type) +GoASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) { return CompilerType(this, type); } @@ -807,19 +807,19 @@ // Returns -1 if this isn't a function of if the function doesn't have a prototype // Returns a value >= 0 if there is a prototype. int -GoASTContext::GetFunctionArgumentCount(void *type) +GoASTContext::GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) { return GetNumberOfFunctionArguments(type); } CompilerType -GoASTContext::GetFunctionArgumentTypeAtIndex(void *type, size_t idx) +GoASTContext::GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx) { return GetFunctionArgumentAtIndex(type, idx); } CompilerType -GoASTContext::GetFunctionReturnType(void *type) +GoASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) { CompilerType result; if (type) @@ -832,25 +832,25 @@ } size_t -GoASTContext::GetNumMemberFunctions(void *type) +GoASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) { return 0; } TypeMemberFunctionImpl -GoASTContext::GetMemberFunctionAtIndex(void *type, size_t idx) +GoASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) { return TypeMemberFunctionImpl(); } CompilerType -GoASTContext::GetNonReferenceType(void *type) +GoASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) { return CompilerType(this, type); } CompilerType -GoASTContext::GetPointeeType(void *type) +GoASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) { if (!type) return CompilerType(); @@ -858,7 +858,7 @@ } CompilerType -GoASTContext::GetPointerType(void *type) +GoASTContext::GetPointerType(lldb::opaque_compiler_type_t type) { if (!type) return CompilerType(); @@ -875,7 +875,7 @@ // If the current object represents a typedef type, get the underlying type CompilerType -GoASTContext::GetTypedefedType(void *type) +GoASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) { if (IsTypedefType(type)) return static_cast(type)->GetElementType(); @@ -904,7 +904,7 @@ //---------------------------------------------------------------------- uint64_t -GoASTContext::GetBitSize(void *type, ExecutionContextScope *exe_scope) +GoASTContext::GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) { if (!type) return 0; @@ -958,7 +958,7 @@ } lldb::Encoding -GoASTContext::GetEncoding(void *type, uint64_t &count) +GoASTContext::GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count) { count = 1; bool is_signed; @@ -977,7 +977,7 @@ } lldb::Format -GoASTContext::GetFormat(void *type) +GoASTContext::GetFormat(lldb::opaque_compiler_type_t type) { if (!type) return eFormatDefault; @@ -1022,13 +1022,13 @@ } size_t -GoASTContext::GetTypeBitAlign(void *type) +GoASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) { return 0; } uint32_t -GoASTContext::GetNumChildren(void *type, bool omit_empty_base_classes) +GoASTContext::GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) { if (!type || !GetCompleteType(type)) return 0; @@ -1048,7 +1048,7 @@ } uint32_t -GoASTContext::GetNumFields(void *type) +GoASTContext::GetNumFields(lldb::opaque_compiler_type_t type) { if (!type || !GetCompleteType(type)) return 0; @@ -1062,7 +1062,7 @@ } CompilerType -GoASTContext::GetFieldAtIndex(void *type, size_t idx, std::string &name, uint64_t *bit_offset_ptr, +GoASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) { if (bit_offset_ptr) @@ -1095,7 +1095,7 @@ } CompilerType -GoASTContext::GetChildCompilerTypeAtIndex(void *type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, +GoASTContext::GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers, bool omit_empty_base_classes, bool ignore_array_bounds, std::string &child_name, uint32_t &child_byte_size, int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset, @@ -1182,7 +1182,7 @@ // Lookup a child given a name. This function will match base class names // and member member names in "clang_type" only, not descendants. uint32_t -GoASTContext::GetIndexOfChildWithName(void *type, const char *name, bool omit_empty_base_classes) +GoASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) { GoType *t = static_cast(type); GoStruct *s = t->GetStruct(); @@ -1208,7 +1208,7 @@ // TODO: Return all matches for a given name by returning a vector> // so we catch all names that match a given child name, not just the first. size_t -GoASTContext::GetIndexOfChildMemberWithName(void *type, const char *name, bool omit_empty_base_classes, +GoASTContext::GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes, std::vector &child_indexes) { uint32_t index = GetIndexOfChildWithName(type, name, omit_empty_base_classes); @@ -1221,7 +1221,7 @@ // Converts "s" to a floating point value and place resulting floating // point bytes in the "dst" buffer. size_t -GoASTContext::ConvertStringToFloatValue(void *type, const char *s, uint8_t *dst, size_t dst_size) +GoASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) { assert(false); return 0; @@ -1230,7 +1230,7 @@ // Dumping types //---------------------------------------------------------------------- void -GoASTContext::DumpValue(void *type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format, +GoASTContext::DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, bool show_summary, bool verbose, uint32_t depth) @@ -1239,7 +1239,7 @@ } bool -GoASTContext::DumpTypeValue(void *type, Stream *s, lldb::Format format, const DataExtractor &data, +GoASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data, lldb::offset_t byte_offset, size_t byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope) { @@ -1329,20 +1329,20 @@ } void -GoASTContext::DumpSummary(void *type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data, +GoASTContext::DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size) { assert(false); } void -GoASTContext::DumpTypeDescription(void *type) +GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) { assert(false); } // Dump to stdout void -GoASTContext::DumpTypeDescription(void *type, Stream *s) +GoASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s) { assert(false); } Index: lldb/trunk/source/Symbol/TypeSystem.cpp =================================================================== --- lldb/trunk/source/Symbol/TypeSystem.cpp +++ lldb/trunk/source/Symbol/TypeSystem.cpp @@ -39,37 +39,37 @@ } CompilerType -TypeSystem::GetLValueReferenceType (void *type) +TypeSystem::GetLValueReferenceType (lldb::opaque_compiler_type_t type) { return CompilerType(); } CompilerType -TypeSystem::GetRValueReferenceType (void *type) +TypeSystem::GetRValueReferenceType (lldb::opaque_compiler_type_t type) { return CompilerType(); } CompilerType -TypeSystem::AddConstModifier (void *type) +TypeSystem::AddConstModifier (lldb::opaque_compiler_type_t type) { return CompilerType(); } CompilerType -TypeSystem::AddVolatileModifier (void *type) +TypeSystem::AddVolatileModifier (lldb::opaque_compiler_type_t type) { return CompilerType(); } CompilerType -TypeSystem::AddRestrictModifier (void *type) +TypeSystem::AddRestrictModifier (lldb::opaque_compiler_type_t type) { return CompilerType(); } CompilerType -TypeSystem::CreateTypedef (void *type, const char *name, const CompilerDeclContext &decl_ctx) +TypeSystem::CreateTypedef (lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx) { return CompilerType(); }