Index: lldb/trunk/include/lldb/Core/Value.h =================================================================== --- lldb/trunk/include/lldb/Core/Value.h +++ lldb/trunk/include/lldb/Core/Value.h @@ -136,7 +136,7 @@ GetCompilerType(); void - SetCompilerType (const CompilerType &clang_type); + SetCompilerType (const CompilerType &compiler_type); ValueType GetValueType() const; @@ -288,7 +288,7 @@ protected: Scalar m_value; Vector m_vector; - CompilerType m_clang_type; + CompilerType m_compiler_type; void * m_context; ValueType m_value_type; ContextType m_context_type; Index: lldb/trunk/include/lldb/Core/ValueObject.h =================================================================== --- lldb/trunk/include/lldb/Core/ValueObject.h +++ lldb/trunk/include/lldb/Core/ValueObject.h @@ -408,7 +408,7 @@ GetObjectRuntimeLanguage(); virtual uint32_t - GetTypeInfo (CompilerType *pointee_or_element_clang_type = NULL); + GetTypeInfo (CompilerType *pointee_or_element_compiler_type = NULL); virtual bool IsPointerType (); @@ -746,7 +746,7 @@ GetCPPVTableAddress(AddressType &address_type); virtual lldb::ValueObjectSP - Cast (const CompilerType &clang_ast_type); + Cast (const CompilerType &compiler_type); virtual lldb::ValueObjectSP CastPointerType (const char *name, Index: lldb/trunk/include/lldb/Core/ValueObjectChild.h =================================================================== --- lldb/trunk/include/lldb/Core/ValueObjectChild.h +++ lldb/trunk/include/lldb/Core/ValueObjectChild.h @@ -92,10 +92,10 @@ virtual CompilerType GetCompilerTypeImpl () { - return m_clang_type; + return m_compiler_type; } - CompilerType m_clang_type; + CompilerType m_compiler_type; ConstString m_type_name; uint64_t m_byte_size; int32_t m_byte_offset; @@ -114,7 +114,7 @@ friend class ValueObjectConstResult; friend class ValueObjectConstResultImpl; ValueObjectChild (ValueObject &parent, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, uint64_t byte_size, int32_t byte_offset, Index: lldb/trunk/include/lldb/Core/ValueObjectConstResult.h =================================================================== --- lldb/trunk/include/lldb/Core/ValueObjectConstResult.h +++ lldb/trunk/include/lldb/Core/ValueObjectConstResult.h @@ -34,14 +34,14 @@ static lldb::ValueObjectSP Create (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, const DataExtractor &data, lldb::addr_t address = LLDB_INVALID_ADDRESS); static lldb::ValueObjectSP Create (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, const lldb::DataBufferSP &result_data_sp, lldb::ByteOrder byte_order, @@ -50,7 +50,7 @@ static lldb::ValueObjectSP Create (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, lldb::addr_t address, AddressType address_type, @@ -132,7 +132,7 @@ GetPreferredDisplayLanguage (); virtual lldb::ValueObjectSP - Cast (const CompilerType &clang_ast_type); + Cast (const CompilerType &compiler_type); protected: virtual bool @@ -154,13 +154,13 @@ lldb::addr_t address); ValueObjectConstResult (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, const DataExtractor &data, lldb::addr_t address); ValueObjectConstResult (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, const lldb::DataBufferSP &result_data_sp, lldb::ByteOrder byte_order, @@ -168,7 +168,7 @@ lldb::addr_t address); ValueObjectConstResult (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, lldb::addr_t address, AddressType address_type, Index: lldb/trunk/include/lldb/Core/ValueObjectConstResultCast.h =================================================================== --- lldb/trunk/include/lldb/Core/ValueObjectConstResultCast.h +++ lldb/trunk/include/lldb/Core/ValueObjectConstResultCast.h @@ -58,7 +58,7 @@ uint32_t item_count = 1) override; lldb::ValueObjectSP - Cast (const CompilerType &clang_ast_type) override; + Cast (const CompilerType &compiler_type) override; protected: ValueObjectConstResultImpl m_impl; Index: lldb/trunk/include/lldb/Core/ValueObjectConstResultChild.h =================================================================== --- lldb/trunk/include/lldb/Core/ValueObjectConstResultChild.h +++ lldb/trunk/include/lldb/Core/ValueObjectConstResultChild.h @@ -27,7 +27,7 @@ public: ValueObjectConstResultChild (ValueObject &parent, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, uint32_t byte_size, int32_t byte_offset, @@ -63,7 +63,7 @@ uint32_t item_count = 1) override; lldb::ValueObjectSP - Cast (const CompilerType &clang_ast_type) override; + Cast (const CompilerType &compiler_type) override; protected: ValueObjectConstResultImpl m_impl; Index: lldb/trunk/include/lldb/Core/ValueObjectConstResultImpl.h =================================================================== --- lldb/trunk/include/lldb/Core/ValueObjectConstResultImpl.h +++ lldb/trunk/include/lldb/Core/ValueObjectConstResultImpl.h @@ -54,7 +54,7 @@ } lldb::ValueObjectSP - Cast (const CompilerType &clang_ast_type); + Cast (const CompilerType &compiler_type); void SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS, Index: lldb/trunk/include/lldb/Core/ValueObjectMemory.h =================================================================== --- lldb/trunk/include/lldb/Core/ValueObjectMemory.h +++ lldb/trunk/include/lldb/Core/ValueObjectMemory.h @@ -71,7 +71,7 @@ Address m_address; ///< The variable that this value object is based upon lldb::TypeSP m_type_sp; - CompilerType m_clang_type; + CompilerType m_compiler_type; private: ValueObjectMemory (ExecutionContextScope *exe_scope, Index: lldb/trunk/include/lldb/Core/ValueObjectRegister.h =================================================================== --- lldb/trunk/include/lldb/Core/ValueObjectRegister.h +++ lldb/trunk/include/lldb/Core/ValueObjectRegister.h @@ -177,7 +177,7 @@ RegisterInfo m_reg_info; RegisterValue m_reg_value; ConstString m_type_name; - CompilerType m_clang_type; + CompilerType m_compiler_type; private: void Index: lldb/trunk/include/lldb/Expression/ASTDumper.h =================================================================== --- lldb/trunk/include/lldb/Expression/ASTDumper.h +++ lldb/trunk/include/lldb/Expression/ASTDumper.h @@ -27,7 +27,7 @@ ASTDumper (const clang::Type *type); ASTDumper (clang::QualType type); ASTDumper (lldb::opaque_compiler_type_t type); - ASTDumper (const CompilerType &clang_type); + ASTDumper (const CompilerType &compiler_type); const char *GetCString(); void ToSTDERR(); Index: lldb/trunk/include/lldb/Expression/ClangASTSource.h =================================================================== --- lldb/trunk/include/lldb/Expression/ClangASTSource.h +++ lldb/trunk/include/lldb/Expression/ClangASTSource.h @@ -389,7 +389,7 @@ /// The source AST context, typically the AST context of whatever /// symbol file the type was found in. /// - /// @param[in] clang_type + /// @param[in] src_type /// The source type. /// /// @return @@ -495,10 +495,10 @@ /// Create a TypeDecl with the name being searched for and the provided /// type and register it in the right places. /// - /// @param[in] type + /// @param[in] compiler_type /// The opaque QualType for the TypeDecl being registered. //------------------------------------------------------------------ - clang::NamedDecl *AddTypeDecl(const CompilerType &clang_type); + clang::NamedDecl *AddTypeDecl(const CompilerType &compiler_type); //------------------------------------------------------------------ Index: lldb/trunk/include/lldb/Expression/ExpressionVariable.h =================================================================== --- lldb/trunk/include/lldb/Expression/ExpressionVariable.h +++ lldb/trunk/include/lldb/Expression/ExpressionVariable.h @@ -95,9 +95,9 @@ } 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 Index: lldb/trunk/include/lldb/Symbol/ClangASTContext.h =================================================================== --- lldb/trunk/include/lldb/Symbol/ClangASTContext.h +++ lldb/trunk/include/lldb/Symbol/ClangASTContext.h @@ -253,7 +253,7 @@ CompilerType GetTypeForIdentifier (const ConstString &type_name) { - CompilerType clang_type; + CompilerType compiler_type; if (type_name.GetLength()) { @@ -269,12 +269,12 @@ { clang::NamedDecl *named_decl = result[0]; if (const RecordDeclType *record_decl = llvm::dyn_cast(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 @@ -707,7 +707,7 @@ GetTypeName (lldb::opaque_compiler_type_t type) override; 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 GetMinimumLanguage (lldb::opaque_compiler_type_t type) override; @@ -959,12 +959,12 @@ static bool SetObjCSuperClass (const CompilerType& type, - const CompilerType &superclass_clang_type); + const CompilerType &superclass_compiler_type); static bool AddObjCClassProperty (const CompilerType& type, const char *property_name, - const CompilerType &property_clang_type, + const CompilerType &property_compiler_type, clang::ObjCIvarDecl *ivar_decl, const char *property_setter_name, const char *property_getter_name, @@ -974,7 +974,7 @@ static clang::ObjCMethodDecl * 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 CompilerType &method_clang_type, + const CompilerType &method_compiler_type, lldb::AccessType access, bool is_artificial); Index: lldb/trunk/include/lldb/Symbol/CompilerType.h =================================================================== --- lldb/trunk/include/lldb/Symbol/CompilerType.h +++ lldb/trunk/include/lldb/Symbol/CompilerType.h @@ -220,7 +220,7 @@ GetDisplayTypeName () const; uint32_t - GetTypeInfo (CompilerType *pointee_or_element_clang_type = NULL) const; + GetTypeInfo (CompilerType *pointee_or_element_compiler_type = NULL) const; lldb::LanguageType GetMinimumLanguage (); @@ -413,7 +413,7 @@ uint32_t GetIndexOfFieldWithName (const char* name, - CompilerType* field_clang_type = NULL, + CompilerType* field_compiler_type = NULL, uint64_t *bit_offset_ptr = NULL, uint32_t *bitfield_bit_size_ptr = NULL, bool *is_bitfield_ptr = NULL) const; Index: lldb/trunk/include/lldb/Symbol/GoASTContext.h =================================================================== --- lldb/trunk/include/lldb/Symbol/GoASTContext.h +++ lldb/trunk/include/lldb/Symbol/GoASTContext.h @@ -198,7 +198,7 @@ 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; Index: lldb/trunk/include/lldb/Symbol/SymbolFile.h =================================================================== --- lldb/trunk/include/lldb/Symbol/SymbolFile.h +++ lldb/trunk/include/lldb/Symbol/SymbolFile.h @@ -130,7 +130,7 @@ virtual size_t ParseTypes (const SymbolContext& sc) = 0; virtual size_t ParseVariablesForContext (const SymbolContext& sc) = 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 CompilerDecl GetDeclForUID (lldb::user_id_t uid) { return CompilerDecl(); } virtual CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) { return CompilerDeclContext(); } Index: lldb/trunk/include/lldb/Symbol/TaggedASTType.h =================================================================== --- lldb/trunk/include/lldb/Symbol/TaggedASTType.h +++ lldb/trunk/include/lldb/Symbol/TaggedASTType.h @@ -20,8 +20,8 @@ template class TaggedASTType : public CompilerType { public: - TaggedASTType (const CompilerType &clang_type) : - CompilerType(clang_type) + TaggedASTType (const CompilerType &compiler_type) : + CompilerType(compiler_type) { } Index: lldb/trunk/include/lldb/Symbol/Type.h =================================================================== --- lldb/trunk/include/lldb/Symbol/Type.h +++ lldb/trunk/include/lldb/Symbol/Type.h @@ -92,8 +92,8 @@ lldb::user_id_t encoding_uid, EncodingDataType encoding_uid_type, const Declaration& decl, - const CompilerType &clang_qual_type, - ResolveState clang_type_resolve_state); + const CompilerType &compiler_qual_type, + ResolveState compiler_type_resolve_state); // This makes an invalid type. Used for functions that return a Type when they // get an error. @@ -293,14 +293,14 @@ EncodingDataType m_encoding_uid_type; uint64_t m_byte_size; Declaration m_decl; - CompilerType m_clang_type; + CompilerType m_compiler_type; struct Flags { #ifdef __GNUC__ // 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 - ResolveState clang_type_resolve_state : 2; + ResolveState compiler_type_resolve_state : 2; #endif bool is_complete_objc_class : 1; } m_flags; @@ -309,7 +309,7 @@ GetEncodingType (); bool - ResolveClangType (ResolveState clang_type_resolve_state); + ResolveClangType (ResolveState compiler_type_resolve_state); }; // these classes are used to back the SBType* objects @@ -318,28 +318,28 @@ { public: TypePair () : - clang_type(), + compiler_type(), type_sp() { } TypePair (CompilerType type) : - clang_type(type), + compiler_type(type), type_sp() { } TypePair (lldb::TypeSP type) : - clang_type(), + compiler_type(), type_sp(type) { - clang_type = type_sp->GetForwardCompilerType (); + compiler_type = type_sp->GetForwardCompilerType (); } bool IsValid () const { - return clang_type.IsValid() || (type_sp.get() != nullptr); + return compiler_type.IsValid() || (type_sp.get() != nullptr); } explicit operator bool () const @@ -350,21 +350,21 @@ bool operator == (const TypePair& rhs) const { - return clang_type == rhs.clang_type && + return compiler_type == rhs.compiler_type && type_sp.get() == rhs.type_sp.get(); } bool operator != (const TypePair& rhs) const { - return clang_type != rhs.clang_type || + return compiler_type != rhs.compiler_type || type_sp.get() != rhs.type_sp.get(); } void Clear () { - clang_type.Clear(); + compiler_type.Clear(); type_sp.reset(); } @@ -373,8 +373,8 @@ { if (type_sp) return type_sp->GetName(); - if (clang_type) - return clang_type.GetTypeName(); + if (compiler_type) + return compiler_type.GetTypeName(); return ConstString (); } @@ -383,8 +383,8 @@ { if (type_sp) return type_sp->GetForwardCompilerType ().GetDisplayTypeName(); - if (clang_type) - return clang_type.GetDisplayTypeName(); + if (compiler_type) + return compiler_type.GetDisplayTypeName(); return ConstString(); } @@ -392,14 +392,14 @@ SetType (CompilerType type) { type_sp.reset(); - clang_type = type; + compiler_type = type; } void SetType (lldb::TypeSP type) { type_sp = type; - clang_type = type_sp->GetForwardCompilerType (); + compiler_type = type_sp->GetForwardCompilerType (); } lldb::TypeSP @@ -411,7 +411,7 @@ CompilerType GetCompilerType () const { - return clang_type; + return compiler_type; } CompilerType @@ -419,7 +419,7 @@ { if (type_sp) return type_sp->GetForwardCompilerType().GetPointerType(); - return clang_type.GetPointerType(); + return compiler_type.GetPointerType(); } CompilerType @@ -427,7 +427,7 @@ { if (type_sp) return type_sp->GetForwardCompilerType ().GetPointeeType(); - return clang_type.GetPointeeType(); + return compiler_type.GetPointeeType(); } CompilerType @@ -436,7 +436,7 @@ if (type_sp) return type_sp->GetForwardCompilerType ().GetLValueReferenceType(); else - return clang_type.GetLValueReferenceType(); + return compiler_type.GetLValueReferenceType(); } CompilerType @@ -445,7 +445,7 @@ if (type_sp) return type_sp->GetForwardCompilerType ().GetTypedefedType(); else - return clang_type.GetTypedefedType(); + return compiler_type.GetTypedefedType(); } CompilerType @@ -454,7 +454,7 @@ if (type_sp) return type_sp->GetForwardCompilerType ().GetNonReferenceType(); else - return clang_type.GetNonReferenceType(); + return compiler_type.GetNonReferenceType(); } CompilerType @@ -463,7 +463,7 @@ if (type_sp) return type_sp->GetForwardCompilerType ().GetFullyUnqualifiedType(); else - return clang_type.GetFullyUnqualifiedType(); + return compiler_type.GetFullyUnqualifiedType(); } CompilerType @@ -471,13 +471,13 @@ { if (type_sp) return type_sp->GetForwardCompilerType ().GetCanonicalType(); - return clang_type.GetCanonicalType(); + return compiler_type.GetCanonicalType(); } TypeSystem * GetTypeSystem () const { - return clang_type.GetTypeSystem(); + return compiler_type.GetTypeSystem(); } lldb::ModuleSP @@ -488,7 +488,7 @@ return lldb::ModuleSP(); } protected: - CompilerType clang_type; + CompilerType compiler_type; lldb::TypeSP type_sp; }; @@ -504,11 +504,11 @@ 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 CompilerType &clang_type, const CompilerType &dynamic); + TypeImpl (const CompilerType &compiler_type, const CompilerType &dynamic); TypeImpl (const TypePair &pair, const CompilerType &dynamic); @@ -516,13 +516,13 @@ SetType (const lldb::TypeSP &type_sp); void - SetType (const CompilerType &clang_type); + SetType (const CompilerType &compiler_type); void SetType (const lldb::TypeSP &type_sp, const CompilerType &dynamic); void - SetType (const CompilerType &clang_type, const CompilerType &dynamic); + SetType (const CompilerType &compiler_type, const CompilerType &dynamic); void SetType (const TypePair &pair, const CompilerType &dynamic); @@ -745,7 +745,7 @@ public: TypeAndOrName (); TypeAndOrName (lldb::TypeSP &type_sp); - TypeAndOrName (const CompilerType &clang_type); + TypeAndOrName (const CompilerType &compiler_type); TypeAndOrName (const char *type_str); TypeAndOrName (const TypeAndOrName &rhs); TypeAndOrName (ConstString &type_const_string); @@ -783,7 +783,7 @@ SetTypeSP (lldb::TypeSP type_sp); void - SetCompilerType (CompilerType clang_type); + SetCompilerType (CompilerType compiler_type); bool IsEmpty () const; Index: lldb/trunk/include/lldb/Symbol/TypeSystem.h =================================================================== --- lldb/trunk/include/lldb/Symbol/TypeSystem.h +++ lldb/trunk/include/lldb/Symbol/TypeSystem.h @@ -211,7 +211,7 @@ GetTypeName (lldb::opaque_compiler_type_t type) = 0; 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 GetMinimumLanguage (lldb::opaque_compiler_type_t type) = 0; Index: lldb/trunk/include/lldb/Target/LanguageRuntime.h =================================================================== --- lldb/trunk/include/lldb/Target/LanguageRuntime.h +++ lldb/trunk/include/lldb/Target/LanguageRuntime.h @@ -120,7 +120,7 @@ CreateExceptionSearchFilter (); virtual bool - GetTypeBitSize (const CompilerType& clang_type, + GetTypeBitSize (const CompilerType& compiler_type, uint64_t &size) { return false; Index: lldb/trunk/include/lldb/Target/ObjCLanguageRuntime.h =================================================================== --- lldb/trunk/include/lldb/Target/ObjCLanguageRuntime.h +++ lldb/trunk/include/lldb/Target/ObjCLanguageRuntime.h @@ -377,7 +377,7 @@ } bool - GetTypeBitSize (const CompilerType& clang_type, + GetTypeBitSize (const CompilerType& compiler_type, uint64_t &size) override; protected: Index: lldb/trunk/source/API/SBType.cpp =================================================================== --- lldb/trunk/source/API/SBType.cpp +++ lldb/trunk/source/API/SBType.cpp @@ -269,9 +269,9 @@ { if (IsValid()) { - CompilerType return_clang_type (m_opaque_sp->GetCompilerType(true).GetFunctionReturnType()); - if (return_clang_type.IsValid()) - return SBType(return_clang_type); + CompilerType return_type (m_opaque_sp->GetCompilerType(true).GetFunctionReturnType()); + if (return_type.IsValid()) + return SBType(return_type); } return lldb::SBType(); } Index: lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp =================================================================== --- lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp +++ lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp @@ -1048,7 +1048,7 @@ valobj_sp = valobj_list.GetValueObjectAtIndex(0); } - CompilerType clang_type; + CompilerType compiler_type; if (valobj_sp) { @@ -1061,7 +1061,7 @@ size = m_option_watchpoint.watch_size == 0 ? valobj_sp->GetByteSize() : m_option_watchpoint.watch_size; } - clang_type = valobj_sp->GetCompilerType(); + compiler_type = valobj_sp->GetCompilerType(); } else { @@ -1078,7 +1078,7 @@ uint32_t watch_type = m_option_watchpoint.watch_type; 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) { wp->SetWatchSpec(command.GetArgumentAtIndex(0)); @@ -1295,10 +1295,10 @@ // 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. - CompilerType clang_type(valobj_sp->GetCompilerType()); + CompilerType compiler_type(valobj_sp->GetCompilerType()); 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) { Stream &output_stream = result.GetOutputStream(); Index: lldb/trunk/source/Core/Value.cpp =================================================================== --- lldb/trunk/source/Core/Value.cpp +++ lldb/trunk/source/Core/Value.cpp @@ -35,7 +35,7 @@ Value::Value() : m_value (), m_vector (), - m_clang_type (), + m_compiler_type (), m_context (NULL), m_value_type (eValueTypeScalar), m_context_type (eContextTypeInvalid), @@ -46,7 +46,7 @@ Value::Value(const Scalar& scalar) : m_value (scalar), m_vector (), - m_clang_type (), + m_compiler_type (), m_context (NULL), m_value_type (eValueTypeScalar), m_context_type (eContextTypeInvalid), @@ -58,7 +58,7 @@ Value::Value(const void *bytes, int len) : m_value (), m_vector (), - m_clang_type (), + m_compiler_type (), m_context (NULL), m_value_type (eValueTypeHostAddress), m_context_type (eContextTypeInvalid), @@ -70,7 +70,7 @@ Value::Value(const Value &v) : m_value (v.m_value), 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_value_type (v.m_value_type), m_context_type (v.m_context_type), @@ -93,7 +93,7 @@ { m_value = rhs.m_value; 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_value_type = rhs.m_value_type; m_context_type = rhs.m_context_type; @@ -300,7 +300,7 @@ const CompilerType & Value::GetCompilerType () { - if (!m_clang_type.IsValid()) + if (!m_compiler_type.IsValid()) { switch (m_context_type) { @@ -308,13 +308,13 @@ break; case eContextTypeRegisterInfo: - break; // TODO: Eventually convert into a clang type? + break; // TODO: Eventually convert into a compiler type? case eContextTypeLLDBType: { Type *lldb_type = GetType(); if (lldb_type) - m_clang_type = lldb_type->GetForwardCompilerType (); + m_compiler_type = lldb_type->GetForwardCompilerType (); } break; @@ -325,20 +325,20 @@ { Type *variable_type = variable->GetType(); if (variable_type) - m_clang_type = variable_type->GetForwardCompilerType (); + m_compiler_type = variable_type->GetForwardCompilerType (); } } break; } } - return m_clang_type; + return m_compiler_type; } 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 @@ -721,8 +721,8 @@ Scalar & Value::ResolveValue(ExecutionContext *exe_ctx) { - const CompilerType &clang_type = GetCompilerType(); - if (clang_type.IsValid()) + const CompilerType &compiler_type = GetCompilerType(); + if (compiler_type.IsValid()) { switch (m_value_type) { @@ -740,7 +740,7 @@ if (error.Success()) { 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_type = eValueTypeScalar; @@ -782,7 +782,7 @@ { m_value.Clear(); m_vector.Clear(); - m_clang_type.Clear(); + m_compiler_type.Clear(); m_value_type = eValueTypeScalar; m_context = NULL; m_context_type = eContextTypeInvalid; Index: lldb/trunk/source/Core/ValueObject.cpp =================================================================== --- lldb/trunk/source/Core/ValueObject.cpp +++ lldb/trunk/source/Core/ValueObject.cpp @@ -324,30 +324,30 @@ CompilerType ValueObject::MaybeCalculateCompleteType () { - CompilerType clang_type(GetCompilerTypeImpl()); + CompilerType compiler_type(GetCompilerTypeImpl()); if (m_did_calculate_complete_objc_class_type) { if (m_override_type.IsValid()) return m_override_type; else - return clang_type; + return compiler_type; } CompilerType class_type; bool is_pointer_type = false; - if (ClangASTContext::IsObjCObjectPointerType(clang_type, &class_type)) + if (ClangASTContext::IsObjCObjectPointerType(compiler_type, &class_type)) { 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 { - return clang_type; + return compiler_type; } m_did_calculate_complete_objc_class_type = true; @@ -391,7 +391,7 @@ } } } - return clang_type; + return compiler_type; } CompilerType @@ -936,10 +936,10 @@ bool ValueObject::IsCStringContainer(bool check_pointer) { - CompilerType pointee_or_element_clang_type; - const Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type)); + CompilerType pointee_or_element_compiler_type; + const Flags type_flags (GetTypeInfo (&pointee_or_element_compiler_type)); 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) return false; if (!check_pointer) @@ -957,8 +957,8 @@ uint32_t item_idx, uint32_t item_count) { - CompilerType pointee_or_element_clang_type; - const uint32_t type_info = GetTypeInfo (&pointee_or_element_clang_type); + CompilerType pointee_or_element_compiler_type; + const uint32_t type_info = GetTypeInfo (&pointee_or_element_compiler_type); const bool is_pointer_type = type_info & eTypeIsPointer; const bool is_array_type = type_info & eTypeIsArray; if (!(is_pointer_type || is_array_type)) @@ -969,7 +969,7 @@ 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 offset = item_idx * item_type_size; @@ -1225,11 +1225,11 @@ size_t bytes_read = 0; size_t total_bytes_read = 0; - CompilerType clang_type = GetCompilerType(); - CompilerType elem_or_pointee_clang_type; - const Flags type_flags (GetTypeInfo (&elem_or_pointee_clang_type)); + CompilerType compiler_type = GetCompilerType(); + CompilerType elem_or_pointee_compiler_type; + const Flags type_flags (GetTypeInfo (&elem_or_pointee_compiler_type)); 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; AddressType cstr_address_type = eAddressTypeInvalid; @@ -1240,7 +1240,7 @@ { // We have an array 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; if (cstr_len > max_length) @@ -1384,11 +1384,11 @@ if (runtime == NULL) { // Aw, hell, if the things a pointer, or even just an integer, let's try ObjC anyway... - CompilerType clang_type = GetCompilerType(); - if (clang_type) + CompilerType compiler_type = GetCompilerType(); + if (compiler_type) { 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); } @@ -2022,9 +2022,9 @@ } 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 @@ -2416,9 +2416,9 @@ if (IsBaseClass()) { bool parent_had_base_class = GetParent() && GetParent()->GetBaseClassPath (s); - CompilerType clang_type = GetCompilerType(); + CompilerType compiler_type = GetCompilerType(); 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 (parent_had_base_class) @@ -2535,8 +2535,8 @@ ValueObject *non_base_class_parent = GetNonBaseClassParent(); if (non_base_class_parent) { - CompilerType non_base_class_parent_clang_type = non_base_class_parent->GetCompilerType(); - if (non_base_class_parent_clang_type) + CompilerType non_base_class_parent_compiler_type = non_base_class_parent->GetCompilerType(); + if (non_base_class_parent_compiler_type) { if (parent && parent->IsDereferenceOfParent() && epformat == eGetExpressionPathFormatHonorPointers) { @@ -2544,7 +2544,7 @@ } 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) { @@ -2756,13 +2756,13 @@ const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr - CompilerType root_clang_type = root->GetCompilerType(); - CompilerType pointee_clang_type; - Flags pointee_clang_type_info; - - Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type)); - if (pointee_clang_type) - pointee_clang_type_info.Reset(pointee_clang_type.GetTypeInfo()); + CompilerType root_compiler_type = root->GetCompilerType(); + CompilerType pointee_compiler_type; + Flags pointee_compiler_type_info; + + Flags root_compiler_type_info(root_compiler_type.GetTypeInfo(&pointee_compiler_type)); + if (pointee_compiler_type) + pointee_compiler_type_info.Reset(pointee_compiler_type.GetTypeInfo()); if (!expression_cstr || *expression_cstr == '\0') { @@ -2775,15 +2775,15 @@ case '-': { 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; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrowInsteadOfDot; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid; return ValueObjectSP(); } - if (root_clang_type_info.Test(eTypeIsObjC) && // if yo are trying to extract an ObjC IVar when this is forbidden - root_clang_type_info.Test(eTypeIsPointer) && + if (root_compiler_type_info.Test(eTypeIsObjC) && // if yo are trying to extract an ObjC IVar when this is forbidden + root_compiler_type_info.Test(eTypeIsPointer) && options.m_no_fragile_ivar) { *first_unparsed = expression_cstr; @@ -2803,7 +2803,7 @@ case '.': // or fallthrough from -> { 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; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDotInsteadOfArrow; @@ -2952,9 +2952,9 @@ } 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 { @@ -2974,7 +2974,7 @@ } 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; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed; @@ -3011,7 +3011,7 @@ } 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; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet; @@ -3027,7 +3027,7 @@ } } // 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); if (!child_valobj_sp) @@ -3050,10 +3050,10 @@ 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 - pointee_clang_type_info.Test(eTypeIsScalar)) + pointee_compiler_type_info.Test(eTypeIsScalar)) { Error error; root = root->Dereference(error); @@ -3073,7 +3073,7 @@ else { if (root->GetCompilerType().GetMinimumLanguage() == eLanguageTypeObjC - && pointee_clang_type_info.AllClear(eTypeIsPointer) + && pointee_compiler_type_info.AllClear(eTypeIsPointer) && root->HasSyntheticValue() && (options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::ToSynthetic || options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both)) @@ -3097,7 +3097,7 @@ } } } - else if (root_clang_type_info.Test(eTypeIsScalar)) + else if (root_compiler_type_info.Test(eTypeIsScalar)) { root = root->GetSyntheticBitFieldChild(index, index, true); if (!root.get()) @@ -3115,7 +3115,7 @@ return root; } } - else if (root_clang_type_info.Test(eTypeIsVector)) + else if (root_compiler_type_info.Test(eTypeIsVector)) { root = root->GetChildAtIndex(index, true); if (!root.get()) @@ -3201,7 +3201,7 @@ index_lower = index_higher; 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); if (!root.get()) @@ -3219,9 +3219,9 @@ 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 && - pointee_clang_type_info.Test(eTypeIsScalar)) + pointee_compiler_type_info.Test(eTypeIsScalar)) { Error error; root = root->Dereference(error); @@ -3280,12 +3280,12 @@ const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr - CompilerType root_clang_type = root->GetCompilerType(); - CompilerType pointee_clang_type; - Flags pointee_clang_type_info; - Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type)); - if (pointee_clang_type) - pointee_clang_type_info.Reset(pointee_clang_type.GetTypeInfo()); + CompilerType root_compiler_type = root->GetCompilerType(); + CompilerType pointee_compiler_type; + Flags pointee_compiler_type_info; + Flags root_compiler_type_info(root_compiler_type.GetTypeInfo(&pointee_compiler_type)); + if (pointee_compiler_type) + pointee_compiler_type_info.Reset(pointee_compiler_type.GetTypeInfo()); if (!expression_cstr || *expression_cstr == '\0') { @@ -3298,9 +3298,9 @@ { 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; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid; @@ -3317,7 +3317,7 @@ } 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; *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed; @@ -3361,7 +3361,7 @@ } 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; for (size_t index = 0; index < max_index; index++) @@ -3384,7 +3384,7 @@ } } // 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); if (!root.get()) @@ -3403,10 +3403,10 @@ 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 - pointee_clang_type_info.Test(eTypeIsScalar)) + pointee_compiler_type_info.Test(eTypeIsScalar)) { Error error; root = root->Dereference(error); @@ -3443,7 +3443,7 @@ } } } - else /*if (ClangASTContext::IsScalarType(root_clang_type))*/ + else /*if (ClangASTContext::IsScalarType(root_compiler_type))*/ { root = root->GetSyntheticBitFieldChild(index, index, true); if (!root.get()) @@ -3488,7 +3488,7 @@ index_lower = index_higher; 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); if (!root.get()) @@ -3507,9 +3507,9 @@ 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 && - pointee_clang_type_info.Test(eTypeIsScalar)) + pointee_compiler_type_info.Test(eTypeIsScalar)) { Error error; root = root->Dereference(error); @@ -3805,14 +3805,14 @@ case eAddressTypeFile: case eAddressTypeLoad: { - CompilerType clang_type = GetCompilerType(); - if (clang_type) + CompilerType compiler_type = GetCompilerType(); + if (compiler_type) { std::string name (1, '&'); name.append (m_name.AsCString("")); ExecutionContext exe_ctx (GetExecutionContextRef()); m_addr_of_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), - clang_type.GetPointerType(), + compiler_type.GetPointerType(), ConstString (name.c_str()), addr, eAddressTypeInvalid, @@ -3835,13 +3835,13 @@ } 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 -ValueObject::CastPointerType (const char *name, CompilerType &clang_ast_type) +ValueObject::CastPointerType (const char *name, CompilerType &compiler_type) { ValueObjectSP valobj_sp; AddressType address_type; @@ -3854,7 +3854,7 @@ valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), name, ptr_addr, - clang_ast_type); + compiler_type); } return valobj_sp; } Index: lldb/trunk/source/Core/ValueObjectCast.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectCast.cpp +++ lldb/trunk/source/Core/ValueObjectCast.cpp @@ -97,9 +97,9 @@ Value old_value(m_value); m_update_point.SetUpdated(); m_value = m_parent->GetValue(); - CompilerType clang_type (GetCompilerType()); - //m_value.SetContext (Value::eContextTypeClangType, clang_type); - m_value.SetCompilerType (clang_type); + CompilerType compiler_type (GetCompilerType()); + //m_value.SetContext (Value::eContextTypeClangType, compiler_type); + m_value.SetCompilerType (compiler_type); SetAddressTypeOfChildren(m_parent->GetAddressTypeOfChildren()); if (!CanProvideValue()) { Index: lldb/trunk/source/Core/ValueObjectChild.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectChild.cpp +++ lldb/trunk/source/Core/ValueObjectChild.cpp @@ -27,7 +27,7 @@ ValueObjectChild::ValueObjectChild ( ValueObject &parent, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, uint64_t byte_size, int32_t byte_offset, @@ -38,7 +38,7 @@ AddressType child_ptr_or_ref_addr_type ) : ValueObject (parent), - m_clang_type (clang_type), + m_compiler_type (compiler_type), m_byte_size (byte_size), m_byte_offset (byte_offset), m_bitfield_bit_size (bitfield_bit_size), @@ -73,11 +73,11 @@ { if (name && bitfield_bit_size) { - const char *clang_type_name = name.AsCString(); - if (clang_type_name) + const char *compiler_type_name = name.AsCString(); + if (compiler_type_name) { - std::vector bitfield_type_name (strlen(clang_type_name) + 32, 0); - ::snprintf (&bitfield_type_name.front(), bitfield_type_name.size(), "%s:%u", clang_type_name, bitfield_bit_size); + std::vector bitfield_type_name (strlen(compiler_type_name) + 32, 0); + ::snprintf (&bitfield_type_name.front(), bitfield_type_name.size(), "%s:%u", compiler_type_name, bitfield_bit_size); name.SetCString(&bitfield_type_name.front()); } } Index: lldb/trunk/source/Core/ValueObjectConstResult.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectConstResult.cpp +++ lldb/trunk/source/Core/ValueObjectConstResult.cpp @@ -61,21 +61,21 @@ ValueObjectConstResult::Create ( ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, const DataExtractor &data, lldb::addr_t address ) { return (new ValueObjectConstResult (exe_scope, - clang_type, + compiler_type, name, data, address))->GetSP(); } ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, const DataExtractor &data, lldb::addr_t address) : @@ -94,7 +94,7 @@ m_value.GetScalar() = (uintptr_t)m_data.GetDataStart(); m_value.SetValueType(Value::eValueTypeHostAddress); - m_value.SetCompilerType(clang_type); + m_value.SetCompilerType(compiler_type); m_name = name; SetIsConstant (); SetValueIsValid(true); @@ -103,7 +103,7 @@ ValueObjectSP ValueObjectConstResult::Create (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, const lldb::DataBufferSP &data_sp, lldb::ByteOrder data_byte_order, @@ -111,7 +111,7 @@ lldb::addr_t address) { return (new ValueObjectConstResult (exe_scope, - clang_type, + compiler_type, name, data_sp, data_byte_order, @@ -129,7 +129,7 @@ } ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, const lldb::DataBufferSP &data_sp, lldb::ByteOrder data_byte_order, @@ -145,8 +145,8 @@ m_data.SetData(data_sp); m_value.GetScalar() = (uintptr_t)data_sp->GetBytes(); m_value.SetValueType(Value::eValueTypeHostAddress); - //m_value.SetContext(Value::eContextTypeClangType, clang_type); - m_value.SetCompilerType (clang_type); + //m_value.SetContext(Value::eContextTypeClangType, compiler_type); + m_value.SetCompilerType (compiler_type); m_name = name; SetIsConstant (); SetValueIsValid(true); @@ -155,14 +155,14 @@ ValueObjectSP ValueObjectConstResult::Create (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, lldb::addr_t address, AddressType address_type, uint32_t addr_byte_size) { return (new ValueObjectConstResult (exe_scope, - clang_type, + compiler_type, name, address, address_type, @@ -170,7 +170,7 @@ } ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, lldb::addr_t address, AddressType address_type, @@ -191,8 +191,8 @@ case eAddressTypeLoad: m_value.SetValueType(Value::eValueTypeLoadAddress); break; case eAddressTypeHost: m_value.SetValueType(Value::eValueTypeHostAddress); break; } -// m_value.SetContext(Value::eContextTypeClangType, clang_type); - m_value.SetCompilerType (clang_type); +// m_value.SetContext(Value::eContextTypeClangType, compiler_type); + m_value.SetCompilerType (compiler_type); m_name = name; SetIsConstant (); SetValueIsValid(true); @@ -366,9 +366,9 @@ } 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 Index: lldb/trunk/source/Core/ValueObjectConstResultCast.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectConstResultCast.cpp +++ lldb/trunk/source/Core/ValueObjectConstResultCast.cpp @@ -69,7 +69,7 @@ } 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); } Index: lldb/trunk/source/Core/ValueObjectConstResultChild.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectConstResultChild.cpp +++ lldb/trunk/source/Core/ValueObjectConstResultChild.cpp @@ -19,7 +19,7 @@ ValueObjectConstResultChild::ValueObjectConstResultChild ( ValueObject &parent, - const CompilerType &clang_type, + const CompilerType &compiler_type, const ConstString &name, uint32_t byte_size, int32_t byte_offset, @@ -30,7 +30,7 @@ lldb::addr_t live_address ) : ValueObjectChild (parent, - clang_type, + compiler_type, name, byte_size, byte_offset, @@ -81,7 +81,7 @@ } 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); } Index: lldb/trunk/source/Core/ValueObjectConstResultImpl.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectConstResultImpl.cpp +++ lldb/trunk/source/Core/ValueObjectConstResultImpl.cpp @@ -71,24 +71,24 @@ bool child_is_deref_of_parent = 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; ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef()); - child_compiler_type = clang_type.GetChildCompilerTypeAtIndex (&exe_ctx, - idx, - transparent_pointers, - omit_empty_base_classes, - ignore_array_bounds, - child_name_str, - child_byte_size, - child_byte_offset, - child_bitfield_bit_size, - child_bitfield_bit_offset, - child_is_base_class, - child_is_deref_of_parent, - m_impl_backend); + child_compiler_type = compiler_type.GetChildCompilerTypeAtIndex (&exe_ctx, + idx, + transparent_pointers, + omit_empty_base_classes, + ignore_array_bounds, + child_name_str, + child_byte_size, + child_byte_offset, + child_bitfield_bit_size, + child_bitfield_bit_offset, + child_is_base_class, + child_is_deref_of_parent, + m_impl_backend); if (child_compiler_type && child_byte_size) { if (synthetic_index) @@ -132,7 +132,7 @@ return lldb::ValueObjectSP(); 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))); @@ -140,7 +140,7 @@ new_name.append(m_impl_backend->GetName().AsCString("")); ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef()); m_address_of_backend = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), - clang_type.GetPointerType(), + compiler_type.GetPointerType(), ConstString(new_name.c_str()), buffer, lldb::endian::InlHostByteOrder(), @@ -156,13 +156,13 @@ } lldb::ValueObjectSP -ValueObjectConstResultImpl::Cast (const CompilerType &clang_ast_type) +ValueObjectConstResultImpl::Cast (const CompilerType &compiler_type) { if (m_impl_backend == NULL) return lldb::ValueObjectSP(); 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(); } Index: lldb/trunk/source/Core/ValueObjectMemory.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectMemory.cpp +++ lldb/trunk/source/Core/ValueObjectMemory.cpp @@ -58,7 +58,7 @@ ValueObject(exe_scope), m_address (address), m_type_sp(type_sp), - m_clang_type() + m_compiler_type() { // Do not attempt to construct one of these objects with no variable! assert (m_type_sp.get() != NULL); @@ -94,17 +94,17 @@ ValueObject(exe_scope), m_address (address), 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! - assert (m_clang_type.GetTypeSystem()); - assert (m_clang_type.GetOpaqueQualType()); + assert (m_compiler_type.GetTypeSystem()); + assert (m_compiler_type.GetOpaqueQualType()); TargetSP target_sp (GetTargetSP()); SetName (ConstString(name)); -// m_value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType()); - m_value.SetCompilerType(m_clang_type); +// m_value.SetContext(Value::eContextTypeClangType, m_compiler_type.GetOpaqueQualType()); + m_value.SetCompilerType(m_compiler_type); lldb::addr_t load_address = m_address.GetLoadAddress (target_sp.get()); if (load_address != LLDB_INVALID_ADDRESS) { @@ -136,7 +136,7 @@ { if (m_type_sp) return m_type_sp->GetForwardCompilerType (); - return m_clang_type; + return m_compiler_type; } ConstString @@ -144,7 +144,7 @@ { if (m_type_sp) return m_type_sp->GetName(); - return m_clang_type.GetConstTypeName(); + return m_compiler_type.GetConstTypeName(); } ConstString @@ -152,7 +152,7 @@ { if (m_type_sp) return m_type_sp->GetForwardCompilerType ().GetDisplayTypeName(); - return m_clang_type.GetDisplayTypeName(); + return m_compiler_type.GetDisplayTypeName(); } size_t @@ -161,7 +161,7 @@ if (m_type_sp) return m_type_sp->GetNumChildren(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 @@ -169,7 +169,7 @@ { if (m_type_sp) return m_type_sp->GetByteSize(); - return m_clang_type.GetByteSize (nullptr); + return m_compiler_type.GetByteSize (nullptr); } lldb::ValueType @@ -249,8 +249,8 @@ value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get()); else { - //value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType()); - value.SetCompilerType(m_clang_type); + //value.SetContext(Value::eContextTypeClangType, m_compiler_type.GetOpaqueQualType()); + value.SetCompilerType(m_compiler_type); } m_error = value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get()); Index: lldb/trunk/source/Core/ValueObjectRegister.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectRegister.cpp +++ lldb/trunk/source/Core/ValueObjectRegister.cpp @@ -279,7 +279,7 @@ m_reg_info (), m_reg_value (), m_type_name (), - m_clang_type () + m_compiler_type () { assert (reg_ctx_sp.get()); ConstructObject(reg_num); @@ -297,7 +297,7 @@ m_reg_info (), m_reg_value (), m_type_name (), - m_clang_type () + m_compiler_type () { assert (reg_ctx); ConstructObject(reg_num); @@ -310,7 +310,7 @@ CompilerType ValueObjectRegister::GetCompilerTypeImpl () { - if (!m_clang_type.IsValid()) + if (!m_compiler_type.IsValid()) { ExecutionContext exe_ctx (GetExecutionContextRef()); Target *target = exe_ctx.GetTargetPtr(); @@ -321,12 +321,12 @@ { TypeSystem *type_system = exe_module->GetTypeSystemForLanguage (eLanguageTypeC); 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); } } } - return m_clang_type; + return m_compiler_type; } ConstString Index: lldb/trunk/source/Core/ValueObjectVariable.cpp =================================================================== --- lldb/trunk/source/Core/ValueObjectVariable.cpp +++ lldb/trunk/source/Core/ValueObjectVariable.cpp @@ -168,15 +168,15 @@ m_resolved_value = m_value; m_value.SetContext(Value::eContextTypeVariable, variable); - CompilerType clang_type = GetCompilerType(); - if (clang_type.IsValid()) - m_value.SetCompilerType(clang_type); + CompilerType compiler_type = GetCompilerType(); + if (compiler_type.IsValid()) + m_value.SetCompilerType(compiler_type); Value::ValueType value_type = m_value.GetValueType(); Process *process = exe_ctx.GetProcessPtr(); 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; switch (value_type) Index: lldb/trunk/source/Expression/ASTDumper.cpp =================================================================== --- lldb/trunk/source/Expression/ASTDumper.cpp +++ lldb/trunk/source/Expression/ASTDumper.cpp @@ -80,9 +80,9 @@ 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(); } Index: lldb/trunk/source/Expression/IRForTarget.cpp =================================================================== --- lldb/trunk/source/Expression/IRForTarget.cpp +++ lldb/trunk/source/Expression/IRForTarget.cpp @@ -1509,7 +1509,7 @@ if (value_decl == NULL) 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; @@ -1524,7 +1524,7 @@ // to the type of $__lldb_expr_result, not the type itself. // // 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); } else @@ -1532,14 +1532,14 @@ value_type = global_variable->getType(); } - const uint64_t value_size = clang_type.GetByteSize(nullptr); - lldb::offset_t value_alignment = (clang_type.GetTypeBitAlign() + 7ull) / 8ull; + const uint64_t value_size = compiler_type.GetByteSize(nullptr); + lldb::offset_t value_alignment = (compiler_type.GetTypeBitAlign() + 7ull) / 8ull; if (log) { log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64 ", align %" PRIu64 "]", 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(), value_size, value_alignment); Index: lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp +++ lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp @@ -332,18 +332,18 @@ if (!value) return false; - CompilerType clang_type = value->GetCompilerType(); - if (clang_type) + CompilerType compiler_type = value->GetCompilerType(); + if (compiler_type) { bool is_signed = false; 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 { @@ -415,15 +415,15 @@ ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl (Thread &thread, - lldb_private::CompilerType &clang_type) const + lldb_private::CompilerType &compiler_type) const { Value value; ValueObjectSP return_valobj_sp; - if (!clang_type) + if (!compiler_type) return return_valobj_sp; - value.SetCompilerType (clang_type); + value.SetCompilerType (compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) @@ -435,9 +435,9 @@ // when reading data 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) { @@ -475,7 +475,7 @@ break; } } - else if (clang_type.IsPointerType ()) + else if (compiler_type.IsPointerType ()) { uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX; value.GetScalar() = ptr; @@ -504,8 +504,8 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; @@ -520,7 +520,7 @@ RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 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; Error data_error; @@ -560,7 +560,7 @@ 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) error.SetErrorString ("We don't support returning complex values at present"); Index: lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp +++ lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp @@ -858,7 +858,7 @@ } 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; Value value; @@ -867,16 +867,16 @@ if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL) return return_valobj_sp; - //value.SetContext (Value::eContextTypeClangType, return_clang_type); - value.SetCompilerType(return_clang_type); + //value.SetContext (Value::eContextTypeClangType, return_compiler_type); + value.SetCompilerType(return_compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) 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 || type_flags & eTypeIsPointer) { @@ -923,7 +923,7 @@ exe_ctx.GetProcessRef().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); return return_valobj_sp; @@ -1040,7 +1040,7 @@ byte_order, exe_ctx.GetProcessRef().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); } @@ -1057,10 +1057,10 @@ uint32_t NGRN = 0; // Search ABI docs for NGRN uint32_t NSRN = 0; // Search ABI docs for NSRN 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_clang_type, + return_compiler_type, ConstString(""), data); } Index: lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp +++ lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp @@ -306,23 +306,23 @@ // We currently only support extracting values with Clang QualTypes. // Do we care about others? - CompilerType clang_type (value->GetCompilerType()); - if (clang_type) + CompilerType compiler_type (value->GetCompilerType()); + if (compiler_type) { bool is_signed; - if (clang_type.IsIntegerType (is_signed)) + if (compiler_type.IsIntegerType (is_signed)) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), is_signed, thread.GetProcess().get(), current_stack_argument); } - else if (clang_type.IsPointerType()) + else if (compiler_type.IsPointerType()) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), false, thread.GetProcess().get(), current_stack_argument); @@ -343,8 +343,8 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; @@ -359,7 +359,7 @@ RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 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; Error data_error; @@ -399,7 +399,7 @@ 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) error.SetErrorString ("We don't support returning complex values at present"); @@ -415,16 +415,16 @@ ValueObjectSP ABIMacOSX_i386::GetReturnValueObjectImpl (Thread &thread, - CompilerType &clang_type) const + CompilerType &compiler_type) const { Value value; ValueObjectSP return_valobj_sp; - if (!clang_type) + if (!compiler_type) return return_valobj_sp; - //value.SetContext (Value::eContextTypeClangType, clang_type.GetOpaqueQualType()); - value.SetCompilerType (clang_type); + //value.SetContext (Value::eContextTypeClangType, compiler_type.GetOpaqueQualType()); + value.SetCompilerType (compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) @@ -432,9 +432,9 @@ 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 edx_id = reg_ctx->GetRegisterInfoByName("edx", 0)->kinds[eRegisterKindLLDB]; @@ -474,7 +474,7 @@ break; } } - else if (clang_type.IsPointerType ()) + else if (compiler_type.IsPointerType ()) { unsigned eax_id = reg_ctx->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB]; uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff; Index: lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp @@ -332,18 +332,18 @@ if (!value) return false; - CompilerType clang_type = value->GetCompilerType(); - if (clang_type) + CompilerType compiler_type = value->GetCompilerType(); + if (compiler_type) { bool is_signed = false; 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 { @@ -416,16 +416,16 @@ ValueObjectSP ABISysV_arm::GetReturnValueObjectImpl (Thread &thread, - lldb_private::CompilerType &clang_type) const + lldb_private::CompilerType &compiler_type) const { Value value; ValueObjectSP return_valobj_sp; - if (!clang_type) + if (!compiler_type) return return_valobj_sp; - //value.SetContext (Value::eContextTypeClangType, clang_type.GetOpaqueQualType()); - value.SetCompilerType (clang_type); + //value.SetContext (Value::eContextTypeClangType, compiler_type.GetOpaqueQualType()); + value.SetCompilerType (compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) @@ -439,9 +439,9 @@ // when reading data 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) { @@ -479,14 +479,14 @@ break; } } - else if (clang_type.IsPointerType ()) + else if (compiler_type.IsPointerType ()) { uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX; 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) { DataBufferHeap buffer(16, 0); @@ -505,7 +505,7 @@ 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) { @@ -539,9 +539,9 @@ 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) { RegisterValue r0_reg_value; @@ -578,8 +578,8 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; @@ -594,7 +594,7 @@ RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 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; Error data_error; @@ -634,7 +634,7 @@ 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) error.SetErrorString ("We don't support returning complex values at present"); Index: lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp @@ -828,7 +828,7 @@ } 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; Value value; @@ -837,16 +837,16 @@ if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL) return return_valobj_sp; - //value.SetContext (Value::eContextTypeClangType, return_clang_type); - value.SetCompilerType(return_clang_type); + //value.SetContext (Value::eContextTypeClangType, return_compiler_type); + value.SetCompilerType(return_compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) 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 || type_flags & eTypeIsPointer) { @@ -895,7 +895,7 @@ exe_ctx.GetProcessRef().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); return return_valobj_sp; @@ -1012,7 +1012,7 @@ byte_order, exe_ctx.GetProcessRef().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); } @@ -1029,10 +1029,10 @@ uint32_t NGRN = 0; // Search ABI docs for NGRN uint32_t NSRN = 0; // Search ABI docs for NSRN 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_clang_type, + return_compiler_type, ConstString(""), data); } Index: lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp @@ -358,14 +358,14 @@ } 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; return return_valobj_sp; } 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; return return_valobj_sp; Index: lldb/trunk/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp @@ -324,22 +324,22 @@ return false; // Currently: Support for extracting values with Clang QualTypes only. - CompilerType clang_type (value->GetCompilerType()); - if (clang_type) + CompilerType compiler_type (value->GetCompilerType()); + if (compiler_type) { bool is_signed; - if (clang_type.IsIntegerType (is_signed)) + if (compiler_type.IsIntegerType (is_signed)) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), is_signed, thread.GetProcess().get(), current_stack_argument); } - else if (clang_type.IsPointerType()) + else if (compiler_type.IsPointerType()) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), false, thread.GetProcess().get(), current_stack_argument); @@ -361,14 +361,14 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; } - const uint32_t type_flags = clang_type.GetTypeInfo (); + const uint32_t type_flags = compiler_type.GetTypeInfo (); Thread *thread = frame_sp->GetThread().get(); RegisterContext *reg_ctx = thread->GetRegisterContext().get(); DataExtractor data; @@ -504,21 +504,21 @@ ValueObjectSP ABISysV_i386::GetReturnValueObjectSimple (Thread &thread, - CompilerType &return_clang_type) const + CompilerType &return_compiler_type) const { ValueObjectSP return_valobj_sp; Value value; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; - value.SetCompilerType (return_clang_type); + value.SetCompilerType (return_compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) 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 edx_id = reg_ctx->GetRegisterInfoByName("edx", 0)->kinds[eRegisterKindLLDB]; @@ -541,7 +541,7 @@ else if ((type_flags & eTypeIsScalar) || (type_flags & eTypeIsEnumeration)) //'Integral' + 'Floating Point' { 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; if (type_flags & eTypeIsInteger) // 'Integral' except enum @@ -657,7 +657,7 @@ return_valobj_sp = ValueObjectMemory::Create (&thread, "", Address (storage_addr, nullptr), - return_clang_type); + return_compiler_type); } } @@ -675,7 +675,7 @@ 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) { const RegisterInfo *vec_reg = reg_ctx->GetRegisterInfoByName("xmm0", 0); @@ -705,7 +705,7 @@ byte_order, process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); } @@ -743,7 +743,7 @@ byte_order, process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); } @@ -764,15 +764,15 @@ 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; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; 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) return return_valobj_sp; @@ -780,14 +780,14 @@ if (!reg_ctx_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]; lldb::addr_t storage_addr = (uint32_t)(thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) & 0xffffffff); return_valobj_sp = ValueObjectMemory::Create (&thread, "", Address (storage_addr, nullptr), - return_clang_type); + return_compiler_type); } return return_valobj_sp; Index: lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp @@ -282,8 +282,8 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; @@ -298,7 +298,7 @@ RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 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; Error data_error; @@ -339,7 +339,7 @@ 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) error.SetErrorString ("We don't support returning complex values at present"); @@ -355,26 +355,26 @@ 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; return return_valobj_sp; } 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; Value value; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; ExecutionContext exe_ctx (thread.shared_from_this()); if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL) return return_valobj_sp; - value.SetCompilerType(return_clang_type); + value.SetCompilerType(return_compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) @@ -386,9 +386,9 @@ // In MIPS register "r2" (v0) holds the integer function return values 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) { @@ -426,12 +426,12 @@ 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; 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. uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r2", 0), 0); @@ -439,10 +439,10 @@ return_valobj_sp = ValueObjectMemory::Create (&thread, "", Address (mem_address, NULL), - return_clang_type); + return_compiler_type); 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 *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0); Index: lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp @@ -247,8 +247,8 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; @@ -270,7 +270,7 @@ return error; } - const uint32_t type_flags = clang_type.GetTypeInfo (NULL); + const uint32_t type_flags = compiler_type.GetTypeInfo (NULL); if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) @@ -325,14 +325,14 @@ 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; return return_valobj_sp; } 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; Value value; @@ -342,7 +342,7 @@ if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL) return return_valobj_sp; - value.SetCompilerType(return_clang_type); + value.SetCompilerType(return_compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) @@ -350,8 +350,8 @@ Target *target = exe_ctx.GetTargetPtr(); ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder(); - const size_t byte_size = return_clang_type.GetByteSize(nullptr); - const uint32_t type_flags = return_clang_type.GetTypeInfo (NULL); + const size_t byte_size = return_compiler_type.GetByteSize(nullptr); + const uint32_t type_flags = return_compiler_type.GetTypeInfo (NULL); const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0); const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0); @@ -467,7 +467,7 @@ target_byte_order); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), return_ext); return return_valobj_sp; @@ -505,7 +505,7 @@ std::string name; bool is_complex; 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 // returned in the two FP return-value registers i.e fp0 and fp2. @@ -516,9 +516,9 @@ // Check if this structure contains only floating point fields 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; else found_non_fp_field = 1; @@ -540,8 +540,8 @@ for (uint32_t idx = 0; idx < num_children; idx++) { - CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); - const size_t field_byte_width = field_clang_type.GetByteSize(nullptr); + CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); + const size_t field_byte_width = field_compiler_type.GetByteSize(nullptr); DataExtractor *copy_from_extractor = NULL; @@ -584,7 +584,7 @@ // The result is in our data buffer. Create a variable object out of it return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), return_ext); @@ -601,8 +601,8 @@ bool is_signed; uint32_t padding; - CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); - const size_t field_byte_width = field_clang_type.GetByteSize(nullptr); + CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); + 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 (field_byte_width == 0) @@ -610,9 +610,9 @@ uint32_t field_byte_offset = field_bit_offset/8; - if (field_clang_type.IsIntegerType (is_signed) - || field_clang_type.IsPointerType () - || field_clang_type.IsFloatingPointType (count, is_complex)) + if (field_compiler_type.IsIntegerType (is_signed) + || field_compiler_type.IsPointerType () + || field_compiler_type.IsFloatingPointType (count, is_complex)) { padding = field_byte_offset - integer_bytes; @@ -689,7 +689,7 @@ { // The result is in our data buffer. Create a variable object out of it return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), return_ext); } @@ -704,7 +704,7 @@ return_valobj_sp = ValueObjectMemory::Create (&thread, "", Address (mem_address, NULL), - return_clang_type); + return_compiler_type); } return return_valobj_sp; } Index: lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp @@ -393,25 +393,25 @@ // We currently only support extracting values with Clang QualTypes. // Do we care about others? - CompilerType clang_type = value->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = value->GetCompilerType(); + if (!compiler_type) return false; bool is_signed; - if (clang_type.IsIntegerType (is_signed)) + if (compiler_type.IsIntegerType (is_signed)) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), is_signed, thread, argument_register_ids, current_argument_register, current_stack_argument); } - else if (clang_type.IsPointerType ()) + else if (compiler_type.IsPointerType ()) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), false, thread, argument_register_ids, @@ -433,8 +433,8 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; @@ -449,7 +449,7 @@ RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 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); @@ -475,13 +475,13 @@ } } - else if (clang_type.IsFloatingPointType (count, is_complex)) + else if (compiler_type.IsFloatingPointType (count, is_complex)) { if (is_complex) error.SetErrorString ("We don't support returning complex values at present"); 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) { DataExtractor data; @@ -520,22 +520,22 @@ ValueObjectSP ABISysV_ppc::GetReturnValueObjectSimple (Thread &thread, - CompilerType &return_clang_type) const + CompilerType &return_compiler_type) const { ValueObjectSP return_valobj_sp; Value value; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; //value.SetContext (Value::eContextTypeClangType, return_value_type); - value.SetCompilerType (return_clang_type); + value.SetCompilerType (return_compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) 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) { value.SetValueType(Value::eValueTypeScalar); @@ -545,7 +545,7 @@ { // 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); const bool is_signed = (type_flags & eTypeIsSigned) != 0; switch (byte_size) @@ -594,7 +594,7 @@ } 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)) { const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0); @@ -638,7 +638,7 @@ } 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) { @@ -666,7 +666,7 @@ byte_order, process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); } @@ -681,15 +681,15 @@ } 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; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; 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) return return_valobj_sp; @@ -697,8 +697,8 @@ if (!reg_ctx_sp) return return_valobj_sp; - const size_t bit_width = return_clang_type.GetBitSize(&thread); - if (return_clang_type.IsAggregateType()) + const size_t bit_width = return_compiler_type.GetBitSize(&thread); + if (return_compiler_type.IsAggregateType()) { Target *target = exe_ctx.GetTargetPtr(); bool is_memory = true; @@ -725,7 +725,7 @@ 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 - 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. is_memory = false; @@ -738,8 +738,8 @@ bool is_complex; uint32_t count; - CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); - const size_t field_bit_width = field_clang_type.GetBitSize(&thread); + CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); + const size_t field_bit_width = field_compiler_type.GetBitSize(&thread); // If there are any unaligned fields, this is stored in memory. if (field_bit_offset % field_bit_width != 0) @@ -755,7 +755,7 @@ DataExtractor *copy_from_extractor = NULL; 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) { @@ -788,7 +788,7 @@ 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. if (field_bit_width == 128) @@ -815,12 +815,12 @@ else { 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, &next_field_bit_offset, NULL, NULL); - if (next_field_clang_type.IsIntegerType (is_signed)) + if (next_field_compiler_type.IsIntegerType (is_signed)) in_gpr = true; else { @@ -839,12 +839,12 @@ else { 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, &prev_field_bit_offset, NULL, NULL); - if (prev_field_clang_type.IsIntegerType (is_signed)) + if (prev_field_compiler_type.IsIntegerType (is_signed)) in_gpr = true; else { @@ -903,7 +903,7 @@ { // The result is in our data buffer. Let's make a variable object out of it: return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), return_ext); } @@ -922,7 +922,7 @@ return_valobj_sp = ValueObjectMemory::Create (&thread, "", Address (storage_addr, NULL), - return_clang_type); + return_compiler_type); } } Index: lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp @@ -394,25 +394,25 @@ // We currently only support extracting values with Clang QualTypes. // Do we care about others? - CompilerType clang_type = value->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = value->GetCompilerType(); + if (!compiler_type) return false; bool is_signed; - if (clang_type.IsIntegerType (is_signed)) + if (compiler_type.IsIntegerType (is_signed)) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), is_signed, thread, argument_register_ids, current_argument_register, current_stack_argument); } - else if (clang_type.IsPointerType ()) + else if (compiler_type.IsPointerType ()) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), false, thread, argument_register_ids, @@ -434,8 +434,8 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; @@ -450,7 +450,7 @@ RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 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); @@ -476,13 +476,13 @@ } } - else if (clang_type.IsFloatingPointType (count, is_complex)) + else if (compiler_type.IsFloatingPointType (count, is_complex)) { if (is_complex) error.SetErrorString ("We don't support returning complex values at present"); 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) { DataExtractor data; @@ -521,22 +521,22 @@ ValueObjectSP ABISysV_ppc64::GetReturnValueObjectSimple (Thread &thread, - CompilerType &return_clang_type) const + CompilerType &return_compiler_type) const { ValueObjectSP return_valobj_sp; Value value; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; //value.SetContext (Value::eContextTypeClangType, return_value_type); - value.SetCompilerType (return_clang_type); + value.SetCompilerType (return_compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) 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) { value.SetValueType(Value::eValueTypeScalar); @@ -546,7 +546,7 @@ { // 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); const bool is_signed = (type_flags & eTypeIsSigned) != 0; switch (byte_size) @@ -595,7 +595,7 @@ } 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)) { const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0); @@ -639,7 +639,7 @@ } 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) { @@ -667,7 +667,7 @@ byte_order, process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); } @@ -682,15 +682,15 @@ } 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; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; 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) return return_valobj_sp; @@ -698,8 +698,8 @@ if (!reg_ctx_sp) return return_valobj_sp; - const size_t bit_width = return_clang_type.GetBitSize(&thread); - if (return_clang_type.IsAggregateType()) + const size_t bit_width = return_compiler_type.GetBitSize(&thread); + if (return_compiler_type.IsAggregateType()) { Target *target = exe_ctx.GetTargetPtr(); bool is_memory = true; @@ -726,7 +726,7 @@ 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 - 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. is_memory = false; @@ -739,8 +739,8 @@ bool is_complex; uint32_t count; - CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); - const size_t field_bit_width = field_clang_type.GetBitSize(&thread); + CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); + const size_t field_bit_width = field_compiler_type.GetBitSize(&thread); // If there are any unaligned fields, this is stored in memory. if (field_bit_offset % field_bit_width != 0) @@ -756,7 +756,7 @@ DataExtractor *copy_from_extractor = NULL; 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) { @@ -789,7 +789,7 @@ 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. if (field_bit_width == 128) @@ -816,12 +816,12 @@ else { 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, &next_field_bit_offset, NULL, NULL); - if (next_field_clang_type.IsIntegerType (is_signed)) + if (next_field_compiler_type.IsIntegerType (is_signed)) in_gpr = true; else { @@ -840,12 +840,12 @@ else { 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, &prev_field_bit_offset, NULL, NULL); - if (prev_field_clang_type.IsIntegerType (is_signed)) + if (prev_field_compiler_type.IsIntegerType (is_signed)) in_gpr = true; else { @@ -904,7 +904,7 @@ { // The result is in our data buffer. Let's make a variable object out of it: return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), return_ext); } @@ -923,7 +923,7 @@ return_valobj_sp = ValueObjectMemory::Create (&thread, "", Address (storage_addr, NULL), - return_clang_type); + return_compiler_type); } } Index: lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp =================================================================== --- lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp +++ lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp @@ -423,25 +423,25 @@ // We currently only support extracting values with Clang QualTypes. // Do we care about others? - CompilerType clang_type = value->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = value->GetCompilerType(); + if (!compiler_type) return false; bool is_signed; - if (clang_type.IsIntegerType (is_signed)) + if (compiler_type.IsIntegerType (is_signed)) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), is_signed, thread, argument_register_ids, current_argument_register, current_stack_argument); } - else if (clang_type.IsPointerType ()) + else if (compiler_type.IsPointerType ()) { ReadIntegerArgument(value->GetScalar(), - clang_type.GetBitSize(&thread), + compiler_type.GetBitSize(&thread), false, thread, argument_register_ids, @@ -463,8 +463,8 @@ return error; } - CompilerType clang_type = new_value_sp->GetCompilerType(); - if (!clang_type) + CompilerType compiler_type = new_value_sp->GetCompilerType(); + if (!compiler_type) { error.SetErrorString ("Null clang type for return value."); return error; @@ -479,7 +479,7 @@ RegisterContext *reg_ctx = thread->GetRegisterContext().get(); 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); @@ -505,13 +505,13 @@ } } - else if (clang_type.IsFloatingPointType (count, is_complex)) + else if (compiler_type.IsFloatingPointType (count, is_complex)) { if (is_complex) error.SetErrorString ("We don't support returning complex values at present"); 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) { const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0); @@ -554,22 +554,22 @@ ValueObjectSP ABISysV_x86_64::GetReturnValueObjectSimple (Thread &thread, - CompilerType &return_clang_type) const + CompilerType &return_compiler_type) const { ValueObjectSP return_valobj_sp; Value value; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; //value.SetContext (Value::eContextTypeClangType, return_value_type); - value.SetCompilerType (return_clang_type); + value.SetCompilerType (return_compiler_type); RegisterContext *reg_ctx = thread.GetRegisterContext().get(); if (!reg_ctx) 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) { value.SetValueType(Value::eValueTypeScalar); @@ -579,7 +579,7 @@ { // 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); const bool is_signed = (type_flags & eTypeIsSigned) != 0; switch (byte_size) @@ -628,7 +628,7 @@ } 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)) { const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0); @@ -676,7 +676,7 @@ } 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) { const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("xmm0", 0); @@ -706,7 +706,7 @@ byte_order, process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); } @@ -744,7 +744,7 @@ byte_order, process_sp->GetTarget().GetArchitecture().GetAddressByteSize()); return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), data); } @@ -760,15 +760,15 @@ } 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; - if (!return_clang_type) + if (!return_compiler_type) return return_valobj_sp; 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) return return_valobj_sp; @@ -776,8 +776,8 @@ if (!reg_ctx_sp) return return_valobj_sp; - const size_t bit_width = return_clang_type.GetBitSize(&thread); - if (return_clang_type.IsAggregateType()) + const size_t bit_width = return_compiler_type.GetBitSize(&thread); + if (return_compiler_type.IsAggregateType()) { Target *target = exe_ctx.GetTargetPtr(); bool is_memory = true; @@ -810,7 +810,7 @@ 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 - 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. is_memory = false; @@ -823,8 +823,8 @@ bool is_complex; uint32_t count; - CompilerType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); - const size_t field_bit_width = field_clang_type.GetBitSize(&thread); + CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL); + 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 (field_bit_width == 0) @@ -844,7 +844,7 @@ DataExtractor *copy_from_extractor = NULL; 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) { @@ -877,7 +877,7 @@ 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. if (field_bit_width == 128) @@ -910,12 +910,12 @@ else { 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, &next_field_bit_offset, NULL, NULL); - if (next_field_clang_type.IsIntegerType (is_signed)) + if (next_field_compiler_type.IsIntegerType (is_signed)) in_gpr = true; else { @@ -934,12 +934,12 @@ else { 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, &prev_field_bit_offset, NULL, NULL); - if (prev_field_clang_type.IsIntegerType (is_signed)) + if (prev_field_compiler_type.IsIntegerType (is_signed)) in_gpr = true; else { @@ -1003,7 +1003,7 @@ { // The result is in our data buffer. Let's make a variable object out of it: return_valobj_sp = ValueObjectConstResult::Create (&thread, - return_clang_type, + return_compiler_type, ConstString(""), return_ext); } @@ -1022,7 +1022,7 @@ return_valobj_sp = ValueObjectMemory::Create (&thread, "", Address (storage_addr, NULL), - return_clang_type); + return_compiler_type); } } Index: lldb/trunk/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp =================================================================== --- lldb/trunk/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp +++ lldb/trunk/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp @@ -109,12 +109,12 @@ return false; // 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; - 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); options.SetLocation(data_addr); Index: lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.cpp =================================================================== --- lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.cpp +++ lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.cpp @@ -29,7 +29,7 @@ static CompilerType GetLLDBNSPairType (TargetSP target_sp) { - CompilerType clang_type; + CompilerType compiler_type; ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext(); @@ -37,23 +37,23 @@ { ConstString g___lldb_autogen_nspair("__lldb_autogen_nspair"); - clang_type = target_ast_context->GetTypeForIdentifier(g___lldb_autogen_nspair); + compiler_type = target_ast_context->GetTypeForIdentifier(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); - CompilerType id_clang_type = target_ast_context->GetBasicType (eBasicTypeObjCID); - ClangASTContext::AddFieldToRecordType(clang_type, "key", id_clang_type, lldb::eAccessPublic, 0); - ClangASTContext::AddFieldToRecordType(clang_type, "value", id_clang_type, lldb::eAccessPublic, 0); - ClangASTContext::CompleteTagDeclarationDefinition(clang_type); + ClangASTContext::StartTagDeclarationDefinition(compiler_type); + CompilerType id_compiler_type = target_ast_context->GetBasicType (eBasicTypeObjCID); + ClangASTContext::AddFieldToRecordType(compiler_type, "key", id_compiler_type, lldb::eAccessPublic, 0); + ClangASTContext::AddFieldToRecordType(compiler_type, "value", id_compiler_type, lldb::eAccessPublic, 0); + ClangASTContext::CompleteTagDeclarationDefinition(compiler_type); } } } - return clang_type; + return compiler_type; } namespace lldb_private { Index: lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp =================================================================== --- lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp +++ lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp @@ -56,11 +56,11 @@ bool AppleObjCRuntime::GetObjectDescription (Stream &str, ValueObject &valobj) { - CompilerType clang_type(valobj.GetCompilerType()); + CompilerType compiler_type(valobj.GetCompilerType()); bool is_signed; // ObjC objects can only be pointers (or numbers that actually represents pointers // 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; // Make the argument list: we pass one arg, the address of our pointer, to the print function. @@ -94,10 +94,10 @@ return false; Target *target = exe_ctx.GetTargetPtr(); - CompilerType clang_type = value.GetCompilerType(); - if (clang_type) + CompilerType compiler_type = value.GetCompilerType(); + if (compiler_type) { - if (!ClangASTContext::IsObjCObjectPointerType(clang_type)) + if (!ClangASTContext::IsObjCObjectPointerType(compiler_type)) { strm.Printf ("Value doesn't point to an ObjC object.\n"); return false; @@ -120,10 +120,10 @@ // This is the return value: ClangASTContext *ast_context = target->GetScratchClangASTContext(); - CompilerType return_clang_type = ast_context->GetCStringType(true); + CompilerType return_compiler_type = ast_context->GetCStringType(true); Value ret; -// ret.SetContext(Value::eContextTypeClangType, return_clang_type); - ret.SetCompilerType (return_clang_type); +// ret.SetContext(Value::eContextTypeClangType, return_compiler_type); + ret.SetCompilerType (return_compiler_type); if (exe_ctx.GetFramePtr() == NULL) { @@ -148,7 +148,7 @@ { Error error; m_print_object_caller_up.reset(exe_scope->CalculateTarget()->GetFunctionCallerForLanguage (eLanguageTypeObjC, - return_clang_type, + return_compiler_type, *function_address, arg_value_list, "objc-object-description", Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h @@ -35,7 +35,7 @@ virtual bool CompleteTypeFromDWARF (const DWARFDIE &die, lldb_private::Type *type, - lldb_private::CompilerType &clang_type) = 0; + lldb_private::CompilerType &compiler_type) = 0; virtual lldb_private::CompilerDecl GetDeclForUIDFromDWARF (const DWARFDIE &die) = 0; Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h @@ -46,7 +46,7 @@ virtual bool CompleteTypeFromDWARF (const DWARFDIE &die, lldb_private::Type *type, - lldb_private::CompilerType &clang_type) override; + lldb_private::CompilerType &compiler_type) override; virtual lldb_private::CompilerDecl GetDeclForUIDFromDWARF (const DWARFDIE &die) override; @@ -107,7 +107,7 @@ bool ParseChildMembers (const lldb_private::SymbolContext& sc, const DWARFDIE &die, - lldb_private::CompilerType &class_clang_type, + lldb_private::CompilerType &class_compiler_type, const lldb::LanguageType class_language, std::vector& base_classes, std::vector& member_accessibilities, @@ -140,7 +140,7 @@ size_t ParseChildEnumerators (const lldb_private::SymbolContext& sc, - lldb_private::CompilerType &clang_type, + lldb_private::CompilerType &compiler_type, bool is_signed, uint32_t enumerator_byte_size, const DWARFDIE &parent_die); Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h @@ -71,7 +71,7 @@ std::vector &element_orders, uint32_t &byte_stride, uint32_t &bit_stride); 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; }; Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp @@ -91,7 +91,7 @@ Declaration decl; Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID; - CompilerType clang_type; + CompilerType compiler_type; DWARFFormValue form_value; dw_attr_t attr; @@ -155,12 +155,12 @@ case DW_TAG_unspecified_type: resolve_state = Type::eResolveStateFull; - clang_type = m_ast.CreateVoidType(type_name_const_str); + compiler_type = m_ast.CreateVoidType(type_name_const_str); break; case DW_TAG_base_type: 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; case DW_TAG_pointer_type: @@ -179,13 +179,13 @@ return type->shared_from_this(); } 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; } 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(); } @@ -258,16 +258,16 @@ DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", dwarf->MakeUserID(die.GetOffset()), DW_TAG_value_to_name(tag), type_name_cstr); - bool clang_type_was_created = false; - clang_type.SetCompilerType(&m_ast, dwarf->m_forward_decl_die_to_clang_type.lookup(die.GetDIE())); - if (!clang_type) + bool compiler_type_was_created = false; + compiler_type.SetCompilerType(&m_ast, dwarf->m_forward_decl_die_to_clang_type.lookup(die.GetDIE())); + if (!compiler_type) { - clang_type_was_created = true; - clang_type = m_ast.CreateStructType(go_kind, type_name_const_str, byte_size); + compiler_type_was_created = true; + 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, - NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, clang_type, + NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, compiler_type, Type::eResolveStateForward)); // Add our type to the unique type map so we don't @@ -288,18 +288,18 @@ if (die.HasChildren() == false) { // 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 // to know the details of the type. lldb_private::Type // will automatically call the SymbolFile virtual function // "SymbolFileDWARF::CompleteType(Type *)" // When the definition needs to be defined. - dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] = clang_type.GetOpaqueQualType(); - dwarf->m_forward_decl_clang_type_to_die[clang_type.GetOpaqueQualType()] = die.GetDIERef(); - // SetHasExternalStorage (clang_type.GetOpaqueQualType(), true); + dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] = compiler_type.GetOpaqueQualType(); + dwarf->m_forward_decl_clang_type_to_die[compiler_type.GetOpaqueQualType()] = die.GetDIERef(); + // SetHasExternalStorage (compiler_type.GetOpaqueQualType(), true); } } } @@ -360,12 +360,12 @@ ParseChildParameters(sc, die, is_variadic, function_param_types); } - // clang_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 will get the function prototype clang type after this call + compiler_type = m_ast.CreateFunctionType(type_name_const_str, function_param_types.data(), function_param_types.size(), is_variadic); 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)); assert(type_sp.get()); } @@ -427,16 +427,16 @@ { if (element_orders.size() > 1) 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]); } 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, byte_stride, NULL, type_die_offset, Type::eEncodingIsUID, &decl, - clang_type, Type::eResolveStateFull)); + compiler_type, Type::eResolveStateFull)); type_sp->SetEncodingType(element_type); } } @@ -619,7 +619,7 @@ } 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) return false; @@ -632,7 +632,7 @@ dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace( log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...", dwarf->MakeUserID(die.GetOffset()), DW_TAG_value_to_name(tag), type->GetName().AsCString()); - assert(clang_type); + assert(compiler_type); DWARFAttributes attributes; switch (tag) @@ -644,11 +644,11 @@ { SymbolContext sc(die.GetLLDBCompileUnit()); - ParseChildMembers(sc, die, clang_type); + ParseChildMembers(sc, die, compiler_type); } } - m_ast.CompleteStructType(clang_type); - return (bool)clang_type; + m_ast.CompleteStructType(compiler_type); + return (bool)compiler_type; } default: @@ -660,13 +660,13 @@ } 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; uint32_t member_idx = 0; ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule(); - GoASTContext *ast = llvm::dyn_cast_or_null(class_clang_type.GetTypeSystem()); + GoASTContext *ast = llvm::dyn_cast_or_null(class_compiler_type.GetTypeSystem()); if (ast == nullptr) return 0; @@ -742,7 +742,7 @@ { CompilerType member_go_type = member_type->GetFullCompilerType(); 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; Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h @@ -143,7 +143,7 @@ ResolveTypeUID(lldb::user_id_t type_uid) override; bool - CompleteType (lldb_private::CompilerType& clang_type) override; + CompleteType (lldb_private::CompilerType& compiler_type) override; lldb_private::Type * ResolveType (const DWARFDIE &die, @@ -292,7 +292,7 @@ } bool - HasForwardDeclForClangType (const lldb_private::CompilerType &clang_type); + HasForwardDeclForClangType (const lldb_private::CompilerType &compiler_type); lldb_private::CompileUnit* GetCompUnitForDWARFCompUnit(DWARFCompileUnit* dwarf_cu, Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp @@ -382,14 +382,14 @@ } } - std::set clang_type_set; + std::set compiler_type_set; size_t num_types_added = 0; for (Type *type : type_set) { - CompilerType clang_type = type->GetForwardCompilerType (); - if (clang_type_set.find(clang_type) == clang_type_set.end()) + CompilerType compiler_type = type->GetForwardCompilerType (); + 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()); ++num_types_added; } @@ -1530,21 +1530,21 @@ // This function is used when SymbolFileDWARFDebugMap owns a bunch of // SymbolFileDWARF objects to detect if this DWARF file is the one that -// can resolve a clang_type. +// can resolve a compiler_type. bool -SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &clang_type) +SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &compiler_type) { - CompilerType clang_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(clang_type); - return GetForwardDeclClangTypeToDie().count (clang_type_no_qualifiers.GetOpaqueQualType()); + CompilerType compiler_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(compiler_type); + return GetForwardDeclClangTypeToDie().count (compiler_type_no_qualifiers.GetOpaqueQualType()); } bool -SymbolFileDWARF::CompleteType (CompilerType &clang_type) +SymbolFileDWARF::CompleteType (CompilerType &compiler_type) { // We have a struct/union/class/enum that needs to be fully resolved. - CompilerType clang_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(clang_type); - auto die_it = GetForwardDeclClangTypeToDie().find (clang_type_no_qualifiers.GetOpaqueQualType()); + CompilerType compiler_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(compiler_type); + auto die_it = GetForwardDeclClangTypeToDie().find (compiler_type_no_qualifiers.GetOpaqueQualType()); if (die_it == GetForwardDeclClangTypeToDie().end()) { // We have already resolved this type... @@ -1569,10 +1569,10 @@ dwarf_die.GetID(), dwarf_die.GetTagAsCString(), type->GetName().AsCString()); - assert (clang_type); + assert (compiler_type); DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser(); if (dwarf_ast) - return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, clang_type); + return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, compiler_type); return false; } Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h @@ -72,7 +72,7 @@ lldb_private::Type* ResolveTypeUID (lldb::user_id_t type_uid) override; lldb_private::CompilerDeclContext GetDeclContextForUID (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::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; Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp +++ lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp @@ -778,15 +778,15 @@ } bool -SymbolFileDWARFDebugMap::CompleteType (CompilerType& clang_type) +SymbolFileDWARFDebugMap::CompleteType (CompilerType& compiler_type) { bool success = false; - if (clang_type) + if (compiler_type) { 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; return true; } Index: lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h +++ lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h @@ -82,7 +82,7 @@ ResolveTypeUID(lldb::user_id_t type_uid); virtual bool - CompleteType (lldb_private::CompilerType& clang_type); + CompleteType (lldb_private::CompilerType& compiler_type); virtual uint32_t ResolveSymbolContext (const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc); Index: lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp =================================================================== --- lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp +++ lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp @@ -291,7 +291,7 @@ } bool -SymbolFileSymtab::CompleteType (lldb_private::CompilerType& clang_opaque_type) +SymbolFileSymtab::CompleteType (lldb_private::CompilerType& compiler_type) { return false; } Index: lldb/trunk/source/Symbol/CompilerType.cpp =================================================================== --- lldb/trunk/source/Symbol/CompilerType.cpp +++ lldb/trunk/source/Symbol/CompilerType.cpp @@ -369,12 +369,12 @@ } uint32_t -CompilerType::GetTypeInfo (CompilerType *pointee_or_element_clang_type) const +CompilerType::GetTypeInfo (CompilerType *pointee_or_element_compiler_type) const { if (!IsValid()) 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); } @@ -730,7 +730,7 @@ uint32_t CompilerType::GetIndexOfFieldWithName (const char* name, - CompilerType* field_clang_type_ptr, + CompilerType* field_compiler_type_ptr, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) const @@ -739,11 +739,11 @@ std::string field_name; 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 (field_clang_type_ptr) - *field_clang_type_ptr = field_clang_type; + if (field_compiler_type_ptr) + *field_compiler_type_ptr = field_compiler_type; return index; } } @@ -1270,10 +1270,10 @@ } //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) -// return clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl(); +// if (opaque_compiler_qual_type) +// return clang::QualType::getFromOpaquePtr(opaque_compiler_qual_type)->getAsCXXRecordDecl(); // return NULL; //} Index: lldb/trunk/source/Symbol/GoASTContext.cpp =================================================================== --- lldb/trunk/source/Symbol/GoASTContext.cpp +++ lldb/trunk/source/Symbol/GoASTContext.cpp @@ -656,15 +656,15 @@ } 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) - pointee_or_element_clang_type->Clear(); + if (pointee_or_element_compiler_type) + pointee_or_element_compiler_type->Clear(); if (!type) return 0; GoType *t = static_cast(type); - if (pointee_or_element_clang_type) - *pointee_or_element_clang_type = t->GetElementType(); + if (pointee_or_element_compiler_type) + *pointee_or_element_compiler_type = t->GetElementType(); int kind = t->GetGoKind(); if (kind == GoType::KIND_ARRAY) return eTypeHasChildren | eTypeIsArray; @@ -1254,12 +1254,12 @@ GoType *t = static_cast(type); if (t->IsTypedef()) { - CompilerType typedef_clang_type = t->GetElementType(); + CompilerType typedef_compiler_type = t->GetElementType(); if (format == eFormatDefault) - format = typedef_clang_type.GetFormat(); - uint64_t typedef_byte_size = typedef_clang_type.GetByteSize(exe_scope); + format = typedef_compiler_type.GetFormat(); + uint64_t typedef_byte_size = typedef_compiler_type.GetByteSize(exe_scope); - return typedef_clang_type.DumpTypeValue( + return typedef_compiler_type.DumpTypeValue( s, format, // The format with which to display the element data, // Data buffer containing all bytes for this type Index: lldb/trunk/source/Symbol/Type.cpp =================================================================== --- lldb/trunk/source/Symbol/Type.cpp +++ lldb/trunk/source/Symbol/Type.cpp @@ -86,8 +86,8 @@ user_id_t encoding_uid, EncodingDataType encoding_uid_type, const Declaration& decl, - const CompilerType &clang_type, - ResolveState clang_type_resolve_state + const CompilerType &compiler_type, + ResolveState compiler_type_resolve_state ) : std::enable_shared_from_this (), UserID (uid), @@ -99,9 +99,9 @@ m_encoding_uid_type (encoding_uid_type), m_byte_size (byte_size), 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; } @@ -116,9 +116,9 @@ m_encoding_uid_type (eEncodingInvalid), m_byte_size (0), 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; } @@ -134,7 +134,7 @@ m_encoding_uid_type (rhs.m_encoding_uid_type), m_byte_size (rhs.m_byte_size), m_decl (rhs.m_decl), - m_clang_type (rhs.m_clang_type), + m_compiler_type (rhs.m_compiler_type), m_flags (rhs.m_flags) { } @@ -175,9 +175,9 @@ bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose); 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); *s << '"'; } @@ -223,9 +223,9 @@ bool show_fullpaths = false; 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); } else if (m_encoding_uid != LLDB_INVALID_UID) @@ -493,11 +493,11 @@ } 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. Type *encoding_type = nullptr; - if (!m_clang_type.IsValid()) + if (!m_compiler_type.IsValid()) { encoding_type = GetEncodingType(); if (encoding_type) @@ -506,43 +506,43 @@ { case eEncodingIsUID: { - CompilerType encoding_clang_type = encoding_type->GetForwardCompilerType (); - if (encoding_clang_type.IsValid()) + CompilerType encoding_compiler_type = encoding_type->GetForwardCompilerType (); + if (encoding_compiler_type.IsValid()) { - m_clang_type = encoding_clang_type; - m_flags.clang_type_resolve_state = encoding_type->m_flags.clang_type_resolve_state; + m_compiler_type = encoding_compiler_type; + m_flags.compiler_type_resolve_state = encoding_type->m_flags.compiler_type_resolve_state; } } break; case eEncodingIsConstUID: - m_clang_type = encoding_type->GetForwardCompilerType ().AddConstModifier(); + m_compiler_type = encoding_type->GetForwardCompilerType ().AddConstModifier(); break; case eEncodingIsRestrictUID: - m_clang_type = encoding_type->GetForwardCompilerType ().AddRestrictModifier(); + m_compiler_type = encoding_type->GetForwardCompilerType ().AddRestrictModifier(); break; case eEncodingIsVolatileUID: - m_clang_type = encoding_type->GetForwardCompilerType ().AddVolatileModifier(); + m_compiler_type = encoding_type->GetForwardCompilerType ().AddVolatileModifier(); break; case eEncodingIsTypedefUID: - m_clang_type = encoding_type->GetForwardCompilerType ().CreateTypedef(GetName().AsCString(), + m_compiler_type = encoding_type->GetForwardCompilerType ().CreateTypedef(GetName().AsCString(), GetSymbolFile()->GetDeclContextContainingUID(GetID())); m_name.Clear(); break; case eEncodingIsPointerUID: - m_clang_type = encoding_type->GetForwardCompilerType ().GetPointerType(); + m_compiler_type = encoding_type->GetForwardCompilerType ().GetPointerType(); break; case eEncodingIsLValueReferenceUID: - m_clang_type = encoding_type->GetForwardCompilerType ().GetLValueReferenceType(); + m_compiler_type = encoding_type->GetForwardCompilerType ().GetLValueReferenceType(); break; case eEncodingIsRValueReferenceUID: - m_clang_type = encoding_type->GetForwardCompilerType ().GetRValueReferenceType(); + m_compiler_type = encoding_type->GetForwardCompilerType ().GetRValueReferenceType(); break; default: @@ -554,40 +554,40 @@ { // We have no encoding type, return void? 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) { case eEncodingIsUID: - m_clang_type = void_clang_type; + m_compiler_type = void_compiler_type; break; case eEncodingIsConstUID: - m_clang_type = void_clang_type.AddConstModifier(); + m_compiler_type = void_compiler_type.AddConstModifier(); break; case eEncodingIsRestrictUID: - m_clang_type = void_clang_type.AddRestrictModifier(); + m_compiler_type = void_compiler_type.AddRestrictModifier(); break; case eEncodingIsVolatileUID: - m_clang_type = void_clang_type.AddVolatileModifier(); + m_compiler_type = void_compiler_type.AddVolatileModifier(); break; case eEncodingIsTypedefUID: - m_clang_type = void_clang_type.CreateTypedef(GetName().AsCString(), + m_compiler_type = void_compiler_type.CreateTypedef(GetName().AsCString(), GetSymbolFile()->GetDeclContextContainingUID(GetID())); break; case eEncodingIsPointerUID: - m_clang_type = void_clang_type.GetPointerType (); + m_compiler_type = void_compiler_type.GetPointerType (); break; case eEncodingIsLValueReferenceUID: - m_clang_type = void_clang_type.GetLValueReferenceType(); + m_compiler_type = void_compiler_type.GetLValueReferenceType(); break; case eEncodingIsRValueReferenceUID: - m_clang_type = void_clang_type.GetRValueReferenceType(); + m_compiler_type = void_compiler_type.GetRValueReferenceType(); break; default: @@ -596,25 +596,25 @@ } } - // 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 // above. - if (m_clang_type.IsValid()) - m_flags.clang_type_resolve_state = eResolveStateForward; + if (m_compiler_type.IsValid()) + m_flags.compiler_type_resolve_state = eResolveStateForward; } // 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? - 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; - if (!m_clang_type.IsDefined ()) + m_flags.compiler_type_resolve_state = eResolveStateFull; + if (!m_compiler_type.IsDefined ()) { // 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); } } } @@ -627,25 +627,25 @@ encoding_type = GetEncodingType(); 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) { case eEncodingIsPointerUID: case eEncodingIsLValueReferenceUID: case eEncodingIsRValueReferenceUID: - encoding_clang_type_resolve_state = eResolveStateForward; + encoding_compiler_type_resolve_state = eResolveStateForward; break; default: 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 Type::GetEncodingMask () @@ -662,21 +662,21 @@ Type::GetFullCompilerType () { ResolveClangType(eResolveStateFull); - return m_clang_type; + return m_compiler_type; } CompilerType Type::GetLayoutCompilerType () { ResolveClangType(eResolveStateLayout); - return m_clang_type; + return m_compiler_type; } CompilerType Type::GetForwardCompilerType () { ResolveClangType (eResolveStateForward); - return m_clang_type; + return m_compiler_type; } int @@ -855,9 +855,9 @@ } 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) m_type_name = m_type_pair.GetName(); } @@ -919,12 +919,12 @@ SetType (type_sp); } -TypeImpl::TypeImpl (const CompilerType &clang_type) : +TypeImpl::TypeImpl (const CompilerType &compiler_type) : m_module_wp (), m_static_type(), m_dynamic_type() { - SetType (clang_type); + SetType (compiler_type); } TypeImpl::TypeImpl (const lldb::TypeSP &type_sp, const CompilerType &dynamic) : @@ -962,10 +962,10 @@ } void -TypeImpl::SetType (const CompilerType &clang_type) +TypeImpl::SetType (const CompilerType &compiler_type) { m_module_wp = lldb::ModuleWP(); - m_static_type.SetType (clang_type); + m_static_type.SetType (compiler_type); } void @@ -976,10 +976,10 @@ } 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_static_type.SetType (clang_type); + m_static_type.SetType (compiler_type); m_dynamic_type = dynamic; } Index: lldb/trunk/source/Symbol/Variable.cpp =================================================================== --- lldb/trunk/source/Symbol/Variable.cpp +++ lldb/trunk/source/Symbol/Variable.cpp @@ -584,7 +584,7 @@ PrivateAutoComplete (StackFrame *frame, const std::string &partial_path, 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, bool &word_complete); @@ -593,7 +593,7 @@ const std::string &partial_member_name, const std::string &partial_path, 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, bool &word_complete); @@ -602,19 +602,19 @@ const std::string &partial_member_name, const std::string &partial_path, 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, bool &word_complete) { // 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) { 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, partial_member_name, @@ -626,13 +626,13 @@ } } - const uint32_t num_vbases = clang_type.GetNumVirtualBaseClasses(); + const uint32_t num_vbases = compiler_type.GetNumVirtualBaseClasses(); if (num_vbases > 0) { 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, partial_member_name, @@ -645,7 +645,7 @@ } // 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) { @@ -653,7 +653,7 @@ { 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() || member_name.find(partial_member_name) == 0) @@ -663,7 +663,7 @@ PrivateAutoComplete (frame, partial_path, prefix_path + member_name, // Anything that has been resolved already will be in here - member_clang_type.GetCanonicalType(), + member_compiler_type.GetCanonicalType(), matches, word_complete); } @@ -680,17 +680,17 @@ PrivateAutoComplete (StackFrame *frame, const std::string &partial_path, 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, bool &word_complete) { // printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path = '%s'\n", prefix_path.c_str(), partial_path.c_str()); 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 (clang_type.IsValid()) + if (compiler_type.IsValid()) { switch (type_class) { @@ -726,7 +726,7 @@ case eTypeClassPointer: { 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 + "->"); else { @@ -768,7 +768,7 @@ PrivateAutoComplete (frame, partial_path.substr(1), std::string("*"), - clang_type, + compiler_type, matches, word_complete); } @@ -780,7 +780,7 @@ PrivateAutoComplete (frame, partial_path.substr(1), std::string("&"), - clang_type, + compiler_type, matches, word_complete); } @@ -793,7 +793,7 @@ { case lldb::eTypeClassPointer: { - CompilerType pointee_type(clang_type.GetPointeeType()); + CompilerType pointee_type(compiler_type.GetPointeeType()); if (partial_path[2]) { // If there is more after the "->", then search deeper @@ -823,7 +823,7 @@ break; case '.': - if (clang_type.IsValid()) + if (compiler_type.IsValid()) { switch (type_class) { @@ -836,7 +836,7 @@ PrivateAutoComplete (frame, partial_path.substr(1), prefix_path + ".", - clang_type, + compiler_type, matches, word_complete); @@ -848,7 +848,7 @@ std::string(), partial_path, prefix_path + ".", - clang_type, + compiler_type, matches, word_complete); } @@ -876,13 +876,13 @@ std::string token(partial_path, 0, pos); remaining_partial_path = partial_path.substr(pos); - if (clang_type.IsValid()) + if (compiler_type.IsValid()) { PrivateAutoCompleteMembers (frame, token, remaining_partial_path, prefix_path, - clang_type, + compiler_type, matches, word_complete); } @@ -912,11 +912,11 @@ Type *variable_type = variable->GetType(); if (variable_type) { - CompilerType variable_clang_type (variable_type->GetForwardCompilerType ()); + CompilerType variable_compiler_type (variable_type->GetForwardCompilerType ()); PrivateAutoComplete (frame, remaining_partial_path, prefix_path + token, // Anything that has been resolved already will be in here - variable_clang_type.GetCanonicalType(), + variable_compiler_type.GetCanonicalType(), matches, word_complete); } @@ -949,14 +949,14 @@ word_complete = false; std::string partial_path; std::string prefix_path; - CompilerType clang_type; + CompilerType compiler_type; if (partial_path_cstr && partial_path_cstr[0]) partial_path = partial_path_cstr; PrivateAutoComplete (exe_ctx.GetFramePtr(), partial_path, prefix_path, - clang_type, + compiler_type, matches, word_complete); Index: lldb/trunk/source/Target/ObjCLanguageRuntime.cpp =================================================================== --- lldb/trunk/source/Target/ObjCLanguageRuntime.cpp +++ lldb/trunk/source/Target/ObjCLanguageRuntime.cpp @@ -368,16 +368,16 @@ } bool -ObjCLanguageRuntime::GetTypeBitSize (const CompilerType& clang_type, +ObjCLanguageRuntime::GetTypeBitSize (const CompilerType& compiler_type, uint64_t &size) { - void *opaque_ptr = clang_type.GetOpaqueQualType(); + void *opaque_ptr = compiler_type.GetOpaqueQualType(); size = m_type_size_cache.Lookup(opaque_ptr); // an ObjC object will at least have an ISA, so 0 is definitely not OK if (size > 0) return true; - ClassDescriptorSP class_descriptor_sp = GetClassDescriptorFromClassName(clang_type.GetTypeName()); + ClassDescriptorSP class_descriptor_sp = GetClassDescriptorFromClassName(compiler_type.GetTypeName()); if (!class_descriptor_sp) return false; Index: lldb/trunk/source/Target/ThreadPlanStepOut.cpp =================================================================== --- lldb/trunk/source/Target/ThreadPlanStepOut.cpp +++ lldb/trunk/source/Target/ThreadPlanStepOut.cpp @@ -533,12 +533,12 @@ if (m_immediate_step_from_function != NULL) { - CompilerType return_clang_type = m_immediate_step_from_function->GetCompilerType().GetFunctionReturnType(); - if (return_clang_type) + CompilerType return_compiler_type = m_immediate_step_from_function->GetCompilerType().GetFunctionReturnType(); + if (return_compiler_type) { lldb::ABISP abi_sp = m_thread.GetProcess()->GetABI(); 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); } } } Index: lldb/trunk/test/lang/objc/foundation/TestObjCMethods.py =================================================================== --- lldb/trunk/test/lang/objc/foundation/TestObjCMethods.py +++ lldb/trunk/test/lang/objc/foundation/TestObjCMethods.py @@ -189,11 +189,11 @@ self.expect("image lookup -t NSString", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ['name = "NSString"', - 'clang_type = "@interface NSString']) + 'compiler_type = "@interface NSString']) self.expect("image lookup -t MyString", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ['name = "MyString"', - 'clang_type = "@interface MyString', + 'compiler_type = "@interface MyString', 'NSString * str;', 'NSDate * date;']) Index: lldb/trunk/www/symbolication.html =================================================================== --- lldb/trunk/www/symbolication.html +++ lldb/trunk/www/symbolication.html @@ -194,7 +194,7 @@ Module: file = "/tmp/a.out", arch = "x86_64" CompileUnit: id = {0x00000000}, file = "/tmp/main.c", language = "ISO C:1999" 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) id = {0x000000ae}, range = [0x100000bf2-0x100000dc4) LineEntry: [0x0000000100000bf2-0x0000000100000bfa): /tmp/main.c:13:23