ClangASTContext.cpp revision 6a97d425a9bb1a137a7dcf7be90edd37d21f4dbb
1a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles)//===-- ClangASTContext.cpp -------------------------------------*- C++ -*-===// 22a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// 32a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// The LLVM Compiler Infrastructure 42a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// 52a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// This file is distributed under the University of Illinois Open Source 62a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// License. See LICENSE.TXT for details. 72a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// 8a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles)//===----------------------------------------------------------------------===// 92a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "lldb/Symbol/ClangASTContext.h" 112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// C Includes 132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// C++ Includes 142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include <string> 152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Other libraries and framework includes 172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Clang headers like to use NDEBUG inside of them to enable/disable debug 19c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing 20c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// or another. This is bad because it means that if clang was built in release 21c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// mode, it assumes that you are building in release mode which is not always 22c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// the case. You can end up with functions that are defined as empty in header 23c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// files when NDEBUG is not defined, and this can cause link errors with the 24c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// clang .a files that you have since you might be missing functions in the .a 254e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles)// file. So we have to define NDEBUG when including clang headers to avoid any 26c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// mismatches. This is covered by rdar://problem/8691220 27c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 28c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF) 29c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#define LLDB_DEFINED_NDEBUG_FOR_CLANG 30c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#define NDEBUG 31c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// Need to include assert.h so it is as clang would expect it to be (disabled) 32c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include <assert.h> 332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#endif 34d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) 35d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles)#include "clang/AST/ASTContext.h" 36d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles)#include "clang/AST/ASTImporter.h" 37d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles)#include "clang/AST/CXXInheritance.h" 38d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles)#include "clang/AST/DeclObjC.h" 392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/AST/DeclTemplate.h" 40c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "clang/AST/RecordLayout.h" 412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/AST/Type.h" 426e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include "clang/Basic/Builtins.h" 436e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include "clang/Basic/Diagnostic.h" 446e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include "clang/Basic/FileManager.h" 452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Basic/FileSystemOptions.h" 462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Basic/SourceManager.h" 472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Basic/TargetInfo.h" 481e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/Basic/TargetOptions.h" 496e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include "clang/Frontend/FrontendOptions.h" 502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Frontend/LangStandard.h" 512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 52c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG 53c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#undef NDEBUG 54c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#undef LLDB_DEFINED_NDEBUG_FOR_CLANG 55c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// Need to re-include assert.h so it is as _we_ would expect it to be (enabled) 56c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include <assert.h> 57c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#endif 58c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 59c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "lldb/Core/ArchSpec.h" 602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "lldb/Core/dwarf.h" 612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "lldb/Core/Flags.h" 622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "lldb/Core/Log.h" 63c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "lldb/Core/RegularExpression.h" 64c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "lldb/Expression/ASTDumper.h" 65c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "lldb/Symbol/ClangExternalASTSourceCommon.h" 66c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "lldb/Symbol/VerifyDecl.h" 67c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "lldb/Target/ExecutionContext.h" 68c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "lldb/Target/Process.h" 69c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "lldb/Target/ObjCLanguageRuntime.h" 70c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 71c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 72c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include <stdio.h> 73c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 74c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)using namespace lldb; 75c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)using namespace lldb_private; 76c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)using namespace llvm; 77c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)using namespace clang; 78c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 79c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 80c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static bool 81c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool allow_completion = true) 82c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles){ 83c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 84c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) switch (type_class) 85c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) { 86c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) case clang::Type::ConstantArray: 872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) { 882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const clang::ArrayType *array_type = dyn_cast<clang::ArrayType>(qual_type.getTypePtr()); 892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (array_type) 91c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return GetCompleteQualType (ast, array_type->getElementType(), allow_completion); 922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 93c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) break; 94c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 95c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) case clang::Type::Record: 962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) case clang::Type::Enum: 97c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) { 98c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr()); 99c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (tag_type) 100c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) { 101c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) clang::TagDecl *tag_decl = tag_type->getDecl(); 1024e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (tag_decl) 103c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) { 104c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (tag_decl->isCompleteDefinition()) 105c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return true; 1064e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) 107c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (!allow_completion) 108c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return false; 109c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 110d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) if (tag_decl->hasExternalLexicalStorage()) 1114e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) { 112d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) if (ast) 113d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) { 1144e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) ExternalASTSource *external_ast_source = ast->getExternalSource(); 1154e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (external_ast_source) 116c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) { 117d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) external_ast_source->CompleteType(tag_decl); 1184e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) return !tag_type->isIncompleteType(); 119c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 120c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 121c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 122c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return false; 1232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 1242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 125c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 126c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 127c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) break; 128c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 129c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) case clang::Type::ObjCObject: 1302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) case clang::Type::ObjCInterface: 1312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) { 1322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type); 1332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (objc_class_type) 1342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) { 1352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 1362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // We currently can't complete objective C types through the newly added ASTContext 1372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // because it only supports TagDecl objects right now... 1382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (class_interface_decl) 1392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) { 1402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (class_interface_decl->getDefinition()) 1412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 1422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 143c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (!allow_completion) 144c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return false; 145c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 146d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) if (class_interface_decl->hasExternalLexicalStorage()) 147d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) { 148d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) if (ast) 1492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) { 1502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ExternalASTSource *external_ast_source = ast->getExternalSource(); 151d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) if (external_ast_source) 152d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) { 153d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) external_ast_source->CompleteType (class_interface_decl); 154d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) return !objc_class_type->isIncompleteType(); 155d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) } 156d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) } 157d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) } 1582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 1592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 160d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) } 161d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) } 1622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) break; 1632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 164c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) case clang::Type::Typedef: 1652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return GetCompleteQualType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion); 1662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) case clang::Type::Elaborated: 168c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return GetCompleteQualType (ast, cast<ElaboratedType>(qual_type)->getNamedType(), allow_completion); 1692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) default: 1712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) break; 1722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 1732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 174d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) return true; 1754e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles)} 1764e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) 1774e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles)static AccessSpecifier 1784e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles)ConvertAccessTypeToAccessSpecifier (AccessType access) 1794e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles){ 180d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) switch (access) 1816e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) { 1824e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) default: break; 1834e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) case eAccessNone: return AS_none; 1844e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) case eAccessPublic: return AS_public; 1854e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) case eAccessPrivate: return AS_private; 1864e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) case eAccessProtected: return AS_protected; 1874e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) } 1884e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) return AS_none; 1894e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles)} 1906e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) 1914e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles)static ObjCIvarDecl::AccessControl 1924e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles)ConvertAccessTypeToObjCIvarAccessControl (AccessType access) 1936e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles){ 1946e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) switch (access) 1956e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) { 1966e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) default: break; 197d0247b1b59f9c528cb6df88b4f2b9afaf80d181eTorne (Richard Coles) case eAccessNone: return ObjCIvarDecl::None; 1982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) case eAccessPublic: return ObjCIvarDecl::Public; 199 case eAccessPrivate: return ObjCIvarDecl::Private; 200 case eAccessProtected: return ObjCIvarDecl::Protected; 201 case eAccessPackage: return ObjCIvarDecl::Package; 202 } 203 return ObjCIvarDecl::None; 204} 205 206 207static void 208ParseLangArgs 209( 210 LangOptions &Opts, 211 InputKind IK 212) 213{ 214 // FIXME: Cleanup per-file based stuff. 215 216 // Set some properties which depend soley on the input kind; it would be nice 217 // to move these to the language standard, and have the driver resolve the 218 // input kind + language standard. 219 if (IK == IK_Asm) { 220 Opts.AsmPreprocessor = 1; 221 } else if (IK == IK_ObjC || 222 IK == IK_ObjCXX || 223 IK == IK_PreprocessedObjC || 224 IK == IK_PreprocessedObjCXX) { 225 Opts.ObjC1 = Opts.ObjC2 = 1; 226 } 227 228 LangStandard::Kind LangStd = LangStandard::lang_unspecified; 229 230 if (LangStd == LangStandard::lang_unspecified) { 231 // Based on the base language, pick one. 232 switch (IK) { 233 case IK_None: 234 case IK_AST: 235 case IK_LLVM_IR: 236 assert (!"Invalid input kind!"); 237 case IK_OpenCL: 238 LangStd = LangStandard::lang_opencl; 239 break; 240 case IK_CUDA: 241 LangStd = LangStandard::lang_cuda; 242 break; 243 case IK_Asm: 244 case IK_C: 245 case IK_PreprocessedC: 246 case IK_ObjC: 247 case IK_PreprocessedObjC: 248 LangStd = LangStandard::lang_gnu99; 249 break; 250 case IK_CXX: 251 case IK_PreprocessedCXX: 252 case IK_ObjCXX: 253 case IK_PreprocessedObjCXX: 254 LangStd = LangStandard::lang_gnucxx98; 255 break; 256 } 257 } 258 259 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd); 260 Opts.BCPLComment = Std.hasBCPLComments(); 261 Opts.C99 = Std.isC99(); 262 Opts.CPlusPlus = Std.isCPlusPlus(); 263 Opts.CPlusPlus0x = Std.isCPlusPlus0x(); 264 Opts.Digraphs = Std.hasDigraphs(); 265 Opts.GNUMode = Std.isGNUMode(); 266 Opts.GNUInline = !Std.isC99(); 267 Opts.HexFloats = Std.hasHexFloats(); 268 Opts.ImplicitInt = Std.hasImplicitInt(); 269 270 // OpenCL has some additional defaults. 271 if (LangStd == LangStandard::lang_opencl) { 272 Opts.OpenCL = 1; 273 Opts.AltiVec = 1; 274 Opts.CXXOperatorNames = 1; 275 Opts.LaxVectorConversions = 1; 276 } 277 278 // OpenCL and C++ both have bool, true, false keywords. 279 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus; 280 281// if (Opts.CPlusPlus) 282// Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names); 283// 284// if (Args.hasArg(OPT_fobjc_gc_only)) 285// Opts.setGCMode(LangOptions::GCOnly); 286// else if (Args.hasArg(OPT_fobjc_gc)) 287// Opts.setGCMode(LangOptions::HybridGC); 288// 289// if (Args.hasArg(OPT_print_ivar_layout)) 290// Opts.ObjCGCBitmapPrint = 1; 291// 292// if (Args.hasArg(OPT_faltivec)) 293// Opts.AltiVec = 1; 294// 295// if (Args.hasArg(OPT_pthread)) 296// Opts.POSIXThreads = 1; 297// 298// llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility, 299// "default"); 300// if (Vis == "default") 301 Opts.setVisibilityMode(DefaultVisibility); 302// else if (Vis == "hidden") 303// Opts.setVisibilityMode(LangOptions::Hidden); 304// else if (Vis == "protected") 305// Opts.setVisibilityMode(LangOptions::Protected); 306// else 307// Diags.Report(diag::err_drv_invalid_value) 308// << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis; 309 310// Opts.OverflowChecking = Args.hasArg(OPT_ftrapv); 311 312 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs 313 // is specified, or -std is set to a conforming mode. 314 Opts.Trigraphs = !Opts.GNUMode; 315// if (Args.hasArg(OPT_trigraphs)) 316// Opts.Trigraphs = 1; 317// 318// Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers, 319// OPT_fno_dollars_in_identifiers, 320// !Opts.AsmPreprocessor); 321// Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings); 322// Opts.Microsoft = Args.hasArg(OPT_fms_extensions); 323// Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings); 324// if (Args.hasArg(OPT_fno_lax_vector_conversions)) 325// Opts.LaxVectorConversions = 0; 326// Opts.Exceptions = Args.hasArg(OPT_fexceptions); 327// Opts.RTTI = !Args.hasArg(OPT_fno_rtti); 328// Opts.Blocks = Args.hasArg(OPT_fblocks); 329// Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char); 330// Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar); 331// Opts.Freestanding = Args.hasArg(OPT_ffreestanding); 332// Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding; 333// Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new); 334// Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions); 335// Opts.AccessControl = Args.hasArg(OPT_faccess_control); 336// Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors); 337// Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno); 338// Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99, 339// Diags); 340// Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime); 341// Opts.ObjCConstantStringClass = getLastArgValue(Args, 342// OPT_fconstant_string_class); 343// Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi); 344// Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior); 345// Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls); 346// Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); 347// Opts.Static = Args.hasArg(OPT_static_define); 348 Opts.OptimizeSize = 0; 349 350 // FIXME: Eliminate this dependency. 351// unsigned Opt = 352// Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags); 353// Opts.Optimize = Opt != 0; 354 unsigned Opt = 0; 355 356 // This is the __NO_INLINE__ define, which just depends on things like the 357 // optimization level and -fno-inline, not actually whether the backend has 358 // inlining enabled. 359 // 360 // FIXME: This is affected by other options (-fno-inline). 361 Opts.NoInlineDefine = !Opt; 362 363// unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags); 364// switch (SSP) { 365// default: 366// Diags.Report(diag::err_drv_invalid_value) 367// << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP; 368// break; 369// case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break; 370// case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break; 371// case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break; 372// } 373} 374 375 376ClangASTContext::ClangASTContext (const char *target_triple) : 377 m_target_triple(), 378 m_ast_ap(), 379 m_language_options_ap(), 380 m_source_manager_ap(), 381 m_diagnostics_engine_ap(), 382 m_target_options_rp(), 383 m_target_info_ap(), 384 m_identifier_table_ap(), 385 m_selector_table_ap(), 386 m_builtins_ap(), 387 m_callback_tag_decl (NULL), 388 m_callback_objc_decl (NULL), 389 m_callback_baton (NULL) 390 391{ 392 if (target_triple && target_triple[0]) 393 SetTargetTriple (target_triple); 394} 395 396//---------------------------------------------------------------------- 397// Destructor 398//---------------------------------------------------------------------- 399ClangASTContext::~ClangASTContext() 400{ 401 m_builtins_ap.reset(); 402 m_selector_table_ap.reset(); 403 m_identifier_table_ap.reset(); 404 m_target_info_ap.reset(); 405 m_target_options_rp.reset(); 406 m_diagnostics_engine_ap.reset(); 407 m_source_manager_ap.reset(); 408 m_language_options_ap.reset(); 409 m_ast_ap.reset(); 410} 411 412 413void 414ClangASTContext::Clear() 415{ 416 m_ast_ap.reset(); 417 m_language_options_ap.reset(); 418 m_source_manager_ap.reset(); 419 m_diagnostics_engine_ap.reset(); 420 m_target_options_rp.reset(); 421 m_target_info_ap.reset(); 422 m_identifier_table_ap.reset(); 423 m_selector_table_ap.reset(); 424 m_builtins_ap.reset(); 425} 426 427const char * 428ClangASTContext::GetTargetTriple () 429{ 430 return m_target_triple.c_str(); 431} 432 433void 434ClangASTContext::SetTargetTriple (const char *target_triple) 435{ 436 Clear(); 437 m_target_triple.assign(target_triple); 438} 439 440void 441ClangASTContext::SetArchitecture (const ArchSpec &arch) 442{ 443 SetTargetTriple(arch.GetTriple().str().c_str()); 444} 445 446bool 447ClangASTContext::HasExternalSource () 448{ 449 ASTContext *ast = getASTContext(); 450 if (ast) 451 return ast->getExternalSource () != NULL; 452 return false; 453} 454 455void 456ClangASTContext::SetExternalSource (llvm::OwningPtr<ExternalASTSource> &ast_source_ap) 457{ 458 ASTContext *ast = getASTContext(); 459 if (ast) 460 { 461 ast->setExternalSource (ast_source_ap); 462 ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true); 463 //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true); 464 } 465} 466 467void 468ClangASTContext::RemoveExternalSource () 469{ 470 ASTContext *ast = getASTContext(); 471 472 if (ast) 473 { 474 llvm::OwningPtr<ExternalASTSource> empty_ast_source_ap; 475 ast->setExternalSource (empty_ast_source_ap); 476 ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false); 477 //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false); 478 } 479} 480 481 482 483ASTContext * 484ClangASTContext::getASTContext() 485{ 486 if (m_ast_ap.get() == NULL) 487 { 488 m_ast_ap.reset(new ASTContext (*getLanguageOptions(), 489 *getSourceManager(), 490 getTargetInfo(), 491 *getIdentifierTable(), 492 *getSelectorTable(), 493 *getBuiltinContext(), 494 0)); 495 496 if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton) 497 { 498 m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage(); 499 //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage(); 500 } 501 502 m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false); 503 } 504 return m_ast_ap.get(); 505} 506 507Builtin::Context * 508ClangASTContext::getBuiltinContext() 509{ 510 if (m_builtins_ap.get() == NULL) 511 m_builtins_ap.reset (new Builtin::Context()); 512 return m_builtins_ap.get(); 513} 514 515IdentifierTable * 516ClangASTContext::getIdentifierTable() 517{ 518 if (m_identifier_table_ap.get() == NULL) 519 m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), NULL)); 520 return m_identifier_table_ap.get(); 521} 522 523LangOptions * 524ClangASTContext::getLanguageOptions() 525{ 526 if (m_language_options_ap.get() == NULL) 527 { 528 m_language_options_ap.reset(new LangOptions()); 529 ParseLangArgs(*m_language_options_ap, IK_ObjCXX); 530// InitializeLangOptions(*m_language_options_ap, IK_ObjCXX); 531 } 532 return m_language_options_ap.get(); 533} 534 535SelectorTable * 536ClangASTContext::getSelectorTable() 537{ 538 if (m_selector_table_ap.get() == NULL) 539 m_selector_table_ap.reset (new SelectorTable()); 540 return m_selector_table_ap.get(); 541} 542 543clang::FileManager * 544ClangASTContext::getFileManager() 545{ 546 if (m_file_manager_ap.get() == NULL) 547 { 548 clang::FileSystemOptions file_system_options; 549 m_file_manager_ap.reset(new clang::FileManager(file_system_options)); 550 } 551 return m_file_manager_ap.get(); 552} 553 554clang::SourceManager * 555ClangASTContext::getSourceManager() 556{ 557 if (m_source_manager_ap.get() == NULL) 558 m_source_manager_ap.reset(new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager())); 559 return m_source_manager_ap.get(); 560} 561 562clang::DiagnosticsEngine * 563ClangASTContext::getDiagnosticsEngine() 564{ 565 if (m_diagnostics_engine_ap.get() == NULL) 566 { 567 llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs()); 568 m_diagnostics_engine_ap.reset(new DiagnosticsEngine(diag_id_sp)); 569 } 570 return m_diagnostics_engine_ap.get(); 571} 572 573class NullDiagnosticConsumer : public DiagnosticConsumer 574{ 575public: 576 NullDiagnosticConsumer () 577 { 578 m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS); 579 } 580 581 void HandleDiagnostic (DiagnosticsEngine::Level DiagLevel, const Diagnostic &info) 582 { 583 if (m_log) 584 { 585 llvm::SmallVector<char, 32> diag_str(10); 586 info.FormatDiagnostic(diag_str); 587 diag_str.push_back('\0'); 588 m_log->Printf("Compiler diagnostic: %s\n", diag_str.data()); 589 } 590 } 591 592 DiagnosticConsumer *clone (DiagnosticsEngine &Diags) const 593 { 594 return new NullDiagnosticConsumer (); 595 } 596private: 597 LogSP m_log; 598}; 599 600DiagnosticConsumer * 601ClangASTContext::getDiagnosticConsumer() 602{ 603 if (m_diagnostic_consumer_ap.get() == NULL) 604 m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer); 605 606 return m_diagnostic_consumer_ap.get(); 607} 608 609TargetOptions * 610ClangASTContext::getTargetOptions() 611{ 612 if (m_target_options_rp.getPtr() == NULL && !m_target_triple.empty()) 613 { 614 m_target_options_rp.reset (); 615 m_target_options_rp = new TargetOptions(); 616 if (m_target_options_rp.getPtr() != NULL) 617 m_target_options_rp->Triple = m_target_triple; 618 } 619 return m_target_options_rp.getPtr(); 620} 621 622 623TargetInfo * 624ClangASTContext::getTargetInfo() 625{ 626 // target_triple should be something like "x86_64-apple-macosx" 627 if (m_target_info_ap.get() == NULL && !m_target_triple.empty()) 628 m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), *getTargetOptions())); 629 return m_target_info_ap.get(); 630} 631 632#pragma mark Basic Types 633 634static inline bool 635QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type) 636{ 637 uint64_t qual_type_bit_size = ast->getTypeSize(qual_type); 638 if (qual_type_bit_size == bit_size) 639 return true; 640 return false; 641} 642 643clang_type_t 644ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size) 645{ 646 ASTContext *ast = getASTContext(); 647 648 assert (ast != NULL); 649 650 return GetBuiltinTypeForEncodingAndBitSize (ast, encoding, bit_size); 651} 652 653clang_type_t 654ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size) 655{ 656 if (!ast) 657 return NULL; 658 659 switch (encoding) 660 { 661 case eEncodingInvalid: 662 if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy)) 663 return ast->VoidPtrTy.getAsOpaquePtr(); 664 break; 665 666 case eEncodingUint: 667 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 668 return ast->UnsignedCharTy.getAsOpaquePtr(); 669 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 670 return ast->UnsignedShortTy.getAsOpaquePtr(); 671 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) 672 return ast->UnsignedIntTy.getAsOpaquePtr(); 673 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) 674 return ast->UnsignedLongTy.getAsOpaquePtr(); 675 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) 676 return ast->UnsignedLongLongTy.getAsOpaquePtr(); 677 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) 678 return ast->UnsignedInt128Ty.getAsOpaquePtr(); 679 break; 680 681 case eEncodingSint: 682 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) 683 return ast->CharTy.getAsOpaquePtr(); 684 if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) 685 return ast->ShortTy.getAsOpaquePtr(); 686 if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) 687 return ast->IntTy.getAsOpaquePtr(); 688 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) 689 return ast->LongTy.getAsOpaquePtr(); 690 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) 691 return ast->LongLongTy.getAsOpaquePtr(); 692 if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) 693 return ast->Int128Ty.getAsOpaquePtr(); 694 break; 695 696 case eEncodingIEEE754: 697 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) 698 return ast->FloatTy.getAsOpaquePtr(); 699 if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) 700 return ast->DoubleTy.getAsOpaquePtr(); 701 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) 702 return ast->LongDoubleTy.getAsOpaquePtr(); 703 break; 704 705 case eEncodingVector: 706 // Sanity check that bit_size is a multiple of 8's. 707 if (bit_size && !(bit_size & 0x7u)) 708 return ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8).getAsOpaquePtr(); 709 break; 710 default: 711 break; 712 } 713 714 return NULL; 715} 716 717clang_type_t 718ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size) 719{ 720 ASTContext *ast = getASTContext(); 721 722#define streq(a,b) strcmp(a,b) == 0 723 assert (ast != NULL); 724 if (ast) 725 { 726 switch (dw_ate) 727 { 728 default: 729 break; 730 731 case DW_ATE_address: 732 if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy)) 733 return ast->VoidPtrTy.getAsOpaquePtr(); 734 break; 735 736 case DW_ATE_boolean: 737 if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy)) 738 return ast->BoolTy.getAsOpaquePtr(); 739 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 740 return ast->UnsignedCharTy.getAsOpaquePtr(); 741 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 742 return ast->UnsignedShortTy.getAsOpaquePtr(); 743 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) 744 return ast->UnsignedIntTy.getAsOpaquePtr(); 745 break; 746 747 case DW_ATE_lo_user: 748 // This has been seen to mean DW_AT_complex_integer 749 if (type_name) 750 { 751 if (::strstr(type_name, "complex")) 752 { 753 clang_type_t complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2); 754 return ast->getComplexType (QualType::getFromOpaquePtr(complex_int_clang_type)).getAsOpaquePtr(); 755 } 756 } 757 break; 758 759 case DW_ATE_complex_float: 760 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy)) 761 return ast->FloatComplexTy.getAsOpaquePtr(); 762 else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy)) 763 return ast->DoubleComplexTy.getAsOpaquePtr(); 764 else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy)) 765 return ast->LongDoubleComplexTy.getAsOpaquePtr(); 766 else 767 { 768 clang_type_t complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2); 769 return ast->getComplexType (QualType::getFromOpaquePtr(complex_float_clang_type)).getAsOpaquePtr(); 770 } 771 break; 772 773 case DW_ATE_float: 774 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) 775 return ast->FloatTy.getAsOpaquePtr(); 776 if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) 777 return ast->DoubleTy.getAsOpaquePtr(); 778 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) 779 return ast->LongDoubleTy.getAsOpaquePtr(); 780 break; 781 782 case DW_ATE_signed: 783 if (type_name) 784 { 785 if (streq(type_name, "wchar_t") && 786 QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy)) 787 return ast->WCharTy.getAsOpaquePtr(); 788 if (streq(type_name, "void") && 789 QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy)) 790 return ast->VoidTy.getAsOpaquePtr(); 791 if (strstr(type_name, "long long") && 792 QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) 793 return ast->LongLongTy.getAsOpaquePtr(); 794 if (strstr(type_name, "long") && 795 QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) 796 return ast->LongTy.getAsOpaquePtr(); 797 if (strstr(type_name, "short") && 798 QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) 799 return ast->ShortTy.getAsOpaquePtr(); 800 if (strstr(type_name, "char")) 801 { 802 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) 803 return ast->CharTy.getAsOpaquePtr(); 804 if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) 805 return ast->SignedCharTy.getAsOpaquePtr(); 806 } 807 if (strstr(type_name, "int")) 808 { 809 if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) 810 return ast->IntTy.getAsOpaquePtr(); 811 if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) 812 return ast->Int128Ty.getAsOpaquePtr(); 813 } 814 } 815 // We weren't able to match up a type name, just search by size 816 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) 817 return ast->CharTy.getAsOpaquePtr(); 818 if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) 819 return ast->ShortTy.getAsOpaquePtr(); 820 if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) 821 return ast->IntTy.getAsOpaquePtr(); 822 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) 823 return ast->LongTy.getAsOpaquePtr(); 824 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) 825 return ast->LongLongTy.getAsOpaquePtr(); 826 if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) 827 return ast->Int128Ty.getAsOpaquePtr(); 828 break; 829 830 case DW_ATE_signed_char: 831 if (type_name) 832 { 833 if (streq(type_name, "signed char")) 834 { 835 if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) 836 return ast->SignedCharTy.getAsOpaquePtr(); 837 } 838 } 839 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) 840 return ast->CharTy.getAsOpaquePtr(); 841 if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) 842 return ast->SignedCharTy.getAsOpaquePtr(); 843 break; 844 845 case DW_ATE_unsigned: 846 if (type_name) 847 { 848 if (strstr(type_name, "long long")) 849 { 850 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) 851 return ast->UnsignedLongLongTy.getAsOpaquePtr(); 852 } 853 else if (strstr(type_name, "long")) 854 { 855 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) 856 return ast->UnsignedLongTy.getAsOpaquePtr(); 857 } 858 else if (strstr(type_name, "short")) 859 { 860 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 861 return ast->UnsignedShortTy.getAsOpaquePtr(); 862 } 863 else if (strstr(type_name, "char")) 864 { 865 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 866 return ast->UnsignedCharTy.getAsOpaquePtr(); 867 } 868 else if (strstr(type_name, "int")) 869 { 870 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) 871 return ast->UnsignedIntTy.getAsOpaquePtr(); 872 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) 873 return ast->UnsignedInt128Ty.getAsOpaquePtr(); 874 } 875 } 876 // We weren't able to match up a type name, just search by size 877 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 878 return ast->UnsignedCharTy.getAsOpaquePtr(); 879 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 880 return ast->UnsignedShortTy.getAsOpaquePtr(); 881 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) 882 return ast->UnsignedIntTy.getAsOpaquePtr(); 883 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) 884 return ast->UnsignedLongTy.getAsOpaquePtr(); 885 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) 886 return ast->UnsignedLongLongTy.getAsOpaquePtr(); 887 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) 888 return ast->UnsignedInt128Ty.getAsOpaquePtr(); 889 break; 890 891 case DW_ATE_unsigned_char: 892 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 893 return ast->UnsignedCharTy.getAsOpaquePtr(); 894 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 895 return ast->UnsignedShortTy.getAsOpaquePtr(); 896 break; 897 898 case DW_ATE_imaginary_float: 899 break; 900 901 case DW_ATE_UTF: 902 if (type_name) 903 { 904 if (streq(type_name, "char16_t")) 905 { 906 return ast->Char16Ty.getAsOpaquePtr(); 907 } 908 else if (streq(type_name, "char32_t")) 909 { 910 return ast->Char32Ty.getAsOpaquePtr(); 911 } 912 } 913 break; 914 } 915 } 916 // This assert should fire for anything that we don't catch above so we know 917 // to fix any issues we run into. 918 if (type_name) 919 { 920 Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type '%s' encoded with DW_ATE = 0x%x, bit_size = %u\n", type_name, dw_ate, bit_size); 921 } 922 else 923 { 924 Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type encoded with DW_ATE = 0x%x, bit_size = %u\n", dw_ate, bit_size); 925 } 926 return NULL; 927} 928 929clang_type_t 930ClangASTContext::GetBuiltInType_void(ASTContext *ast) 931{ 932 return ast->VoidTy.getAsOpaquePtr(); 933} 934 935clang_type_t 936ClangASTContext::GetBuiltInType_bool() 937{ 938 return getASTContext()->BoolTy.getAsOpaquePtr(); 939} 940 941clang_type_t 942ClangASTContext::GetBuiltInType_objc_id() 943{ 944 return getASTContext()->getObjCIdType().getAsOpaquePtr(); 945} 946 947clang_type_t 948ClangASTContext::GetBuiltInType_objc_Class() 949{ 950 return getASTContext()->getObjCClassType().getAsOpaquePtr(); 951} 952 953clang_type_t 954ClangASTContext::GetBuiltInType_objc_selector() 955{ 956 return getASTContext()->getObjCSelType().getAsOpaquePtr(); 957} 958 959clang_type_t 960ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast) 961{ 962 return ast->UnknownAnyTy.getAsOpaquePtr(); 963} 964 965clang_type_t 966ClangASTContext::GetCStringType (bool is_const) 967{ 968 QualType char_type(getASTContext()->CharTy); 969 970 if (is_const) 971 char_type.addConst(); 972 973 return getASTContext()->getPointerType(char_type).getAsOpaquePtr(); 974} 975 976clang_type_t 977ClangASTContext::GetVoidType() 978{ 979 return GetVoidType(getASTContext()); 980} 981 982clang_type_t 983ClangASTContext::GetVoidType(ASTContext *ast) 984{ 985 return ast->VoidTy.getAsOpaquePtr(); 986} 987 988clang_type_t 989ClangASTContext::GetVoidPtrType (bool is_const) 990{ 991 return GetVoidPtrType(getASTContext(), is_const); 992} 993 994clang_type_t 995ClangASTContext::GetVoidPtrType (ASTContext *ast, bool is_const) 996{ 997 QualType void_ptr_type(ast->VoidPtrTy); 998 999 if (is_const) 1000 void_ptr_type.addConst(); 1001 1002 return void_ptr_type.getAsOpaquePtr(); 1003} 1004 1005clang::DeclContext * 1006ClangASTContext::GetTranslationUnitDecl (clang::ASTContext *ast) 1007{ 1008 return ast->getTranslationUnitDecl(); 1009} 1010 1011clang_type_t 1012ClangASTContext::CopyType (ASTContext *dst_ast, 1013 ASTContext *src_ast, 1014 clang_type_t clang_type) 1015{ 1016 FileSystemOptions file_system_options; 1017 FileManager file_manager (file_system_options); 1018 ASTImporter importer(*dst_ast, file_manager, 1019 *src_ast, file_manager, 1020 false); 1021 1022 QualType src (QualType::getFromOpaquePtr(clang_type)); 1023 QualType dst (importer.Import(src)); 1024 1025 return dst.getAsOpaquePtr(); 1026} 1027 1028 1029clang::Decl * 1030ClangASTContext::CopyDecl (ASTContext *dst_ast, 1031 ASTContext *src_ast, 1032 clang::Decl *source_decl) 1033{ 1034 FileSystemOptions file_system_options; 1035 FileManager file_manager (file_system_options); 1036 ASTImporter importer(*dst_ast, file_manager, 1037 *src_ast, file_manager, 1038 false); 1039 1040 return importer.Import(source_decl); 1041} 1042 1043bool 1044ClangASTContext::AreTypesSame (ASTContext *ast, 1045 clang_type_t type1, 1046 clang_type_t type2, 1047 bool ignore_qualifiers) 1048{ 1049 if (type1 == type2) 1050 return true; 1051 1052 QualType type1_qual = QualType::getFromOpaquePtr(type1); 1053 QualType type2_qual = QualType::getFromOpaquePtr(type2); 1054 1055 if (ignore_qualifiers) 1056 { 1057 type1_qual = type1_qual.getUnqualifiedType(); 1058 type2_qual = type2_qual.getUnqualifiedType(); 1059 } 1060 1061 return ast->hasSameType (type1_qual, 1062 type2_qual); 1063} 1064 1065#pragma mark CVR modifiers 1066 1067clang_type_t 1068ClangASTContext::AddConstModifier (clang_type_t clang_type) 1069{ 1070 if (clang_type) 1071 { 1072 QualType result(QualType::getFromOpaquePtr(clang_type)); 1073 result.addConst(); 1074 return result.getAsOpaquePtr(); 1075 } 1076 return NULL; 1077} 1078 1079clang_type_t 1080ClangASTContext::AddRestrictModifier (clang_type_t clang_type) 1081{ 1082 if (clang_type) 1083 { 1084 QualType result(QualType::getFromOpaquePtr(clang_type)); 1085 result.getQualifiers().setRestrict (true); 1086 return result.getAsOpaquePtr(); 1087 } 1088 return NULL; 1089} 1090 1091clang_type_t 1092ClangASTContext::AddVolatileModifier (clang_type_t clang_type) 1093{ 1094 if (clang_type) 1095 { 1096 QualType result(QualType::getFromOpaquePtr(clang_type)); 1097 result.getQualifiers().setVolatile (true); 1098 return result.getAsOpaquePtr(); 1099 } 1100 return NULL; 1101} 1102 1103 1104clang_type_t 1105ClangASTContext::GetTypeForDecl (TagDecl *decl) 1106{ 1107 // No need to call the getASTContext() accessor (which can create the AST 1108 // if it isn't created yet, because we can't have created a decl in this 1109 // AST if our AST didn't already exist... 1110 if (m_ast_ap.get()) 1111 return m_ast_ap->getTagDeclType(decl).getAsOpaquePtr(); 1112 return NULL; 1113} 1114 1115clang_type_t 1116ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl) 1117{ 1118 // No need to call the getASTContext() accessor (which can create the AST 1119 // if it isn't created yet, because we can't have created a decl in this 1120 // AST if our AST didn't already exist... 1121 if (m_ast_ap.get()) 1122 return m_ast_ap->getObjCInterfaceType(decl).getAsOpaquePtr(); 1123 return NULL; 1124} 1125 1126#pragma mark Structure, Unions, Classes 1127 1128clang_type_t 1129ClangASTContext::CreateRecordType (DeclContext *decl_ctx, AccessType access_type, const char *name, int kind, LanguageType language, uint64_t metadata) 1130{ 1131 ASTContext *ast = getASTContext(); 1132 assert (ast != NULL); 1133 1134 if (decl_ctx == NULL) 1135 decl_ctx = ast->getTranslationUnitDecl(); 1136 1137 1138 if (language == eLanguageTypeObjC || language == eLanguageTypeObjC_plus_plus) 1139 { 1140 bool isForwardDecl = true; 1141 bool isInternal = false; 1142 return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal, metadata); 1143 } 1144 1145 // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and 1146 // we will need to update this code. I was told to currently always use 1147 // the CXXRecordDecl class since we often don't know from debug information 1148 // if something is struct or a class, so we default to always use the more 1149 // complete definition just in case. 1150 CXXRecordDecl *decl = CXXRecordDecl::Create (*ast, 1151 (TagDecl::TagKind)kind, 1152 decl_ctx, 1153 SourceLocation(), 1154 SourceLocation(), 1155 name && name[0] ? &ast->Idents.get(name) : NULL); 1156 1157 if (decl) 1158 SetMetadata(ast, (uintptr_t)decl, metadata); 1159 1160 if (decl_ctx) 1161 { 1162 if (access_type != eAccessNone) 1163 decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type)); 1164 decl_ctx->addDecl (decl); 1165 } 1166 return ast->getTagDeclType(decl).getAsOpaquePtr(); 1167} 1168 1169static TemplateParameterList * 1170CreateTemplateParameterList (ASTContext *ast, 1171 const ClangASTContext::TemplateParameterInfos &template_param_infos, 1172 llvm::SmallVector<NamedDecl *, 8> &template_param_decls) 1173{ 1174 const bool parameter_pack = false; 1175 const bool is_typename = false; 1176 const unsigned depth = 0; 1177 const size_t num_template_params = template_param_infos.GetSize(); 1178 for (size_t i=0; i<num_template_params; ++i) 1179 { 1180 const char *name = template_param_infos.names[i]; 1181 if (template_param_infos.args[i].getKind() == TemplateArgument::Integral) 1182 { 1183 template_param_decls.push_back (NonTypeTemplateParmDecl::Create (*ast, 1184 ast->getTranslationUnitDecl(), // Is this the right decl context?, SourceLocation StartLoc, 1185 SourceLocation(), 1186 SourceLocation(), 1187 depth, 1188 i, 1189 &ast->Idents.get(name), 1190 template_param_infos.args[i].getIntegralType(), 1191 parameter_pack, 1192 NULL)); 1193 1194 } 1195 else 1196 { 1197 template_param_decls.push_back (TemplateTypeParmDecl::Create (*ast, 1198 ast->getTranslationUnitDecl(), // Is this the right decl context? 1199 SourceLocation(), 1200 SourceLocation(), 1201 depth, 1202 i, 1203 &ast->Idents.get(name), 1204 is_typename, 1205 parameter_pack)); 1206 } 1207 } 1208 1209 TemplateParameterList *template_param_list = TemplateParameterList::Create (*ast, 1210 SourceLocation(), 1211 SourceLocation(), 1212 &template_param_decls.front(), 1213 template_param_decls.size(), 1214 SourceLocation()); 1215 return template_param_list; 1216} 1217 1218clang::FunctionTemplateDecl * 1219ClangASTContext::CreateFunctionTemplateDecl (clang::DeclContext *decl_ctx, 1220 clang::FunctionDecl *func_decl, 1221 const char *name, 1222 const TemplateParameterInfos &template_param_infos) 1223{ 1224// /// \brief Create a function template node. 1225 ASTContext *ast = getASTContext(); 1226 1227 llvm::SmallVector<NamedDecl *, 8> template_param_decls; 1228 1229 TemplateParameterList *template_param_list = CreateTemplateParameterList (ast, 1230 template_param_infos, 1231 template_param_decls); 1232 FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create (*ast, 1233 decl_ctx, 1234 func_decl->getLocation(), 1235 func_decl->getDeclName(), 1236 template_param_list, 1237 func_decl); 1238 1239 for (size_t i=0, template_param_decl_count = template_param_decls.size(); 1240 i < template_param_decl_count; 1241 ++i) 1242 { 1243 // TODO: verify which decl context we should put template_param_decls into.. 1244 template_param_decls[i]->setDeclContext (func_decl); 1245 } 1246 1247 return func_tmpl_decl; 1248} 1249 1250void 1251ClangASTContext::CreateFunctionTemplateSpecializationInfo (FunctionDecl *func_decl, 1252 clang::FunctionTemplateDecl *func_tmpl_decl, 1253 const TemplateParameterInfos &infos) 1254{ 1255 TemplateArgumentList template_args (TemplateArgumentList::OnStack, 1256 infos.args.data(), 1257 infos.args.size()); 1258 1259 func_decl->setFunctionTemplateSpecialization (func_tmpl_decl, 1260 &template_args, 1261 NULL); 1262} 1263 1264 1265ClassTemplateDecl * 1266ClangASTContext::CreateClassTemplateDecl (DeclContext *decl_ctx, 1267 lldb::AccessType access_type, 1268 const char *class_name, 1269 int kind, 1270 const TemplateParameterInfos &template_param_infos) 1271{ 1272 ASTContext *ast = getASTContext(); 1273 1274 ClassTemplateDecl *class_template_decl = NULL; 1275 if (decl_ctx == NULL) 1276 decl_ctx = ast->getTranslationUnitDecl(); 1277 1278 IdentifierInfo &identifier_info = ast->Idents.get(class_name); 1279 DeclarationName decl_name (&identifier_info); 1280 1281 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); 1282 for (clang::DeclContext::lookup_iterator pos = result.first, end = result.second; pos != end; ++pos) 1283 { 1284 class_template_decl = dyn_cast<clang::ClassTemplateDecl>(*pos); 1285 if (class_template_decl) 1286 return class_template_decl; 1287 } 1288 1289 llvm::SmallVector<NamedDecl *, 8> template_param_decls; 1290 1291 TemplateParameterList *template_param_list = CreateTemplateParameterList (ast, 1292 template_param_infos, 1293 template_param_decls); 1294 1295 CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create (*ast, 1296 (TagDecl::TagKind)kind, 1297 decl_ctx, // What decl context do we use here? TU? The actual decl context? 1298 SourceLocation(), 1299 SourceLocation(), 1300 &identifier_info); 1301 1302 for (size_t i=0, template_param_decl_count = template_param_decls.size(); 1303 i < template_param_decl_count; 1304 ++i) 1305 { 1306 template_param_decls[i]->setDeclContext (template_cxx_decl); 1307 } 1308 1309 // With templated classes, we say that a class is templated with 1310 // specializations, but that the bare class has no functions. 1311 template_cxx_decl->startDefinition(); 1312 template_cxx_decl->completeDefinition(); 1313 1314 class_template_decl = ClassTemplateDecl::Create (*ast, 1315 decl_ctx, // What decl context do we use here? TU? The actual decl context? 1316 SourceLocation(), 1317 decl_name, 1318 template_param_list, 1319 template_cxx_decl, 1320 NULL); 1321 1322 if (class_template_decl) 1323 { 1324 if (access_type != eAccessNone) 1325 class_template_decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type)); 1326 1327 //if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx)) 1328 // CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl)); 1329 1330 decl_ctx->addDecl (class_template_decl); 1331 1332#ifdef LLDB_CONFIGURATION_DEBUG 1333 VerifyDecl(class_template_decl); 1334#endif 1335 } 1336 1337 return class_template_decl; 1338} 1339 1340 1341ClassTemplateSpecializationDecl * 1342ClangASTContext::CreateClassTemplateSpecializationDecl (DeclContext *decl_ctx, 1343 ClassTemplateDecl *class_template_decl, 1344 int kind, 1345 const TemplateParameterInfos &template_param_infos) 1346{ 1347 ASTContext *ast = getASTContext(); 1348 ClassTemplateSpecializationDecl *class_template_specialization_decl = ClassTemplateSpecializationDecl::Create (*ast, 1349 (TagDecl::TagKind)kind, 1350 decl_ctx, 1351 SourceLocation(), 1352 SourceLocation(), 1353 class_template_decl, 1354 &template_param_infos.args.front(), 1355 template_param_infos.args.size(), 1356 NULL); 1357 1358 return class_template_specialization_decl; 1359} 1360 1361lldb::clang_type_t 1362ClangASTContext::CreateClassTemplateSpecializationType (ClassTemplateSpecializationDecl *class_template_specialization_decl) 1363{ 1364 if (class_template_specialization_decl) 1365 { 1366 ASTContext *ast = getASTContext(); 1367 if (ast) 1368 return ast->getTagDeclType(class_template_specialization_decl).getAsOpaquePtr(); 1369 } 1370 return NULL; 1371} 1372 1373bool 1374ClangASTContext::SetHasExternalStorage (clang_type_t clang_type, bool has_extern) 1375{ 1376 if (clang_type == NULL) 1377 return false; 1378 1379 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 1380 1381 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 1382 switch (type_class) 1383 { 1384 case clang::Type::Record: 1385 { 1386 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 1387 if (cxx_record_decl) 1388 { 1389 cxx_record_decl->setHasExternalLexicalStorage (has_extern); 1390 cxx_record_decl->setHasExternalVisibleStorage (has_extern); 1391 return true; 1392 } 1393 } 1394 break; 1395 1396 case clang::Type::Enum: 1397 { 1398 EnumDecl *enum_decl = cast<EnumType>(qual_type)->getDecl(); 1399 if (enum_decl) 1400 { 1401 enum_decl->setHasExternalLexicalStorage (has_extern); 1402 enum_decl->setHasExternalVisibleStorage (has_extern); 1403 return true; 1404 } 1405 } 1406 break; 1407 1408 case clang::Type::ObjCObject: 1409 case clang::Type::ObjCInterface: 1410 { 1411 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 1412 assert (objc_class_type); 1413 if (objc_class_type) 1414 { 1415 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 1416 1417 if (class_interface_decl) 1418 { 1419 class_interface_decl->setHasExternalLexicalStorage (has_extern); 1420 class_interface_decl->setHasExternalVisibleStorage (has_extern); 1421 return true; 1422 } 1423 } 1424 } 1425 break; 1426 1427 case clang::Type::Typedef: 1428 return ClangASTContext::SetHasExternalStorage (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), has_extern); 1429 1430 case clang::Type::Elaborated: 1431 return ClangASTContext::SetHasExternalStorage (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), has_extern); 1432 1433 default: 1434 break; 1435 } 1436 return false; 1437} 1438 1439static bool 1440IsOperator (const char *name, OverloadedOperatorKind &op_kind) 1441{ 1442 if (name == NULL || name[0] == '\0') 1443 return false; 1444 1445#define OPERATOR_PREFIX "operator" 1446#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1) 1447 1448 const char *post_op_name = NULL; 1449 1450 bool no_space = true; 1451 1452 if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH)) 1453 return false; 1454 1455 post_op_name = name + OPERATOR_PREFIX_LENGTH; 1456 1457 if (post_op_name[0] == ' ') 1458 { 1459 post_op_name++; 1460 no_space = false; 1461 } 1462 1463#undef OPERATOR_PREFIX 1464#undef OPERATOR_PREFIX_LENGTH 1465 1466 // This is an operator, set the overloaded operator kind to invalid 1467 // in case this is a conversion operator... 1468 op_kind = NUM_OVERLOADED_OPERATORS; 1469 1470 switch (post_op_name[0]) 1471 { 1472 default: 1473 if (no_space) 1474 return false; 1475 break; 1476 case 'n': 1477 if (no_space) 1478 return false; 1479 if (strcmp (post_op_name, "new") == 0) 1480 op_kind = OO_New; 1481 else if (strcmp (post_op_name, "new[]") == 0) 1482 op_kind = OO_Array_New; 1483 break; 1484 1485 case 'd': 1486 if (no_space) 1487 return false; 1488 if (strcmp (post_op_name, "delete") == 0) 1489 op_kind = OO_Delete; 1490 else if (strcmp (post_op_name, "delete[]") == 0) 1491 op_kind = OO_Array_Delete; 1492 break; 1493 1494 case '+': 1495 if (post_op_name[1] == '\0') 1496 op_kind = OO_Plus; 1497 else if (post_op_name[2] == '\0') 1498 { 1499 if (post_op_name[1] == '=') 1500 op_kind = OO_PlusEqual; 1501 else if (post_op_name[1] == '+') 1502 op_kind = OO_PlusPlus; 1503 } 1504 break; 1505 1506 case '-': 1507 if (post_op_name[1] == '\0') 1508 op_kind = OO_Minus; 1509 else if (post_op_name[2] == '\0') 1510 { 1511 switch (post_op_name[1]) 1512 { 1513 case '=': op_kind = OO_MinusEqual; break; 1514 case '-': op_kind = OO_MinusMinus; break; 1515 case '>': op_kind = OO_Arrow; break; 1516 } 1517 } 1518 else if (post_op_name[3] == '\0') 1519 { 1520 if (post_op_name[2] == '*') 1521 op_kind = OO_ArrowStar; break; 1522 } 1523 break; 1524 1525 case '*': 1526 if (post_op_name[1] == '\0') 1527 op_kind = OO_Star; 1528 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1529 op_kind = OO_StarEqual; 1530 break; 1531 1532 case '/': 1533 if (post_op_name[1] == '\0') 1534 op_kind = OO_Slash; 1535 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1536 op_kind = OO_SlashEqual; 1537 break; 1538 1539 case '%': 1540 if (post_op_name[1] == '\0') 1541 op_kind = OO_Percent; 1542 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1543 op_kind = OO_PercentEqual; 1544 break; 1545 1546 1547 case '^': 1548 if (post_op_name[1] == '\0') 1549 op_kind = OO_Caret; 1550 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1551 op_kind = OO_CaretEqual; 1552 break; 1553 1554 case '&': 1555 if (post_op_name[1] == '\0') 1556 op_kind = OO_Amp; 1557 else if (post_op_name[2] == '\0') 1558 { 1559 switch (post_op_name[1]) 1560 { 1561 case '=': op_kind = OO_AmpEqual; break; 1562 case '&': op_kind = OO_AmpAmp; break; 1563 } 1564 } 1565 break; 1566 1567 case '|': 1568 if (post_op_name[1] == '\0') 1569 op_kind = OO_Pipe; 1570 else if (post_op_name[2] == '\0') 1571 { 1572 switch (post_op_name[1]) 1573 { 1574 case '=': op_kind = OO_PipeEqual; break; 1575 case '|': op_kind = OO_PipePipe; break; 1576 } 1577 } 1578 break; 1579 1580 case '~': 1581 if (post_op_name[1] == '\0') 1582 op_kind = OO_Tilde; 1583 break; 1584 1585 case '!': 1586 if (post_op_name[1] == '\0') 1587 op_kind = OO_Exclaim; 1588 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1589 op_kind = OO_ExclaimEqual; 1590 break; 1591 1592 case '=': 1593 if (post_op_name[1] == '\0') 1594 op_kind = OO_Equal; 1595 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1596 op_kind = OO_EqualEqual; 1597 break; 1598 1599 case '<': 1600 if (post_op_name[1] == '\0') 1601 op_kind = OO_Less; 1602 else if (post_op_name[2] == '\0') 1603 { 1604 switch (post_op_name[1]) 1605 { 1606 case '<': op_kind = OO_LessLess; break; 1607 case '=': op_kind = OO_LessEqual; break; 1608 } 1609 } 1610 else if (post_op_name[3] == '\0') 1611 { 1612 if (post_op_name[2] == '=') 1613 op_kind = OO_LessLessEqual; 1614 } 1615 break; 1616 1617 case '>': 1618 if (post_op_name[1] == '\0') 1619 op_kind = OO_Greater; 1620 else if (post_op_name[2] == '\0') 1621 { 1622 switch (post_op_name[1]) 1623 { 1624 case '>': op_kind = OO_GreaterGreater; break; 1625 case '=': op_kind = OO_GreaterEqual; break; 1626 } 1627 } 1628 else if (post_op_name[1] == '>' && 1629 post_op_name[2] == '=' && 1630 post_op_name[3] == '\0') 1631 { 1632 op_kind = OO_GreaterGreaterEqual; 1633 } 1634 break; 1635 1636 case ',': 1637 if (post_op_name[1] == '\0') 1638 op_kind = OO_Comma; 1639 break; 1640 1641 case '(': 1642 if (post_op_name[1] == ')' && post_op_name[2] == '\0') 1643 op_kind = OO_Call; 1644 break; 1645 1646 case '[': 1647 if (post_op_name[1] == ']' && post_op_name[2] == '\0') 1648 op_kind = OO_Subscript; 1649 break; 1650 } 1651 1652 return true; 1653} 1654 1655static inline bool 1656check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params) 1657{ 1658 // Special-case call since it can take any number of operands 1659 if(op_kind == OO_Call) 1660 return true; 1661 1662 // The parameter count doens't include "this" 1663 if (num_params == 0) 1664 return unary; 1665 if (num_params == 1) 1666 return binary; 1667 else 1668 return false; 1669} 1670 1671bool 1672ClangASTContext::CheckOverloadedOperatorKindParameterCount (uint32_t op_kind, uint32_t num_params) 1673{ 1674 switch (op_kind) 1675 { 1676 default: 1677 break; 1678 // C++ standard allows any number of arguments to new/delete 1679 case OO_New: 1680 case OO_Array_New: 1681 case OO_Delete: 1682 case OO_Array_Delete: 1683 return true; 1684 } 1685 1686#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) case OO_##Name: return check_op_param (op_kind, Unary, Binary, num_params); 1687 switch (op_kind) 1688 { 1689#include "clang/Basic/OperatorKinds.def" 1690 default: break; 1691 } 1692 return false; 1693} 1694 1695CXXMethodDecl * 1696ClangASTContext::AddMethodToCXXRecordType 1697( 1698 ASTContext *ast, 1699 clang_type_t record_opaque_type, 1700 const char *name, 1701 clang_type_t method_opaque_type, 1702 lldb::AccessType access, 1703 bool is_virtual, 1704 bool is_static, 1705 bool is_inline, 1706 bool is_explicit, 1707 bool is_attr_used, 1708 bool is_artificial 1709) 1710{ 1711 if (!record_opaque_type || !method_opaque_type || !name) 1712 return NULL; 1713 1714 assert(ast); 1715 1716 IdentifierTable *identifier_table = &ast->Idents; 1717 1718 assert(identifier_table); 1719 1720 QualType record_qual_type(QualType::getFromOpaquePtr(record_opaque_type)); 1721 1722 CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl(); 1723 1724 if (cxx_record_decl == NULL) 1725 return NULL; 1726 1727 QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type)); 1728 1729 CXXMethodDecl *cxx_method_decl = NULL; 1730 1731 DeclarationName decl_name (&identifier_table->get(name)); 1732 1733 const clang::FunctionType *function_Type = dyn_cast<FunctionType>(method_qual_type.getTypePtr()); 1734 1735 if (function_Type == NULL) 1736 return NULL; 1737 1738 const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_Type)); 1739 1740 if (!method_function_prototype) 1741 return NULL; 1742 1743 unsigned int num_params = method_function_prototype->getNumArgs(); 1744 1745 CXXDestructorDecl *cxx_dtor_decl(NULL); 1746 CXXConstructorDecl *cxx_ctor_decl(NULL); 1747 1748 if (name[0] == '~') 1749 { 1750 cxx_dtor_decl = CXXDestructorDecl::Create (*ast, 1751 cxx_record_decl, 1752 SourceLocation(), 1753 DeclarationNameInfo (ast->DeclarationNames.getCXXDestructorName (ast->getCanonicalType (record_qual_type)), SourceLocation()), 1754 method_qual_type, 1755 NULL, 1756 is_inline, 1757 is_artificial); 1758 cxx_method_decl = cxx_dtor_decl; 1759 } 1760 else if (decl_name == cxx_record_decl->getDeclName()) 1761 { 1762 cxx_ctor_decl = CXXConstructorDecl::Create (*ast, 1763 cxx_record_decl, 1764 SourceLocation(), 1765 DeclarationNameInfo (ast->DeclarationNames.getCXXConstructorName (ast->getCanonicalType (record_qual_type)), SourceLocation()), 1766 method_qual_type, 1767 NULL, // TypeSourceInfo * 1768 is_explicit, 1769 is_inline, 1770 is_artificial, 1771 false /*is_constexpr*/); 1772 cxx_method_decl = cxx_ctor_decl; 1773 } 1774 else 1775 { 1776 1777 OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS; 1778 if (IsOperator (name, op_kind)) 1779 { 1780 if (op_kind != NUM_OVERLOADED_OPERATORS) 1781 { 1782 // Check the number of operator parameters. Sometimes we have 1783 // seen bad DWARF that doesn't correctly describe operators and 1784 // if we try to create a methed and add it to the class, clang 1785 // will assert and crash, so we need to make sure things are 1786 // acceptable. 1787 if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params)) 1788 return NULL; 1789 cxx_method_decl = CXXMethodDecl::Create (*ast, 1790 cxx_record_decl, 1791 SourceLocation(), 1792 DeclarationNameInfo (ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()), 1793 method_qual_type, 1794 NULL, // TypeSourceInfo * 1795 is_static, 1796 SC_None, 1797 is_inline, 1798 false /*is_constexpr*/, 1799 SourceLocation()); 1800 } 1801 else if (num_params == 0) 1802 { 1803 // Conversion operators don't take params... 1804 cxx_method_decl = CXXConversionDecl::Create (*ast, 1805 cxx_record_decl, 1806 SourceLocation(), 1807 DeclarationNameInfo (ast->DeclarationNames.getCXXConversionFunctionName (ast->getCanonicalType (function_Type->getResultType())), SourceLocation()), 1808 method_qual_type, 1809 NULL, // TypeSourceInfo * 1810 is_inline, 1811 is_explicit, 1812 false /*is_constexpr*/, 1813 SourceLocation()); 1814 } 1815 } 1816 1817 if (cxx_method_decl == NULL) 1818 { 1819 cxx_method_decl = CXXMethodDecl::Create (*ast, 1820 cxx_record_decl, 1821 SourceLocation(), 1822 DeclarationNameInfo (decl_name, SourceLocation()), 1823 method_qual_type, 1824 NULL, // TypeSourceInfo * 1825 is_static, 1826 SC_None, 1827 is_inline, 1828 false /*is_constexpr*/, 1829 SourceLocation()); 1830 } 1831 } 1832 1833 AccessSpecifier access_specifier = ConvertAccessTypeToAccessSpecifier (access); 1834 1835 cxx_method_decl->setAccess (access_specifier); 1836 cxx_method_decl->setVirtualAsWritten (is_virtual); 1837 1838 if (is_attr_used) 1839 cxx_method_decl->addAttr(::new (*ast) UsedAttr(SourceRange(), *ast)); 1840 1841 // Populate the method decl with parameter decls 1842 1843 llvm::SmallVector<ParmVarDecl *, 12> params; 1844 1845 for (int param_index = 0; 1846 param_index < num_params; 1847 ++param_index) 1848 { 1849 params.push_back (ParmVarDecl::Create (*ast, 1850 cxx_method_decl, 1851 SourceLocation(), 1852 SourceLocation(), 1853 NULL, // anonymous 1854 method_function_prototype->getArgType(param_index), 1855 NULL, 1856 SC_None, 1857 SC_None, 1858 NULL)); 1859 } 1860 1861 cxx_method_decl->setParams (ArrayRef<ParmVarDecl*>(params)); 1862 1863 cxx_record_decl->addDecl (cxx_method_decl); 1864 1865 // Sometimes the debug info will mention a constructor (default/copy/move), 1866 // destructor, or assignment operator (copy/move) but there won't be any 1867 // version of this in the code. So we check if the function was artificially 1868 // generated and if it is trivial and this lets the compiler/backend know 1869 // that it can inline the IR for these when it needs to and we can avoid a 1870 // "missing function" error when running expressions. 1871 1872 if (is_artificial) 1873 { 1874 if (cxx_ctor_decl && 1875 ((cxx_ctor_decl->isDefaultConstructor() && cxx_record_decl->hasTrivialDefaultConstructor ()) || 1876 (cxx_ctor_decl->isCopyConstructor() && cxx_record_decl->hasTrivialCopyConstructor ()) || 1877 (cxx_ctor_decl->isMoveConstructor() && cxx_record_decl->hasTrivialMoveConstructor ()) )) 1878 { 1879 cxx_ctor_decl->setDefaulted(); 1880 cxx_ctor_decl->setTrivial(true); 1881 } 1882 else if (cxx_dtor_decl) 1883 { 1884 if (cxx_record_decl->hasTrivialDestructor()) 1885 { 1886 cxx_dtor_decl->setDefaulted(); 1887 cxx_dtor_decl->setTrivial(true); 1888 } 1889 } 1890 else if ((cxx_method_decl->isCopyAssignmentOperator() && cxx_record_decl->hasTrivialCopyAssignment()) || 1891 (cxx_method_decl->isMoveAssignmentOperator() && cxx_record_decl->hasTrivialMoveAssignment())) 1892 { 1893 cxx_method_decl->setDefaulted(); 1894 cxx_method_decl->setTrivial(true); 1895 } 1896 } 1897 1898#ifdef LLDB_CONFIGURATION_DEBUG 1899 VerifyDecl(cxx_method_decl); 1900#endif 1901 1902// printf ("decl->isPolymorphic() = %i\n", cxx_record_decl->isPolymorphic()); 1903// printf ("decl->isAggregate() = %i\n", cxx_record_decl->isAggregate()); 1904// printf ("decl->isPOD() = %i\n", cxx_record_decl->isPOD()); 1905// printf ("decl->isEmpty() = %i\n", cxx_record_decl->isEmpty()); 1906// printf ("decl->isAbstract() = %i\n", cxx_record_decl->isAbstract()); 1907// printf ("decl->hasTrivialConstructor() = %i\n", cxx_record_decl->hasTrivialConstructor()); 1908// printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor()); 1909// printf ("decl->hasTrivialCopyAssignment() = %i\n", cxx_record_decl->hasTrivialCopyAssignment()); 1910// printf ("decl->hasTrivialDestructor() = %i\n", cxx_record_decl->hasTrivialDestructor()); 1911 return cxx_method_decl; 1912} 1913 1914clang::FieldDecl * 1915ClangASTContext::AddFieldToRecordType 1916( 1917 ASTContext *ast, 1918 clang_type_t record_clang_type, 1919 const char *name, 1920 clang_type_t field_type, 1921 AccessType access, 1922 uint32_t bitfield_bit_size 1923) 1924{ 1925 if (record_clang_type == NULL || field_type == NULL) 1926 return NULL; 1927 1928 FieldDecl *field = NULL; 1929 IdentifierTable *identifier_table = &ast->Idents; 1930 1931 assert (ast != NULL); 1932 assert (identifier_table != NULL); 1933 1934 QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type)); 1935 1936 const clang::Type *clang_type = record_qual_type.getTypePtr(); 1937 if (clang_type) 1938 { 1939 const RecordType *record_type = dyn_cast<RecordType>(clang_type); 1940 1941 if (record_type) 1942 { 1943 RecordDecl *record_decl = record_type->getDecl(); 1944 1945 clang::Expr *bit_width = NULL; 1946 if (bitfield_bit_size != 0) 1947 { 1948 APInt bitfield_bit_size_apint(ast->getTypeSize(ast->IntTy), bitfield_bit_size); 1949 bit_width = new (*ast)IntegerLiteral (*ast, bitfield_bit_size_apint, ast->IntTy, SourceLocation()); 1950 } 1951 field = FieldDecl::Create (*ast, 1952 record_decl, 1953 SourceLocation(), 1954 SourceLocation(), 1955 name ? &identifier_table->get(name) : NULL, // Identifier 1956 QualType::getFromOpaquePtr(field_type), // Field type 1957 NULL, // TInfo * 1958 bit_width, // BitWidth 1959 false, // Mutable 1960 ICIS_NoInit); // HasInit 1961 1962 if (!name) { 1963 // Determine whether this field corresponds to an anonymous 1964 // struct or union. 1965 if (const TagType *TagT = field->getType()->getAs<TagType>()) { 1966 if (RecordDecl *Rec = dyn_cast<RecordDecl>(TagT->getDecl())) 1967 if (!Rec->getDeclName()) { 1968 Rec->setAnonymousStructOrUnion(true); 1969 field->setImplicit(); 1970 1971 } 1972 } 1973 } 1974 1975 field->setAccess (ConvertAccessTypeToAccessSpecifier (access)); 1976 1977 if (field) 1978 { 1979 record_decl->addDecl(field); 1980 1981#ifdef LLDB_CONFIGURATION_DEBUG 1982 VerifyDecl(field); 1983#endif 1984 } 1985 } 1986 else 1987 { 1988 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(clang_type); 1989 if (objc_class_type) 1990 { 1991 bool is_synthesized = false; 1992 field = ClangASTContext::AddObjCClassIVar (ast, 1993 record_clang_type, 1994 name, 1995 field_type, 1996 access, 1997 bitfield_bit_size, 1998 is_synthesized); 1999 } 2000 } 2001 } 2002 return field; 2003} 2004 2005static clang::AccessSpecifier UnifyAccessSpecifiers (clang::AccessSpecifier lhs, 2006 clang::AccessSpecifier rhs) 2007{ 2008 clang::AccessSpecifier ret = lhs; 2009 2010 // Make the access equal to the stricter of the field and the nested field's access 2011 switch (ret) 2012 { 2013 case clang::AS_none: 2014 break; 2015 case clang::AS_private: 2016 break; 2017 case clang::AS_protected: 2018 if (rhs == AS_private) 2019 ret = AS_private; 2020 break; 2021 case clang::AS_public: 2022 ret = rhs; 2023 break; 2024 } 2025 2026 return ret; 2027} 2028 2029void 2030ClangASTContext::BuildIndirectFields (clang::ASTContext *ast, 2031 lldb::clang_type_t record_clang_type) 2032{ 2033 QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type)); 2034 2035 const RecordType *record_type = record_qual_type->getAs<RecordType>(); 2036 2037 if (!record_type) 2038 return; 2039 2040 RecordDecl *record_decl = record_type->getDecl(); 2041 2042 if (!record_decl) 2043 return; 2044 2045 typedef llvm::SmallVector <IndirectFieldDecl *, 1> IndirectFieldVector; 2046 2047 IndirectFieldVector indirect_fields; 2048 2049 for (RecordDecl::field_iterator fi = record_decl->field_begin(), fe = record_decl->field_end(); 2050 fi != fe; 2051 ++fi) 2052 { 2053 if (fi->isAnonymousStructOrUnion()) 2054 { 2055 QualType field_qual_type = fi->getType(); 2056 2057 const RecordType *field_record_type = field_qual_type->getAs<RecordType>(); 2058 2059 if (!field_record_type) 2060 continue; 2061 2062 RecordDecl *field_record_decl = field_record_type->getDecl(); 2063 2064 if (!field_record_decl) 2065 continue; 2066 2067 for (RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end(); 2068 di != de; 2069 ++di) 2070 { 2071 if (FieldDecl *nested_field_decl = dyn_cast<FieldDecl>(*di)) 2072 { 2073 NamedDecl **chain = new (*ast) NamedDecl*[2]; 2074 chain[0] = *fi; 2075 chain[1] = nested_field_decl; 2076 IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*ast, 2077 record_decl, 2078 SourceLocation(), 2079 nested_field_decl->getIdentifier(), 2080 nested_field_decl->getType(), 2081 chain, 2082 2); 2083 2084 indirect_field->setAccess(UnifyAccessSpecifiers(fi->getAccess(), 2085 nested_field_decl->getAccess())); 2086 2087 indirect_fields.push_back(indirect_field); 2088 } 2089 else if (IndirectFieldDecl *nested_indirect_field_decl = dyn_cast<IndirectFieldDecl>(*di)) 2090 { 2091 int nested_chain_size = nested_indirect_field_decl->getChainingSize(); 2092 NamedDecl **chain = new (*ast) NamedDecl*[nested_chain_size + 1]; 2093 chain[0] = *fi; 2094 2095 int chain_index = 1; 2096 for (IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(), 2097 nce = nested_indirect_field_decl->chain_end(); 2098 nci < nce; 2099 ++nci) 2100 { 2101 chain[chain_index] = *nci; 2102 chain_index++; 2103 } 2104 2105 IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*ast, 2106 record_decl, 2107 SourceLocation(), 2108 nested_indirect_field_decl->getIdentifier(), 2109 nested_indirect_field_decl->getType(), 2110 chain, 2111 nested_chain_size + 1); 2112 2113 indirect_field->setAccess(UnifyAccessSpecifiers(fi->getAccess(), 2114 nested_indirect_field_decl->getAccess())); 2115 2116 indirect_fields.push_back(indirect_field); 2117 } 2118 } 2119 } 2120 } 2121 2122 for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), ife = indirect_fields.end(); 2123 ifi < ife; 2124 ++ifi) 2125 { 2126 record_decl->addDecl(*ifi); 2127 } 2128} 2129 2130bool 2131ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size) 2132{ 2133 return FieldIsBitfield(getASTContext(), field, bitfield_bit_size); 2134} 2135 2136bool 2137ClangASTContext::FieldIsBitfield 2138( 2139 ASTContext *ast, 2140 FieldDecl* field, 2141 uint32_t& bitfield_bit_size 2142) 2143{ 2144 if (ast == NULL || field == NULL) 2145 return false; 2146 2147 if (field->isBitField()) 2148 { 2149 Expr* bit_width_expr = field->getBitWidth(); 2150 if (bit_width_expr) 2151 { 2152 llvm::APSInt bit_width_apsint; 2153 if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast)) 2154 { 2155 bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX); 2156 return true; 2157 } 2158 } 2159 } 2160 return false; 2161} 2162 2163bool 2164ClangASTContext::RecordHasFields (const RecordDecl *record_decl) 2165{ 2166 if (record_decl == NULL) 2167 return false; 2168 2169 if (!record_decl->field_empty()) 2170 return true; 2171 2172 // No fields, lets check this is a CXX record and check the base classes 2173 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 2174 if (cxx_record_decl) 2175 { 2176 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 2177 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 2178 base_class != base_class_end; 2179 ++base_class) 2180 { 2181 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 2182 if (RecordHasFields(base_class_decl)) 2183 return true; 2184 } 2185 } 2186 return false; 2187} 2188 2189void 2190ClangASTContext::SetDefaultAccessForRecordFields (clang_type_t clang_type, int default_accessibility, int *assigned_accessibilities, size_t num_assigned_accessibilities) 2191{ 2192 if (clang_type) 2193 { 2194 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 2195 2196 const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr()); 2197 if (record_type) 2198 { 2199 RecordDecl *record_decl = record_type->getDecl(); 2200 if (record_decl) 2201 { 2202 uint32_t field_idx; 2203 RecordDecl::field_iterator field, field_end; 2204 for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0; 2205 field != field_end; 2206 ++field, ++field_idx) 2207 { 2208 // If no accessibility was assigned, assign the correct one 2209 if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none) 2210 field->setAccess ((AccessSpecifier)default_accessibility); 2211 } 2212 } 2213 } 2214 } 2215} 2216 2217#pragma mark C++ Base Classes 2218 2219CXXBaseSpecifier * 2220ClangASTContext::CreateBaseClassSpecifier (clang_type_t base_class_type, AccessType access, bool is_virtual, bool base_of_class) 2221{ 2222 if (base_class_type) 2223 return new CXXBaseSpecifier (SourceRange(), 2224 is_virtual, 2225 base_of_class, 2226 ConvertAccessTypeToAccessSpecifier (access), 2227 getASTContext()->CreateTypeSourceInfo (QualType::getFromOpaquePtr(base_class_type)), 2228 SourceLocation()); 2229 return NULL; 2230} 2231 2232void 2233ClangASTContext::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes) 2234{ 2235 for (unsigned i=0; i<num_base_classes; ++i) 2236 { 2237 delete base_classes[i]; 2238 base_classes[i] = NULL; 2239 } 2240} 2241 2242bool 2243ClangASTContext::SetBaseClassesForClassType (clang_type_t class_clang_type, CXXBaseSpecifier const * const *base_classes, unsigned num_base_classes) 2244{ 2245 if (class_clang_type) 2246 { 2247 CXXRecordDecl *cxx_record_decl = QualType::getFromOpaquePtr(class_clang_type)->getAsCXXRecordDecl(); 2248 if (cxx_record_decl) 2249 { 2250 cxx_record_decl->setBases(base_classes, num_base_classes); 2251 return true; 2252 } 2253 } 2254 return false; 2255} 2256#pragma mark Objective C Classes 2257 2258clang_type_t 2259ClangASTContext::CreateObjCClass 2260( 2261 const char *name, 2262 DeclContext *decl_ctx, 2263 bool isForwardDecl, 2264 bool isInternal, 2265 uint64_t metadata 2266) 2267{ 2268 ASTContext *ast = getASTContext(); 2269 assert (ast != NULL); 2270 assert (name && name[0]); 2271 if (decl_ctx == NULL) 2272 decl_ctx = ast->getTranslationUnitDecl(); 2273 2274 // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and 2275 // we will need to update this code. I was told to currently always use 2276 // the CXXRecordDecl class since we often don't know from debug information 2277 // if something is struct or a class, so we default to always use the more 2278 // complete definition just in case. 2279 ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast, 2280 decl_ctx, 2281 SourceLocation(), 2282 &ast->Idents.get(name), 2283 NULL, 2284 SourceLocation(), 2285 /*isForwardDecl,*/ 2286 isInternal); 2287 2288 if (decl) 2289 SetMetadata(ast, (uintptr_t)decl, metadata); 2290 2291 return ast->getObjCInterfaceType(decl).getAsOpaquePtr(); 2292} 2293 2294bool 2295ClangASTContext::SetObjCSuperClass (clang_type_t class_opaque_type, clang_type_t super_opaque_type) 2296{ 2297 if (class_opaque_type && super_opaque_type) 2298 { 2299 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type)); 2300 QualType super_qual_type(QualType::getFromOpaquePtr(super_opaque_type)); 2301 const clang::Type *class_type = class_qual_type.getTypePtr(); 2302 const clang::Type *super_type = super_qual_type.getTypePtr(); 2303 if (class_type && super_type) 2304 { 2305 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type); 2306 const ObjCObjectType *objc_super_type = dyn_cast<ObjCObjectType>(super_type); 2307 if (objc_class_type && objc_super_type) 2308 { 2309 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2310 ObjCInterfaceDecl *super_interface_decl = objc_super_type->getInterface(); 2311 if (class_interface_decl && super_interface_decl) 2312 { 2313 class_interface_decl->setSuperClass(super_interface_decl); 2314 return true; 2315 } 2316 } 2317 } 2318 } 2319 return false; 2320} 2321 2322 2323FieldDecl * 2324ClangASTContext::AddObjCClassIVar 2325( 2326 ASTContext *ast, 2327 clang_type_t class_opaque_type, 2328 const char *name, 2329 clang_type_t ivar_opaque_type, 2330 AccessType access, 2331 uint32_t bitfield_bit_size, 2332 bool is_synthesized 2333) 2334{ 2335 if (class_opaque_type == NULL || ivar_opaque_type == NULL) 2336 return NULL; 2337 2338 ObjCIvarDecl *field = NULL; 2339 2340 IdentifierTable *identifier_table = &ast->Idents; 2341 2342 assert (ast != NULL); 2343 assert (identifier_table != NULL); 2344 2345 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type)); 2346 2347 const clang::Type *class_type = class_qual_type.getTypePtr(); 2348 if (class_type) 2349 { 2350 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type); 2351 2352 if (objc_class_type) 2353 { 2354 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2355 2356 if (class_interface_decl) 2357 { 2358 clang::Expr *bit_width = NULL; 2359 if (bitfield_bit_size != 0) 2360 { 2361 APInt bitfield_bit_size_apint(ast->getTypeSize(ast->IntTy), bitfield_bit_size); 2362 bit_width = new (*ast)IntegerLiteral (*ast, bitfield_bit_size_apint, ast->IntTy, SourceLocation()); 2363 } 2364 2365 field = ObjCIvarDecl::Create (*ast, 2366 class_interface_decl, 2367 SourceLocation(), 2368 SourceLocation(), 2369 &identifier_table->get(name), // Identifier 2370 QualType::getFromOpaquePtr(ivar_opaque_type), // Field type 2371 NULL, // TypeSourceInfo * 2372 ConvertAccessTypeToObjCIvarAccessControl (access), 2373 bit_width, 2374 is_synthesized); 2375 2376 if (field) 2377 { 2378 class_interface_decl->addDecl(field); 2379 2380#ifdef LLDB_CONFIGURATION_DEBUG 2381 VerifyDecl(field); 2382#endif 2383 2384 return field; 2385 } 2386 } 2387 } 2388 } 2389 return NULL; 2390} 2391 2392bool 2393ClangASTContext::AddObjCClassProperty 2394( 2395 ASTContext *ast, 2396 clang_type_t class_opaque_type, 2397 const char *property_name, 2398 clang_type_t property_opaque_type, 2399 ObjCIvarDecl *ivar_decl, 2400 const char *property_setter_name, 2401 const char *property_getter_name, 2402 uint32_t property_attributes, 2403 uint64_t metadata 2404) 2405{ 2406 if (class_opaque_type == NULL || property_name == NULL || property_name[0] == '\0') 2407 return false; 2408 2409 IdentifierTable *identifier_table = &ast->Idents; 2410 2411 assert (ast != NULL); 2412 assert (identifier_table != NULL); 2413 2414 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type)); 2415 const clang::Type *class_type = class_qual_type.getTypePtr(); 2416 if (class_type) 2417 { 2418 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type); 2419 2420 if (objc_class_type) 2421 { 2422 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2423 2424 clang_type_t property_opaque_type_to_access = NULL; 2425 2426 if (property_opaque_type) 2427 property_opaque_type_to_access = property_opaque_type; 2428 else if (ivar_decl) 2429 property_opaque_type_to_access = ivar_decl->getType().getAsOpaquePtr(); 2430 2431 if (class_interface_decl && property_opaque_type_to_access) 2432 { 2433 clang::TypeSourceInfo *prop_type_source; 2434 if (ivar_decl) 2435 prop_type_source = ast->CreateTypeSourceInfo (ivar_decl->getType()); 2436 else 2437 prop_type_source = ast->CreateTypeSourceInfo (QualType::getFromOpaquePtr(property_opaque_type)); 2438 2439 ObjCPropertyDecl *property_decl = ObjCPropertyDecl::Create(*ast, 2440 class_interface_decl, 2441 SourceLocation(), // Source Location 2442 &identifier_table->get(property_name), 2443 SourceLocation(), //Source Location for AT 2444 SourceLocation(), //Source location for ( 2445 prop_type_source 2446 ); 2447 2448 if (property_decl) 2449 { 2450 SetMetadata(ast, (uintptr_t)property_decl, metadata); 2451 2452 class_interface_decl->addDecl (property_decl); 2453 2454 Selector setter_sel, getter_sel; 2455 2456 if (property_setter_name != NULL) 2457 { 2458 std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1); 2459 clang::IdentifierInfo *setter_ident = &identifier_table->get(property_setter_no_colon.c_str()); 2460 setter_sel = ast->Selectors.getSelector(1, &setter_ident); 2461 } 2462 else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) 2463 { 2464 std::string setter_sel_string("set"); 2465 setter_sel_string.push_back(::toupper(property_name[0])); 2466 setter_sel_string.append(&property_name[1]); 2467 clang::IdentifierInfo *setter_ident = &identifier_table->get(setter_sel_string.c_str()); 2468 setter_sel = ast->Selectors.getSelector(1, &setter_ident); 2469 } 2470 property_decl->setSetterName(setter_sel); 2471 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter); 2472 2473 if (property_getter_name != NULL) 2474 { 2475 clang::IdentifierInfo *getter_ident = &identifier_table->get(property_getter_name); 2476 getter_sel = ast->Selectors.getSelector(0, &getter_ident); 2477 } 2478 else 2479 { 2480 clang::IdentifierInfo *getter_ident = &identifier_table->get(property_name); 2481 getter_sel = ast->Selectors.getSelector(0, &getter_ident); 2482 } 2483 property_decl->setGetterName(getter_sel); 2484 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_getter); 2485 2486 if (ivar_decl) 2487 property_decl->setPropertyIvarDecl (ivar_decl); 2488 2489 if (property_attributes & DW_APPLE_PROPERTY_readonly) 2490 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readonly); 2491 if (property_attributes & DW_APPLE_PROPERTY_readwrite) 2492 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readwrite); 2493 if (property_attributes & DW_APPLE_PROPERTY_assign) 2494 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_assign); 2495 if (property_attributes & DW_APPLE_PROPERTY_retain) 2496 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_retain); 2497 if (property_attributes & DW_APPLE_PROPERTY_copy) 2498 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_copy); 2499 if (property_attributes & DW_APPLE_PROPERTY_nonatomic) 2500 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_nonatomic); 2501 2502 if (!getter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(getter_sel)) 2503 { 2504 QualType result_type = QualType::getFromOpaquePtr(property_opaque_type_to_access); 2505 2506 const bool isInstance = true; 2507 const bool isVariadic = false; 2508 const bool isSynthesized = false; 2509 const bool isImplicitlyDeclared = true; 2510 const bool isDefined = false; 2511 const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None; 2512 const bool HasRelatedResultType = false; 2513 2514 ObjCMethodDecl *getter = ObjCMethodDecl::Create(*ast, 2515 SourceLocation(), 2516 SourceLocation(), 2517 getter_sel, 2518 result_type, 2519 NULL, 2520 class_interface_decl, 2521 isInstance, 2522 isVariadic, 2523 isSynthesized, 2524 isImplicitlyDeclared, 2525 isDefined, 2526 impControl, 2527 HasRelatedResultType); 2528 2529 if (getter) 2530 SetMetadata(ast, (uintptr_t)getter, metadata); 2531 2532 getter->setMethodParams(*ast, ArrayRef<ParmVarDecl*>(), ArrayRef<SourceLocation>()); 2533 2534 class_interface_decl->addDecl(getter); 2535 } 2536 2537 if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel)) 2538 { 2539 QualType result_type = ast->VoidTy; 2540 2541 const bool isInstance = true; 2542 const bool isVariadic = false; 2543 const bool isSynthesized = false; 2544 const bool isImplicitlyDeclared = true; 2545 const bool isDefined = false; 2546 const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None; 2547 const bool HasRelatedResultType = false; 2548 2549 ObjCMethodDecl *setter = ObjCMethodDecl::Create(*ast, 2550 SourceLocation(), 2551 SourceLocation(), 2552 setter_sel, 2553 result_type, 2554 NULL, 2555 class_interface_decl, 2556 isInstance, 2557 isVariadic, 2558 isSynthesized, 2559 isImplicitlyDeclared, 2560 isDefined, 2561 impControl, 2562 HasRelatedResultType); 2563 2564 if (setter) 2565 SetMetadata(ast, (uintptr_t)setter, metadata); 2566 2567 llvm::SmallVector<ParmVarDecl *, 1> params; 2568 2569 params.push_back (ParmVarDecl::Create (*ast, 2570 setter, 2571 SourceLocation(), 2572 SourceLocation(), 2573 NULL, // anonymous 2574 QualType::getFromOpaquePtr(property_opaque_type_to_access), 2575 NULL, 2576 SC_Auto, 2577 SC_Auto, 2578 NULL)); 2579 2580 setter->setMethodParams(*ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>()); 2581 2582 class_interface_decl->addDecl(setter); 2583 } 2584 2585 return true; 2586 } 2587 } 2588 } 2589 } 2590 return false; 2591} 2592 2593bool 2594ClangASTContext::ObjCTypeHasIVars (clang_type_t class_opaque_type, bool check_superclass) 2595{ 2596 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type)); 2597 2598 const clang::Type *class_type = class_qual_type.getTypePtr(); 2599 if (class_type) 2600 { 2601 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type); 2602 2603 if (objc_class_type) 2604 return ObjCDeclHasIVars (objc_class_type->getInterface(), check_superclass); 2605 } 2606 return false; 2607} 2608 2609bool 2610ClangASTContext::ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass) 2611{ 2612 while (class_interface_decl) 2613 { 2614 if (class_interface_decl->ivar_size() > 0) 2615 return true; 2616 2617 if (check_superclass) 2618 class_interface_decl = class_interface_decl->getSuperClass(); 2619 else 2620 break; 2621 } 2622 return false; 2623} 2624 2625ObjCMethodDecl * 2626ClangASTContext::AddMethodToObjCObjectType 2627( 2628 ASTContext *ast, 2629 clang_type_t class_opaque_type, 2630 const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]") 2631 clang_type_t method_opaque_type, 2632 lldb::AccessType access 2633) 2634{ 2635 if (class_opaque_type == NULL || method_opaque_type == NULL) 2636 return NULL; 2637 2638 IdentifierTable *identifier_table = &ast->Idents; 2639 2640 assert (ast != NULL); 2641 assert (identifier_table != NULL); 2642 2643 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type)); 2644 2645 const clang::Type *class_type = class_qual_type.getTypePtr(); 2646 if (class_type == NULL) 2647 return NULL; 2648 2649 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type); 2650 2651 if (objc_class_type == NULL) 2652 return NULL; 2653 2654 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2655 2656 if (class_interface_decl == NULL) 2657 return NULL; 2658 2659 const char *selector_start = ::strchr (name, ' '); 2660 if (selector_start == NULL) 2661 return NULL; 2662 2663 selector_start++; 2664 if (!(::isalpha (selector_start[0]) || selector_start[0] == '_')) 2665 return NULL; 2666 llvm::SmallVector<IdentifierInfo *, 12> selector_idents; 2667 2668 size_t len = 0; 2669 const char *start; 2670 //printf ("name = '%s'\n", name); 2671 2672 unsigned num_selectors_with_args = 0; 2673 for (start = selector_start; 2674 start && *start != '\0' && *start != ']'; 2675 start += len) 2676 { 2677 len = ::strcspn(start, ":]"); 2678 bool has_arg = (start[len] == ':'); 2679 if (has_arg) 2680 ++num_selectors_with_args; 2681 selector_idents.push_back (&identifier_table->get (StringRef (start, len))); 2682 if (has_arg) 2683 len += 1; 2684 } 2685 2686 2687 if (selector_idents.size() == 0) 2688 return 0; 2689 2690 clang::Selector method_selector = ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0, 2691 selector_idents.data()); 2692 2693 QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type)); 2694 2695 // Populate the method decl with parameter decls 2696 const clang::Type *method_type(method_qual_type.getTypePtr()); 2697 2698 if (method_type == NULL) 2699 return NULL; 2700 2701 const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type)); 2702 2703 if (!method_function_prototype) 2704 return NULL; 2705 2706 2707 bool is_variadic = false; 2708 bool is_synthesized = false; 2709 bool is_defined = false; 2710 ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None; 2711 2712 const unsigned num_args = method_function_prototype->getNumArgs(); 2713 2714 ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*ast, 2715 SourceLocation(), // beginLoc, 2716 SourceLocation(), // endLoc, 2717 method_selector, 2718 method_function_prototype->getResultType(), 2719 NULL, // TypeSourceInfo *ResultTInfo, 2720 GetDeclContextForType (class_opaque_type), 2721 name[0] == '-', 2722 is_variadic, 2723 is_synthesized, 2724 true, // is_implicitly_declared 2725 is_defined, 2726 imp_control, 2727 false /*has_related_result_type*/); 2728 2729 2730 if (objc_method_decl == NULL) 2731 return NULL; 2732 2733 if (num_args > 0) 2734 { 2735 llvm::SmallVector<ParmVarDecl *, 12> params; 2736 2737 for (int param_index = 0; param_index < num_args; ++param_index) 2738 { 2739 params.push_back (ParmVarDecl::Create (*ast, 2740 objc_method_decl, 2741 SourceLocation(), 2742 SourceLocation(), 2743 NULL, // anonymous 2744 method_function_prototype->getArgType(param_index), 2745 NULL, 2746 SC_Auto, 2747 SC_Auto, 2748 NULL)); 2749 } 2750 2751 objc_method_decl->setMethodParams(*ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>()); 2752 } 2753 2754 class_interface_decl->addDecl (objc_method_decl); 2755 2756#ifdef LLDB_CONFIGURATION_DEBUG 2757 VerifyDecl(objc_method_decl); 2758#endif 2759 2760 return objc_method_decl; 2761} 2762 2763size_t 2764ClangASTContext::GetNumTemplateArguments (clang::ASTContext *ast, clang_type_t clang_type) 2765{ 2766 if (clang_type) 2767 { 2768 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 2769 2770 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2771 switch (type_class) 2772 { 2773 case clang::Type::Record: 2774 if (GetCompleteQualType (ast, qual_type)) 2775 { 2776 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2777 if (cxx_record_decl) 2778 { 2779 const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl); 2780 if (template_decl) 2781 return template_decl->getTemplateArgs().size(); 2782 } 2783 } 2784 break; 2785 2786 case clang::Type::Typedef: 2787 return ClangASTContext::GetNumTemplateArguments (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 2788 default: 2789 break; 2790 } 2791 } 2792 return 0; 2793} 2794 2795clang_type_t 2796ClangASTContext::GetTemplateArgument (clang::ASTContext *ast, clang_type_t clang_type, size_t arg_idx, lldb::TemplateArgumentKind &kind) 2797{ 2798 if (clang_type) 2799 { 2800 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 2801 2802 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2803 switch (type_class) 2804 { 2805 case clang::Type::Record: 2806 if (GetCompleteQualType (ast, qual_type)) 2807 { 2808 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2809 if (cxx_record_decl) 2810 { 2811 const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl); 2812 if (template_decl && arg_idx < template_decl->getTemplateArgs().size()) 2813 { 2814 const TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx]; 2815 switch (template_arg.getKind()) 2816 { 2817 case clang::TemplateArgument::Null: 2818 kind = eTemplateArgumentKindNull; 2819 return NULL; 2820 2821 case clang::TemplateArgument::Type: 2822 kind = eTemplateArgumentKindType; 2823 return template_arg.getAsType().getAsOpaquePtr(); 2824 2825 case clang::TemplateArgument::Declaration: 2826 kind = eTemplateArgumentKindDeclaration; 2827 return NULL; 2828 2829 case clang::TemplateArgument::Integral: 2830 kind = eTemplateArgumentKindIntegral; 2831 return template_arg.getIntegralType().getAsOpaquePtr(); 2832 2833 case clang::TemplateArgument::Template: 2834 kind = eTemplateArgumentKindTemplate; 2835 return NULL; 2836 2837 case clang::TemplateArgument::TemplateExpansion: 2838 kind = eTemplateArgumentKindTemplateExpansion; 2839 return NULL; 2840 2841 case clang::TemplateArgument::Expression: 2842 kind = eTemplateArgumentKindExpression; 2843 return NULL; 2844 2845 case clang::TemplateArgument::Pack: 2846 kind = eTemplateArgumentKindPack; 2847 return NULL; 2848 2849 default: 2850 assert (!"Unhandled TemplateArgument::ArgKind"); 2851 kind = eTemplateArgumentKindNull; 2852 return NULL; 2853 } 2854 } 2855 } 2856 } 2857 break; 2858 2859 case clang::Type::Typedef: 2860 return ClangASTContext::GetTemplateArgument (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), arg_idx, kind); 2861 default: 2862 break; 2863 } 2864 } 2865 kind = eTemplateArgumentKindNull; 2866 return NULL; 2867} 2868 2869uint32_t 2870ClangASTContext::GetTypeInfo 2871( 2872 clang_type_t clang_type, 2873 clang::ASTContext *ast, 2874 clang_type_t *pointee_or_element_clang_type 2875) 2876{ 2877 if (clang_type == NULL) 2878 return 0; 2879 2880 if (pointee_or_element_clang_type) 2881 *pointee_or_element_clang_type = NULL; 2882 2883 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 2884 2885 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2886 switch (type_class) 2887 { 2888 case clang::Type::Builtin: 2889 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 2890 { 2891 case clang::BuiltinType::ObjCId: 2892 case clang::BuiltinType::ObjCClass: 2893 if (ast && pointee_or_element_clang_type) 2894 *pointee_or_element_clang_type = ast->ObjCBuiltinClassTy.getAsOpaquePtr(); 2895 return eTypeIsBuiltIn | eTypeIsPointer | eTypeHasValue; 2896 break; 2897 case clang::BuiltinType::Bool: 2898 case clang::BuiltinType::Char_U: 2899 case clang::BuiltinType::UChar: 2900 case clang::BuiltinType::WChar_U: 2901 case clang::BuiltinType::Char16: 2902 case clang::BuiltinType::Char32: 2903 case clang::BuiltinType::UShort: 2904 case clang::BuiltinType::UInt: 2905 case clang::BuiltinType::ULong: 2906 case clang::BuiltinType::ULongLong: 2907 case clang::BuiltinType::UInt128: 2908 case clang::BuiltinType::Char_S: 2909 case clang::BuiltinType::SChar: 2910 case clang::BuiltinType::WChar_S: 2911 case clang::BuiltinType::Short: 2912 case clang::BuiltinType::Int: 2913 case clang::BuiltinType::Long: 2914 case clang::BuiltinType::LongLong: 2915 case clang::BuiltinType::Int128: 2916 case clang::BuiltinType::Float: 2917 case clang::BuiltinType::Double: 2918 case clang::BuiltinType::LongDouble: 2919 return eTypeIsBuiltIn | eTypeHasValue | eTypeIsScalar; 2920 default: 2921 break; 2922 } 2923 return eTypeIsBuiltIn | eTypeHasValue; 2924 2925 case clang::Type::BlockPointer: 2926 if (pointee_or_element_clang_type) 2927 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr(); 2928 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock; 2929 2930 case clang::Type::Complex: return eTypeIsBuiltIn | eTypeHasValue; 2931 2932 case clang::Type::ConstantArray: 2933 case clang::Type::DependentSizedArray: 2934 case clang::Type::IncompleteArray: 2935 case clang::Type::VariableArray: 2936 if (pointee_or_element_clang_type) 2937 *pointee_or_element_clang_type = cast<ArrayType>(qual_type.getTypePtr())->getElementType().getAsOpaquePtr(); 2938 return eTypeHasChildren | eTypeIsArray; 2939 2940 case clang::Type::DependentName: return 0; 2941 case clang::Type::DependentSizedExtVector: return eTypeHasChildren | eTypeIsVector; 2942 case clang::Type::DependentTemplateSpecialization: return eTypeIsTemplate; 2943 case clang::Type::Decltype: return 0; 2944 2945 case clang::Type::Enum: 2946 if (pointee_or_element_clang_type) 2947 *pointee_or_element_clang_type = cast<EnumType>(qual_type)->getDecl()->getIntegerType().getAsOpaquePtr(); 2948 return eTypeIsEnumeration | eTypeHasValue; 2949 2950 case clang::Type::Elaborated: 2951 return ClangASTContext::GetTypeInfo (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), 2952 ast, 2953 pointee_or_element_clang_type); 2954 case clang::Type::ExtVector: return eTypeHasChildren | eTypeIsVector; 2955 case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue; 2956 case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue; 2957 case clang::Type::InjectedClassName: return 0; 2958 2959 case clang::Type::LValueReference: 2960 case clang::Type::RValueReference: 2961 if (pointee_or_element_clang_type) 2962 *pointee_or_element_clang_type = cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(); 2963 return eTypeHasChildren | eTypeIsReference | eTypeHasValue; 2964 2965 case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue; 2966 2967 case clang::Type::ObjCObjectPointer: 2968 if (pointee_or_element_clang_type) 2969 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr(); 2970 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue; 2971 2972 case clang::Type::ObjCObject: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; 2973 case clang::Type::ObjCInterface: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; 2974 2975 case clang::Type::Pointer: 2976 if (pointee_or_element_clang_type) 2977 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr(); 2978 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue; 2979 2980 case clang::Type::Record: 2981 if (qual_type->getAsCXXRecordDecl()) 2982 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus; 2983 else 2984 return eTypeHasChildren | eTypeIsStructUnion; 2985 break; 2986 case clang::Type::SubstTemplateTypeParm: return eTypeIsTemplate; 2987 case clang::Type::TemplateTypeParm: return eTypeIsTemplate; 2988 case clang::Type::TemplateSpecialization: return eTypeIsTemplate; 2989 2990 case clang::Type::Typedef: 2991 return eTypeIsTypedef | ClangASTContext::GetTypeInfo (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 2992 ast, 2993 pointee_or_element_clang_type); 2994 2995 case clang::Type::TypeOfExpr: return 0; 2996 case clang::Type::TypeOf: return 0; 2997 case clang::Type::UnresolvedUsing: return 0; 2998 case clang::Type::Vector: return eTypeHasChildren | eTypeIsVector; 2999 default: return 0; 3000 } 3001 return 0; 3002} 3003 3004 3005#pragma mark Aggregate Types 3006 3007bool 3008ClangASTContext::IsAggregateType (clang_type_t clang_type) 3009{ 3010 if (clang_type == NULL) 3011 return false; 3012 3013 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 3014 3015 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3016 switch (type_class) 3017 { 3018 case clang::Type::IncompleteArray: 3019 case clang::Type::VariableArray: 3020 case clang::Type::ConstantArray: 3021 case clang::Type::ExtVector: 3022 case clang::Type::Vector: 3023 case clang::Type::Record: 3024 case clang::Type::ObjCObject: 3025 case clang::Type::ObjCInterface: 3026 return true; 3027 case clang::Type::Elaborated: 3028 return ClangASTContext::IsAggregateType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 3029 case clang::Type::Typedef: 3030 return ClangASTContext::IsAggregateType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 3031 3032 default: 3033 break; 3034 } 3035 // The clang type does have a value 3036 return false; 3037} 3038 3039uint32_t 3040ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type, bool omit_empty_base_classes) 3041{ 3042 if (clang_type == NULL) 3043 return 0; 3044 3045 uint32_t num_children = 0; 3046 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3047 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3048 switch (type_class) 3049 { 3050 case clang::Type::Builtin: 3051 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 3052 { 3053 case clang::BuiltinType::ObjCId: // child is Class 3054 case clang::BuiltinType::ObjCClass: // child is Class 3055 num_children = 1; 3056 break; 3057 3058 default: 3059 break; 3060 } 3061 break; 3062 3063 case clang::Type::Complex: return 0; 3064 3065 case clang::Type::Record: 3066 if (GetCompleteQualType (ast, qual_type)) 3067 { 3068 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 3069 const RecordDecl *record_decl = record_type->getDecl(); 3070 assert(record_decl); 3071 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3072 if (cxx_record_decl) 3073 { 3074 if (omit_empty_base_classes) 3075 { 3076 // Check each base classes to see if it or any of its 3077 // base classes contain any fields. This can help 3078 // limit the noise in variable views by not having to 3079 // show base classes that contain no members. 3080 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3081 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3082 base_class != base_class_end; 3083 ++base_class) 3084 { 3085 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3086 3087 // Skip empty base classes 3088 if (RecordHasFields(base_class_decl) == false) 3089 continue; 3090 3091 num_children++; 3092 } 3093 } 3094 else 3095 { 3096 // Include all base classes 3097 num_children += cxx_record_decl->getNumBases(); 3098 } 3099 3100 } 3101 RecordDecl::field_iterator field, field_end; 3102 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) 3103 ++num_children; 3104 } 3105 break; 3106 3107 case clang::Type::ObjCObject: 3108 case clang::Type::ObjCInterface: 3109 if (GetCompleteQualType (ast, qual_type)) 3110 { 3111 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 3112 assert (objc_class_type); 3113 if (objc_class_type) 3114 { 3115 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3116 3117 if (class_interface_decl) 3118 { 3119 3120 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3121 if (superclass_interface_decl) 3122 { 3123 if (omit_empty_base_classes) 3124 { 3125 if (ClangASTContext::ObjCDeclHasIVars (superclass_interface_decl, true)) 3126 ++num_children; 3127 } 3128 else 3129 ++num_children; 3130 } 3131 3132 num_children += class_interface_decl->ivar_size(); 3133 } 3134 } 3135 } 3136 break; 3137 3138 case clang::Type::ObjCObjectPointer: 3139 { 3140 const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr()); 3141 QualType pointee_type = pointer_type->getPointeeType(); 3142 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast, 3143 pointee_type.getAsOpaquePtr(), 3144 omit_empty_base_classes); 3145 // If this type points to a simple type, then it has 1 child 3146 if (num_pointee_children == 0) 3147 num_children = 1; 3148 else 3149 num_children = num_pointee_children; 3150 } 3151 break; 3152 3153 case clang::Type::ConstantArray: 3154 num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue(); 3155 break; 3156 3157 case clang::Type::Pointer: 3158 { 3159 const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); 3160 QualType pointee_type (pointer_type->getPointeeType()); 3161 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast, 3162 pointee_type.getAsOpaquePtr(), 3163 omit_empty_base_classes); 3164 if (num_pointee_children == 0) 3165 { 3166 // We have a pointer to a pointee type that claims it has no children. 3167 // We will want to look at 3168 num_children = ClangASTContext::GetNumPointeeChildren (pointee_type.getAsOpaquePtr()); 3169 } 3170 else 3171 num_children = num_pointee_children; 3172 } 3173 break; 3174 3175 case clang::Type::LValueReference: 3176 case clang::Type::RValueReference: 3177 { 3178 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 3179 QualType pointee_type = reference_type->getPointeeType(); 3180 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast, 3181 pointee_type.getAsOpaquePtr(), 3182 omit_empty_base_classes); 3183 // If this type points to a simple type, then it has 1 child 3184 if (num_pointee_children == 0) 3185 num_children = 1; 3186 else 3187 num_children = num_pointee_children; 3188 } 3189 break; 3190 3191 3192 case clang::Type::Typedef: 3193 num_children = ClangASTContext::GetNumChildren (ast, 3194 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 3195 omit_empty_base_classes); 3196 break; 3197 3198 case clang::Type::Elaborated: 3199 num_children = ClangASTContext::GetNumChildren (ast, 3200 cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), 3201 omit_empty_base_classes); 3202 break; 3203 3204 default: 3205 break; 3206 } 3207 return num_children; 3208} 3209 3210uint32_t 3211ClangASTContext::GetNumDirectBaseClasses (clang::ASTContext *ast, clang_type_t clang_type) 3212{ 3213 if (clang_type == NULL) 3214 return 0; 3215 3216 uint32_t count = 0; 3217 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3218 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3219 switch (type_class) 3220 { 3221 case clang::Type::Record: 3222 if (GetCompleteQualType (ast, qual_type)) 3223 { 3224 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 3225 if (cxx_record_decl) 3226 count = cxx_record_decl->getNumBases(); 3227 } 3228 break; 3229 3230 case clang::Type::ObjCObject: 3231 case clang::Type::ObjCInterface: 3232 if (GetCompleteQualType (ast, qual_type)) 3233 { 3234 const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); 3235 if (objc_class_type) 3236 { 3237 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3238 3239 if (class_interface_decl && class_interface_decl->getSuperClass()) 3240 count = 1; 3241 } 3242 } 3243 break; 3244 3245 3246 case clang::Type::Typedef: 3247 count = ClangASTContext::GetNumDirectBaseClasses (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 3248 break; 3249 3250 case clang::Type::Elaborated: 3251 count = ClangASTContext::GetNumDirectBaseClasses (ast, cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 3252 break; 3253 3254 default: 3255 break; 3256 } 3257 return count; 3258} 3259 3260uint32_t 3261ClangASTContext::GetNumVirtualBaseClasses (clang::ASTContext *ast, 3262 clang_type_t clang_type) 3263{ 3264 if (clang_type == NULL) 3265 return 0; 3266 3267 uint32_t count = 0; 3268 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3269 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3270 switch (type_class) 3271 { 3272 case clang::Type::Record: 3273 if (GetCompleteQualType (ast, qual_type)) 3274 { 3275 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 3276 if (cxx_record_decl) 3277 count = cxx_record_decl->getNumVBases(); 3278 } 3279 break; 3280 3281 case clang::Type::Typedef: 3282 count = ClangASTContext::GetNumVirtualBaseClasses (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 3283 break; 3284 3285 case clang::Type::Elaborated: 3286 count = ClangASTContext::GetNumVirtualBaseClasses (ast, cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 3287 break; 3288 3289 default: 3290 break; 3291 } 3292 return count; 3293} 3294 3295uint32_t 3296ClangASTContext::GetNumFields (clang::ASTContext *ast, clang_type_t clang_type) 3297{ 3298 if (clang_type == NULL) 3299 return 0; 3300 3301 uint32_t count = 0; 3302 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3303 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3304 switch (type_class) 3305 { 3306 case clang::Type::Record: 3307 if (GetCompleteQualType (ast, qual_type)) 3308 { 3309 const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr()); 3310 if (record_type) 3311 { 3312 RecordDecl *record_decl = record_type->getDecl(); 3313 if (record_decl) 3314 { 3315 uint32_t field_idx = 0; 3316 RecordDecl::field_iterator field, field_end; 3317 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) 3318 ++field_idx; 3319 count = field_idx; 3320 } 3321 } 3322 } 3323 break; 3324 3325 case clang::Type::Typedef: 3326 count = ClangASTContext::GetNumFields (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 3327 break; 3328 3329 case clang::Type::Elaborated: 3330 count = ClangASTContext::GetNumFields (ast, cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 3331 break; 3332 3333 case clang::Type::ObjCObject: 3334 case clang::Type::ObjCInterface: 3335 if (GetCompleteQualType (ast, qual_type)) 3336 { 3337 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 3338 if (objc_class_type) 3339 { 3340 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3341 3342 if (class_interface_decl) 3343 count = class_interface_decl->ivar_size(); 3344 } 3345 } 3346 break; 3347 3348 default: 3349 break; 3350 } 3351 return count; 3352} 3353 3354clang_type_t 3355ClangASTContext::GetDirectBaseClassAtIndex (clang::ASTContext *ast, 3356 clang_type_t clang_type, 3357 uint32_t idx, 3358 uint32_t *bit_offset_ptr) 3359{ 3360 if (clang_type == NULL) 3361 return 0; 3362 3363 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3364 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3365 switch (type_class) 3366 { 3367 case clang::Type::Record: 3368 if (GetCompleteQualType (ast, qual_type)) 3369 { 3370 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 3371 if (cxx_record_decl) 3372 { 3373 uint32_t curr_idx = 0; 3374 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3375 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3376 base_class != base_class_end; 3377 ++base_class, ++curr_idx) 3378 { 3379 if (curr_idx == idx) 3380 { 3381 if (bit_offset_ptr) 3382 { 3383 const ASTRecordLayout &record_layout = ast->getASTRecordLayout(cxx_record_decl); 3384 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3385// if (base_class->isVirtual()) 3386// *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 3387// else 3388 *bit_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; 3389 } 3390 return base_class->getType().getAsOpaquePtr(); 3391 } 3392 } 3393 } 3394 } 3395 break; 3396 3397 case clang::Type::ObjCObject: 3398 case clang::Type::ObjCInterface: 3399 if (idx == 0 && GetCompleteQualType (ast, qual_type)) 3400 { 3401 const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); 3402 if (objc_class_type) 3403 { 3404 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3405 3406 if (class_interface_decl) 3407 { 3408 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3409 if (superclass_interface_decl) 3410 { 3411 if (bit_offset_ptr) 3412 *bit_offset_ptr = 0; 3413 return ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(); 3414 } 3415 } 3416 } 3417 } 3418 break; 3419 3420 3421 case clang::Type::Typedef: 3422 return ClangASTContext::GetDirectBaseClassAtIndex (ast, 3423 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 3424 idx, 3425 bit_offset_ptr); 3426 3427 case clang::Type::Elaborated: 3428 return ClangASTContext::GetDirectBaseClassAtIndex (ast, 3429 cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), 3430 idx, 3431 bit_offset_ptr); 3432 3433 default: 3434 break; 3435 } 3436 return NULL; 3437} 3438 3439clang_type_t 3440ClangASTContext::GetVirtualBaseClassAtIndex (clang::ASTContext *ast, 3441 clang_type_t clang_type, 3442 uint32_t idx, 3443 uint32_t *bit_offset_ptr) 3444{ 3445 if (clang_type == NULL) 3446 return 0; 3447 3448 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3449 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3450 switch (type_class) 3451 { 3452 case clang::Type::Record: 3453 if (GetCompleteQualType (ast, qual_type)) 3454 { 3455 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 3456 if (cxx_record_decl) 3457 { 3458 uint32_t curr_idx = 0; 3459 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3460 for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end(); 3461 base_class != base_class_end; 3462 ++base_class, ++curr_idx) 3463 { 3464 if (curr_idx == idx) 3465 { 3466 if (bit_offset_ptr) 3467 { 3468 const ASTRecordLayout &record_layout = ast->getASTRecordLayout(cxx_record_decl); 3469 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3470 *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 3471 3472 } 3473 return base_class->getType().getAsOpaquePtr(); 3474 } 3475 } 3476 } 3477 } 3478 break; 3479 3480 case clang::Type::Typedef: 3481 return ClangASTContext::GetVirtualBaseClassAtIndex (ast, 3482 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 3483 idx, 3484 bit_offset_ptr); 3485 3486 case clang::Type::Elaborated: 3487 return ClangASTContext::GetVirtualBaseClassAtIndex (ast, 3488 cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), 3489 idx, 3490 bit_offset_ptr); 3491 3492 default: 3493 break; 3494 } 3495 return NULL; 3496} 3497 3498clang_type_t 3499ClangASTContext::GetFieldAtIndex (clang::ASTContext *ast, 3500 clang_type_t clang_type, 3501 uint32_t idx, 3502 std::string& name, 3503 uint64_t *bit_offset_ptr, 3504 uint32_t *bitfield_bit_size_ptr, 3505 bool *is_bitfield_ptr) 3506{ 3507 if (clang_type == NULL) 3508 return 0; 3509 3510 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3511 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3512 switch (type_class) 3513 { 3514 case clang::Type::Record: 3515 if (GetCompleteQualType (ast, qual_type)) 3516 { 3517 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 3518 const RecordDecl *record_decl = record_type->getDecl(); 3519 uint32_t field_idx = 0; 3520 RecordDecl::field_iterator field, field_end; 3521 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx) 3522 { 3523 if (idx == field_idx) 3524 { 3525 // Print the member type if requested 3526 // Print the member name and equal sign 3527 name.assign(field->getNameAsString()); 3528 3529 // Figure out the type byte size (field_type_info.first) and 3530 // alignment (field_type_info.second) from the AST context. 3531 if (bit_offset_ptr) 3532 { 3533 const ASTRecordLayout &record_layout = ast->getASTRecordLayout(record_decl); 3534 *bit_offset_ptr = record_layout.getFieldOffset (field_idx); 3535 } 3536 3537 const bool is_bitfield = field->isBitField(); 3538 3539 if (bitfield_bit_size_ptr) 3540 { 3541 *bitfield_bit_size_ptr = 0; 3542 3543 if (is_bitfield && ast) 3544 { 3545 Expr *bitfield_bit_size_expr = field->getBitWidth(); 3546 llvm::APSInt bitfield_apsint; 3547 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast)) 3548 { 3549 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); 3550 } 3551 } 3552 } 3553 if (is_bitfield_ptr) 3554 *is_bitfield_ptr = is_bitfield; 3555 3556 return field->getType().getAsOpaquePtr(); 3557 } 3558 } 3559 } 3560 break; 3561 3562 case clang::Type::ObjCObject: 3563 case clang::Type::ObjCInterface: 3564 if (GetCompleteQualType (ast, qual_type)) 3565 { 3566 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 3567 assert (objc_class_type); 3568 if (objc_class_type) 3569 { 3570 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3571 3572 if (class_interface_decl) 3573 { 3574 if (idx < (class_interface_decl->ivar_size())) 3575 { 3576 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 3577 uint32_t ivar_idx = 0; 3578 3579 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx) 3580 { 3581 if (ivar_idx == idx) 3582 { 3583 const ObjCIvarDecl* ivar_decl = *ivar_pos; 3584 3585 QualType ivar_qual_type(ivar_decl->getType()); 3586 3587 name.assign(ivar_decl->getNameAsString()); 3588 3589 if (bit_offset_ptr) 3590 { 3591 const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl); 3592 *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx); 3593 } 3594 3595 const bool is_bitfield = ivar_pos->isBitField(); 3596 3597 if (bitfield_bit_size_ptr) 3598 { 3599 *bitfield_bit_size_ptr = 0; 3600 3601 if (is_bitfield && ast) 3602 { 3603 Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth(); 3604 llvm::APSInt bitfield_apsint; 3605 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast)) 3606 { 3607 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); 3608 } 3609 } 3610 } 3611 if (is_bitfield_ptr) 3612 *is_bitfield_ptr = is_bitfield; 3613 3614 return ivar_qual_type.getAsOpaquePtr(); 3615 } 3616 } 3617 } 3618 } 3619 } 3620 } 3621 break; 3622 3623 3624 case clang::Type::Typedef: 3625 return ClangASTContext::GetFieldAtIndex (ast, 3626 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 3627 idx, 3628 name, 3629 bit_offset_ptr, 3630 bitfield_bit_size_ptr, 3631 is_bitfield_ptr); 3632 3633 case clang::Type::Elaborated: 3634 return ClangASTContext::GetFieldAtIndex (ast, 3635 cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), 3636 idx, 3637 name, 3638 bit_offset_ptr, 3639 bitfield_bit_size_ptr, 3640 is_bitfield_ptr); 3641 3642 default: 3643 break; 3644 } 3645 return NULL; 3646} 3647 3648lldb::BasicType 3649ClangASTContext::GetLLDBBasicTypeEnumeration (clang_type_t clang_type) 3650{ 3651 if (clang_type) 3652 { 3653 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3654 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3655 if (type_class == clang::Type::Builtin) 3656 { 3657 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 3658 { 3659 case clang::BuiltinType::Void: return eBasicTypeVoid; 3660 case clang::BuiltinType::Bool: return eBasicTypeBool; 3661 case clang::BuiltinType::Char_S: return eBasicTypeSignedChar; 3662 case clang::BuiltinType::Char_U: return eBasicTypeUnsignedChar; 3663 case clang::BuiltinType::Char16: return eBasicTypeChar16; 3664 case clang::BuiltinType::Char32: return eBasicTypeChar32; 3665 case clang::BuiltinType::UChar: return eBasicTypeUnsignedChar; 3666 case clang::BuiltinType::SChar: return eBasicTypeSignedChar; 3667 case clang::BuiltinType::WChar_S: return eBasicTypeSignedWChar; 3668 case clang::BuiltinType::WChar_U: return eBasicTypeUnsignedWChar; 3669 case clang::BuiltinType::Short: return eBasicTypeShort; 3670 case clang::BuiltinType::UShort: return eBasicTypeUnsignedShort; 3671 case clang::BuiltinType::Int: return eBasicTypeInt; 3672 case clang::BuiltinType::UInt: return eBasicTypeUnsignedInt; 3673 case clang::BuiltinType::Long: return eBasicTypeLong; 3674 case clang::BuiltinType::ULong: return eBasicTypeUnsignedLong; 3675 case clang::BuiltinType::LongLong: return eBasicTypeLongLong; 3676 case clang::BuiltinType::ULongLong: return eBasicTypeUnsignedLongLong; 3677 case clang::BuiltinType::Int128: return eBasicTypeInt128; 3678 case clang::BuiltinType::UInt128: return eBasicTypeUnsignedInt128; 3679 3680 case clang::BuiltinType::Half: return eBasicTypeHalf; 3681 case clang::BuiltinType::Float: return eBasicTypeFloat; 3682 case clang::BuiltinType::Double: return eBasicTypeDouble; 3683 case clang::BuiltinType::LongDouble:return eBasicTypeLongDouble; 3684 3685 case clang::BuiltinType::NullPtr: return eBasicTypeNullPtr; 3686 case clang::BuiltinType::ObjCId: return eBasicTypeObjCID; 3687 case clang::BuiltinType::ObjCClass: return eBasicTypeObjCClass; 3688 case clang::BuiltinType::ObjCSel: return eBasicTypeObjCSel; 3689 case clang::BuiltinType::Dependent: 3690 case clang::BuiltinType::Overload: 3691 case clang::BuiltinType::BoundMember: 3692 case clang::BuiltinType::PseudoObject: 3693 case clang::BuiltinType::UnknownAny: 3694 case clang::BuiltinType::BuiltinFn: 3695 case clang::BuiltinType::ARCUnbridgedCast: 3696 return eBasicTypeOther; 3697 } 3698 } 3699 } 3700 3701 return eBasicTypeInvalid; 3702} 3703 3704 3705 3706// If a pointer to a pointee type (the clang_type arg) says that it has no 3707// children, then we either need to trust it, or override it and return a 3708// different result. For example, an "int *" has one child that is an integer, 3709// but a function pointer doesn't have any children. Likewise if a Record type 3710// claims it has no children, then there really is nothing to show. 3711uint32_t 3712ClangASTContext::GetNumPointeeChildren (clang_type_t clang_type) 3713{ 3714 if (clang_type == NULL) 3715 return 0; 3716 3717 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 3718 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3719 switch (type_class) 3720 { 3721 case clang::Type::Builtin: 3722 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 3723 { 3724 case clang::BuiltinType::UnknownAny: 3725 case clang::BuiltinType::Void: 3726 case clang::BuiltinType::NullPtr: 3727 return 0; 3728 case clang::BuiltinType::Bool: 3729 case clang::BuiltinType::Char_U: 3730 case clang::BuiltinType::UChar: 3731 case clang::BuiltinType::WChar_U: 3732 case clang::BuiltinType::Char16: 3733 case clang::BuiltinType::Char32: 3734 case clang::BuiltinType::UShort: 3735 case clang::BuiltinType::UInt: 3736 case clang::BuiltinType::ULong: 3737 case clang::BuiltinType::ULongLong: 3738 case clang::BuiltinType::UInt128: 3739 case clang::BuiltinType::Char_S: 3740 case clang::BuiltinType::SChar: 3741 case clang::BuiltinType::WChar_S: 3742 case clang::BuiltinType::Short: 3743 case clang::BuiltinType::Int: 3744 case clang::BuiltinType::Long: 3745 case clang::BuiltinType::LongLong: 3746 case clang::BuiltinType::Int128: 3747 case clang::BuiltinType::Float: 3748 case clang::BuiltinType::Double: 3749 case clang::BuiltinType::LongDouble: 3750 case clang::BuiltinType::Dependent: 3751 case clang::BuiltinType::Overload: 3752 case clang::BuiltinType::ObjCId: 3753 case clang::BuiltinType::ObjCClass: 3754 case clang::BuiltinType::ObjCSel: 3755 case clang::BuiltinType::BoundMember: 3756 case clang::BuiltinType::Half: 3757 case clang::BuiltinType::ARCUnbridgedCast: 3758 case clang::BuiltinType::PseudoObject: 3759 case clang::BuiltinType::BuiltinFn: 3760 return 1; 3761 } 3762 break; 3763 3764 case clang::Type::Complex: return 1; 3765 case clang::Type::Pointer: return 1; 3766 case clang::Type::BlockPointer: return 0; // If block pointers don't have debug info, then no children for them 3767 case clang::Type::LValueReference: return 1; 3768 case clang::Type::RValueReference: return 1; 3769 case clang::Type::MemberPointer: return 0; 3770 case clang::Type::ConstantArray: return 0; 3771 case clang::Type::IncompleteArray: return 0; 3772 case clang::Type::VariableArray: return 0; 3773 case clang::Type::DependentSizedArray: return 0; 3774 case clang::Type::DependentSizedExtVector: return 0; 3775 case clang::Type::Vector: return 0; 3776 case clang::Type::ExtVector: return 0; 3777 case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children... 3778 case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children... 3779 case clang::Type::UnresolvedUsing: return 0; 3780 case clang::Type::Paren: return 0; 3781 case clang::Type::Typedef: return ClangASTContext::GetNumPointeeChildren (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 3782 case clang::Type::Elaborated: return ClangASTContext::GetNumPointeeChildren (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 3783 case clang::Type::TypeOfExpr: return 0; 3784 case clang::Type::TypeOf: return 0; 3785 case clang::Type::Decltype: return 0; 3786 case clang::Type::Record: return 0; 3787 case clang::Type::Enum: return 1; 3788 case clang::Type::TemplateTypeParm: return 1; 3789 case clang::Type::SubstTemplateTypeParm: return 1; 3790 case clang::Type::TemplateSpecialization: return 1; 3791 case clang::Type::InjectedClassName: return 0; 3792 case clang::Type::DependentName: return 1; 3793 case clang::Type::DependentTemplateSpecialization: return 1; 3794 case clang::Type::ObjCObject: return 0; 3795 case clang::Type::ObjCInterface: return 0; 3796 case clang::Type::ObjCObjectPointer: return 1; 3797 default: 3798 break; 3799 } 3800 return 0; 3801} 3802 3803clang_type_t 3804ClangASTContext::GetChildClangTypeAtIndex 3805( 3806 ExecutionContext *exe_ctx, 3807 const char *parent_name, 3808 clang_type_t parent_clang_type, 3809 uint32_t idx, 3810 bool transparent_pointers, 3811 bool omit_empty_base_classes, 3812 bool ignore_array_bounds, 3813 std::string& child_name, 3814 uint32_t &child_byte_size, 3815 int32_t &child_byte_offset, 3816 uint32_t &child_bitfield_bit_size, 3817 uint32_t &child_bitfield_bit_offset, 3818 bool &child_is_base_class, 3819 bool &child_is_deref_of_parent 3820) 3821{ 3822 if (parent_clang_type) 3823 3824 return GetChildClangTypeAtIndex (exe_ctx, 3825 getASTContext(), 3826 parent_name, 3827 parent_clang_type, 3828 idx, 3829 transparent_pointers, 3830 omit_empty_base_classes, 3831 ignore_array_bounds, 3832 child_name, 3833 child_byte_size, 3834 child_byte_offset, 3835 child_bitfield_bit_size, 3836 child_bitfield_bit_offset, 3837 child_is_base_class, 3838 child_is_deref_of_parent); 3839 return NULL; 3840} 3841 3842clang_type_t 3843ClangASTContext::GetChildClangTypeAtIndex 3844( 3845 ExecutionContext *exe_ctx, 3846 ASTContext *ast, 3847 const char *parent_name, 3848 clang_type_t parent_clang_type, 3849 uint32_t idx, 3850 bool transparent_pointers, 3851 bool omit_empty_base_classes, 3852 bool ignore_array_bounds, 3853 std::string& child_name, 3854 uint32_t &child_byte_size, 3855 int32_t &child_byte_offset, 3856 uint32_t &child_bitfield_bit_size, 3857 uint32_t &child_bitfield_bit_offset, 3858 bool &child_is_base_class, 3859 bool &child_is_deref_of_parent 3860) 3861{ 3862 if (parent_clang_type == NULL) 3863 return NULL; 3864 3865 if (idx < ClangASTContext::GetNumChildren (ast, parent_clang_type, omit_empty_base_classes)) 3866 { 3867 uint32_t bit_offset; 3868 child_bitfield_bit_size = 0; 3869 child_bitfield_bit_offset = 0; 3870 child_is_base_class = false; 3871 QualType parent_qual_type(QualType::getFromOpaquePtr(parent_clang_type)); 3872 const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass(); 3873 switch (parent_type_class) 3874 { 3875 case clang::Type::Builtin: 3876 switch (cast<clang::BuiltinType>(parent_qual_type)->getKind()) 3877 { 3878 case clang::BuiltinType::ObjCId: 3879 case clang::BuiltinType::ObjCClass: 3880 child_name = "isa"; 3881 child_byte_size = ast->getTypeSize(ast->ObjCBuiltinClassTy) / CHAR_BIT; 3882 return ast->ObjCBuiltinClassTy.getAsOpaquePtr(); 3883 3884 default: 3885 break; 3886 } 3887 break; 3888 3889 case clang::Type::Record: 3890 if (GetCompleteQualType (ast, parent_qual_type)) 3891 { 3892 const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr()); 3893 const RecordDecl *record_decl = record_type->getDecl(); 3894 assert(record_decl); 3895 const ASTRecordLayout &record_layout = ast->getASTRecordLayout(record_decl); 3896 uint32_t child_idx = 0; 3897 3898 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3899 if (cxx_record_decl) 3900 { 3901 // We might have base classes to print out first 3902 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3903 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3904 base_class != base_class_end; 3905 ++base_class) 3906 { 3907 const CXXRecordDecl *base_class_decl = NULL; 3908 3909 // Skip empty base classes 3910 if (omit_empty_base_classes) 3911 { 3912 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3913 if (RecordHasFields(base_class_decl) == false) 3914 continue; 3915 } 3916 3917 if (idx == child_idx) 3918 { 3919 if (base_class_decl == NULL) 3920 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3921 3922 3923 if (base_class->isVirtual()) 3924 bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 3925 else 3926 bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; 3927 3928 // Base classes should be a multiple of 8 bits in size 3929 child_byte_offset = bit_offset/8; 3930 3931 child_name = ClangASTType::GetTypeNameForQualType(ast, base_class->getType()); 3932 3933 uint64_t clang_type_info_bit_size = ast->getTypeSize(base_class->getType()); 3934 3935 // Base classes bit sizes should be a multiple of 8 bits in size 3936 assert (clang_type_info_bit_size % 8 == 0); 3937 child_byte_size = clang_type_info_bit_size / 8; 3938 child_is_base_class = true; 3939 return base_class->getType().getAsOpaquePtr(); 3940 } 3941 // We don't increment the child index in the for loop since we might 3942 // be skipping empty base classes 3943 ++child_idx; 3944 } 3945 } 3946 // Make sure index is in range... 3947 uint32_t field_idx = 0; 3948 RecordDecl::field_iterator field, field_end; 3949 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) 3950 { 3951 if (idx == child_idx) 3952 { 3953 // Print the member type if requested 3954 // Print the member name and equal sign 3955 child_name.assign(field->getNameAsString().c_str()); 3956 3957 // Figure out the type byte size (field_type_info.first) and 3958 // alignment (field_type_info.second) from the AST context. 3959 std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(field->getType()); 3960 assert(field_idx < record_layout.getFieldCount()); 3961 3962 child_byte_size = field_type_info.first / 8; 3963 3964 // Figure out the field offset within the current struct/union/class type 3965 bit_offset = record_layout.getFieldOffset (field_idx); 3966 child_byte_offset = bit_offset / 8; 3967 if (ClangASTContext::FieldIsBitfield (ast, *field, child_bitfield_bit_size)) 3968 child_bitfield_bit_offset = bit_offset % 8; 3969 3970 return field->getType().getAsOpaquePtr(); 3971 } 3972 } 3973 } 3974 break; 3975 3976 case clang::Type::ObjCObject: 3977 case clang::Type::ObjCInterface: 3978 if (GetCompleteQualType (ast, parent_qual_type)) 3979 { 3980 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr()); 3981 assert (objc_class_type); 3982 if (objc_class_type) 3983 { 3984 uint32_t child_idx = 0; 3985 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3986 3987 if (class_interface_decl) 3988 { 3989 3990 const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl); 3991 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3992 if (superclass_interface_decl) 3993 { 3994 if (omit_empty_base_classes) 3995 { 3996 if (ClangASTContext::GetNumChildren(ast, ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(), omit_empty_base_classes) > 0) 3997 { 3998 if (idx == 0) 3999 { 4000 QualType ivar_qual_type(ast->getObjCInterfaceType(superclass_interface_decl)); 4001 4002 4003 child_name.assign(superclass_interface_decl->getNameAsString().c_str()); 4004 4005 std::pair<uint64_t, unsigned> ivar_type_info = ast->getTypeInfo(ivar_qual_type.getTypePtr()); 4006 4007 child_byte_size = ivar_type_info.first / 8; 4008 child_byte_offset = 0; 4009 child_is_base_class = true; 4010 4011 return ivar_qual_type.getAsOpaquePtr(); 4012 } 4013 4014 ++child_idx; 4015 } 4016 } 4017 else 4018 ++child_idx; 4019 } 4020 4021 const uint32_t superclass_idx = child_idx; 4022 4023 if (idx < (child_idx + class_interface_decl->ivar_size())) 4024 { 4025 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 4026 4027 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos) 4028 { 4029 if (child_idx == idx) 4030 { 4031 ObjCIvarDecl* ivar_decl = *ivar_pos; 4032 4033 QualType ivar_qual_type(ivar_decl->getType()); 4034 4035 child_name.assign(ivar_decl->getNameAsString().c_str()); 4036 4037 std::pair<uint64_t, unsigned> ivar_type_info = ast->getTypeInfo(ivar_qual_type.getTypePtr()); 4038 4039 child_byte_size = ivar_type_info.first / 8; 4040 4041 // Figure out the field offset within the current struct/union/class type 4042 // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since 4043 // that doesn't account for the space taken up by unbacked properties, or from 4044 // the changing size of base classes that are newer than this class. 4045 // So if we have a process around that we can ask about this object, do so. 4046 child_byte_offset = LLDB_INVALID_IVAR_OFFSET; 4047 Process *process = NULL; 4048 if (exe_ctx) 4049 process = exe_ctx->GetProcessPtr(); 4050 if (process) 4051 { 4052 ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime(); 4053 if (objc_runtime != NULL) 4054 { 4055 ClangASTType parent_ast_type (ast, parent_qual_type.getAsOpaquePtr()); 4056 child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str()); 4057 } 4058 } 4059 4060 // Setting this to UINT32_MAX to make sure we don't compute it twice... 4061 bit_offset = UINT32_MAX; 4062 4063 if (child_byte_offset == LLDB_INVALID_IVAR_OFFSET) 4064 { 4065 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx); 4066 child_byte_offset = bit_offset / 8; 4067 } 4068 4069 // Note, the ObjC Ivar Byte offset is just that, it doesn't account for the bit offset 4070 // of a bitfield within its containing object. So regardless of where we get the byte 4071 // offset from, we still need to get the bit offset for bitfields from the layout. 4072 4073 if (ClangASTContext::FieldIsBitfield (ast, ivar_decl, child_bitfield_bit_size)) 4074 { 4075 if (bit_offset == UINT32_MAX) 4076 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx); 4077 4078 child_bitfield_bit_offset = bit_offset % 8; 4079 } 4080 return ivar_qual_type.getAsOpaquePtr(); 4081 } 4082 ++child_idx; 4083 } 4084 } 4085 } 4086 } 4087 } 4088 break; 4089 4090 case clang::Type::ObjCObjectPointer: 4091 { 4092 const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(parent_qual_type.getTypePtr()); 4093 QualType pointee_type = pointer_type->getPointeeType(); 4094 4095 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 4096 { 4097 child_is_deref_of_parent = false; 4098 bool tmp_child_is_deref_of_parent = false; 4099 return GetChildClangTypeAtIndex (exe_ctx, 4100 ast, 4101 parent_name, 4102 pointer_type->getPointeeType().getAsOpaquePtr(), 4103 idx, 4104 transparent_pointers, 4105 omit_empty_base_classes, 4106 ignore_array_bounds, 4107 child_name, 4108 child_byte_size, 4109 child_byte_offset, 4110 child_bitfield_bit_size, 4111 child_bitfield_bit_offset, 4112 child_is_base_class, 4113 tmp_child_is_deref_of_parent); 4114 } 4115 else 4116 { 4117 child_is_deref_of_parent = true; 4118 if (parent_name) 4119 { 4120 child_name.assign(1, '*'); 4121 child_name += parent_name; 4122 } 4123 4124 // We have a pointer to an simple type 4125 if (idx == 0 && GetCompleteQualType(ast, pointee_type)) 4126 { 4127 std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type); 4128 assert(clang_type_info.first % 8 == 0); 4129 child_byte_size = clang_type_info.first / 8; 4130 child_byte_offset = 0; 4131 return pointee_type.getAsOpaquePtr(); 4132 } 4133 } 4134 } 4135 break; 4136 4137 case clang::Type::ConstantArray: 4138 { 4139 const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); 4140 const uint64_t element_count = array->getSize().getLimitedValue(); 4141 4142 if (ignore_array_bounds || idx < element_count) 4143 { 4144 if (GetCompleteQualType (ast, array->getElementType())) 4145 { 4146 std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); 4147 4148 char element_name[64]; 4149 ::snprintf (element_name, sizeof (element_name), "[%u]", idx); 4150 4151 child_name.assign(element_name); 4152 assert(field_type_info.first % 8 == 0); 4153 child_byte_size = field_type_info.first / 8; 4154 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; 4155 return array->getElementType().getAsOpaquePtr(); 4156 } 4157 } 4158 } 4159 break; 4160 4161 case clang::Type::Pointer: 4162 { 4163 const PointerType *pointer_type = cast<PointerType>(parent_qual_type.getTypePtr()); 4164 QualType pointee_type = pointer_type->getPointeeType(); 4165 4166 // Don't dereference "void *" pointers 4167 if (pointee_type->isVoidType()) 4168 return NULL; 4169 4170 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 4171 { 4172 child_is_deref_of_parent = false; 4173 bool tmp_child_is_deref_of_parent = false; 4174 return GetChildClangTypeAtIndex (exe_ctx, 4175 ast, 4176 parent_name, 4177 pointer_type->getPointeeType().getAsOpaquePtr(), 4178 idx, 4179 transparent_pointers, 4180 omit_empty_base_classes, 4181 ignore_array_bounds, 4182 child_name, 4183 child_byte_size, 4184 child_byte_offset, 4185 child_bitfield_bit_size, 4186 child_bitfield_bit_offset, 4187 child_is_base_class, 4188 tmp_child_is_deref_of_parent); 4189 } 4190 else 4191 { 4192 child_is_deref_of_parent = true; 4193 4194 if (parent_name) 4195 { 4196 child_name.assign(1, '*'); 4197 child_name += parent_name; 4198 } 4199 4200 // We have a pointer to an simple type 4201 if (idx == 0) 4202 { 4203 std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type); 4204 assert(clang_type_info.first % 8 == 0); 4205 child_byte_size = clang_type_info.first / 8; 4206 child_byte_offset = 0; 4207 return pointee_type.getAsOpaquePtr(); 4208 } 4209 } 4210 } 4211 break; 4212 4213 case clang::Type::LValueReference: 4214 case clang::Type::RValueReference: 4215 { 4216 const ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr()); 4217 QualType pointee_type(reference_type->getPointeeType()); 4218 clang_type_t pointee_clang_type = pointee_type.getAsOpaquePtr(); 4219 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_clang_type)) 4220 { 4221 child_is_deref_of_parent = false; 4222 bool tmp_child_is_deref_of_parent = false; 4223 return GetChildClangTypeAtIndex (exe_ctx, 4224 ast, 4225 parent_name, 4226 pointee_clang_type, 4227 idx, 4228 transparent_pointers, 4229 omit_empty_base_classes, 4230 ignore_array_bounds, 4231 child_name, 4232 child_byte_size, 4233 child_byte_offset, 4234 child_bitfield_bit_size, 4235 child_bitfield_bit_offset, 4236 child_is_base_class, 4237 tmp_child_is_deref_of_parent); 4238 } 4239 else 4240 { 4241 if (parent_name) 4242 { 4243 child_name.assign(1, '&'); 4244 child_name += parent_name; 4245 } 4246 4247 // We have a pointer to an simple type 4248 if (idx == 0) 4249 { 4250 std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type); 4251 assert(clang_type_info.first % 8 == 0); 4252 child_byte_size = clang_type_info.first / 8; 4253 child_byte_offset = 0; 4254 return pointee_type.getAsOpaquePtr(); 4255 } 4256 } 4257 } 4258 break; 4259 4260 case clang::Type::Typedef: 4261 return GetChildClangTypeAtIndex (exe_ctx, 4262 ast, 4263 parent_name, 4264 cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 4265 idx, 4266 transparent_pointers, 4267 omit_empty_base_classes, 4268 ignore_array_bounds, 4269 child_name, 4270 child_byte_size, 4271 child_byte_offset, 4272 child_bitfield_bit_size, 4273 child_bitfield_bit_offset, 4274 child_is_base_class, 4275 child_is_deref_of_parent); 4276 break; 4277 4278 case clang::Type::Elaborated: 4279 return GetChildClangTypeAtIndex (exe_ctx, 4280 ast, 4281 parent_name, 4282 cast<ElaboratedType>(parent_qual_type)->getNamedType().getAsOpaquePtr(), 4283 idx, 4284 transparent_pointers, 4285 omit_empty_base_classes, 4286 ignore_array_bounds, 4287 child_name, 4288 child_byte_size, 4289 child_byte_offset, 4290 child_bitfield_bit_size, 4291 child_bitfield_bit_offset, 4292 child_is_base_class, 4293 child_is_deref_of_parent); 4294 4295 default: 4296 break; 4297 } 4298 } 4299 return NULL; 4300} 4301 4302static inline bool 4303BaseSpecifierIsEmpty (const CXXBaseSpecifier *b) 4304{ 4305 return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false; 4306} 4307 4308static uint32_t 4309GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes) 4310{ 4311 uint32_t num_bases = 0; 4312 if (cxx_record_decl) 4313 { 4314 if (omit_empty_base_classes) 4315 { 4316 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 4317 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 4318 base_class != base_class_end; 4319 ++base_class) 4320 { 4321 // Skip empty base classes 4322 if (omit_empty_base_classes) 4323 { 4324 if (BaseSpecifierIsEmpty (base_class)) 4325 continue; 4326 } 4327 ++num_bases; 4328 } 4329 } 4330 else 4331 num_bases = cxx_record_decl->getNumBases(); 4332 } 4333 return num_bases; 4334} 4335 4336 4337static uint32_t 4338GetIndexForRecordBase 4339( 4340 const RecordDecl *record_decl, 4341 const CXXBaseSpecifier *base_spec, 4342 bool omit_empty_base_classes 4343) 4344{ 4345 uint32_t child_idx = 0; 4346 4347 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 4348 4349// const char *super_name = record_decl->getNameAsCString(); 4350// const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString(); 4351// printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name); 4352// 4353 if (cxx_record_decl) 4354 { 4355 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 4356 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 4357 base_class != base_class_end; 4358 ++base_class) 4359 { 4360 if (omit_empty_base_classes) 4361 { 4362 if (BaseSpecifierIsEmpty (base_class)) 4363 continue; 4364 } 4365 4366// printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name, 4367// child_idx, 4368// base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString()); 4369// 4370// 4371 if (base_class == base_spec) 4372 return child_idx; 4373 ++child_idx; 4374 } 4375 } 4376 4377 return UINT32_MAX; 4378} 4379 4380 4381static uint32_t 4382GetIndexForRecordChild 4383( 4384 const RecordDecl *record_decl, 4385 NamedDecl *canonical_decl, 4386 bool omit_empty_base_classes 4387) 4388{ 4389 uint32_t child_idx = GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl), omit_empty_base_classes); 4390 4391// const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 4392// 4393//// printf ("GetIndexForRecordChild (%s, %s)\n", record_decl->getNameAsCString(), canonical_decl->getNameAsCString()); 4394// if (cxx_record_decl) 4395// { 4396// CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 4397// for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 4398// base_class != base_class_end; 4399// ++base_class) 4400// { 4401// if (omit_empty_base_classes) 4402// { 4403// if (BaseSpecifierIsEmpty (base_class)) 4404// continue; 4405// } 4406// 4407//// printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", 4408//// record_decl->getNameAsCString(), 4409//// canonical_decl->getNameAsCString(), 4410//// child_idx, 4411//// base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString()); 4412// 4413// 4414// CXXRecordDecl *curr_base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 4415// if (curr_base_class_decl == canonical_decl) 4416// { 4417// return child_idx; 4418// } 4419// ++child_idx; 4420// } 4421// } 4422// 4423// const uint32_t num_bases = child_idx; 4424 RecordDecl::field_iterator field, field_end; 4425 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 4426 field != field_end; 4427 ++field, ++child_idx) 4428 { 4429// printf ("GetIndexForRecordChild (%s, %s) field[%u] = %s\n", 4430// record_decl->getNameAsCString(), 4431// canonical_decl->getNameAsCString(), 4432// child_idx - num_bases, 4433// field->getNameAsCString()); 4434 4435 if (field->getCanonicalDecl() == canonical_decl) 4436 return child_idx; 4437 } 4438 4439 return UINT32_MAX; 4440} 4441 4442// Look for a child member (doesn't include base classes, but it does include 4443// their members) in the type hierarchy. Returns an index path into "clang_type" 4444// on how to reach the appropriate member. 4445// 4446// class A 4447// { 4448// public: 4449// int m_a; 4450// int m_b; 4451// }; 4452// 4453// class B 4454// { 4455// }; 4456// 4457// class C : 4458// public B, 4459// public A 4460// { 4461// }; 4462// 4463// If we have a clang type that describes "class C", and we wanted to looked 4464// "m_b" in it: 4465// 4466// With omit_empty_base_classes == false we would get an integer array back with: 4467// { 1, 1 } 4468// The first index 1 is the child index for "class A" within class C 4469// The second index 1 is the child index for "m_b" within class A 4470// 4471// With omit_empty_base_classes == true we would get an integer array back with: 4472// { 0, 1 } 4473// The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count) 4474// The second index 1 is the child index for "m_b" within class A 4475 4476size_t 4477ClangASTContext::GetIndexOfChildMemberWithName 4478( 4479 ASTContext *ast, 4480 clang_type_t clang_type, 4481 const char *name, 4482 bool omit_empty_base_classes, 4483 std::vector<uint32_t>& child_indexes 4484) 4485{ 4486 if (clang_type && name && name[0]) 4487 { 4488 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 4489 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 4490 switch (type_class) 4491 { 4492 case clang::Type::Record: 4493 if (GetCompleteQualType (ast, qual_type)) 4494 { 4495 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 4496 const RecordDecl *record_decl = record_type->getDecl(); 4497 4498 assert(record_decl); 4499 uint32_t child_idx = 0; 4500 4501 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 4502 4503 // Try and find a field that matches NAME 4504 RecordDecl::field_iterator field, field_end; 4505 StringRef name_sref(name); 4506 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 4507 field != field_end; 4508 ++field, ++child_idx) 4509 { 4510 if (field->getName().equals (name_sref)) 4511 { 4512 // We have to add on the number of base classes to this index! 4513 child_indexes.push_back (child_idx + GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes)); 4514 return child_indexes.size(); 4515 } 4516 } 4517 4518 if (cxx_record_decl) 4519 { 4520 const RecordDecl *parent_record_decl = cxx_record_decl; 4521 4522 //printf ("parent = %s\n", parent_record_decl->getNameAsCString()); 4523 4524 //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl(); 4525 // Didn't find things easily, lets let clang do its thang... 4526 IdentifierInfo & ident_ref = ast->Idents.get(name_sref); 4527 DeclarationName decl_name(&ident_ref); 4528 4529 CXXBasePaths paths; 4530 if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember, 4531 decl_name.getAsOpaquePtr(), 4532 paths)) 4533 { 4534 CXXBasePaths::const_paths_iterator path, path_end = paths.end(); 4535 for (path = paths.begin(); path != path_end; ++path) 4536 { 4537 const size_t num_path_elements = path->size(); 4538 for (size_t e=0; e<num_path_elements; ++e) 4539 { 4540 CXXBasePathElement elem = (*path)[e]; 4541 4542 child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes); 4543 if (child_idx == UINT32_MAX) 4544 { 4545 child_indexes.clear(); 4546 return 0; 4547 } 4548 else 4549 { 4550 child_indexes.push_back (child_idx); 4551 parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl()); 4552 } 4553 } 4554 DeclContext::lookup_iterator named_decl_pos; 4555 for (named_decl_pos = path->Decls.first; 4556 named_decl_pos != path->Decls.second && parent_record_decl; 4557 ++named_decl_pos) 4558 { 4559 child_idx = GetIndexForRecordChild (parent_record_decl, *named_decl_pos, omit_empty_base_classes); 4560 if (child_idx == UINT32_MAX) 4561 { 4562 child_indexes.clear(); 4563 return 0; 4564 } 4565 else 4566 { 4567 child_indexes.push_back (child_idx); 4568 } 4569 } 4570 } 4571 return child_indexes.size(); 4572 } 4573 } 4574 4575 } 4576 break; 4577 4578 case clang::Type::ObjCObject: 4579 case clang::Type::ObjCInterface: 4580 if (GetCompleteQualType (ast, qual_type)) 4581 { 4582 StringRef name_sref(name); 4583 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 4584 assert (objc_class_type); 4585 if (objc_class_type) 4586 { 4587 uint32_t child_idx = 0; 4588 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 4589 4590 if (class_interface_decl) 4591 { 4592 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 4593 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 4594 4595 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) 4596 { 4597 const ObjCIvarDecl* ivar_decl = *ivar_pos; 4598 4599 if (ivar_decl->getName().equals (name_sref)) 4600 { 4601 if ((!omit_empty_base_classes && superclass_interface_decl) || 4602 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true))) 4603 ++child_idx; 4604 4605 child_indexes.push_back (child_idx); 4606 return child_indexes.size(); 4607 } 4608 } 4609 4610 if (superclass_interface_decl) 4611 { 4612 // The super class index is always zero for ObjC classes, 4613 // so we push it onto the child indexes in case we find 4614 // an ivar in our superclass... 4615 child_indexes.push_back (0); 4616 4617 if (GetIndexOfChildMemberWithName (ast, 4618 ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(), 4619 name, 4620 omit_empty_base_classes, 4621 child_indexes)) 4622 { 4623 // We did find an ivar in a superclass so just 4624 // return the results! 4625 return child_indexes.size(); 4626 } 4627 4628 // We didn't find an ivar matching "name" in our 4629 // superclass, pop the superclass zero index that 4630 // we pushed on above. 4631 child_indexes.pop_back(); 4632 } 4633 } 4634 } 4635 } 4636 break; 4637 4638 case clang::Type::ObjCObjectPointer: 4639 { 4640 return GetIndexOfChildMemberWithName (ast, 4641 cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(), 4642 name, 4643 omit_empty_base_classes, 4644 child_indexes); 4645 } 4646 break; 4647 4648 4649 case clang::Type::ConstantArray: 4650 { 4651// const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); 4652// const uint64_t element_count = array->getSize().getLimitedValue(); 4653// 4654// if (idx < element_count) 4655// { 4656// std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); 4657// 4658// char element_name[32]; 4659// ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx); 4660// 4661// child_name.assign(element_name); 4662// assert(field_type_info.first % 8 == 0); 4663// child_byte_size = field_type_info.first / 8; 4664// child_byte_offset = idx * child_byte_size; 4665// return array->getElementType().getAsOpaquePtr(); 4666// } 4667 } 4668 break; 4669 4670// case clang::Type::MemberPointerType: 4671// { 4672// MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr()); 4673// QualType pointee_type = mem_ptr_type->getPointeeType(); 4674// 4675// if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 4676// { 4677// return GetIndexOfChildWithName (ast, 4678// mem_ptr_type->getPointeeType().getAsOpaquePtr(), 4679// name); 4680// } 4681// } 4682// break; 4683// 4684 case clang::Type::LValueReference: 4685 case clang::Type::RValueReference: 4686 { 4687 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 4688 QualType pointee_type = reference_type->getPointeeType(); 4689 4690 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 4691 { 4692 return GetIndexOfChildMemberWithName (ast, 4693 reference_type->getPointeeType().getAsOpaquePtr(), 4694 name, 4695 omit_empty_base_classes, 4696 child_indexes); 4697 } 4698 } 4699 break; 4700 4701 case clang::Type::Pointer: 4702 { 4703 const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); 4704 QualType pointee_type = pointer_type->getPointeeType(); 4705 4706 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 4707 { 4708 return GetIndexOfChildMemberWithName (ast, 4709 pointer_type->getPointeeType().getAsOpaquePtr(), 4710 name, 4711 omit_empty_base_classes, 4712 child_indexes); 4713 } 4714 else 4715 { 4716// if (parent_name) 4717// { 4718// child_name.assign(1, '*'); 4719// child_name += parent_name; 4720// } 4721// 4722// // We have a pointer to an simple type 4723// if (idx == 0) 4724// { 4725// std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type); 4726// assert(clang_type_info.first % 8 == 0); 4727// child_byte_size = clang_type_info.first / 8; 4728// child_byte_offset = 0; 4729// return pointee_type.getAsOpaquePtr(); 4730// } 4731 } 4732 } 4733 break; 4734 4735 case clang::Type::Typedef: 4736 return GetIndexOfChildMemberWithName (ast, 4737 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 4738 name, 4739 omit_empty_base_classes, 4740 child_indexes); 4741 4742 default: 4743 break; 4744 } 4745 } 4746 return 0; 4747} 4748 4749 4750// Get the index of the child of "clang_type" whose name matches. This function 4751// doesn't descend into the children, but only looks one level deep and name 4752// matches can include base class names. 4753 4754uint32_t 4755ClangASTContext::GetIndexOfChildWithName 4756( 4757 ASTContext *ast, 4758 clang_type_t clang_type, 4759 const char *name, 4760 bool omit_empty_base_classes 4761) 4762{ 4763 if (clang_type && name && name[0]) 4764 { 4765 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 4766 4767 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 4768 4769 switch (type_class) 4770 { 4771 case clang::Type::Record: 4772 if (GetCompleteQualType (ast, qual_type)) 4773 { 4774 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 4775 const RecordDecl *record_decl = record_type->getDecl(); 4776 4777 assert(record_decl); 4778 uint32_t child_idx = 0; 4779 4780 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 4781 4782 if (cxx_record_decl) 4783 { 4784 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 4785 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 4786 base_class != base_class_end; 4787 ++base_class) 4788 { 4789 // Skip empty base classes 4790 CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 4791 if (omit_empty_base_classes && RecordHasFields(base_class_decl) == false) 4792 continue; 4793 4794 std::string base_class_type_name (ClangASTType::GetTypeNameForQualType(ast, base_class->getType())); 4795 if (base_class_type_name.compare (name) == 0) 4796 return child_idx; 4797 ++child_idx; 4798 } 4799 } 4800 4801 // Try and find a field that matches NAME 4802 RecordDecl::field_iterator field, field_end; 4803 StringRef name_sref(name); 4804 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 4805 field != field_end; 4806 ++field, ++child_idx) 4807 { 4808 if (field->getName().equals (name_sref)) 4809 return child_idx; 4810 } 4811 4812 } 4813 break; 4814 4815 case clang::Type::ObjCObject: 4816 case clang::Type::ObjCInterface: 4817 if (GetCompleteQualType (ast, qual_type)) 4818 { 4819 StringRef name_sref(name); 4820 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 4821 assert (objc_class_type); 4822 if (objc_class_type) 4823 { 4824 uint32_t child_idx = 0; 4825 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 4826 4827 if (class_interface_decl) 4828 { 4829 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 4830 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 4831 4832 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) 4833 { 4834 const ObjCIvarDecl* ivar_decl = *ivar_pos; 4835 4836 if (ivar_decl->getName().equals (name_sref)) 4837 { 4838 if ((!omit_empty_base_classes && superclass_interface_decl) || 4839 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true))) 4840 ++child_idx; 4841 4842 return child_idx; 4843 } 4844 } 4845 4846 if (superclass_interface_decl) 4847 { 4848 if (superclass_interface_decl->getName().equals (name_sref)) 4849 return 0; 4850 } 4851 } 4852 } 4853 } 4854 break; 4855 4856 case clang::Type::ObjCObjectPointer: 4857 { 4858 return GetIndexOfChildWithName (ast, 4859 cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(), 4860 name, 4861 omit_empty_base_classes); 4862 } 4863 break; 4864 4865 case clang::Type::ConstantArray: 4866 { 4867// const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); 4868// const uint64_t element_count = array->getSize().getLimitedValue(); 4869// 4870// if (idx < element_count) 4871// { 4872// std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); 4873// 4874// char element_name[32]; 4875// ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx); 4876// 4877// child_name.assign(element_name); 4878// assert(field_type_info.first % 8 == 0); 4879// child_byte_size = field_type_info.first / 8; 4880// child_byte_offset = idx * child_byte_size; 4881// return array->getElementType().getAsOpaquePtr(); 4882// } 4883 } 4884 break; 4885 4886// case clang::Type::MemberPointerType: 4887// { 4888// MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr()); 4889// QualType pointee_type = mem_ptr_type->getPointeeType(); 4890// 4891// if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 4892// { 4893// return GetIndexOfChildWithName (ast, 4894// mem_ptr_type->getPointeeType().getAsOpaquePtr(), 4895// name); 4896// } 4897// } 4898// break; 4899// 4900 case clang::Type::LValueReference: 4901 case clang::Type::RValueReference: 4902 { 4903 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 4904 QualType pointee_type = reference_type->getPointeeType(); 4905 4906 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 4907 { 4908 return GetIndexOfChildWithName (ast, 4909 reference_type->getPointeeType().getAsOpaquePtr(), 4910 name, 4911 omit_empty_base_classes); 4912 } 4913 } 4914 break; 4915 4916 case clang::Type::Pointer: 4917 { 4918 const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); 4919 QualType pointee_type = pointer_type->getPointeeType(); 4920 4921 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 4922 { 4923 return GetIndexOfChildWithName (ast, 4924 pointer_type->getPointeeType().getAsOpaquePtr(), 4925 name, 4926 omit_empty_base_classes); 4927 } 4928 else 4929 { 4930// if (parent_name) 4931// { 4932// child_name.assign(1, '*'); 4933// child_name += parent_name; 4934// } 4935// 4936// // We have a pointer to an simple type 4937// if (idx == 0) 4938// { 4939// std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type); 4940// assert(clang_type_info.first % 8 == 0); 4941// child_byte_size = clang_type_info.first / 8; 4942// child_byte_offset = 0; 4943// return pointee_type.getAsOpaquePtr(); 4944// } 4945 } 4946 } 4947 break; 4948 4949 case clang::Type::Typedef: 4950 return GetIndexOfChildWithName (ast, 4951 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 4952 name, 4953 omit_empty_base_classes); 4954 4955 default: 4956 break; 4957 } 4958 } 4959 return UINT32_MAX; 4960} 4961 4962#pragma mark TagType 4963 4964bool 4965ClangASTContext::SetTagTypeKind (clang_type_t tag_clang_type, int kind) 4966{ 4967 if (tag_clang_type) 4968 { 4969 QualType tag_qual_type(QualType::getFromOpaquePtr(tag_clang_type)); 4970 const clang::Type *clang_type = tag_qual_type.getTypePtr(); 4971 if (clang_type) 4972 { 4973 const TagType *tag_type = dyn_cast<TagType>(clang_type); 4974 if (tag_type) 4975 { 4976 TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl()); 4977 if (tag_decl) 4978 { 4979 tag_decl->setTagKind ((TagDecl::TagKind)kind); 4980 return true; 4981 } 4982 } 4983 } 4984 } 4985 return false; 4986} 4987 4988 4989#pragma mark DeclContext Functions 4990 4991DeclContext * 4992ClangASTContext::GetDeclContextForType (clang_type_t clang_type) 4993{ 4994 if (clang_type == NULL) 4995 return NULL; 4996 4997 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 4998 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 4999 switch (type_class) 5000 { 5001 case clang::Type::UnaryTransform: break; 5002 case clang::Type::FunctionNoProto: break; 5003 case clang::Type::FunctionProto: break; 5004 case clang::Type::IncompleteArray: break; 5005 case clang::Type::VariableArray: break; 5006 case clang::Type::ConstantArray: break; 5007 case clang::Type::DependentSizedArray: break; 5008 case clang::Type::ExtVector: break; 5009 case clang::Type::DependentSizedExtVector: break; 5010 case clang::Type::Vector: break; 5011 case clang::Type::Builtin: break; 5012 case clang::Type::BlockPointer: break; 5013 case clang::Type::Pointer: break; 5014 case clang::Type::LValueReference: break; 5015 case clang::Type::RValueReference: break; 5016 case clang::Type::MemberPointer: break; 5017 case clang::Type::Complex: break; 5018 case clang::Type::ObjCObject: break; 5019 case clang::Type::ObjCInterface: return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface(); 5020 case clang::Type::ObjCObjectPointer: return ClangASTContext::GetDeclContextForType (cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr()); 5021 case clang::Type::Record: return cast<RecordType>(qual_type)->getDecl(); 5022 case clang::Type::Enum: return cast<EnumType>(qual_type)->getDecl(); 5023 case clang::Type::Typedef: return ClangASTContext::GetDeclContextForType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 5024 case clang::Type::Elaborated: return ClangASTContext::GetDeclContextForType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 5025 case clang::Type::TypeOfExpr: break; 5026 case clang::Type::TypeOf: break; 5027 case clang::Type::Decltype: break; 5028 //case clang::Type::QualifiedName: break; 5029 case clang::Type::TemplateSpecialization: break; 5030 case clang::Type::DependentTemplateSpecialization: break; 5031 case clang::Type::TemplateTypeParm: break; 5032 case clang::Type::SubstTemplateTypeParm: break; 5033 case clang::Type::SubstTemplateTypeParmPack:break; 5034 case clang::Type::PackExpansion: break; 5035 case clang::Type::UnresolvedUsing: break; 5036 case clang::Type::Paren: break; 5037 case clang::Type::Attributed: break; 5038 case clang::Type::Auto: break; 5039 case clang::Type::InjectedClassName: break; 5040 case clang::Type::DependentName: break; 5041 case clang::Type::Atomic: break; 5042 } 5043 // No DeclContext in this type... 5044 return NULL; 5045} 5046 5047#pragma mark Namespace Declarations 5048 5049NamespaceDecl * 5050ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx) 5051{ 5052 NamespaceDecl *namespace_decl = NULL; 5053 ASTContext *ast = getASTContext(); 5054 TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl (); 5055 if (decl_ctx == NULL) 5056 decl_ctx = translation_unit_decl; 5057 5058 if (name) 5059 { 5060 IdentifierInfo &identifier_info = ast->Idents.get(name); 5061 DeclarationName decl_name (&identifier_info); 5062 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); 5063 for (clang::DeclContext::lookup_iterator pos = result.first, end = result.second; pos != end; ++pos) 5064 { 5065 namespace_decl = dyn_cast<clang::NamespaceDecl>(*pos); 5066 if (namespace_decl) 5067 return namespace_decl; 5068 } 5069 5070 namespace_decl = NamespaceDecl::Create(*ast, 5071 decl_ctx, 5072 false, 5073 SourceLocation(), 5074 SourceLocation(), 5075 &identifier_info, 5076 NULL); 5077 5078 decl_ctx->addDecl (namespace_decl); 5079 } 5080 else 5081 { 5082 if (decl_ctx == translation_unit_decl) 5083 { 5084 namespace_decl = translation_unit_decl->getAnonymousNamespace(); 5085 if (namespace_decl) 5086 return namespace_decl; 5087 5088 namespace_decl = NamespaceDecl::Create(*ast, 5089 decl_ctx, 5090 false, 5091 SourceLocation(), 5092 SourceLocation(), 5093 NULL, 5094 NULL); 5095 translation_unit_decl->setAnonymousNamespace (namespace_decl); 5096 translation_unit_decl->addDecl (namespace_decl); 5097 assert (namespace_decl == translation_unit_decl->getAnonymousNamespace()); 5098 } 5099 else 5100 { 5101 NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx); 5102 if (parent_namespace_decl) 5103 { 5104 namespace_decl = parent_namespace_decl->getAnonymousNamespace(); 5105 if (namespace_decl) 5106 return namespace_decl; 5107 namespace_decl = NamespaceDecl::Create(*ast, 5108 decl_ctx, 5109 false, 5110 SourceLocation(), 5111 SourceLocation(), 5112 NULL, 5113 NULL); 5114 parent_namespace_decl->setAnonymousNamespace (namespace_decl); 5115 parent_namespace_decl->addDecl (namespace_decl); 5116 assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace()); 5117 } 5118 else 5119 { 5120 // BAD!!! 5121 } 5122 } 5123 5124 5125 if (namespace_decl) 5126 { 5127 // If we make it here, we are creating the anonymous namespace decl 5128 // for the first time, so we need to do the using directive magic 5129 // like SEMA does 5130 UsingDirectiveDecl* using_directive_decl = UsingDirectiveDecl::Create (*ast, 5131 decl_ctx, 5132 SourceLocation(), 5133 SourceLocation(), 5134 NestedNameSpecifierLoc(), 5135 SourceLocation(), 5136 namespace_decl, 5137 decl_ctx); 5138 using_directive_decl->setImplicit(); 5139 decl_ctx->addDecl(using_directive_decl); 5140 } 5141 } 5142#ifdef LLDB_CONFIGURATION_DEBUG 5143 VerifyDecl(namespace_decl); 5144#endif 5145 return namespace_decl; 5146} 5147 5148 5149#pragma mark Function Types 5150 5151FunctionDecl * 5152ClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx, const char *name, clang_type_t function_clang_type, int storage, bool is_inline) 5153{ 5154 FunctionDecl *func_decl = NULL; 5155 ASTContext *ast = getASTContext(); 5156 if (decl_ctx == NULL) 5157 decl_ctx = ast->getTranslationUnitDecl(); 5158 5159 if (name && name[0]) 5160 { 5161 func_decl = FunctionDecl::Create (*ast, 5162 decl_ctx, 5163 SourceLocation(), 5164 SourceLocation(), 5165 DeclarationName (&ast->Idents.get(name)), 5166 QualType::getFromOpaquePtr(function_clang_type), 5167 NULL, 5168 (FunctionDecl::StorageClass)storage, 5169 (FunctionDecl::StorageClass)storage, 5170 is_inline); 5171 } 5172 else 5173 { 5174 func_decl = FunctionDecl::Create (*ast, 5175 decl_ctx, 5176 SourceLocation(), 5177 SourceLocation(), 5178 DeclarationName (), 5179 QualType::getFromOpaquePtr(function_clang_type), 5180 NULL, 5181 (FunctionDecl::StorageClass)storage, 5182 (FunctionDecl::StorageClass)storage, 5183 is_inline); 5184 } 5185 if (func_decl) 5186 decl_ctx->addDecl (func_decl); 5187 5188#ifdef LLDB_CONFIGURATION_DEBUG 5189 VerifyDecl(func_decl); 5190#endif 5191 5192 return func_decl; 5193} 5194 5195clang_type_t 5196ClangASTContext::CreateFunctionType (ASTContext *ast, 5197 clang_type_t result_type, 5198 clang_type_t *args, 5199 unsigned num_args, 5200 bool is_variadic, 5201 unsigned type_quals) 5202{ 5203 assert (ast != NULL); 5204 std::vector<QualType> qual_type_args; 5205 for (unsigned i=0; i<num_args; ++i) 5206 qual_type_args.push_back (QualType::getFromOpaquePtr(args[i])); 5207 5208 // TODO: Detect calling convention in DWARF? 5209 FunctionProtoType::ExtProtoInfo proto_info; 5210 proto_info.Variadic = is_variadic; 5211 proto_info.ExceptionSpecType = EST_None; 5212 proto_info.TypeQuals = type_quals; 5213 proto_info.RefQualifier = RQ_None; 5214 proto_info.NumExceptions = 0; 5215 proto_info.Exceptions = NULL; 5216 5217 return ast->getFunctionType (QualType::getFromOpaquePtr(result_type), 5218 qual_type_args.empty() ? NULL : &qual_type_args.front(), 5219 qual_type_args.size(), 5220 proto_info).getAsOpaquePtr(); // NoReturn); 5221} 5222 5223ParmVarDecl * 5224ClangASTContext::CreateParameterDeclaration (const char *name, clang_type_t param_type, int storage) 5225{ 5226 ASTContext *ast = getASTContext(); 5227 assert (ast != NULL); 5228 return ParmVarDecl::Create(*ast, 5229 ast->getTranslationUnitDecl(), 5230 SourceLocation(), 5231 SourceLocation(), 5232 name && name[0] ? &ast->Idents.get(name) : NULL, 5233 QualType::getFromOpaquePtr(param_type), 5234 NULL, 5235 (VarDecl::StorageClass)storage, 5236 (VarDecl::StorageClass)storage, 5237 0); 5238} 5239 5240void 5241ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params) 5242{ 5243 if (function_decl) 5244 function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params)); 5245} 5246 5247 5248#pragma mark Array Types 5249 5250clang_type_t 5251ClangASTContext::CreateArrayType (clang_type_t element_type, size_t element_count, uint32_t bit_stride) 5252{ 5253 if (element_type) 5254 { 5255 ASTContext *ast = getASTContext(); 5256 assert (ast != NULL); 5257 llvm::APInt ap_element_count (64, element_count); 5258 return ast->getConstantArrayType(QualType::getFromOpaquePtr(element_type), 5259 ap_element_count, 5260 ArrayType::Normal, 5261 0).getAsOpaquePtr(); // ElemQuals 5262 } 5263 return NULL; 5264} 5265 5266 5267#pragma mark TagDecl 5268 5269bool 5270ClangASTContext::StartTagDeclarationDefinition (clang_type_t clang_type) 5271{ 5272 if (clang_type) 5273 { 5274 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5275 const clang::Type *t = qual_type.getTypePtr(); 5276 if (t) 5277 { 5278 const TagType *tag_type = dyn_cast<TagType>(t); 5279 if (tag_type) 5280 { 5281 TagDecl *tag_decl = tag_type->getDecl(); 5282 if (tag_decl) 5283 { 5284 tag_decl->startDefinition(); 5285 return true; 5286 } 5287 } 5288 5289 const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(t); 5290 if (object_type) 5291 { 5292 ObjCInterfaceDecl *interface_decl = object_type->getInterface(); 5293 if (interface_decl) 5294 { 5295 interface_decl->startDefinition(); 5296 return true; 5297 } 5298 } 5299 } 5300 } 5301 return false; 5302} 5303 5304bool 5305ClangASTContext::CompleteTagDeclarationDefinition (clang_type_t clang_type) 5306{ 5307 if (clang_type) 5308 { 5309 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5310 5311 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 5312 5313 if (cxx_record_decl) 5314 { 5315 cxx_record_decl->completeDefinition(); 5316 5317 return true; 5318 } 5319 5320 const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr()); 5321 5322 if (enum_type) 5323 { 5324 EnumDecl *enum_decl = enum_type->getDecl(); 5325 5326 if (enum_decl) 5327 { 5328 /// TODO This really needs to be fixed. 5329 5330 unsigned NumPositiveBits = 1; 5331 unsigned NumNegativeBits = 0; 5332 5333 ASTContext *ast = getASTContext(); 5334 5335 QualType promotion_qual_type; 5336 // If the enum integer type is less than an integer in bit width, 5337 // then we must promote it to an integer size. 5338 if (ast->getTypeSize(enum_decl->getIntegerType()) < ast->getTypeSize(ast->IntTy)) 5339 { 5340 if (enum_decl->getIntegerType()->isSignedIntegerType()) 5341 promotion_qual_type = ast->IntTy; 5342 else 5343 promotion_qual_type = ast->UnsignedIntTy; 5344 } 5345 else 5346 promotion_qual_type = enum_decl->getIntegerType(); 5347 5348 enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits); 5349 return true; 5350 } 5351 } 5352 } 5353 return false; 5354} 5355 5356 5357#pragma mark Enumeration Types 5358 5359clang_type_t 5360ClangASTContext::CreateEnumerationType 5361( 5362 const char *name, 5363 DeclContext *decl_ctx, 5364 const Declaration &decl, 5365 clang_type_t integer_qual_type 5366) 5367{ 5368 // TODO: Do something intelligent with the Declaration object passed in 5369 // like maybe filling in the SourceLocation with it... 5370 ASTContext *ast = getASTContext(); 5371 assert (ast != NULL); 5372 5373 // TODO: ask about these... 5374// const bool IsScoped = false; 5375// const bool IsFixed = false; 5376 5377 EnumDecl *enum_decl = EnumDecl::Create (*ast, 5378 decl_ctx, 5379 SourceLocation(), 5380 SourceLocation(), 5381 name && name[0] ? &ast->Idents.get(name) : NULL, 5382 NULL, 5383 false, // IsScoped 5384 false, // IsScopedUsingClassTag 5385 false); // IsFixed 5386 5387 5388 if (enum_decl) 5389 { 5390 // TODO: check if we should be setting the promotion type too? 5391 enum_decl->setIntegerType(QualType::getFromOpaquePtr (integer_qual_type)); 5392 5393 enum_decl->setAccess(AS_public); // TODO respect what's in the debug info 5394 5395 return ast->getTagDeclType(enum_decl).getAsOpaquePtr(); 5396 } 5397 return NULL; 5398} 5399 5400clang_type_t 5401ClangASTContext::GetEnumerationIntegerType (clang_type_t enum_clang_type) 5402{ 5403 QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type)); 5404 5405 const clang::Type *clang_type = enum_qual_type.getTypePtr(); 5406 if (clang_type) 5407 { 5408 const EnumType *enum_type = dyn_cast<EnumType>(clang_type); 5409 if (enum_type) 5410 { 5411 EnumDecl *enum_decl = enum_type->getDecl(); 5412 if (enum_decl) 5413 return enum_decl->getIntegerType().getAsOpaquePtr(); 5414 } 5415 } 5416 return NULL; 5417} 5418bool 5419ClangASTContext::AddEnumerationValueToEnumerationType 5420( 5421 clang_type_t enum_clang_type, 5422 clang_type_t enumerator_clang_type, 5423 const Declaration &decl, 5424 const char *name, 5425 int64_t enum_value, 5426 uint32_t enum_value_bit_size 5427) 5428{ 5429 if (enum_clang_type && enumerator_clang_type && name) 5430 { 5431 // TODO: Do something intelligent with the Declaration object passed in 5432 // like maybe filling in the SourceLocation with it... 5433 ASTContext *ast = getASTContext(); 5434 IdentifierTable *identifier_table = getIdentifierTable(); 5435 5436 assert (ast != NULL); 5437 assert (identifier_table != NULL); 5438 QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type)); 5439 5440 const clang::Type *clang_type = enum_qual_type.getTypePtr(); 5441 if (clang_type) 5442 { 5443 const EnumType *enum_type = dyn_cast<EnumType>(clang_type); 5444 5445 if (enum_type) 5446 { 5447 llvm::APSInt enum_llvm_apsint(enum_value_bit_size, false); 5448 enum_llvm_apsint = enum_value; 5449 EnumConstantDecl *enumerator_decl = 5450 EnumConstantDecl::Create (*ast, 5451 enum_type->getDecl(), 5452 SourceLocation(), 5453 name ? &identifier_table->get(name) : NULL, // Identifier 5454 QualType::getFromOpaquePtr(enumerator_clang_type), 5455 NULL, 5456 enum_llvm_apsint); 5457 5458 if (enumerator_decl) 5459 { 5460 enum_type->getDecl()->addDecl(enumerator_decl); 5461 5462#ifdef LLDB_CONFIGURATION_DEBUG 5463 VerifyDecl(enumerator_decl); 5464#endif 5465 5466 return true; 5467 } 5468 } 5469 } 5470 } 5471 return false; 5472} 5473 5474#pragma mark Pointers & References 5475 5476clang_type_t 5477ClangASTContext::CreatePointerType (clang_type_t clang_type) 5478{ 5479 return CreatePointerType (getASTContext(), clang_type); 5480} 5481 5482clang_type_t 5483ClangASTContext::CreatePointerType (clang::ASTContext *ast, clang_type_t clang_type) 5484{ 5485 if (ast && clang_type) 5486 { 5487 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5488 5489 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5490 switch (type_class) 5491 { 5492 case clang::Type::ObjCObject: 5493 case clang::Type::ObjCInterface: 5494 return ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr(); 5495 5496 default: 5497 return ast->getPointerType(qual_type).getAsOpaquePtr(); 5498 } 5499 } 5500 return NULL; 5501} 5502 5503clang_type_t 5504ClangASTContext::CreateLValueReferenceType (clang::ASTContext *ast, 5505 clang_type_t clang_type) 5506{ 5507 if (clang_type) 5508 return ast->getLValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr(); 5509 return NULL; 5510} 5511 5512clang_type_t 5513ClangASTContext::CreateRValueReferenceType (clang::ASTContext *ast, 5514 clang_type_t clang_type) 5515{ 5516 if (clang_type) 5517 return ast->getRValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr(); 5518 return NULL; 5519} 5520 5521clang_type_t 5522ClangASTContext::CreateMemberPointerType (clang_type_t clang_pointee_type, clang_type_t clang_class_type) 5523{ 5524 if (clang_pointee_type && clang_pointee_type) 5525 return getASTContext()->getMemberPointerType(QualType::getFromOpaquePtr(clang_pointee_type), 5526 QualType::getFromOpaquePtr(clang_class_type).getTypePtr()).getAsOpaquePtr(); 5527 return NULL; 5528} 5529 5530uint32_t 5531ClangASTContext::GetPointerBitSize () 5532{ 5533 ASTContext *ast = getASTContext(); 5534 return ast->getTypeSize(ast->VoidPtrTy); 5535} 5536 5537bool 5538ClangASTContext::IsPossibleDynamicType (clang::ASTContext *ast, 5539 clang_type_t clang_type, 5540 clang_type_t *dynamic_pointee_type, 5541 bool check_cplusplus, 5542 bool check_objc) 5543{ 5544 QualType pointee_qual_type; 5545 if (clang_type) 5546 { 5547 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5548 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5549 bool success = false; 5550 switch (type_class) 5551 { 5552 case clang::Type::Builtin: 5553 if (check_objc && cast<clang::BuiltinType>(qual_type)->getKind() == clang::BuiltinType::ObjCId) 5554 { 5555 if (dynamic_pointee_type) 5556 *dynamic_pointee_type = clang_type; 5557 return true; 5558 } 5559 break; 5560 5561 case clang::Type::ObjCObjectPointer: 5562 if (check_objc) 5563 { 5564 if (dynamic_pointee_type) 5565 *dynamic_pointee_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5566 return true; 5567 } 5568 break; 5569 5570 case clang::Type::Pointer: 5571 pointee_qual_type = cast<PointerType>(qual_type)->getPointeeType(); 5572 success = true; 5573 break; 5574 5575 case clang::Type::LValueReference: 5576 case clang::Type::RValueReference: 5577 pointee_qual_type = cast<ReferenceType>(qual_type)->getPointeeType(); 5578 success = true; 5579 break; 5580 5581 case clang::Type::Typedef: 5582 return ClangASTContext::IsPossibleDynamicType (ast, 5583 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 5584 dynamic_pointee_type, 5585 check_cplusplus, 5586 check_objc); 5587 5588 case clang::Type::Elaborated: 5589 return ClangASTContext::IsPossibleDynamicType (ast, 5590 cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), 5591 dynamic_pointee_type, 5592 check_cplusplus, 5593 check_objc); 5594 5595 default: 5596 break; 5597 } 5598 5599 if (success) 5600 { 5601 // Check to make sure what we are pointing too is a possible dynamic C++ type 5602 // We currently accept any "void *" (in case we have a class that has been 5603 // watered down to an opaque pointer) and virtual C++ classes. 5604 const clang::Type::TypeClass pointee_type_class = pointee_qual_type->getTypeClass(); 5605 switch (pointee_type_class) 5606 { 5607 case clang::Type::Builtin: 5608 switch (cast<clang::BuiltinType>(pointee_qual_type)->getKind()) 5609 { 5610 case clang::BuiltinType::UnknownAny: 5611 case clang::BuiltinType::Void: 5612 if (dynamic_pointee_type) 5613 *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr(); 5614 return true; 5615 5616 case clang::BuiltinType::NullPtr: 5617 case clang::BuiltinType::Bool: 5618 case clang::BuiltinType::Char_U: 5619 case clang::BuiltinType::UChar: 5620 case clang::BuiltinType::WChar_U: 5621 case clang::BuiltinType::Char16: 5622 case clang::BuiltinType::Char32: 5623 case clang::BuiltinType::UShort: 5624 case clang::BuiltinType::UInt: 5625 case clang::BuiltinType::ULong: 5626 case clang::BuiltinType::ULongLong: 5627 case clang::BuiltinType::UInt128: 5628 case clang::BuiltinType::Char_S: 5629 case clang::BuiltinType::SChar: 5630 case clang::BuiltinType::WChar_S: 5631 case clang::BuiltinType::Short: 5632 case clang::BuiltinType::Int: 5633 case clang::BuiltinType::Long: 5634 case clang::BuiltinType::LongLong: 5635 case clang::BuiltinType::Int128: 5636 case clang::BuiltinType::Float: 5637 case clang::BuiltinType::Double: 5638 case clang::BuiltinType::LongDouble: 5639 case clang::BuiltinType::Dependent: 5640 case clang::BuiltinType::Overload: 5641 case clang::BuiltinType::ObjCId: 5642 case clang::BuiltinType::ObjCClass: 5643 case clang::BuiltinType::ObjCSel: 5644 case clang::BuiltinType::BoundMember: 5645 case clang::BuiltinType::Half: 5646 case clang::BuiltinType::ARCUnbridgedCast: 5647 case clang::BuiltinType::PseudoObject: 5648 case clang::BuiltinType::BuiltinFn: 5649 break; 5650 } 5651 break; 5652 5653 case clang::Type::Record: 5654 if (check_cplusplus) 5655 { 5656 CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl(); 5657 if (cxx_record_decl) 5658 { 5659 bool is_complete = cxx_record_decl->isCompleteDefinition(); 5660 if (!is_complete) 5661 is_complete = ClangASTContext::GetCompleteType (ast, pointee_qual_type.getAsOpaquePtr()); 5662 5663 if (is_complete) 5664 { 5665 success = cxx_record_decl->isDynamicClass(); 5666 } 5667 else 5668 { 5669 success = false; 5670 } 5671 5672 if (success) 5673 { 5674 if (dynamic_pointee_type) 5675 *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr(); 5676 return true; 5677 } 5678 } 5679 } 5680 break; 5681 5682 case clang::Type::ObjCObject: 5683 case clang::Type::ObjCInterface: 5684 if (check_objc) 5685 { 5686 if (dynamic_pointee_type) 5687 *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr(); 5688 return true; 5689 } 5690 break; 5691 5692 default: 5693 break; 5694 } 5695 } 5696 } 5697 if (dynamic_pointee_type) 5698 *dynamic_pointee_type = NULL; 5699 return false; 5700} 5701 5702 5703bool 5704ClangASTContext::IsPossibleCPlusPlusDynamicType (clang::ASTContext *ast, clang_type_t clang_type, clang_type_t *dynamic_pointee_type) 5705{ 5706 return IsPossibleDynamicType (ast, 5707 clang_type, 5708 dynamic_pointee_type, 5709 true, // Check for dynamic C++ types 5710 false); // Check for dynamic ObjC types 5711} 5712 5713bool 5714ClangASTContext::IsReferenceType (clang_type_t clang_type, clang_type_t *target_type) 5715{ 5716 if (clang_type == NULL) 5717 return false; 5718 5719 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5720 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5721 5722 switch (type_class) 5723 { 5724 case clang::Type::LValueReference: 5725 if (target_type) 5726 *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr(); 5727 return true; 5728 case clang::Type::RValueReference: 5729 if (target_type) 5730 *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr(); 5731 return true; 5732 case clang::Type::Typedef: 5733 return ClangASTContext::IsReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 5734 case clang::Type::Elaborated: 5735 return ClangASTContext::IsReferenceType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 5736 default: 5737 break; 5738 } 5739 5740 return false; 5741} 5742 5743bool 5744ClangASTContext::IsPointerOrReferenceType (clang_type_t clang_type, clang_type_t*target_type) 5745{ 5746 if (clang_type == NULL) 5747 return false; 5748 5749 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5750 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5751 switch (type_class) 5752 { 5753 case clang::Type::Builtin: 5754 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 5755 { 5756 default: 5757 break; 5758 case clang::BuiltinType::ObjCId: 5759 case clang::BuiltinType::ObjCClass: 5760 return true; 5761 } 5762 return false; 5763 case clang::Type::ObjCObjectPointer: 5764 if (target_type) 5765 *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5766 return true; 5767 case clang::Type::BlockPointer: 5768 if (target_type) 5769 *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5770 return true; 5771 case clang::Type::Pointer: 5772 if (target_type) 5773 *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5774 return true; 5775 case clang::Type::MemberPointer: 5776 if (target_type) 5777 *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5778 return true; 5779 case clang::Type::LValueReference: 5780 if (target_type) 5781 *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr(); 5782 return true; 5783 case clang::Type::RValueReference: 5784 if (target_type) 5785 *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr(); 5786 return true; 5787 case clang::Type::Typedef: 5788 return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 5789 case clang::Type::Elaborated: 5790 return ClangASTContext::IsPointerOrReferenceType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 5791 default: 5792 break; 5793 } 5794 return false; 5795} 5796 5797bool 5798ClangASTContext::IsIntegerType (clang_type_t clang_type, bool &is_signed) 5799{ 5800 if (!clang_type) 5801 return false; 5802 5803 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5804 const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()); 5805 5806 if (builtin_type) 5807 { 5808 if (builtin_type->isInteger()) 5809 { 5810 is_signed = builtin_type->isSignedInteger(); 5811 return true; 5812 } 5813 } 5814 5815 return false; 5816} 5817 5818bool 5819ClangASTContext::IsPointerType (clang_type_t clang_type, clang_type_t *target_type) 5820{ 5821 if (target_type) 5822 *target_type = NULL; 5823 5824 if (clang_type) 5825 { 5826 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5827 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5828 switch (type_class) 5829 { 5830 case clang::Type::Builtin: 5831 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 5832 { 5833 default: 5834 break; 5835 case clang::BuiltinType::ObjCId: 5836 case clang::BuiltinType::ObjCClass: 5837 return true; 5838 } 5839 return false; 5840 case clang::Type::ObjCObjectPointer: 5841 if (target_type) 5842 *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5843 return true; 5844 case clang::Type::BlockPointer: 5845 if (target_type) 5846 *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5847 return true; 5848 case clang::Type::Pointer: 5849 if (target_type) 5850 *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5851 return true; 5852 case clang::Type::MemberPointer: 5853 if (target_type) 5854 *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr(); 5855 return true; 5856 case clang::Type::Typedef: 5857 return ClangASTContext::IsPointerType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), target_type); 5858 case clang::Type::Elaborated: 5859 return ClangASTContext::IsPointerType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), target_type); 5860 default: 5861 break; 5862 } 5863 } 5864 return false; 5865} 5866 5867bool 5868ClangASTContext::IsFloatingPointType (clang_type_t clang_type, uint32_t &count, bool &is_complex) 5869{ 5870 if (clang_type) 5871 { 5872 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5873 5874 if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal())) 5875 { 5876 clang::BuiltinType::Kind kind = BT->getKind(); 5877 if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble) 5878 { 5879 count = 1; 5880 is_complex = false; 5881 return true; 5882 } 5883 } 5884 else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal())) 5885 { 5886 if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count, is_complex)) 5887 { 5888 count = 2; 5889 is_complex = true; 5890 return true; 5891 } 5892 } 5893 else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal())) 5894 { 5895 if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count, is_complex)) 5896 { 5897 count = VT->getNumElements(); 5898 is_complex = false; 5899 return true; 5900 } 5901 } 5902 } 5903 return false; 5904} 5905 5906bool 5907ClangASTContext::IsScalarType (lldb::clang_type_t clang_type) 5908{ 5909 bool is_signed; 5910 if (ClangASTContext::IsIntegerType(clang_type, is_signed)) 5911 return true; 5912 5913 uint32_t count; 5914 bool is_complex; 5915 return ClangASTContext::IsFloatingPointType(clang_type, count, is_complex) && !is_complex; 5916} 5917 5918bool 5919ClangASTContext::IsPointerToScalarType (lldb::clang_type_t clang_type) 5920{ 5921 if (!IsPointerType(clang_type)) 5922 return false; 5923 5924 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5925 lldb::clang_type_t pointee_type = qual_type.getTypePtr()->getPointeeType().getAsOpaquePtr(); 5926 return IsScalarType(pointee_type); 5927} 5928 5929bool 5930ClangASTContext::IsArrayOfScalarType (lldb::clang_type_t clang_type) 5931{ 5932 clang_type = GetAsArrayType(clang_type); 5933 5934 if (clang_type == 0) 5935 return false; 5936 5937 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5938 lldb::clang_type_t item_type = cast<ArrayType>(qual_type.getTypePtr())->getElementType().getAsOpaquePtr(); 5939 return IsScalarType(item_type); 5940} 5941 5942 5943bool 5944ClangASTContext::GetCXXClassName (clang_type_t clang_type, std::string &class_name) 5945{ 5946 if (clang_type) 5947 { 5948 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5949 5950 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 5951 if (cxx_record_decl) 5952 { 5953 class_name.assign (cxx_record_decl->getIdentifier()->getNameStart()); 5954 return true; 5955 } 5956 } 5957 class_name.clear(); 5958 return false; 5959} 5960 5961 5962bool 5963ClangASTContext::IsCXXClassType (clang_type_t clang_type) 5964{ 5965 if (clang_type) 5966 { 5967 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5968 if (qual_type->getAsCXXRecordDecl() != NULL) 5969 return true; 5970 } 5971 return false; 5972} 5973 5974bool 5975ClangASTContext::IsBeingDefined (lldb::clang_type_t clang_type) 5976{ 5977 if (clang_type) 5978 { 5979 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5980 const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type); 5981 if (tag_type) 5982 return tag_type->isBeingDefined(); 5983 } 5984 return false; 5985} 5986 5987bool 5988ClangASTContext::IsObjCClassType (clang_type_t clang_type) 5989{ 5990 if (clang_type) 5991 { 5992 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 5993 if (qual_type->isObjCObjectOrInterfaceType()) 5994 return true; 5995 } 5996 return false; 5997} 5998 5999bool 6000ClangASTContext::IsObjCObjectPointerType (lldb::clang_type_t clang_type, clang_type_t *class_type) 6001{ 6002 if (clang_type) 6003 { 6004 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 6005 if (qual_type->isObjCObjectPointerType()) 6006 { 6007 if (class_type) 6008 { 6009 *class_type = NULL; 6010 6011 if (!qual_type->isObjCClassType() && 6012 !qual_type->isObjCIdType()) 6013 { 6014 const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type); 6015 if (!obj_pointer_type) 6016 *class_type = NULL; 6017 else 6018 *class_type = QualType(obj_pointer_type->getInterfaceType(), 0).getAsOpaquePtr(); 6019 } 6020 } 6021 return true; 6022 } 6023 } 6024 return false; 6025} 6026 6027bool 6028ClangASTContext::GetObjCClassName (lldb::clang_type_t clang_type, 6029 std::string &class_name) 6030{ 6031 if (!clang_type) 6032 return false; 6033 6034 const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(QualType::getFromOpaquePtr(clang_type)); 6035 if (!object_type) 6036 return false; 6037 6038 const ObjCInterfaceDecl *interface = object_type->getInterface(); 6039 if (!interface) 6040 return false; 6041 6042 class_name = interface->getNameAsString(); 6043 return true; 6044} 6045 6046bool 6047ClangASTContext::IsCharType (clang_type_t clang_type) 6048{ 6049 if (clang_type) 6050 return QualType::getFromOpaquePtr(clang_type)->isCharType(); 6051 return false; 6052} 6053 6054bool 6055ClangASTContext::IsCStringType (clang_type_t clang_type, uint32_t &length) 6056{ 6057 clang_type_t pointee_or_element_clang_type = NULL; 6058 Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, NULL, &pointee_or_element_clang_type)); 6059 6060 if (pointee_or_element_clang_type == NULL) 6061 return false; 6062 6063 if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer)) 6064 { 6065 QualType pointee_or_element_qual_type (QualType::getFromOpaquePtr (pointee_or_element_clang_type)); 6066 6067 if (pointee_or_element_qual_type.getUnqualifiedType()->isCharType()) 6068 { 6069 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 6070 if (type_flags.Test (eTypeIsArray)) 6071 { 6072 // We know the size of the array and it could be a C string 6073 // since it is an array of characters 6074 length = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue(); 6075 return true; 6076 } 6077 else 6078 { 6079 length = 0; 6080 return true; 6081 } 6082 6083 } 6084 } 6085 return false; 6086} 6087 6088bool 6089ClangASTContext::IsFunctionPointerType (clang_type_t clang_type) 6090{ 6091 if (clang_type) 6092 { 6093 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 6094 6095 if (qual_type->isFunctionPointerType()) 6096 return true; 6097 6098 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 6099 switch (type_class) 6100 { 6101 default: 6102 break; 6103 case clang::Type::Typedef: 6104 return ClangASTContext::IsFunctionPointerType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 6105 case clang::Type::Elaborated: 6106 return ClangASTContext::IsFunctionPointerType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 6107 6108 case clang::Type::LValueReference: 6109 case clang::Type::RValueReference: 6110 { 6111 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 6112 if (reference_type) 6113 return ClangASTContext::IsFunctionPointerType (reference_type->getPointeeType().getAsOpaquePtr()); 6114 } 6115 break; 6116 } 6117 } 6118 return false; 6119} 6120 6121size_t 6122ClangASTContext::GetArraySize (clang_type_t clang_type) 6123{ 6124 if (clang_type) 6125 { 6126 QualType qual_type(QualType::getFromOpaquePtr(clang_type)); 6127 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 6128 switch (type_class) 6129 { 6130 case clang::Type::ConstantArray: 6131 { 6132 const ConstantArrayType *array = cast<ConstantArrayType>(QualType::getFromOpaquePtr(clang_type).getTypePtr()); 6133 if (array) 6134 return array->getSize().getLimitedValue(); 6135 } 6136 break; 6137 6138 case clang::Type::Typedef: 6139 return ClangASTContext::GetArraySize(cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); 6140 6141 case clang::Type::Elaborated: 6142 return ClangASTContext::GetArraySize(cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); 6143 6144 default: 6145 break; 6146 } 6147 } 6148 return 0; 6149} 6150 6151clang_type_t 6152ClangASTContext::GetAsArrayType (clang_type_t clang_type, clang_type_t*member_type, uint64_t *size) 6153{ 6154 if (!clang_type) 6155 return 0; 6156 6157 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 6158 6159 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 6160 switch (type_class) 6161 { 6162 default: 6163 break; 6164 6165 case clang::Type::ConstantArray: 6166 if (member_type) 6167 *member_type = cast<ConstantArrayType>(qual_type)->getElementType().getAsOpaquePtr(); 6168 if (size) 6169 *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX); 6170 return clang_type; 6171 6172 case clang::Type::IncompleteArray: 6173 if (member_type) 6174 *member_type = cast<IncompleteArrayType>(qual_type)->getElementType().getAsOpaquePtr(); 6175 if (size) 6176 *size = 0; 6177 return clang_type; 6178 6179 case clang::Type::VariableArray: 6180 if (member_type) 6181 *member_type = cast<VariableArrayType>(qual_type)->getElementType().getAsOpaquePtr(); 6182 if (size) 6183 *size = 0; 6184 return clang_type; 6185 6186 case clang::Type::DependentSizedArray: 6187 if (member_type) 6188 *member_type = cast<DependentSizedArrayType>(qual_type)->getElementType().getAsOpaquePtr(); 6189 if (size) 6190 *size = 0; 6191 return clang_type; 6192 6193 case clang::Type::Typedef: 6194 return ClangASTContext::GetAsArrayType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), 6195 member_type, 6196 size); 6197 6198 case clang::Type::Elaborated: 6199 return ClangASTContext::GetAsArrayType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), 6200 member_type, 6201 size); 6202 } 6203 return 0; 6204} 6205 6206 6207#pragma mark Typedefs 6208 6209clang_type_t 6210ClangASTContext::CreateTypedefType (const char *name, clang_type_t clang_type, DeclContext *decl_ctx) 6211{ 6212 if (clang_type) 6213 { 6214 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 6215 ASTContext *ast = getASTContext(); 6216 IdentifierTable *identifier_table = getIdentifierTable(); 6217 assert (ast != NULL); 6218 assert (identifier_table != NULL); 6219 if (decl_ctx == NULL) 6220 decl_ctx = ast->getTranslationUnitDecl(); 6221 TypedefDecl *decl = TypedefDecl::Create (*ast, 6222 decl_ctx, 6223 SourceLocation(), 6224 SourceLocation(), 6225 name ? &identifier_table->get(name) : NULL, // Identifier 6226 ast->CreateTypeSourceInfo(qual_type)); 6227 6228 //decl_ctx->addDecl (decl); 6229 6230 decl->setAccess(AS_public); // TODO respect proper access specifier 6231 6232 // Get a uniqued QualType for the typedef decl type 6233 return ast->getTypedefType (decl).getAsOpaquePtr(); 6234 } 6235 return NULL; 6236} 6237 6238// Disable this for now since I can't seem to get a nicely formatted float 6239// out of the APFloat class without just getting the float, double or quad 6240// and then using a formatted print on it which defeats the purpose. We ideally 6241// would like to get perfect string values for any kind of float semantics 6242// so we can support remote targets. The code below also requires a patch to 6243// llvm::APInt. 6244//bool 6245//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, clang_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str) 6246//{ 6247// uint32_t count = 0; 6248// bool is_complex = false; 6249// if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex)) 6250// { 6251// unsigned num_bytes_per_float = byte_size / count; 6252// unsigned num_bits_per_float = num_bytes_per_float * 8; 6253// 6254// float_str.clear(); 6255// uint32_t i; 6256// for (i=0; i<count; i++) 6257// { 6258// APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order); 6259// bool is_ieee = false; 6260// APFloat ap_float(ap_int, is_ieee); 6261// char s[1024]; 6262// unsigned int hex_digits = 0; 6263// bool upper_case = false; 6264// 6265// if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0) 6266// { 6267// if (i > 0) 6268// float_str.append(", "); 6269// float_str.append(s); 6270// if (i == 1 && is_complex) 6271// float_str.append(1, 'i'); 6272// } 6273// } 6274// return !float_str.empty(); 6275// } 6276// return false; 6277//} 6278 6279size_t 6280ClangASTContext::ConvertStringToFloatValue (ASTContext *ast, clang_type_t clang_type, const char *s, uint8_t *dst, size_t dst_size) 6281{ 6282 if (clang_type) 6283 { 6284 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 6285 uint32_t count = 0; 6286 bool is_complex = false; 6287 if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex)) 6288 { 6289 // TODO: handle complex and vector types 6290 if (count != 1) 6291 return false; 6292 6293 StringRef s_sref(s); 6294 APFloat ap_float(ast->getFloatTypeSemantics(qual_type), s_sref); 6295 6296 const uint64_t bit_size = ast->getTypeSize (qual_type); 6297 const uint64_t byte_size = bit_size / 8; 6298 if (dst_size >= byte_size) 6299 { 6300 if (bit_size == sizeof(float)*8) 6301 { 6302 float float32 = ap_float.convertToFloat(); 6303 ::memcpy (dst, &float32, byte_size); 6304 return byte_size; 6305 } 6306 else if (bit_size >= 64) 6307 { 6308 llvm::APInt ap_int(ap_float.bitcastToAPInt()); 6309 ::memcpy (dst, ap_int.getRawData(), byte_size); 6310 return byte_size; 6311 } 6312 } 6313 } 6314 } 6315 return 0; 6316} 6317 6318unsigned 6319ClangASTContext::GetTypeQualifiers(clang_type_t clang_type) 6320{ 6321 assert (clang_type); 6322 6323 QualType qual_type (QualType::getFromOpaquePtr(clang_type)); 6324 6325 return qual_type.getQualifiers().getCVRQualifiers(); 6326} 6327 6328bool 6329ClangASTContext::GetCompleteType (clang::ASTContext *ast, lldb::clang_type_t clang_type) 6330{ 6331 if (clang_type == NULL) 6332 return false; 6333 6334 return GetCompleteQualType (ast, clang::QualType::getFromOpaquePtr(clang_type)); 6335} 6336 6337 6338bool 6339ClangASTContext::GetCompleteType (clang_type_t clang_type) 6340{ 6341 return ClangASTContext::GetCompleteType (getASTContext(), clang_type); 6342} 6343 6344bool 6345ClangASTContext::IsCompleteType (clang::ASTContext *ast, lldb::clang_type_t clang_type) 6346{ 6347 if (clang_type == NULL) 6348 return false; 6349 6350 return GetCompleteQualType (ast, clang::QualType::getFromOpaquePtr(clang_type), false); // just check but don't let it actually complete 6351} 6352 6353 6354bool 6355ClangASTContext::IsCompleteType (clang_type_t clang_type) 6356{ 6357 return ClangASTContext::IsCompleteType (getASTContext(), clang_type); 6358} 6359 6360bool 6361ClangASTContext::GetCompleteDecl (clang::ASTContext *ast, 6362 clang::Decl *decl) 6363{ 6364 if (!decl) 6365 return false; 6366 6367 ExternalASTSource *ast_source = ast->getExternalSource(); 6368 6369 if (!ast_source) 6370 return false; 6371 6372 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) 6373 { 6374 if (tag_decl->isCompleteDefinition()) 6375 return true; 6376 6377 if (!tag_decl->hasExternalLexicalStorage()) 6378 return false; 6379 6380 ast_source->CompleteType(tag_decl); 6381 6382 return !tag_decl->getTypeForDecl()->isIncompleteType(); 6383 } 6384 else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) 6385 { 6386 if (objc_interface_decl->getDefinition()) 6387 return true; 6388 6389 if (!objc_interface_decl->hasExternalLexicalStorage()) 6390 return false; 6391 6392 ast_source->CompleteType(objc_interface_decl); 6393 6394 return !objc_interface_decl->getTypeForDecl()->isIncompleteType(); 6395 } 6396 else 6397 { 6398 return false; 6399 } 6400} 6401 6402void 6403ClangASTContext::SetMetadata (clang::ASTContext *ast, 6404 uintptr_t object, 6405 uint64_t metadata) 6406{ 6407 ClangExternalASTSourceCommon *external_source = 6408 static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource()); 6409 6410 if (external_source) 6411 external_source->SetMetadata(object, metadata); 6412} 6413 6414uint64_t 6415ClangASTContext::GetMetadata (clang::ASTContext *ast, 6416 uintptr_t object) 6417{ 6418 ClangExternalASTSourceCommon *external_source = 6419 static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource()); 6420 6421 if (external_source && external_source->HasMetadata(object)) 6422 return external_source->GetMetadata(object); 6423 else 6424 return 0; 6425} 6426 6427clang::DeclContext * 6428ClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl) 6429{ 6430 return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl); 6431} 6432 6433clang::DeclContext * 6434ClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl) 6435{ 6436 return llvm::dyn_cast<clang::DeclContext>(objc_method_decl); 6437} 6438 6439 6440bool 6441ClangASTContext::GetClassMethodInfoForDeclContext (clang::DeclContext *decl_ctx, 6442 lldb::LanguageType &language, 6443 bool &is_instance_method, 6444 ConstString &language_object_name) 6445{ 6446 language_object_name.Clear(); 6447 language = eLanguageTypeUnknown; 6448 is_instance_method = false; 6449 6450 if (decl_ctx) 6451 { 6452 if (clang::CXXMethodDecl *method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx)) 6453 { 6454 if (method_decl->isStatic()) 6455 { 6456 is_instance_method = false; 6457 } 6458 else 6459 { 6460 language_object_name.SetCString("this"); 6461 is_instance_method = true; 6462 } 6463 language = eLanguageTypeC_plus_plus; 6464 return true; 6465 } 6466 else if (clang::ObjCMethodDecl *method_decl = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx)) 6467 { 6468 // Both static and instance methods have a "self" object in objective C 6469 language_object_name.SetCString("self"); 6470 if (method_decl->isInstanceMethod()) 6471 { 6472 is_instance_method = true; 6473 } 6474 else 6475 { 6476 is_instance_method = false; 6477 } 6478 language = eLanguageTypeObjC; 6479 return true; 6480 } 6481 } 6482 return false; 6483} 6484 6485