Updated Clang to a version that supports propagating

the "virtual" flag when importing a C++ function
declaration.  Made changes to LLDB to support other
changes in Clang.

llvm-svn: 124355

7 files changed, 61 insertions, 56 deletions

diff --git a/lldb/scripts/build-llvm.pl b/lldb/scripts/build-llvm.pl
index b4e88231023..99bcdf3eb36 100644
--- a/lldb/scripts/build-llvm.pl
+++ b/lldb/scripts/build-llvm.pl
@@ -25,7 +25,7 @@ our @llvm_clang_slices; # paths to the single architecture static libraries (arc
 
 our $llvm_configuration = $ENV{LLVM_CONFIGURATION};
 
-our $llvm_revision = "123723";
+our $llvm_revision = "124349";
 our $llvm_source_dir = "$ENV{SRCROOT}";
 our $cc = "$ENV{DEVELOPER_BIN_DIR}/gcc-4.2";
 our $cxx = "$ENV{DEVELOPER_BIN_DIR}/g++-4.2";
diff --git a/lldb/source/Expression/ASTResultSynthesizer.cpp b/lldb/source/Expression/ASTResultSynthesizer.cpp
index e581b965fea..7dd1ab45c8b 100644
--- a/lldb/source/Expression/ASTResultSynthesizer.cpp
+++ b/lldb/source/Expression/ASTResultSynthesizer.cpp
@@ -290,7 +290,7 @@ ASTResultSynthesizer::SynthesizeBodyResult (CompoundStmt *Body,
         (last_expr->getObjectKind() == OK_Ordinary);
     
     QualType expr_qual_type = last_expr->getType();
-    clang::Type *expr_type = expr_qual_type.getTypePtr();
+    const clang::Type *expr_type = expr_qual_type.getTypePtr();
     
     if (!expr_type)
         return false;
diff --git a/lldb/source/Expression/ClangASTSource.cpp b/lldb/source/Expression/ClangASTSource.cpp
index a23547d83dd..fa9d50e34b2 100644
--- a/lldb/source/Expression/ClangASTSource.cpp
+++ b/lldb/source/Expression/ClangASTSource.cpp
@@ -244,7 +244,7 @@ NameSearchContext::AddTypeDecl(void *type)
     {
         QualType qual_type = QualType::getFromOpaquePtr(type);
 
-        if (TagType *tag_type = dyn_cast<clang::TagType>(qual_type))
+        if (const TagType *tag_type = dyn_cast<clang::TagType>(qual_type))
         {
             TagDecl *tag_decl = tag_type->getDecl();
             
@@ -252,7 +252,7 @@ NameSearchContext::AddTypeDecl(void *type)
             
             return tag_decl;
         }
-        else if (ObjCObjectType *objc_object_type = dyn_cast<clang::ObjCObjectType>(qual_type))
+        else if (const ObjCObjectType *objc_object_type = dyn_cast<clang::ObjCObjectType>(qual_type))
         {
             ObjCInterfaceDecl *interface_decl = objc_object_type->getInterface();
             
diff --git a/lldb/source/Expression/IRForTarget.cpp b/lldb/source/Expression/IRForTarget.cpp
index fceb67ff6ed..517ab13f72a 100644
--- a/lldb/source/Expression/IRForTarget.cpp
+++ b/lldb/source/Expression/IRForTarget.cpp
@@ -271,8 +271,8 @@ IRForTarget::CreateResultVariable (llvm::Module &llvm_module, llvm::Function &ll
     if (m_result_is_pointer)
     {
         clang::QualType pointer_qual_type = result_decl->getType();
-        clang::Type *pointer_type = pointer_qual_type.getTypePtr();
-        clang::PointerType *pointer_pointertype = dyn_cast<clang::PointerType>(pointer_type);
+        const clang::Type *pointer_type = pointer_qual_type.getTypePtr();
+        const clang::PointerType *pointer_pointertype = dyn_cast<clang::PointerType>(pointer_type);
         
         if (!pointer_pointertype)
         {
@@ -1252,6 +1252,7 @@ IRForTarget::MaybeHandleCall (Module &llvm_module, CallInst *llvm_call_inst)
         Value *val = llvm_call_inst->getCalledValue();
         
         ConstantExpr *const_expr = dyn_cast<ConstantExpr>(val);
+        LoadInst *load_inst = dyn_cast<LoadInst>(val);
         
         if (const_expr && const_expr->getOpcode() == Instruction::BitCast)
         {
@@ -1269,6 +1270,10 @@ IRForTarget::MaybeHandleCall (Module &llvm_module, CallInst *llvm_call_inst)
         {
             return true; // already resolved
         }
+        else if (load_inst)
+        {
+            return true; // virtual method call
+        }
         else
         {
             if (m_error_stream)
diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp
index 3edbf8acb0e..e179bdefd1d 100644
--- a/lldb/source/Symbol/ClangASTContext.cpp
+++ b/lldb/source/Symbol/ClangASTContext.cpp
@@ -75,7 +75,7 @@ GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type)
     case clang::Type::Record:
     case clang::Type::Enum:
         {
-            clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
+            const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
             if (tag_type)
             {
                 clang::TagDecl *tag_decl = tag_type->getDecl();
@@ -103,7 +103,7 @@ GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type)
     case clang::Type::ObjCObject:
     case clang::Type::ObjCInterface:
         {
-            clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type);
+            const clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type);
             if (objc_class_type)
             {
                 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
@@ -1078,7 +1078,7 @@ ClangASTContext::SetHasExternalStorage (clang_type_t clang_type, bool has_extern
     case clang::Type::ObjCObject:
     case clang::Type::ObjCInterface:
         {
-            ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
             assert (objc_class_type);
             if (objc_class_type)
             {
@@ -1357,12 +1357,12 @@ ClangASTContext::AddMethodToCXXRecordType
 
     const bool is_implicitly_declared = false;
     
-    clang::FunctionType *function_Type = dyn_cast<FunctionType>(method_qual_type.getTypePtr());
+    const clang::FunctionType *function_Type = dyn_cast<FunctionType>(method_qual_type.getTypePtr());
     
     if (function_Type == NULL)
         return NULL;
 
-    FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_Type));
+    const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_Type));
     
     if (!method_function_prototype)
         return NULL;
@@ -1494,7 +1494,7 @@ ClangASTContext::AddFieldToRecordType
 
     QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type));
 
-    clang::Type *clang_type = record_qual_type.getTypePtr();
+    const clang::Type *clang_type = record_qual_type.getTypePtr();
     if (clang_type)
     {
         const RecordType *record_type = dyn_cast<RecordType>(clang_type);
@@ -1527,7 +1527,7 @@ ClangASTContext::AddFieldToRecordType
         }
         else
         {
-            ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(clang_type);
+            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(clang_type);
             if (objc_class_type)
             {
                 bool is_synthesized = false;
@@ -1610,7 +1610,7 @@ ClangASTContext::SetDefaultAccessForRecordFields (clang_type_t clang_type, int d
     {
         QualType qual_type(QualType::getFromOpaquePtr(clang_type));
 
-        RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr());
+        const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr());
         if (record_type)
         {
             RecordDecl *record_decl = record_type->getDecl();
@@ -1710,12 +1710,12 @@ ClangASTContext::SetObjCSuperClass (clang_type_t class_opaque_type, clang_type_t
     {
         QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
         QualType super_qual_type(QualType::getFromOpaquePtr(super_opaque_type));
-        clang::Type *class_type = class_qual_type.getTypePtr();
-        clang::Type *super_type = super_qual_type.getTypePtr();
+        const clang::Type *class_type = class_qual_type.getTypePtr();
+        const clang::Type *super_type = super_qual_type.getTypePtr();
         if (class_type && super_type)
         {
-            ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
-            ObjCObjectType *objc_super_type = dyn_cast<ObjCObjectType>(super_type);
+            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
+            const ObjCObjectType *objc_super_type = dyn_cast<ObjCObjectType>(super_type);
             if (objc_class_type && objc_super_type)
             {
                 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
@@ -1754,10 +1754,10 @@ ClangASTContext::AddObjCClassIVar
 
     QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
 
-    clang::Type *class_type = class_qual_type.getTypePtr();
+    const clang::Type *class_type = class_qual_type.getTypePtr();
     if (class_type)
     {
-        ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
+        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
 
         if (objc_class_type)
         {
@@ -1799,10 +1799,10 @@ ClangASTContext::ObjCTypeHasIVars (clang_type_t class_opaque_type, bool check_su
 {
     QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
 
-    clang::Type *class_type = class_qual_type.getTypePtr();
+    const clang::Type *class_type = class_qual_type.getTypePtr();
     if (class_type)
     {
-        ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
+        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
 
         if (objc_class_type)
             return ObjCDeclHasIVars (objc_class_type->getInterface(), check_superclass);
@@ -1846,11 +1846,11 @@ ClangASTContext::AddMethodToObjCObjectType
 
     QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
 
-    clang::Type *class_type = class_qual_type.getTypePtr();
+    const clang::Type *class_type = class_qual_type.getTypePtr();
     if (class_type == NULL)
         return NULL;
 
-    ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
+    const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
 
     if (objc_class_type == NULL)
         return NULL;
@@ -1897,12 +1897,12 @@ ClangASTContext::AddMethodToObjCObjectType
     QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
 
     // Populate the method decl with parameter decls
-    clang::Type *method_type(method_qual_type.getTypePtr());
+    const clang::Type *method_type(method_qual_type.getTypePtr());
     
     if (method_type == NULL)
         return NULL;
     
-    FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type));
+    const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type));
     
     if (!method_function_prototype)
         return NULL;
@@ -2175,7 +2175,7 @@ ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type
     case clang::Type::ObjCInterface:
         if (GetCompleteQualType (ast, qual_type))
         {
-            ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
             assert (objc_class_type);
             if (objc_class_type)
             {
@@ -2204,7 +2204,7 @@ ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type
         
     case clang::Type::ObjCObjectPointer:
         {
-            ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr());
+            const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr());
             QualType pointee_type = pointer_type->getPointeeType();
             uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
                                                                              pointee_type.getAsOpaquePtr(), 
@@ -2223,7 +2223,7 @@ ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type
 
     case clang::Type::Pointer:
         {
-            PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
+            const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
             QualType pointee_type (pointer_type->getPointeeType());
             uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
                                                                              pointee_type.getAsOpaquePtr(), 
@@ -2242,7 +2242,7 @@ ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type
     case clang::Type::LValueReference:
     case clang::Type::RValueReference:
         {
-            ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
+            const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
             QualType pointee_type = reference_type->getPointeeType();
             uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
                                                                              pointee_type.getAsOpaquePtr(), 
@@ -2533,7 +2533,7 @@ ClangASTContext::GetChildClangTypeAtIndex
         case clang::Type::ObjCInterface:
             if (GetCompleteQualType (ast, parent_qual_type))
             {
-                ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr());
+                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr());
                 assert (objc_class_type);
                 if (objc_class_type)
                 {
@@ -2610,7 +2610,7 @@ ClangASTContext::GetChildClangTypeAtIndex
             
         case clang::Type::ObjCObjectPointer:
             {
-                ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(parent_qual_type.getTypePtr());
+                const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(parent_qual_type.getTypePtr());
                 QualType pointee_type = pointer_type->getPointeeType();
 
                 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
@@ -2679,7 +2679,7 @@ ClangASTContext::GetChildClangTypeAtIndex
 
         case clang::Type::Pointer:
             {
-                PointerType *pointer_type = cast<PointerType>(parent_qual_type.getTypePtr());
+                const PointerType *pointer_type = cast<PointerType>(parent_qual_type.getTypePtr());
                 QualType pointee_type = pointer_type->getPointeeType();
                 
                 // Don't dereference "void *" pointers
@@ -2730,7 +2730,7 @@ ClangASTContext::GetChildClangTypeAtIndex
         case clang::Type::LValueReference:
         case clang::Type::RValueReference:
             {
-                ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr());
+                const ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr());
                 QualType pointee_type(reference_type->getPointeeType());
                 clang_type_t pointee_clang_type = pointee_type.getAsOpaquePtr();
                 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_clang_type))
@@ -3078,7 +3078,7 @@ ClangASTContext::GetIndexOfChildMemberWithName
             if (GetCompleteQualType (ast, qual_type))
             {
                 StringRef name_sref(name);
-                ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
                 assert (objc_class_type);
                 if (objc_class_type)
                 {
@@ -3182,7 +3182,7 @@ ClangASTContext::GetIndexOfChildMemberWithName
         case clang::Type::LValueReference:
         case clang::Type::RValueReference:
             {
-                ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
+                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
                 QualType pointee_type = reference_type->getPointeeType();
 
                 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
@@ -3198,7 +3198,7 @@ ClangASTContext::GetIndexOfChildMemberWithName
 
         case clang::Type::Pointer:
             {
-                PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
+                const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
                 QualType pointee_type = pointer_type->getPointeeType();
 
                 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
@@ -3314,7 +3314,7 @@ ClangASTContext::GetIndexOfChildWithName
             if (GetCompleteQualType (ast, qual_type))
             {
                 StringRef name_sref(name);
-                ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
+                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
                 assert (objc_class_type);
                 if (objc_class_type)
                 {
@@ -3397,7 +3397,7 @@ ClangASTContext::GetIndexOfChildWithName
         case clang::Type::LValueReference:
         case clang::Type::RValueReference:
             {
-                ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
+                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
                 QualType pointee_type = reference_type->getPointeeType();
 
                 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
@@ -3412,7 +3412,7 @@ ClangASTContext::GetIndexOfChildWithName
 
         case clang::Type::Pointer:
             {
-                PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
+                const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
                 QualType pointee_type = pointer_type->getPointeeType();
 
                 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
@@ -3464,10 +3464,10 @@ ClangASTContext::SetTagTypeKind (clang_type_t tag_clang_type, int kind)
     if (tag_clang_type)
     {
         QualType tag_qual_type(QualType::getFromOpaquePtr(tag_clang_type));
-        clang::Type *clang_type = tag_qual_type.getTypePtr();
+        const clang::Type *clang_type = tag_qual_type.getTypePtr();
         if (clang_type)
         {
-            TagType *tag_type = dyn_cast<TagType>(clang_type);
+            const TagType *tag_type = dyn_cast<TagType>(clang_type);
             if (tag_type)
             {
                 TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl());
@@ -3661,10 +3661,10 @@ ClangASTContext::StartTagDeclarationDefinition (clang_type_t clang_type)
     if (clang_type)
     {
         QualType qual_type (QualType::getFromOpaquePtr(clang_type));
-        clang::Type *t = qual_type.getTypePtr();
+        const clang::Type *t = qual_type.getTypePtr();
         if (t)
         {
-            TagType *tag_type = dyn_cast<TagType>(t);
+            const TagType *tag_type = dyn_cast<TagType>(t);
             if (tag_type)
             {
                 TagDecl *tag_decl = tag_type->getDecl();
@@ -3695,7 +3695,7 @@ ClangASTContext::CompleteTagDeclarationDefinition (clang_type_t clang_type)
             return true;
         }
         
-        ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
+        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
         
         if (objc_class_type)
         {
@@ -3789,7 +3789,7 @@ ClangASTContext::GetEnumerationIntegerType (clang_type_t enum_clang_type)
 {
     QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
 
-    clang::Type *clang_type = enum_qual_type.getTypePtr();
+    const clang::Type *clang_type = enum_qual_type.getTypePtr();
     if (clang_type)
     {
         const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
@@ -3824,7 +3824,7 @@ ClangASTContext::AddEnumerationValueToEnumerationType
         assert (identifier_table != NULL);
         QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
 
-        clang::Type *clang_type = enum_qual_type.getTypePtr();
+        const clang::Type *clang_type = enum_qual_type.getTypePtr();
         if (clang_type)
         {
             const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
@@ -4177,7 +4177,7 @@ ClangASTContext::IsFunctionPointerType (clang_type_t clang_type)
         case clang::Type::LValueReference:
         case clang::Type::RValueReference:
             {
-                ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
+                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
                 if (reference_type)
                     return ClangASTContext::IsFunctionPointerType (reference_type->getPointeeType().getAsOpaquePtr());
             }
@@ -4192,7 +4192,7 @@ ClangASTContext::GetArraySize (clang_type_t clang_type)
 {
     if (clang_type)
     {
-        ConstantArrayType *array = cast<ConstantArrayType>(QualType::getFromOpaquePtr(clang_type).getTypePtr());
+        const ConstantArrayType *array = cast<ConstantArrayType>(QualType::getFromOpaquePtr(clang_type).getTypePtr());
         if (array)
             return array->getSize().getLimitedValue();
     }
diff --git a/lldb/source/Symbol/ClangASTType.cpp b/lldb/source/Symbol/ClangASTType.cpp
index 328c7b45226..b3ed25ebdd2 100644
--- a/lldb/source/Symbol/ClangASTType.cpp
+++ b/lldb/source/Symbol/ClangASTType.cpp
@@ -522,7 +522,7 @@ ClangASTType::DumpValue
             bool is_array_of_characters = false;
             clang::QualType element_qual_type = array->getElementType();
 
-            clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr();
+            const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr();
             if (canonical_type)
                 is_array_of_characters = canonical_type->isCharType();
 
@@ -898,7 +898,7 @@ bool
 ClangASTType::IsDefined (clang_type_t clang_type)
 {
     clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type));
-    clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
+    const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
     if (tag_type)
     {
         clang::TagDecl *tag_decl = tag_type->getDecl();
@@ -908,7 +908,7 @@ ClangASTType::IsDefined (clang_type_t clang_type)
     }
     else
     {
-        clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type);
+        const clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type);
         if (objc_class_type)
         {
             clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
@@ -951,7 +951,7 @@ ClangASTType::DumpTypeDescription (clang::ASTContext *ast_context, clang_type_t
         llvm::SmallVector<char, 1024> buf;
         llvm::raw_svector_ostream llvm_ostrm (buf);
 
-        clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
+        const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
         if (tag_type)
         {
             clang::TagDecl *tag_decl = tag_type->getDecl();
@@ -966,7 +966,7 @@ ClangASTType::DumpTypeDescription (clang::ASTContext *ast_context, clang_type_t
             case clang::Type::ObjCObject:
             case clang::Type::ObjCInterface:
                 {
-                    clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
+                    const clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
                     assert (objc_class_type);
                     if (objc_class_type)
                     {
diff --git a/lldb/source/Symbol/Function.cpp b/lldb/source/Symbol/Function.cpp
index 373d5e6c2a1..c2ad76b2f59 100644
--- a/lldb/source/Symbol/Function.cpp
+++ b/lldb/source/Symbol/Function.cpp
@@ -404,7 +404,7 @@ Function::GetReturnType ()
 {
     clang::QualType clang_type (clang::QualType::getFromOpaquePtr(GetType()->GetClangType()));
     assert (clang_type->isFunctionType());
-    clang::FunctionType *function_type = dyn_cast<clang::FunctionType> (clang_type);
+    const clang::FunctionType *function_type = dyn_cast<clang::FunctionType> (clang_type);
     clang::QualType fun_return_qualtype = function_type->getResultType();
 
     const ConstString fun_return_name(ClangASTType::GetClangTypeName(fun_return_qualtype.getAsOpaquePtr()));
@@ -484,7 +484,7 @@ Function::GetArgumentTypeAtIndex (size_t idx)
 const char *
 Function::GetArgumentNameAtIndex (size_t idx)
 {
-   clang::Type *clang_type = static_cast<clang::QualType *>(GetType()->GetClangType())->getTypePtr();
+   const clang::Type *clang_type = static_cast<clang::QualType *>(GetType()->GetClangType())->getTypePtr();
    assert (clang_type->isFunctionType());
    if (!clang_type->isFunctionProtoType())
        return NULL;