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