11 #include "llvm/Support/FormatAdapters.h"
12 #include "llvm/Support/FormatVariadic.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/ASTImporter.h"
20 #include "clang/AST/Attr.h"
21 #include "clang/AST/CXXInheritance.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Mangle.h"
25 #include "clang/AST/RecordLayout.h"
26 #include "clang/AST/Type.h"
27 #include "clang/AST/VTableBuilder.h"
28 #include "clang/Basic/Builtins.h"
29 #include "clang/Basic/Diagnostic.h"
30 #include "clang/Basic/FileManager.h"
31 #include "clang/Basic/FileSystemOptions.h"
32 #include "clang/Basic/LangStandard.h"
33 #include "clang/Basic/SourceManager.h"
34 #include "clang/Basic/TargetInfo.h"
35 #include "clang/Basic/TargetOptions.h"
36 #include "clang/Frontend/FrontendOptions.h"
37 #include "clang/Lex/HeaderSearch.h"
38 #include "clang/Lex/HeaderSearchOptions.h"
39 #include "clang/Lex/ModuleMap.h"
40 #include "clang/Sema/Sema.h"
42 #include "llvm/Support/Signals.h"
43 #include "llvm/Support/Threading.h"
84 using namespace clang;
85 using llvm::StringSwitch;
90 static void VerifyDecl(clang::Decl *decl) {
91 assert(decl &&
"VerifyDecl called with nullptr?");
118 bool isOverload(clang::CXXMethodDecl *m1, clang::CXXMethodDecl *m2) {
120 lldbassert(&m1->getASTContext() == &m2->getASTContext() &&
121 "Methods should have the same AST context");
122 clang::ASTContext &context = m1->getASTContext();
124 const auto *m1Type = llvm::cast<clang::FunctionProtoType>(
125 context.getCanonicalType(m1->getType()));
127 const auto *m2Type = llvm::cast<clang::FunctionProtoType>(
128 context.getCanonicalType(m2->getType()));
130 auto compareArgTypes = [&context](
const clang::QualType &m1p,
131 const clang::QualType &m2p) {
132 return context.hasSameType(m1p.getUnqualifiedType(),
133 m2p.getUnqualifiedType());
138 return (m1->getNumParams() != m2->getNumParams()) ||
139 !std::equal(m1Type->param_type_begin(), m1Type->param_type_end(),
140 m2Type->param_type_begin(), compareArgTypes);
146 void addOverridesForMethod(clang::CXXMethodDecl *decl) {
147 if (!decl->isVirtual())
150 clang::CXXBasePaths paths;
151 llvm::SmallVector<clang::NamedDecl *, 4> decls;
153 auto find_overridden_methods =
154 [&decls, decl](
const clang::CXXBaseSpecifier *specifier,
155 clang::CXXBasePath &path) {
156 if (
auto *base_record = llvm::dyn_cast<clang::CXXRecordDecl>(
157 specifier->getType()->castAs<clang::RecordType>()->getDecl())) {
159 clang::DeclarationName name = decl->getDeclName();
163 if (name.getNameKind() == clang::DeclarationName::CXXDestructorName)
164 if (
auto *baseDtorDecl = base_record->getDestructor()) {
165 if (baseDtorDecl->isVirtual()) {
166 decls.push_back(baseDtorDecl);
173 for (path.Decls = base_record->lookup(name).begin();
174 path.Decls != path.Decls.end(); ++path.Decls) {
175 if (
auto *method_decl =
176 llvm::dyn_cast<clang::CXXMethodDecl>(*path.Decls))
177 if (method_decl->isVirtual() && !isOverload(decl, method_decl)) {
178 decls.push_back(method_decl);
187 if (decl->getParent()->lookupInBases(find_overridden_methods, paths)) {
188 for (
auto *overridden_decl : decls)
189 decl->addOverriddenMethod(
190 llvm::cast<clang::CXXMethodDecl>(overridden_decl));
196 VTableContextBase &vtable_ctx,
198 const ASTRecordLayout &record_layout) {
207 bool ptr_or_ref =
false;
208 if (type_info & (eTypeIsPointer | eTypeIsReference)) {
214 const uint32_t cpp_class = eTypeIsClass | eTypeIsCPlusPlus;
215 if ((type_info & cpp_class) != cpp_class)
220 vtable_ctx.isMicrosoft() ? record_layout.getVBPtrOffset().getQuantity()
234 vbtable_ptr_addr += vbtable_ptr_offset;
245 auto size = valobj.
GetData(data, err);
253 VTableContextBase &vtable_ctx,
255 const CXXRecordDecl *cxx_record_decl,
256 const CXXRecordDecl *base_class_decl) {
257 if (vtable_ctx.isMicrosoft()) {
258 clang::MicrosoftVTableContext &msoft_vtable_ctx =
259 static_cast<clang::MicrosoftVTableContext &
>(vtable_ctx);
263 const unsigned vbtable_index =
264 msoft_vtable_ctx.getVBTableIndex(cxx_record_decl, base_class_decl);
265 const lldb::addr_t base_offset_addr = vtable_ptr + vbtable_index * 4;
271 clang::ItaniumVTableContext &itanium_vtable_ctx =
272 static_cast<clang::ItaniumVTableContext &
>(vtable_ctx);
274 clang::CharUnits base_offset_offset =
275 itanium_vtable_ctx.getVirtualBaseOffsetOffset(cxx_record_decl,
278 vtable_ptr + base_offset_offset.getQuantity();
287 const ASTRecordLayout &record_layout,
288 const CXXRecordDecl *cxx_record_decl,
289 const CXXRecordDecl *base_class_decl,
290 int32_t &bit_offset) {
302 *process, vtable_ctx, vtable_ptr, cxx_record_decl, base_class_decl);
303 if (base_offset == INT64_MAX)
306 bit_offset = base_offset * 8;
316 static llvm::once_flag g_once_flag;
317 llvm::call_once(g_once_flag, []() {
324 bool is_complete_objc_class)
325 : m_payload(owning_module.GetValue()) {
337 const clang::Decl *parent) {
338 if (!member || !parent)
345 member->setFromASTFile();
346 member->setOwningModuleID(
id.GetValue());
347 member->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
348 if (llvm::isa<clang::NamedDecl>(member))
349 if (
auto *dc = llvm::dyn_cast<clang::DeclContext>(parent)) {
350 dc->setHasExternalVisibleStorage(
true);
353 dc->setHasExternalLexicalStorage(
true);
360 clang::OverloadedOperatorKind &op_kind) {
362 if (!name.consume_front(
"operator"))
367 bool space_after_operator = name.consume_front(
" ");
369 op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
370 .Case(
"+", clang::OO_Plus)
371 .Case(
"+=", clang::OO_PlusEqual)
372 .Case(
"++", clang::OO_PlusPlus)
373 .Case(
"-", clang::OO_Minus)
374 .Case(
"-=", clang::OO_MinusEqual)
375 .Case(
"--", clang::OO_MinusMinus)
376 .Case(
"->", clang::OO_Arrow)
377 .Case(
"->*", clang::OO_ArrowStar)
378 .Case(
"*", clang::OO_Star)
379 .Case(
"*=", clang::OO_StarEqual)
380 .Case(
"/", clang::OO_Slash)
381 .Case(
"/=", clang::OO_SlashEqual)
382 .Case(
"%", clang::OO_Percent)
383 .Case(
"%=", clang::OO_PercentEqual)
384 .Case(
"^", clang::OO_Caret)
385 .Case(
"^=", clang::OO_CaretEqual)
386 .Case(
"&", clang::OO_Amp)
387 .Case(
"&=", clang::OO_AmpEqual)
388 .Case(
"&&", clang::OO_AmpAmp)
389 .Case(
"|", clang::OO_Pipe)
390 .Case(
"|=", clang::OO_PipeEqual)
391 .Case(
"||", clang::OO_PipePipe)
392 .Case(
"~", clang::OO_Tilde)
393 .Case(
"!", clang::OO_Exclaim)
394 .Case(
"!=", clang::OO_ExclaimEqual)
395 .Case(
"=", clang::OO_Equal)
396 .Case(
"==", clang::OO_EqualEqual)
397 .Case(
"<", clang::OO_Less)
398 .Case(
"<<", clang::OO_LessLess)
399 .Case(
"<<=", clang::OO_LessLessEqual)
400 .Case(
"<=", clang::OO_LessEqual)
401 .Case(
">", clang::OO_Greater)
402 .Case(
">>", clang::OO_GreaterGreater)
403 .Case(
">>=", clang::OO_GreaterGreaterEqual)
404 .Case(
">=", clang::OO_GreaterEqual)
405 .Case(
"()", clang::OO_Call)
406 .Case(
"[]", clang::OO_Subscript)
407 .Case(
",", clang::OO_Comma)
408 .Default(clang::NUM_OVERLOADED_OPERATORS);
411 if (op_kind != clang::NUM_OVERLOADED_OPERATORS)
423 if (!space_after_operator)
428 op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
429 .Case(
"new", clang::OO_New)
430 .Case(
"new[]", clang::OO_Array_New)
431 .Case(
"delete", clang::OO_Delete)
432 .Case(
"delete[]", clang::OO_Array_Delete)
434 .Default(clang::NUM_OVERLOADED_OPERATORS);
439 clang::AccessSpecifier
456 static void ParseLangArgs(LangOptions &Opts, InputKind IK,
const char *triple) {
462 if (IK.getLanguage() == clang::Language::Asm) {
463 Opts.AsmPreprocessor = 1;
464 }
else if (IK.isObjectiveC()) {
468 LangStandard::Kind LangStd = LangStandard::lang_unspecified;
470 if (LangStd == LangStandard::lang_unspecified) {
472 switch (IK.getLanguage()) {
473 case clang::Language::Unknown:
474 case clang::Language::LLVM_IR:
475 case clang::Language::RenderScript:
476 llvm_unreachable(
"Invalid input kind!");
477 case clang::Language::OpenCL:
478 LangStd = LangStandard::lang_opencl10;
480 case clang::Language::OpenCLCXX:
481 LangStd = LangStandard::lang_openclcpp10;
483 case clang::Language::CUDA:
484 LangStd = LangStandard::lang_cuda;
486 case clang::Language::Asm:
487 case clang::Language::C:
488 case clang::Language::ObjC:
489 LangStd = LangStandard::lang_gnu99;
491 case clang::Language::CXX:
492 case clang::Language::ObjCXX:
493 LangStd = LangStandard::lang_gnucxx98;
495 case clang::Language::HIP:
496 LangStd = LangStandard::lang_hip;
498 case clang::Language::HLSL:
499 LangStd = LangStandard::lang_hlsl;
504 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
505 Opts.LineComment = Std.hasLineComments();
506 Opts.C99 = Std.isC99();
507 Opts.CPlusPlus = Std.isCPlusPlus();
508 Opts.CPlusPlus11 = Std.isCPlusPlus11();
509 Opts.Digraphs = Std.hasDigraphs();
510 Opts.GNUMode = Std.isGNUMode();
511 Opts.GNUInline = !Std.isC99();
512 Opts.HexFloats = Std.hasHexFloats();
517 if (LangStd == LangStandard::lang_opencl10) {
520 Opts.CXXOperatorNames = 1;
521 Opts.setLaxVectorConversions(LangOptions::LaxVectorConversionKind::All);
525 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
527 Opts.setValueVisibilityMode(DefaultVisibility);
531 Opts.Trigraphs = !Opts.GNUMode;
533 Opts.OptimizeSize = 0;
546 Opts.NoInlineDefine = !Opt;
550 Opts.ModulesLocalVisibility = 1;
554 llvm::Triple target_triple) {
556 if (!target_triple.str().empty())
564 ASTContext &existing_ctxt) {
578 if (!TypeSystemClangSupportsLanguage(language))
579 return lldb::TypeSystemSP();
587 return lldb::TypeSystemSP();
592 if (triple.getVendor() == llvm::Triple::Apple &&
593 triple.getOS() == llvm::Triple::UnknownOS) {
594 if (triple.getArch() == llvm::Triple::arm ||
595 triple.getArch() == llvm::Triple::aarch64 ||
596 triple.getArch() == llvm::Triple::aarch64_32 ||
597 triple.getArch() == llvm::Triple::thumb) {
598 triple.setOS(llvm::Triple::IOS);
600 triple.setOS(llvm::Triple::MacOSX);
607 return std::make_shared<TypeSystemClang>(ast_name, triple);
608 }
else if (target && target->
IsValid())
609 return std::make_shared<ScratchTypeSystemClang>(*target, triple);
610 return lldb::TypeSystemSP();
667 assert(s ==
nullptr || &s->getASTContext() ==
m_ast_up.get());
680 llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_up) {
682 ast.getTranslationUnitDecl()->setHasExternalLexicalStorage(
true);
683 ast.setExternalSource(ast_source_up);
696 const clang::Diagnostic &info)
override {
698 llvm::SmallVector<char, 32> diag_str(10);
699 info.FormatDiagnostic(diag_str);
700 diag_str.push_back(
'\0');
701 LLDB_LOGF(m_log,
"Compiler diagnostic: %s\n", diag_str.data());
705 DiagnosticConsumer *
clone(DiagnosticsEngine &Diags)
const {
727 clang::FileSystemOptions file_system_options;
731 llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(
new DiagnosticIDs());
733 std::make_unique<DiagnosticsEngine>(diag_id_sp,
new DiagnosticOptions());
737 m_ast_up = std::make_unique<ASTContext>(
749 m_ast_up->InitBuiltinTypes(*target_info);
753 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_up(
786 #pragma mark Basic Types
789 ASTContext &ast, QualType qual_type) {
790 uint64_t qual_type_bit_size = ast.getTypeSize(qual_type);
791 return qual_type_bit_size == bit_size;
806 return GetType(ast.UnsignedCharTy);
808 return GetType(ast.UnsignedShortTy);
810 return GetType(ast.UnsignedIntTy);
812 return GetType(ast.UnsignedLongTy);
814 return GetType(ast.UnsignedLongLongTy);
816 return GetType(ast.UnsignedInt128Ty);
821 return GetType(ast.SignedCharTy);
829 return GetType(ast.LongLongTy);
840 return GetType(ast.LongDoubleTy);
847 if (bit_size && !(bit_size & 0x7u))
848 return GetType(ast.getExtVectorType(ast.UnsignedCharTy, bit_size / 8));
859 static TypeNameToBasicTypeMap g_type_map;
860 static llvm::once_flag g_once_flag;
861 llvm::call_once(g_once_flag, []() {
877 g_type_map.Append(
ConstString(
"unsigned short int"),
890 g_type_map.Append(
ConstString(
"unsigned long int"),
896 g_type_map.Append(
ConstString(
"unsigned long long"),
898 g_type_map.Append(
ConstString(
"unsigned long long int"),
958 return GetType(ast.UnsignedCharTy);
960 return GetType(ast.UnsignedShortTy);
962 return GetType(ast.UnsignedIntTy);
967 if (type_name.contains(
"complex")) {
976 case DW_ATE_complex_float: {
977 CanQualType FloatComplexTy = ast.getComplexType(ast.FloatTy);
979 return GetType(FloatComplexTy);
981 CanQualType DoubleComplexTy = ast.getComplexType(ast.DoubleTy);
983 return GetType(DoubleComplexTy);
985 CanQualType LongDoubleComplexTy = ast.getComplexType(ast.LongDoubleTy);
987 return GetType(LongDoubleComplexTy);
997 if (type_name ==
"float" &&
1000 if (type_name ==
"double" &&
1003 if (type_name ==
"long double" &&
1005 return GetType(ast.LongDoubleTy);
1012 return GetType(ast.LongDoubleTy);
1018 if (!type_name.empty()) {
1019 if (type_name ==
"wchar_t" &&
1024 if (type_name ==
"void" &&
1027 if (type_name.contains(
"long long") &&
1029 return GetType(ast.LongLongTy);
1030 if (type_name.contains(
"long") &&
1033 if (type_name.contains(
"short") &&
1036 if (type_name.contains(
"char")) {
1040 return GetType(ast.SignedCharTy);
1042 if (type_name.contains(
"int")) {
1059 return GetType(ast.LongLongTy);
1064 case DW_ATE_signed_char:
1065 if (ast.getLangOpts().CharIsSigned && type_name ==
"char") {
1070 return GetType(ast.SignedCharTy);
1073 case DW_ATE_unsigned:
1074 if (!type_name.empty()) {
1075 if (type_name ==
"wchar_t") {
1082 if (type_name.contains(
"long long")) {
1084 return GetType(ast.UnsignedLongLongTy);
1085 }
else if (type_name.contains(
"long")) {
1087 return GetType(ast.UnsignedLongTy);
1088 }
else if (type_name.contains(
"short")) {
1090 return GetType(ast.UnsignedShortTy);
1091 }
else if (type_name.contains(
"char")) {
1093 return GetType(ast.UnsignedCharTy);
1094 }
else if (type_name.contains(
"int")) {
1096 return GetType(ast.UnsignedIntTy);
1098 return GetType(ast.UnsignedInt128Ty);
1103 return GetType(ast.UnsignedCharTy);
1105 return GetType(ast.UnsignedShortTy);
1107 return GetType(ast.UnsignedIntTy);
1109 return GetType(ast.UnsignedLongTy);
1111 return GetType(ast.UnsignedLongLongTy);
1113 return GetType(ast.UnsignedInt128Ty);
1116 case DW_ATE_unsigned_char:
1117 if (!ast.getLangOpts().CharIsSigned && type_name ==
"char") {
1122 return GetType(ast.UnsignedCharTy);
1124 return GetType(ast.UnsignedShortTy);
1127 case DW_ATE_imaginary_float:
1139 if (!type_name.empty()) {
1140 if (type_name ==
"char16_t")
1142 if (type_name ==
"char32_t")
1144 if (type_name ==
"char8_t")
1153 "error: need to add support for DW_TAG_base_type '{0}' "
1154 "encoded with DW_ATE = {1:x}, bit_size = {2}",
1155 type_name, dw_ate, bit_size);
1161 QualType char_type(ast.CharTy);
1164 char_type.addConst();
1166 return GetType(ast.getPointerType(char_type));
1170 bool ignore_qualifiers) {
1172 llvm::dyn_cast_or_null<TypeSystemClang>(type1.
GetTypeSystem());
1182 if (ignore_qualifiers) {
1183 type1_qual = type1_qual.getUnqualifiedType();
1184 type2_qual = type2_qual.getUnqualifiedType();
1187 return ast->
getASTContext().hasSameType(type1_qual, type2_qual);
1194 clang::Decl *decl =
static_cast<clang::Decl *
>(opaque_decl);
1195 if (
auto *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl))
1207 if (clang::ObjCInterfaceDecl *interface_decl =
1208 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
1210 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
1223 #pragma mark Structure, Unions, Classes
1227 if (!decl || !owning_module.
HasValue())
1230 decl->setFromASTFile();
1231 decl->setOwningModuleID(owning_module.
GetValue());
1232 decl->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
1238 bool is_framework,
bool is_explicit) {
1240 auto *ast_source = llvm::dyn_cast_or_null<ClangExternalASTSourceCallbacks>(
1242 assert(ast_source &&
"external ast source was lost");
1248 auto HSOpts = std::make_shared<clang::HeaderSearchOptions>();
1259 clang::Module *module;
1260 auto parent_desc = ast_source->getSourceDescriptor(parent.
GetValue());
1262 name, parent_desc ? parent_desc->getModuleOrNull() :
nullptr,
1263 is_framework, is_explicit);
1265 return ast_source->GetIDForModule(module);
1267 return ast_source->RegisterModule(module);
1272 AccessType access_type, llvm::StringRef name,
int kind,
1276 if (decl_ctx ==
nullptr)
1277 decl_ctx = ast.getTranslationUnitDecl();
1281 bool isForwardDecl =
true;
1282 bool isInternal =
false;
1284 isInternal, metadata);
1293 bool has_name = !name.empty();
1294 CXXRecordDecl *decl = CXXRecordDecl::CreateDeserialized(ast, 0);
1295 decl->setTagKind(
static_cast<TagDecl::TagKind
>(kind));
1296 decl->setDeclContext(decl_ctx);
1298 decl->setDeclName(&ast.Idents.get(name));
1326 if (isa<CXXRecordDecl>(decl_ctx) && exports_symbols)
1327 decl->setAnonymousStructOrUnion(
true);
1337 decl_ctx->addDecl(decl);
1339 return GetType(ast.getTagDeclType(decl));
1345 bool IsValueParam(
const clang::TemplateArgument &argument) {
1346 return argument.getKind() == TemplateArgument::Integral;
1349 void AddAccessSpecifierDecl(clang::CXXRecordDecl *cxx_record_decl,
1351 clang::AccessSpecifier previous_access,
1352 clang::AccessSpecifier access_specifier) {
1353 if (!cxx_record_decl->isClass() && !cxx_record_decl->isStruct())
1355 if (previous_access != access_specifier) {
1358 if ((cxx_record_decl->isStruct() &&
1359 previous_access == clang::AccessSpecifier::AS_none &&
1360 access_specifier == clang::AccessSpecifier::AS_public) ||
1361 (cxx_record_decl->isClass() &&
1362 previous_access == clang::AccessSpecifier::AS_none &&
1363 access_specifier == clang::AccessSpecifier::AS_private)) {
1366 cxx_record_decl->addDecl(
1367 AccessSpecDecl::Create(ct, access_specifier, cxx_record_decl,
1368 SourceLocation(), SourceLocation()));
1376 llvm::SmallVector<NamedDecl *, 8> &template_param_decls) {
1377 const bool parameter_pack =
false;
1378 const bool is_typename =
false;
1379 const unsigned depth = 0;
1380 const size_t num_template_params = template_param_infos.
args.size();
1381 DeclContext *
const decl_context =
1382 ast.getTranslationUnitDecl();
1383 for (
size_t i = 0; i < num_template_params; ++i) {
1384 const char *name = template_param_infos.
names[i];
1386 IdentifierInfo *identifier_info =
nullptr;
1387 if (name && name[0])
1388 identifier_info = &ast.Idents.get(name);
1389 if (IsValueParam(template_param_infos.
args[i])) {
1390 QualType template_param_type =
1391 template_param_infos.
args[i].getIntegralType();
1392 template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1393 ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
1394 identifier_info, template_param_type, parameter_pack,
1395 ast.getTrivialTypeSourceInfo(template_param_type)));
1397 template_param_decls.push_back(TemplateTypeParmDecl::Create(
1398 ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
1399 identifier_info, is_typename, parameter_pack));
1404 IdentifierInfo *identifier_info =
nullptr;
1406 identifier_info = &ast.Idents.get(template_param_infos.
pack_name);
1407 const bool parameter_pack_true =
true;
1409 if (!template_param_infos.
packed_args->args.empty() &&
1410 IsValueParam(template_param_infos.
packed_args->args[0])) {
1411 QualType template_param_type =
1412 template_param_infos.
packed_args->args[0].getIntegralType();
1413 template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1414 ast, decl_context, SourceLocation(), SourceLocation(), depth,
1415 num_template_params, identifier_info, template_param_type,
1416 parameter_pack_true,
1417 ast.getTrivialTypeSourceInfo(template_param_type)));
1419 template_param_decls.push_back(TemplateTypeParmDecl::Create(
1420 ast, decl_context, SourceLocation(), SourceLocation(), depth,
1421 num_template_params, identifier_info, is_typename,
1422 parameter_pack_true));
1425 clang::Expr *
const requires_clause =
nullptr;
1426 TemplateParameterList *template_param_list = TemplateParameterList::Create(
1427 ast, SourceLocation(), SourceLocation(), template_param_decls,
1428 SourceLocation(), requires_clause);
1429 return template_param_list;
1434 clang::FunctionDecl *func_decl,
1439 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1441 ast, template_param_infos, template_param_decls);
1442 FunctionTemplateDecl *func_tmpl_decl =
1443 FunctionTemplateDecl::CreateDeserialized(ast, 0);
1444 func_tmpl_decl->setDeclContext(decl_ctx);
1445 func_tmpl_decl->setLocation(func_decl->getLocation());
1446 func_tmpl_decl->setDeclName(func_decl->getDeclName());
1447 func_tmpl_decl->init(func_decl, template_param_list);
1450 for (
size_t i = 0, template_param_decl_count = template_param_decls.size();
1451 i < template_param_decl_count; ++i) {
1453 template_param_decls[i]->setDeclContext(func_decl);
1458 if (decl_ctx->isRecord())
1459 func_tmpl_decl->setAccess(clang::AccessSpecifier::AS_public);
1461 return func_tmpl_decl;
1465 FunctionDecl *func_decl, clang::FunctionTemplateDecl *func_tmpl_decl,
1467 TemplateArgumentList *template_args_ptr =
1468 TemplateArgumentList::CreateCopy(func_decl->getASTContext(), infos.
args);
1470 func_decl->setFunctionTemplateSpecialization(func_tmpl_decl,
1471 template_args_ptr,
nullptr);
1478 const TemplateArgument &value) {
1479 if (llvm::isa<TemplateTypeParmDecl>(param)) {
1481 if (value.getKind() != TemplateArgument::Type)
1483 }
else if (
auto *type_param =
1484 llvm::dyn_cast<NonTypeTemplateParmDecl>(param)) {
1486 if (!IsValueParam(value))
1489 if (type_param->getType() != value.getIntegralType())
1497 "Don't know how to compare template parameter to passed"
1498 " value. Decl kind of parameter is: {0}",
1499 param->getDeclKindName());
1500 lldbassert(
false &&
"Can't compare this TemplateParmDecl subclass");
1515 ClassTemplateDecl *class_template_decl,
1518 TemplateParameterList ¶ms = *class_template_decl->getTemplateParameters();
1524 llvm::Optional<NamedDecl *> pack_parameter;
1526 size_t non_pack_params = params.size();
1527 for (
size_t i = 0; i < params.size(); ++i) {
1528 NamedDecl *param = params.getParam(i);
1529 if (param->isParameterPack()) {
1530 pack_parameter = param;
1531 non_pack_params = i;
1539 if (non_pack_params != instantiation_values.
args.size())
1550 if (pack_parameter && !instantiation_values.
packed_args->args.empty() &&
1552 *pack_parameter, instantiation_values.
packed_args->args.front()))
1557 for (
const auto pair : llvm::zip_first(instantiation_values.
args, params)) {
1558 const TemplateArgument &passed_arg = std::get<0>(pair);
1559 NamedDecl *found_param = std::get<1>(pair);
1564 return class_template_decl;
1573 ClassTemplateDecl *class_template_decl =
nullptr;
1574 if (decl_ctx ==
nullptr)
1575 decl_ctx = ast.getTranslationUnitDecl();
1577 IdentifierInfo &identifier_info = ast.Idents.get(class_name);
1578 DeclarationName decl_name(&identifier_info);
1581 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1582 for (NamedDecl *decl : result) {
1583 class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
1584 if (!class_template_decl)
1593 template_param_infos))
1595 return class_template_decl;
1598 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1601 ast, template_param_infos, template_param_decls);
1603 CXXRecordDecl *template_cxx_decl = CXXRecordDecl::CreateDeserialized(ast, 0);
1604 template_cxx_decl->setTagKind(
static_cast<TagDecl::TagKind
>(kind));
1606 template_cxx_decl->setDeclContext(decl_ctx);
1607 template_cxx_decl->setDeclName(decl_name);
1610 for (
size_t i = 0, template_param_decl_count = template_param_decls.size();
1611 i < template_param_decl_count; ++i) {
1612 template_param_decls[i]->setDeclContext(template_cxx_decl);
1620 class_template_decl = ClassTemplateDecl::CreateDeserialized(ast, 0);
1622 class_template_decl->setDeclContext(decl_ctx);
1623 class_template_decl->setDeclName(decl_name);
1624 class_template_decl->init(template_cxx_decl, template_param_list);
1625 template_cxx_decl->setDescribedClassTemplate(class_template_decl);
1629 class_template_decl->setAccess(
1632 decl_ctx->addDecl(class_template_decl);
1634 VerifyDecl(class_template_decl);
1636 return class_template_decl;
1639 TemplateTemplateParmDecl *
1643 auto *decl_ctx = ast.getTranslationUnitDecl();
1645 IdentifierInfo &identifier_info = ast.Idents.get(template_name);
1646 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1650 ast, template_param_infos, template_param_decls);
1656 return TemplateTemplateParmDecl::Create(
1657 ast, decl_ctx, SourceLocation(),
1659 false, &identifier_info, template_param_list);
1662 ClassTemplateSpecializationDecl *
1665 ClassTemplateDecl *class_template_decl,
int kind,
1668 llvm::SmallVector<clang::TemplateArgument, 2> args(
1669 template_param_infos.
args.size() +
1671 std::copy(template_param_infos.
args.begin(), template_param_infos.
args.end(),
1674 args[args.size() - 1] = TemplateArgument::CreatePackCopy(
1677 ClassTemplateSpecializationDecl *class_template_specialization_decl =
1678 ClassTemplateSpecializationDecl::CreateDeserialized(ast, 0);
1679 class_template_specialization_decl->setTagKind(
1680 static_cast<TagDecl::TagKind
>(kind));
1681 class_template_specialization_decl->setDeclContext(decl_ctx);
1682 class_template_specialization_decl->setInstantiationOf(class_template_decl);
1683 class_template_specialization_decl->setTemplateArgs(
1684 TemplateArgumentList::CreateCopy(ast, args));
1685 ast.getTypeDeclType(class_template_specialization_decl,
nullptr);
1686 class_template_specialization_decl->setDeclName(
1687 class_template_decl->getDeclName());
1689 decl_ctx->addDecl(class_template_specialization_decl);
1691 class_template_specialization_decl->setSpecializationKind(
1692 TSK_ExplicitSpecialization);
1694 return class_template_specialization_decl;
1698 ClassTemplateSpecializationDecl *class_template_specialization_decl) {
1699 if (class_template_specialization_decl) {
1701 return GetType(ast.getTagDeclType(class_template_specialization_decl));
1707 clang::OverloadedOperatorKind op_kind,
1708 bool unary,
bool binary,
1711 if (op_kind == OO_Call)
1717 if (num_params == 1)
1719 if (num_params == 2)
1726 bool is_method, clang::OverloadedOperatorKind op_kind,
1735 case OO_Array_Delete:
1739 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
1741 return check_op_param(is_method, op_kind, Unary, Binary, num_params);
1743 #include "clang/Basic/OperatorKinds.def"
1750 clang::AccessSpecifier
1752 clang::AccessSpecifier rhs) {
1755 if (lhs == AS_none || rhs == AS_none)
1757 if (lhs == AS_private || rhs == AS_private)
1759 if (lhs == AS_protected || rhs == AS_protected)
1760 return AS_protected;
1767 if (field ==
nullptr)
1770 if (field->isBitField()) {
1771 Expr *bit_width_expr = field->getBitWidth();
1772 if (bit_width_expr) {
1773 if (Optional<llvm::APSInt> bit_width_apsint =
1774 bit_width_expr->getIntegerConstantExpr(ast)) {
1775 bitfield_bit_size = bit_width_apsint->getLimitedValue(
UINT32_MAX);
1784 if (record_decl ==
nullptr)
1787 if (!record_decl->field_empty())
1791 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1792 if (cxx_record_decl) {
1793 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1794 for (base_class = cxx_record_decl->bases_begin(),
1795 base_class_end = cxx_record_decl->bases_end();
1796 base_class != base_class_end; ++base_class) {
1797 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(
1798 base_class->getType()->getAs<RecordType>()->getDecl());
1806 #pragma mark Objective-C Classes
1809 llvm::StringRef name, clang::DeclContext *decl_ctx,
1813 assert(!name.empty());
1815 decl_ctx = ast.getTranslationUnitDecl();
1817 ObjCInterfaceDecl *decl = ObjCInterfaceDecl::CreateDeserialized(ast, 0);
1818 decl->setDeclContext(decl_ctx);
1819 decl->setDeclName(&ast.Idents.get(name));
1821 decl->setImplicit(isInternal);
1827 return GetType(ast.getObjCInterfaceType(decl));
1836 bool omit_empty_base_classes) {
1838 if (cxx_record_decl) {
1839 if (omit_empty_base_classes) {
1840 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1841 for (base_class = cxx_record_decl->bases_begin(),
1842 base_class_end = cxx_record_decl->bases_end();
1843 base_class != base_class_end; ++base_class) {
1850 num_bases = cxx_record_decl->getNumBases();
1855 #pragma mark Namespace Declarations
1858 const char *name, clang::DeclContext *decl_ctx,
1860 NamespaceDecl *namespace_decl =
nullptr;
1862 TranslationUnitDecl *translation_unit_decl = ast.getTranslationUnitDecl();
1864 decl_ctx = translation_unit_decl;
1867 IdentifierInfo &identifier_info = ast.Idents.get(name);
1868 DeclarationName decl_name(&identifier_info);
1869 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1870 for (NamedDecl *decl : result) {
1871 namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
1873 return namespace_decl;
1877 NamespaceDecl::Create(ast, decl_ctx, is_inline, SourceLocation(),
1878 SourceLocation(), &identifier_info,
nullptr);
1880 decl_ctx->addDecl(namespace_decl);
1882 if (decl_ctx == translation_unit_decl) {
1883 namespace_decl = translation_unit_decl->getAnonymousNamespace();
1885 return namespace_decl;
1888 NamespaceDecl::Create(ast, decl_ctx,
false, SourceLocation(),
1889 SourceLocation(),
nullptr,
nullptr);
1890 translation_unit_decl->setAnonymousNamespace(namespace_decl);
1891 translation_unit_decl->addDecl(namespace_decl);
1892 assert(namespace_decl == translation_unit_decl->getAnonymousNamespace());
1894 NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
1895 if (parent_namespace_decl) {
1896 namespace_decl = parent_namespace_decl->getAnonymousNamespace();
1898 return namespace_decl;
1900 NamespaceDecl::Create(ast, decl_ctx,
false, SourceLocation(),
1901 SourceLocation(),
nullptr,
nullptr);
1902 parent_namespace_decl->setAnonymousNamespace(namespace_decl);
1903 parent_namespace_decl->addDecl(namespace_decl);
1904 assert(namespace_decl ==
1905 parent_namespace_decl->getAnonymousNamespace());
1907 assert(
false &&
"GetUniqueNamespaceDeclaration called with no name and "
1908 "no namespace as decl_ctx");
1916 VerifyDecl(namespace_decl);
1917 return namespace_decl;
1924 clang::BlockDecl *decl =
1926 decl->setDeclContext(ctx);
1935 clang::DeclContext *right,
1936 clang::DeclContext *root) {
1937 if (root ==
nullptr)
1940 std::set<clang::DeclContext *> path_left;
1941 for (clang::DeclContext *d = left; d !=
nullptr; d = d->getParent())
1942 path_left.insert(d);
1944 for (clang::DeclContext *d = right; d !=
nullptr; d = d->getParent())
1945 if (path_left.find(d) != path_left.end())
1953 clang::NamespaceDecl *ns_decl) {
1954 if (decl_ctx && ns_decl) {
1955 auto *translation_unit =
getASTContext().getTranslationUnitDecl();
1956 clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(
1958 clang::SourceLocation(), clang::NestedNameSpecifierLoc(),
1959 clang::SourceLocation(), ns_decl,
1962 decl_ctx->addDecl(using_decl);
1972 clang::NamedDecl *target) {
1973 if (current_decl_ctx && target) {
1974 clang::UsingDecl *using_decl = clang::UsingDecl::Create(
1976 clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(),
false);
1978 clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
1980 target->getDeclName(), using_decl, target);
1982 using_decl->addShadowDecl(shadow_decl);
1983 current_decl_ctx->addDecl(using_decl);
1991 const char *name, clang::QualType type) {
1993 clang::VarDecl *var_decl =
1995 var_decl->setDeclContext(decl_context);
1996 if (name && name[0])
1997 var_decl->setDeclName(&
getASTContext().Idents.getOwn(name));
1998 var_decl->setType(type);
2000 var_decl->setAccess(clang::AS_public);
2001 decl_context->addDecl(var_decl);
2010 switch (basic_type) {
2012 return ast->VoidTy.getAsOpaquePtr();
2014 return ast->CharTy.getAsOpaquePtr();
2016 return ast->SignedCharTy.getAsOpaquePtr();
2018 return ast->UnsignedCharTy.getAsOpaquePtr();
2020 return ast->getWCharType().getAsOpaquePtr();
2022 return ast->getSignedWCharType().getAsOpaquePtr();
2024 return ast->getUnsignedWCharType().getAsOpaquePtr();
2026 return ast->Char8Ty.getAsOpaquePtr();
2028 return ast->Char16Ty.getAsOpaquePtr();
2030 return ast->Char32Ty.getAsOpaquePtr();
2032 return ast->ShortTy.getAsOpaquePtr();
2034 return ast->UnsignedShortTy.getAsOpaquePtr();
2036 return ast->IntTy.getAsOpaquePtr();
2038 return ast->UnsignedIntTy.getAsOpaquePtr();
2040 return ast->LongTy.getAsOpaquePtr();
2042 return ast->UnsignedLongTy.getAsOpaquePtr();
2044 return ast->LongLongTy.getAsOpaquePtr();
2046 return ast->UnsignedLongLongTy.getAsOpaquePtr();
2048 return ast->Int128Ty.getAsOpaquePtr();
2050 return ast->UnsignedInt128Ty.getAsOpaquePtr();
2052 return ast->BoolTy.getAsOpaquePtr();
2054 return ast->HalfTy.getAsOpaquePtr();
2056 return ast->FloatTy.getAsOpaquePtr();
2058 return ast->DoubleTy.getAsOpaquePtr();
2060 return ast->LongDoubleTy.getAsOpaquePtr();
2062 return ast->getComplexType(ast->FloatTy).getAsOpaquePtr();
2064 return ast->getComplexType(ast->DoubleTy).getAsOpaquePtr();
2066 return ast->getComplexType(ast->LongDoubleTy).getAsOpaquePtr();
2068 return ast->getObjCIdType().getAsOpaquePtr();
2070 return ast->getObjCClassType().getAsOpaquePtr();
2072 return ast->getObjCSelType().getAsOpaquePtr();
2074 return ast->NullPtrTy.getAsOpaquePtr();
2080 #pragma mark Function Types
2082 clang::DeclarationName
2085 clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
2086 if (!
IsOperator(name, op_kind) || op_kind == clang::NUM_OVERLOADED_OPERATORS)
2095 const clang::FunctionProtoType *function_type =
2096 llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr());
2097 if (function_type ==
nullptr)
2098 return clang::DeclarationName();
2100 const bool is_method =
false;
2101 const unsigned int num_params = function_type->getNumParams();
2103 is_method, op_kind, num_params))
2104 return clang::DeclarationName();
2106 return getASTContext().DeclarationNames.getCXXOperatorName(op_kind);
2110 clang::PrintingPolicy printing_policy(
getASTContext().getPrintingPolicy());
2111 printing_policy.SuppressTagKeyword =
true;
2114 printing_policy.SuppressInlineNamespace =
false;
2115 printing_policy.SuppressUnwrittenScope =
false;
2127 printing_policy.SuppressDefaultTemplateArgs =
false;
2128 return printing_policy;
2134 llvm::raw_string_ostream os(result);
2135 named_decl->printQualifiedName(os, printing_policy);
2141 llvm::StringRef name,
const CompilerType &function_clang_type,
2142 clang::StorageClass storage,
bool is_inline) {
2143 FunctionDecl *func_decl =
nullptr;
2146 decl_ctx = ast.getTranslationUnitDecl();
2148 const bool hasWrittenPrototype =
true;
2149 const bool isConstexprSpecified =
false;
2151 clang::DeclarationName declarationName =
2153 func_decl = FunctionDecl::CreateDeserialized(ast, 0);
2154 func_decl->setDeclContext(decl_ctx);
2155 func_decl->setDeclName(declarationName);
2157 func_decl->setStorageClass(storage);
2158 func_decl->setInlineSpecified(is_inline);
2159 func_decl->setHasWrittenPrototype(hasWrittenPrototype);
2160 func_decl->setConstexprKind(isConstexprSpecified
2161 ? ConstexprSpecKind::Constexpr
2162 : ConstexprSpecKind::Unspecified);
2164 decl_ctx->addDecl(func_decl);
2166 VerifyDecl(func_decl);
2174 bool is_variadic,
unsigned type_quals,
2175 clang::CallingConv cc) {
2179 std::vector<QualType> qual_type_args;
2180 if (num_args > 0 && args ==
nullptr)
2184 for (
unsigned i = 0; i < num_args; ++i) {
2199 FunctionProtoType::ExtProtoInfo proto_info;
2200 proto_info.ExtInfo = cc;
2201 proto_info.Variadic = is_variadic;
2202 proto_info.ExceptionSpec = EST_None;
2203 proto_info.TypeQuals = clang::Qualifiers::fromFastMask(type_quals);
2204 proto_info.RefQualifier = RQ_None;
2212 const char *name,
const CompilerType ¶m_type,
int storage,
2215 auto *decl = ParmVarDecl::CreateDeserialized(ast, 0);
2216 decl->setDeclContext(decl_ctx);
2217 if (name && name[0])
2218 decl->setDeclName(&ast.Idents.get(name));
2220 decl->setStorageClass(
static_cast<clang::StorageClass
>(storage));
2223 decl_ctx->addDecl(decl);
2229 FunctionDecl *function_decl, llvm::ArrayRef<ParmVarDecl *> params) {
2231 function_decl->setParams(params);
2236 QualType block_type =
m_ast_up->getBlockPointerType(
2242 #pragma mark Array Types
2245 size_t element_count,
2255 llvm::APInt ap_element_count(64, element_count);
2256 if (element_count == 0) {
2257 return GetType(ast.getIncompleteArrayType(
2260 return GetType(ast.getConstantArrayType(
2262 clang::ArrayType::Normal, 0));
2271 const std::initializer_list<std::pair<const char *, CompilerType>>
2276 (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name))
2278 lldbassert(0 &&
"Trying to create a type for an existing name");
2286 for (
const auto &field : type_fields)
2297 const std::initializer_list<std::pair<const char *, CompilerType>>
2301 if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
2307 #pragma mark Enumeration Types
2310 llvm::StringRef name, clang::DeclContext *decl_ctx,
2312 const CompilerType &integer_clang_type,
bool is_scoped) {
2319 EnumDecl *enum_decl = EnumDecl::CreateDeserialized(ast, 0);
2320 enum_decl->setDeclContext(decl_ctx);
2322 enum_decl->setDeclName(&ast.Idents.get(name));
2323 enum_decl->setScoped(is_scoped);
2324 enum_decl->setScopedUsingClassTag(is_scoped);
2325 enum_decl->setFixed(
false);
2328 decl_ctx->addDecl(enum_decl);
2333 enum_decl->setAccess(AS_public);
2335 return GetType(ast.getTagDeclType(enum_decl));
2343 if (bit_size == ast.getTypeSize(ast.SignedCharTy))
2344 return GetType(ast.SignedCharTy);
2346 if (bit_size == ast.getTypeSize(ast.ShortTy))
2349 if (bit_size == ast.getTypeSize(ast.IntTy))
2352 if (bit_size == ast.getTypeSize(ast.LongTy))
2355 if (bit_size == ast.getTypeSize(ast.LongLongTy))
2356 return GetType(ast.LongLongTy);
2358 if (bit_size == ast.getTypeSize(ast.Int128Ty))
2361 if (bit_size == ast.getTypeSize(ast.UnsignedCharTy))
2362 return GetType(ast.UnsignedCharTy);
2364 if (bit_size == ast.getTypeSize(ast.UnsignedShortTy))
2365 return GetType(ast.UnsignedShortTy);
2367 if (bit_size == ast.getTypeSize(ast.UnsignedIntTy))
2368 return GetType(ast.UnsignedIntTy);
2370 if (bit_size == ast.getTypeSize(ast.UnsignedLongTy))
2371 return GetType(ast.UnsignedLongTy);
2373 if (bit_size == ast.getTypeSize(ast.UnsignedLongLongTy))
2374 return GetType(ast.UnsignedLongLongTy);
2376 if (bit_size == ast.getTypeSize(ast.UnsignedInt128Ty))
2377 return GetType(ast.UnsignedInt128Ty);
2391 clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx);
2393 printf(
"%20s: %s\n", decl_ctx->getDeclKindName(),
2394 named_decl->getDeclName().getAsString().c_str());
2396 printf(
"%20s\n", decl_ctx->getDeclKindName());
2402 if (decl ==
nullptr)
2406 clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl);
2408 printf(
"%20s: %s%s\n", decl->getDeclKindName(),
2409 record_decl->getDeclName().getAsString().c_str(),
2410 record_decl->isInjectedClassName() ?
" (injected class name)" :
"");
2413 clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl);
2415 printf(
"%20s: %s\n", decl->getDeclKindName(),
2416 named_decl->getDeclName().getAsString().c_str());
2418 printf(
"%20s\n", decl->getDeclKindName());
2424 clang::Decl *rhs_decl) {
2425 if (lhs_decl && rhs_decl) {
2427 const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind();
2428 const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind();
2430 if (lhs_decl_kind == rhs_decl_kind) {
2433 clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
2434 clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
2435 if (lhs_decl_ctx && rhs_decl_ctx) {
2437 if (lhs_decl_ctx && rhs_decl_ctx) {
2438 const clang::Decl::Kind lhs_decl_ctx_kind =
2439 lhs_decl_ctx->getDeclKind();
2440 const clang::Decl::Kind rhs_decl_ctx_kind =
2441 rhs_decl_ctx->getDeclKind();
2442 if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) {
2443 lhs_decl_ctx = lhs_decl_ctx->getParent();
2444 rhs_decl_ctx = rhs_decl_ctx->getParent();
2446 if (lhs_decl_ctx ==
nullptr && rhs_decl_ctx ==
nullptr)
2455 clang::NamedDecl *lhs_named_decl =
2456 llvm::dyn_cast<clang::NamedDecl>(lhs_decl);
2457 clang::NamedDecl *rhs_named_decl =
2458 llvm::dyn_cast<clang::NamedDecl>(rhs_decl);
2459 if (lhs_named_decl && rhs_named_decl) {
2460 clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
2461 clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
2462 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2463 if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2472 lhs_decl_ctx = lhs_decl->getDeclContext();
2473 rhs_decl_ctx = rhs_decl->getDeclContext();
2475 switch (lhs_decl_ctx->getDeclKind()) {
2476 case clang::Decl::TranslationUnit:
2480 clang::NamedDecl *lhs_named_decl =
2481 llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
2482 clang::NamedDecl *rhs_named_decl =
2483 llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx);
2484 if (lhs_named_decl && rhs_named_decl) {
2485 clang::DeclarationName lhs_decl_name =
2486 lhs_named_decl->getDeclName();
2487 clang::DeclarationName rhs_decl_name =
2488 rhs_named_decl->getDeclName();
2489 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2490 if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2498 lhs_decl_ctx = lhs_decl_ctx->getParent();
2499 rhs_decl_ctx = rhs_decl_ctx->getParent();
2507 clang::Decl *decl) {
2511 ExternalASTSource *ast_source = ast->getExternalSource();
2516 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) {
2517 if (tag_decl->isCompleteDefinition())
2520 if (!tag_decl->hasExternalLexicalStorage())
2523 ast_source->CompleteType(tag_decl);
2525 return !tag_decl->getTypeForDecl()->isIncompleteType();
2526 }
else if (clang::ObjCInterfaceDecl *objc_interface_decl =
2527 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) {
2528 if (objc_interface_decl->getDefinition())
2531 if (!objc_interface_decl->hasExternalLexicalStorage())
2534 ast_source->CompleteType(objc_interface_decl);
2536 return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
2581 clang::AccessSpecifier access) {
2582 if (access == clang::AccessSpecifier::AS_none)
2588 clang::AccessSpecifier
2593 return clang::AccessSpecifier::AS_none;
2596 clang::DeclContext *
2608 if (find(mask, type->getTypeClass()) != mask.end())
2610 switch (type->getTypeClass()) {
2613 case clang::Type::Atomic:
2614 type = cast<clang::AtomicType>(type)->getValueType();
2616 case clang::Type::Auto:
2617 case clang::Type::Decltype:
2618 case clang::Type::Elaborated:
2619 case clang::Type::Paren:
2620 case clang::Type::SubstTemplateTypeParm:
2621 case clang::Type::TemplateSpecialization:
2622 case clang::Type::Typedef:
2623 case clang::Type::TypeOf:
2624 case clang::Type::TypeOfExpr:
2625 case clang::Type::Using:
2626 type = type->getLocallyUnqualifiedSingleStepDesugaredType();
2634 clang::DeclContext *
2640 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2641 switch (type_class) {
2642 case clang::Type::ObjCInterface:
2643 return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())
2645 case clang::Type::ObjCObjectPointer:
2647 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
2648 ->getPointeeType());
2649 case clang::Type::Record:
2650 return llvm::cast<clang::RecordType>(qual_type)->getDecl();
2651 case clang::Type::Enum:
2652 return llvm::cast<clang::EnumType>(qual_type)->getDecl();
2661 clang::QualType qual_type,
2662 bool allow_completion =
true) {
2664 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2665 switch (type_class) {
2666 case clang::Type::ConstantArray:
2667 case clang::Type::IncompleteArray:
2668 case clang::Type::VariableArray: {
2669 const clang::ArrayType *array_type =
2670 llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
2676 case clang::Type::Record: {
2677 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2678 if (cxx_record_decl) {
2679 if (cxx_record_decl->hasExternalLexicalStorage()) {
2680 const bool is_complete = cxx_record_decl->isCompleteDefinition();
2681 const bool fields_loaded =
2682 cxx_record_decl->hasLoadedFieldsFromExternalStorage();
2683 if (is_complete && fields_loaded)
2686 if (!allow_completion)
2691 clang::ExternalASTSource *external_ast_source =
2692 ast->getExternalSource();
2693 if (external_ast_source) {
2694 external_ast_source->CompleteType(cxx_record_decl);
2695 if (cxx_record_decl->isCompleteDefinition()) {
2696 cxx_record_decl->field_begin();
2697 cxx_record_decl->setHasLoadedFieldsFromExternalStorage(
true);
2702 const clang::TagType *tag_type =
2703 llvm::cast<clang::TagType>(qual_type.getTypePtr());
2704 return !tag_type->isIncompleteType();
2707 case clang::Type::Enum: {
2708 const clang::TagType *tag_type =
2709 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
2711 clang::TagDecl *tag_decl = tag_type->getDecl();
2713 if (tag_decl->getDefinition())
2716 if (!allow_completion)
2719 if (tag_decl->hasExternalLexicalStorage()) {
2721 clang::ExternalASTSource *external_ast_source =
2722 ast->getExternalSource();
2723 if (external_ast_source) {
2724 external_ast_source->CompleteType(tag_decl);
2725 return !tag_type->isIncompleteType();
2734 case clang::Type::ObjCObject:
2735 case clang::Type::ObjCInterface: {
2736 const clang::ObjCObjectType *objc_class_type =
2737 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
2738 if (objc_class_type) {
2739 clang::ObjCInterfaceDecl *class_interface_decl =
2740 objc_class_type->getInterface();
2743 if (class_interface_decl) {
2744 if (class_interface_decl->getDefinition())
2747 if (!allow_completion)
2750 if (class_interface_decl->hasExternalLexicalStorage()) {
2752 clang::ExternalASTSource *external_ast_source =
2753 ast->getExternalSource();
2754 if (external_ast_source) {
2755 external_ast_source->CompleteType(class_interface_decl);
2756 return !objc_class_type->isIncompleteType();
2765 case clang::Type::Attributed:
2767 ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(),
2777 static clang::ObjCIvarDecl::AccessControl
2781 return clang::ObjCIvarDecl::None;
2783 return clang::ObjCIvarDecl::Public;
2785 return clang::ObjCIvarDecl::Private;
2787 return clang::ObjCIvarDecl::Protected;
2789 return clang::ObjCIvarDecl::Package;
2791 return clang::ObjCIvarDecl::None;
2798 return !type || llvm::isa<clang::Type>(
GetQualType(type).getTypePtr());
2805 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2806 switch (type_class) {
2807 case clang::Type::IncompleteArray:
2808 case clang::Type::VariableArray:
2809 case clang::Type::ConstantArray:
2810 case clang::Type::ExtVector:
2811 case clang::Type::Vector:
2812 case clang::Type::Record:
2813 case clang::Type::ObjCObject:
2814 case clang::Type::ObjCInterface:
2826 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2827 switch (type_class) {
2828 case clang::Type::Record: {
2829 if (
const clang::RecordType *record_type =
2830 llvm::dyn_cast_or_null<clang::RecordType>(
2831 qual_type.getTypePtrOrNull())) {
2832 if (
const clang::RecordDecl *record_decl = record_type->getDecl()) {
2833 return record_decl->isAnonymousStructOrUnion();
2847 uint64_t *size,
bool *is_incomplete) {
2850 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2851 switch (type_class) {
2855 case clang::Type::ConstantArray:
2856 if (element_type_ptr)
2858 this, llvm::cast<clang::ConstantArrayType>(qual_type)
2862 *size = llvm::cast<clang::ConstantArrayType>(qual_type)
2864 .getLimitedValue(ULLONG_MAX);
2866 *is_incomplete =
false;
2869 case clang::Type::IncompleteArray:
2870 if (element_type_ptr)
2872 this, llvm::cast<clang::IncompleteArrayType>(qual_type)
2878 *is_incomplete =
true;
2881 case clang::Type::VariableArray:
2882 if (element_type_ptr)
2884 this, llvm::cast<clang::VariableArrayType>(qual_type)
2890 *is_incomplete =
false;
2893 case clang::Type::DependentSizedArray:
2894 if (element_type_ptr)
2896 this, llvm::cast<clang::DependentSizedArrayType>(qual_type)
2902 *is_incomplete =
false;
2905 if (element_type_ptr)
2906 element_type_ptr->
Clear();
2910 *is_incomplete =
false;
2918 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2919 switch (type_class) {
2920 case clang::Type::Vector: {
2921 const clang::VectorType *vector_type =
2922 qual_type->getAs<clang::VectorType>();
2925 *size = vector_type->getNumElements();
2927 *element_type =
GetType(vector_type->getElementType());
2931 case clang::Type::ExtVector: {
2932 const clang::ExtVectorType *ext_vector_type =
2933 qual_type->getAs<clang::ExtVectorType>();
2934 if (ext_vector_type) {
2936 *size = ext_vector_type->getNumElements();
2939 CompilerType(
this, ext_vector_type->getElementType().getAsOpaquePtr());
2955 if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
2958 clang::ObjCInterfaceDecl *result_iface_decl =
2959 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
2964 return (ast_metadata->
GetISAPtr() != 0);
2968 return GetQualType(type).getUnqualifiedType()->isCharType();
2977 const bool allow_completion =
true;
2992 if (!pointee_or_element_clang_type.
IsValid())
2995 if (type_flags.
AnySet(eTypeIsArray | eTypeIsPointer)) {
2996 if (pointee_or_element_clang_type.
IsCharType()) {
2997 if (type_flags.
Test(eTypeIsArray)) {
3000 length = llvm::cast<clang::ConstantArrayType>(
3015 if (qual_type->isFunctionType()) {
3019 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3020 switch (type_class) {
3023 case clang::Type::LValueReference:
3024 case clang::Type::RValueReference: {
3025 const clang::ReferenceType *reference_type =
3026 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3029 reference_type->getPointeeType().getAsOpaquePtr());
3044 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3045 switch (type_class) {
3046 case clang::Type::Record:
3048 const clang::CXXRecordDecl *cxx_record_decl =
3049 qual_type->getAsCXXRecordDecl();
3050 if (cxx_record_decl) {
3051 if (cxx_record_decl->getNumBases() || cxx_record_decl->isDynamicClass())
3054 const clang::RecordType *record_type =
3055 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3057 const clang::RecordDecl *record_decl = record_type->getDecl();
3061 clang::RecordDecl::field_iterator field_pos,
3062 field_end = record_decl->field_end();
3064 bool is_hva =
false;
3065 bool is_hfa =
false;
3066 clang::QualType base_qual_type;
3067 uint64_t base_bitwidth = 0;
3068 for (field_pos = record_decl->field_begin(); field_pos != field_end;
3070 clang::QualType field_qual_type = field_pos->getType();
3071 uint64_t field_bitwidth =
getASTContext().getTypeSize(qual_type);
3072 if (field_qual_type->isFloatingType()) {
3073 if (field_qual_type->isComplexType())
3076 if (num_fields == 0)
3077 base_qual_type = field_qual_type;
3082 if (field_qual_type.getTypePtr() !=
3083 base_qual_type.getTypePtr())
3087 }
else if (field_qual_type->isVectorType() ||
3088 field_qual_type->isExtVectorType()) {
3089 if (num_fields == 0) {
3090 base_qual_type = field_qual_type;
3091 base_bitwidth = field_bitwidth;
3096 if (base_bitwidth != field_bitwidth)
3098 if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
3106 *base_type_ptr =
CompilerType(
this, base_qual_type.getAsOpaquePtr());
3123 const clang::FunctionProtoType *func =
3124 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3126 return func->getNumParams();
3133 const size_t index) {
3136 const clang::FunctionProtoType *func =
3137 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3139 if (index < func->getNumParams())
3140 return CompilerType(
this, func->getParamType(index).getAsOpaquePtr());
3150 if (qual_type->isFunctionPointerType())
3153 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3154 switch (type_class) {
3158 case clang::Type::LValueReference:
3159 case clang::Type::RValueReference: {
3160 const clang::ReferenceType *reference_type =
3161 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3164 reference_type->getPointeeType().getAsOpaquePtr());
3177 if (qual_type->isBlockPointerType()) {
3178 if (function_pointer_type_ptr) {
3179 const clang::BlockPointerType *block_pointer_type =
3180 qual_type->castAs<clang::BlockPointerType>();
3181 QualType pointee_type = block_pointer_type->getPointeeType();
3182 QualType function_pointer_type =
m_ast_up->getPointerType(pointee_type);
3183 *function_pointer_type_ptr =
3184 CompilerType(
this, function_pointer_type.getAsOpaquePtr());
3189 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3190 switch (type_class) {
3194 case clang::Type::LValueReference:
3195 case clang::Type::RValueReference: {
3196 const clang::ReferenceType *reference_type =
3197 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3200 reference_type->getPointeeType().getAsOpaquePtr(),
3201 function_pointer_type_ptr);
3214 const clang::BuiltinType *builtin_type =
3215 llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
3218 if (builtin_type->isInteger()) {
3219 is_signed = builtin_type->isSignedInteger();
3230 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3234 IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(),
3246 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3250 return enum_type->isScopedEnumeralType();
3261 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3262 switch (type_class) {
3263 case clang::Type::Builtin:
3264 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3267 case clang::BuiltinType::ObjCId:
3268 case clang::BuiltinType::ObjCClass:
3272 case clang::Type::ObjCObjectPointer:
3275 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3279 case clang::Type::BlockPointer:
3282 this, llvm::cast<clang::BlockPointerType>(qual_type)
3286 case clang::Type::Pointer:
3289 llvm::cast<clang::PointerType>(qual_type)
3293 case clang::Type::MemberPointer:
3296 this, llvm::cast<clang::MemberPointerType>(qual_type)
3305 pointee_type->
Clear();
3313 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3314 switch (type_class) {
3315 case clang::Type::Builtin:
3316 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3319 case clang::BuiltinType::ObjCId:
3320 case clang::BuiltinType::ObjCClass:
3324 case clang::Type::ObjCObjectPointer:
3327 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3328 ->getPointeeType().getAsOpaquePtr());
3330 case clang::Type::BlockPointer:
3333 this, llvm::cast<clang::BlockPointerType>(qual_type)
3337 case clang::Type::Pointer:
3340 llvm::cast<clang::PointerType>(qual_type)
3344 case clang::Type::MemberPointer:
3347 this, llvm::cast<clang::MemberPointerType>(qual_type)
3351 case clang::Type::LValueReference:
3354 this, llvm::cast<clang::LValueReferenceType>(qual_type)
3358 case clang::Type::RValueReference:
3361 this, llvm::cast<clang::RValueReferenceType>(qual_type)
3370 pointee_type->
Clear();
3379 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3381 switch (type_class) {
3382 case clang::Type::LValueReference:
3385 this, llvm::cast<clang::LValueReferenceType>(qual_type)
3391 case clang::Type::RValueReference:
3394 this, llvm::cast<clang::RValueReferenceType>(qual_type)
3406 pointee_type->
Clear();
3411 uint32_t &count,
bool &is_complex) {
3415 if (
const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(
3416 qual_type->getCanonicalTypeInternal())) {
3417 clang::BuiltinType::Kind kind = BT->getKind();
3418 if (kind >= clang::BuiltinType::Float &&
3419 kind <= clang::BuiltinType::LongDouble) {
3424 }
else if (
const clang::ComplexType *CT =
3425 llvm::dyn_cast<clang::ComplexType>(
3426 qual_type->getCanonicalTypeInternal())) {
3433 }
else if (
const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(
3434 qual_type->getCanonicalTypeInternal())) {
3437 count = VT->getNumElements();
3453 const clang::TagType *tag_type =
3454 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
3456 clang::TagDecl *tag_decl = tag_type->getDecl();
3458 return tag_decl->isCompleteDefinition();
3461 const clang::ObjCObjectType *objc_class_type =
3462 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
3463 if (objc_class_type) {
3464 clang::ObjCInterfaceDecl *class_interface_decl =
3465 objc_class_type->getInterface();
3466 if (class_interface_decl)
3467 return class_interface_decl->getDefinition() !=
nullptr;
3478 const clang::ObjCObjectPointerType *obj_pointer_type =
3479 llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3481 if (obj_pointer_type)
3482 return obj_pointer_type->isObjCClassType();
3497 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3498 return (type_class == clang::Type::Record);
3505 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3506 return (type_class == clang::Type::Enum);
3512 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3513 switch (type_class) {
3514 case clang::Type::Record:
3516 const clang::RecordType *record_type =
3517 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3518 const clang::RecordDecl *record_decl = record_type->getDecl();
3520 const clang::CXXRecordDecl *cxx_record_decl =
3521 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3522 if (cxx_record_decl)
3523 return cxx_record_decl->isPolymorphic();
3537 bool check_cplusplus,
3539 clang::QualType pointee_qual_type;
3542 bool success =
false;
3543 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3544 switch (type_class) {
3545 case clang::Type::Builtin:
3547 llvm::cast<clang::BuiltinType>(qual_type)->getKind() ==
3548 clang::BuiltinType::ObjCId) {
3549 if (dynamic_pointee_type)
3555 case clang::Type::ObjCObjectPointer:
3557 if (
const auto *objc_pointee_type =
3558 qual_type->getPointeeType().getTypePtrOrNull()) {
3559 if (
const auto *objc_object_type =
3560 llvm::dyn_cast_or_null<clang::ObjCObjectType>(
3561 objc_pointee_type)) {
3562 if (objc_object_type->isObjCClass())
3566 if (dynamic_pointee_type)
3568 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3575 case clang::Type::Pointer:
3577 llvm::cast<clang::PointerType>(qual_type)->getPointeeType();
3581 case clang::Type::LValueReference:
3582 case clang::Type::RValueReference:
3584 llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType();
3596 const clang::Type::TypeClass pointee_type_class =
3597 pointee_qual_type.getCanonicalType()->getTypeClass();
3598 switch (pointee_type_class) {
3599 case clang::Type::Builtin:
3600 switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind()) {
3601 case clang::BuiltinType::UnknownAny:
3602 case clang::BuiltinType::Void:
3603 if (dynamic_pointee_type)
3605 this, pointee_qual_type.getAsOpaquePtr());
3612 case clang::Type::Record:
3613 if (check_cplusplus) {
3614 clang::CXXRecordDecl *cxx_record_decl =
3615 pointee_qual_type->getAsCXXRecordDecl();
3616 if (cxx_record_decl) {
3617 bool is_complete = cxx_record_decl->isCompleteDefinition();
3620 success = cxx_record_decl->isDynamicClass();
3628 success = cxx_record_decl->isDynamicClass();
3635 if (dynamic_pointee_type)
3637 this, pointee_qual_type.getAsOpaquePtr());
3644 case clang::Type::ObjCObject:
3645 case clang::Type::ObjCInterface:
3647 if (dynamic_pointee_type)
3649 this, pointee_qual_type.getAsOpaquePtr());
3659 if (dynamic_pointee_type)
3660 dynamic_pointee_type->
Clear();
3668 return (
GetTypeInfo(type,
nullptr) & eTypeIsScalar) != 0;
3675 ->getTypeClass() == clang::Type::Typedef;
3685 if (
auto *record_decl =
3687 return record_decl->canPassInRegisters();
3693 return TypeSystemClangSupportsLanguage(language);
3696 Optional<std::string>
3702 if (qual_type.isNull())
3705 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3706 if (!cxx_record_decl)
3709 return std::string(cxx_record_decl->getIdentifier()->getNameStart());
3717 return !qual_type.isNull() && qual_type->getAsCXXRecordDecl() !=
nullptr;
3724 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
3726 return tag_type->isBeingDefined();
3737 if (!qual_type.isNull() && qual_type->isObjCObjectPointerType()) {
3738 if (class_type_ptr) {
3739 if (!qual_type->isObjCClassType() && !qual_type->isObjCIdType()) {
3740 const clang::ObjCObjectPointerType *obj_pointer_type =
3741 llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3742 if (obj_pointer_type ==
nullptr)
3743 class_type_ptr->
Clear();
3747 clang::QualType(obj_pointer_type->getInterfaceType(), 0)
3754 class_type_ptr->
Clear();
3763 const bool allow_completion =
true;
3782 {clang::Type::Typedef, clang::Type::Atomic});
3785 if (
const auto *typedef_type = qual_type->getAs<clang::TypedefType>()) {
3786 const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
3799 clang::PrintingPolicy printing_policy(
getASTContext().getPrintingPolicy());
3800 printing_policy.SuppressTagKeyword =
true;
3801 printing_policy.SuppressScope =
false;
3802 printing_policy.SuppressUnwrittenScope =
true;
3803 printing_policy.SuppressInlineNamespace =
true;
3804 return ConstString(qual_type.getAsString(printing_policy));
3813 if (pointee_or_element_clang_type)
3814 pointee_or_element_clang_type->
Clear();
3816 clang::QualType qual_type =
3819 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3820 switch (type_class) {
3821 case clang::Type::Attributed:
3822 return GetTypeInfo(qual_type->castAs<clang::AttributedType>()
3825 pointee_or_element_clang_type);
3826 case clang::Type::Builtin: {
3827 const clang::BuiltinType *builtin_type =
3828 llvm::cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
3830 uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
3831 switch (builtin_type->getKind()) {
3832 case clang::BuiltinType::ObjCId:
3833 case clang::BuiltinType::ObjCClass:
3834 if (pointee_or_element_clang_type)
3837 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3840 case clang::BuiltinType::ObjCSel:
3841 if (pointee_or_element_clang_type)
3844 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3847 case clang::BuiltinType::Bool:
3848 case clang::BuiltinType::Char_U:
3849 case clang::BuiltinType::UChar:
3850 case clang::BuiltinType::WChar_U:
3851 case clang::BuiltinType::Char16:
3852 case clang::BuiltinType::Char32:
3853 case clang::BuiltinType::UShort:
3855 case clang::BuiltinType::ULong:
3856 case clang::BuiltinType::ULongLong:
3857 case clang::BuiltinType::UInt128:
3858 case clang::BuiltinType::Char_S:
3859 case clang::BuiltinType::SChar:
3860 case clang::BuiltinType::WChar_S:
3861 case clang::BuiltinType::Short:
3862 case clang::BuiltinType::Int:
3863 case clang::BuiltinType::Long:
3864 case clang::BuiltinType::LongLong:
3865 case clang::BuiltinType::Int128:
3866 case clang::BuiltinType::Float:
3867 case clang::BuiltinType::Double:
3868 case clang::BuiltinType::LongDouble:
3869 builtin_type_flags |= eTypeIsScalar;
3870 if (builtin_type->isInteger()) {
3871 builtin_type_flags |= eTypeIsInteger;
3872 if (builtin_type->isSignedInteger())
3873 builtin_type_flags |= eTypeIsSigned;
3874 }
else if (builtin_type->isFloatingPoint())
3875 builtin_type_flags |= eTypeIsFloat;
3880 return builtin_type_flags;
3883 case clang::Type::BlockPointer:
3884 if (pointee_or_element_clang_type)
3886 this, qual_type->getPointeeType().getAsOpaquePtr());
3887 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
3889 case clang::Type::Complex: {
3891 eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
3892 const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(
3893 qual_type->getCanonicalTypeInternal());
3895 clang::QualType complex_element_type(complex_type->getElementType());
3896 if (complex_element_type->isIntegerType())
3897 complex_type_flags |= eTypeIsFloat;
3898 else if (complex_element_type->isFloatingType())
3899 complex_type_flags |= eTypeIsInteger;
3901 return complex_type_flags;
3904 case clang::Type::ConstantArray:
3905 case clang::Type::DependentSizedArray:
3906 case clang::Type::IncompleteArray:
3907 case clang::Type::VariableArray:
3908 if (pointee_or_element_clang_type)
3910 this, llvm::cast<clang::ArrayType>(qual_type.getTypePtr())
3913 return eTypeHasChildren | eTypeIsArray;
3915 case clang::Type::DependentName:
3917 case clang::Type::DependentSizedExtVector:
3918 return eTypeHasChildren | eTypeIsVector;
3919 case clang::Type::DependentTemplateSpecialization:
3920 return eTypeIsTemplate;
3922 case clang::Type::Enum:
3923 if (pointee_or_element_clang_type)
3925 this, llvm::cast<clang::EnumType>(qual_type)
3929 return eTypeIsEnumeration | eTypeHasValue;
3931 case clang::Type::FunctionProto:
3932 return eTypeIsFuncPrototype | eTypeHasValue;
3933 case clang::Type::FunctionNoProto:
3934 return eTypeIsFuncPrototype | eTypeHasValue;
3935 case clang::Type::InjectedClassName:
3938 case clang::Type::LValueReference:
3939 case clang::Type::RValueReference:
3940 if (pointee_or_element_clang_type)
3942 this, llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())
3945 return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
3947 case clang::Type::MemberPointer:
3948 return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
3950 case clang::Type::ObjCObjectPointer:
3951 if (pointee_or_element_clang_type)
3953 this, qual_type->getPointeeType().getAsOpaquePtr());
3954 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer |
3957 case clang::Type::ObjCObject:
3958 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3959 case clang::Type::ObjCInterface:
3960 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3962 case clang::Type::Pointer:
3963 if (pointee_or_element_clang_type)
3965 this, qual_type->getPointeeType().getAsOpaquePtr());
3966 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
3968 case clang::Type::Record:
3969 if (qual_type->getAsCXXRecordDecl())
3970 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
3972 return eTypeHasChildren | eTypeIsStructUnion;
3974 case clang::Type::SubstTemplateTypeParm:
3975 return eTypeIsTemplate;
3976 case clang::Type::TemplateTypeParm:
3977 return eTypeIsTemplate;
3978 case clang::Type::TemplateSpecialization:
3979 return eTypeIsTemplate;
3981 case clang::Type::Typedef:
3982 return eTypeIsTypedef |
GetType(llvm::cast<clang::TypedefType>(qual_type)
3984 ->getUnderlyingType())
3986 case clang::Type::UnresolvedUsing:
3989 case clang::Type::ExtVector:
3990 case clang::Type::Vector: {
3991 uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
3992 const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(
3993 qual_type->getCanonicalTypeInternal());
3995 if (vector_type->isIntegerType())
3996 vector_type_flags |= eTypeIsFloat;
3997 else if (vector_type->isFloatingType())
3998 vector_type_flags |= eTypeIsInteger;
4000 return vector_type_flags;
4015 if (qual_type->isAnyPointerType()) {
4016 if (qual_type->isObjCObjectPointerType())
4018 if (qual_type->getPointeeCXXRecordDecl())
4021 clang::QualType pointee_type(qual_type->getPointeeType());
4022 if (pointee_type->getPointeeCXXRecordDecl())
4024 if (pointee_type->isObjCObjectOrInterfaceType())
4026 if (pointee_type->isObjCClassType())
4028 if (pointee_type.getTypePtr() ==
4032 if (qual_type->isObjCObjectOrInterfaceType())
4034 if (qual_type->getAsCXXRecordDecl())
4036 switch (qual_type->getTypeClass()) {
4039 case clang::Type::Builtin:
4040 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4042 case clang::BuiltinType::Void:
4043 case clang::BuiltinType::Bool:
4044 case clang::BuiltinType::Char_U:
4045 case clang::BuiltinType::UChar:
4046 case clang::BuiltinType::WChar_U:
4047 case clang::BuiltinType::Char16:
4048 case clang::BuiltinType::Char32:
4049 case clang::BuiltinType::UShort:
4051 case clang::BuiltinType::ULong:
4052 case clang::BuiltinType::ULongLong:
4053 case clang::BuiltinType::UInt128:
4054 case clang::BuiltinType::Char_S:
4055 case clang::BuiltinType::SChar:
4056 case clang::BuiltinType::WChar_S:
4057 case clang::BuiltinType::Short:
4058 case clang::BuiltinType::Int:
4059 case clang::BuiltinType::Long:
4060 case clang::BuiltinType::LongLong:
4061 case clang::BuiltinType::Int128:
4062 case clang::BuiltinType::Float:
4063 case clang::BuiltinType::Double:
4064 case clang::BuiltinType::LongDouble:
4067 case clang::BuiltinType::NullPtr:
4070 case clang::BuiltinType::ObjCId:
4071 case clang::BuiltinType::ObjCClass:
4072 case clang::BuiltinType::ObjCSel:
4075 case clang::BuiltinType::Dependent:
4076 case clang::BuiltinType::Overload:
4077 case clang::BuiltinType::BoundMember:
4078 case clang::BuiltinType::UnknownAny:
4082 case clang::Type::Typedef:
4083 return GetType(llvm::cast<clang::TypedefType>(qual_type)
4085 ->getUnderlyingType())
4095 return lldb::eTypeClassInvalid;
4097 clang::QualType qual_type =
4100 switch (qual_type->getTypeClass()) {
4101 case clang::Type::Atomic:
4102 case clang::Type::Auto:
4103 case clang::Type::Decltype:
4104 case clang::Type::Elaborated:
4105 case clang::Type::Paren:
4106 case clang::Type::TypeOf:
4107 case clang::Type::TypeOfExpr:
4108 case clang::Type::Using:
4109 llvm_unreachable(
"Handled in RemoveWrappingTypes!");
4110 case clang::Type::UnaryTransform:
4112 case clang::Type::FunctionNoProto:
4113 return lldb::eTypeClassFunction;
4114 case clang::Type::FunctionProto:
4115 return lldb::eTypeClassFunction;
4116 case clang::Type::IncompleteArray:
4117 return lldb::eTypeClassArray;
4118 case clang::Type::VariableArray:
4119 return lldb::eTypeClassArray;
4120 case clang::Type::ConstantArray:
4121 return lldb::eTypeClassArray;
4122 case clang::Type::DependentSizedArray:
4123 return lldb::eTypeClassArray;
4124 case clang::Type::DependentSizedExtVector:
4125 return lldb::eTypeClassVector;
4126 case clang::Type::DependentVector:
4127 return lldb::eTypeClassVector;
4128 case clang::Type::ExtVector:
4129 return lldb::eTypeClassVector;
4130 case clang::Type::Vector:
4131 return lldb::eTypeClassVector;
4132 case clang::Type::Builtin:
4134 case clang::Type::BitInt:
4135 case clang::Type::DependentBitInt:
4136 return lldb::eTypeClassBuiltin;
4137 case clang::Type::ObjCObjectPointer:
4138 return lldb::eTypeClassObjCObjectPointer;
4139 case clang::Type::BlockPointer:
4140 return lldb::eTypeClassBlockPointer;
4141 case clang::Type::Pointer:
4142 return lldb::eTypeClassPointer;
4143 case clang::Type::LValueReference:
4144 return lldb::eTypeClassReference;
4145 case clang::Type::RValueReference:
4146 return lldb::eTypeClassReference;
4147 case clang::Type::MemberPointer:
4148 return lldb::eTypeClassMemberPointer;
4149 case clang::Type::Complex:
4150 if (qual_type->isComplexType())
4151 return lldb::eTypeClassComplexFloat;
4153 return lldb::eTypeClassComplexInteger;
4154 case clang::Type::ObjCObject:
4155 return lldb::eTypeClassObjCObject;
4156 case clang::Type::ObjCInterface:
4157 return lldb::eTypeClassObjCInterface;
4158 case clang::Type::Record: {
4159 const clang::RecordType *record_type =
4160 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4161 const clang::RecordDecl *record_decl = record_type->getDecl();
4162 if (record_decl->isUnion())
4163 return lldb::eTypeClassUnion;
4164 else if (record_decl->isStruct())
4165 return lldb::eTypeClassStruct;
4167 return lldb::eTypeClassClass;
4169 case clang::Type::Enum:
4170 return lldb::eTypeClassEnumeration;
4171 case clang::Type::Typedef:
4172 return lldb::eTypeClassTypedef;
4173 case clang::Type::UnresolvedUsing:
4176 case clang::Type::Attributed:
4177 case clang::Type::BTFTagAttributed:
4179 case clang::Type::TemplateTypeParm:
4181 case clang::Type::SubstTemplateTypeParm:
4183 case clang::Type::SubstTemplateTypeParmPack:
4185 case clang::Type::InjectedClassName:
4187 case clang::Type::DependentName:
4189 case clang::Type::DependentTemplateSpecialization:
4191 case clang::Type::PackExpansion:
4194 case clang::Type::TemplateSpecialization:
4196 case clang::Type::DeducedTemplateSpecialization:
4202 case clang::Type::Decayed:
4204 case clang::Type::Adjusted:
4206 case clang::Type::ObjCTypeParam:
4209 case clang::Type::DependentAddressSpace:
4211 case clang::Type::MacroQualified:
4215 case clang::Type::ConstantMatrix:
4216 case clang::Type::DependentSizedMatrix:
4220 return lldb::eTypeClassOther;
4225 return GetQualType(type).getQualifiers().getCVRQualifiers();
4237 const clang::Type *array_eletype =
4238 qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
4243 return GetType(clang::QualType(array_eletype, 0));
4254 return GetType(ast_ctx.getConstantArrayType(
4255 qual_type, llvm::APInt(64, size),
nullptr,
4256 clang::ArrayType::ArraySizeModifier::Normal, 0));
4258 return GetType(ast_ctx.getIncompleteArrayType(
4259 qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0));
4273 clang::QualType qual_type) {
4274 if (qual_type->isPointerType())
4275 qual_type = ast->getPointerType(
4277 else if (
const ConstantArrayType *arr =
4278 ast->getAsConstantArrayType(qual_type)) {
4279 qual_type = ast->getConstantArrayType(
4281 arr->getSize(), arr->getSizeExpr(), arr->getSizeModifier(),
4282 arr->getIndexTypeQualifiers().getAsOpaqueValue());
4284 qual_type = qual_type.getUnqualifiedType();
4285 qual_type.removeLocalConst();
4286 qual_type.removeLocalRestrict();
4287 qual_type.removeLocalVolatile();
4309 const clang::FunctionProtoType *func =
4312 return func->getNumParams();
4320 const clang::FunctionProtoType *func =
4321 llvm::dyn_cast<clang::FunctionProtoType>(
GetQualType(type));
4323 const uint32_t num_args = func->getNumParams();
4325 return GetType(func->getParamType(idx));
4335 const clang::FunctionProtoType *func =
4336 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
4338 return GetType(func->getReturnType());
4345 size_t num_functions = 0;
4348 switch (qual_type->getTypeClass()) {
4349 case clang::Type::Record:
4351 const clang::RecordType *record_type =
4352 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4353 const clang::RecordDecl *record_decl = record_type->getDecl();
4354 assert(record_decl);
4355 const clang::CXXRecordDecl *cxx_record_decl =
4356 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4357 if (cxx_record_decl)
4358 num_functions = std::distance(cxx_record_decl->method_begin(),
4359 cxx_record_decl->method_end());
4363 case clang::Type::ObjCObjectPointer: {
4364 const clang::ObjCObjectPointerType *objc_class_type =
4365 qual_type->castAs<clang::ObjCObjectPointerType>();
4366 const clang::ObjCInterfaceType *objc_interface_type =
4367 objc_class_type->getInterfaceType();
4368 if (objc_interface_type &&
4370 const_cast<clang::ObjCInterfaceType *
>(objc_interface_type)))) {
4371 clang::ObjCInterfaceDecl *class_interface_decl =
4372 objc_interface_type->getDecl();
4373 if (class_interface_decl) {
4374 num_functions = std::distance(class_interface_decl->meth_begin(),
4375 class_interface_decl->meth_end());
4381 case clang::Type::ObjCObject:
4382 case clang::Type::ObjCInterface:
4384 const clang::ObjCObjectType *objc_class_type =
4385 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4386 if (objc_class_type) {
4387 clang::ObjCInterfaceDecl *class_interface_decl =
4388 objc_class_type->getInterface();
4389 if (class_interface_decl)
4390 num_functions = std::distance(class_interface_decl->meth_begin(),
4391 class_interface_decl->meth_end());
4400 return num_functions;
4412 switch (qual_type->getTypeClass()) {
4413 case clang::Type::Record:
4415 const clang::RecordType *record_type =
4416 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4417 const clang::RecordDecl *record_decl = record_type->getDecl();
4418 assert(record_decl);
4419 const clang::CXXRecordDecl *cxx_record_decl =
4420 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4421 if (cxx_record_decl) {
4422 auto method_iter = cxx_record_decl->method_begin();
4423 auto method_end = cxx_record_decl->method_end();
4425 static_cast<size_t>(std::distance(method_iter, method_end))) {
4426 std::advance(method_iter, idx);
4427 clang::CXXMethodDecl *cxx_method_decl =
4428 method_iter->getCanonicalDecl();
4429 if (cxx_method_decl) {
4430 name = cxx_method_decl->getDeclName().getAsString();
4431 if (cxx_method_decl->isStatic())
4433 else if (llvm::isa<clang::CXXConstructorDecl>(cxx_method_decl))
4435 else if (llvm::isa<clang::CXXDestructorDecl>(cxx_method_decl))
4439 clang_type =
GetType(cxx_method_decl->getType());
4447 case clang::Type::ObjCObjectPointer: {
4448 const clang::ObjCObjectPointerType *objc_class_type =
4449 qual_type->castAs<clang::ObjCObjectPointerType>();
4450 const clang::ObjCInterfaceType *objc_interface_type =
4451 objc_class_type->getInterfaceType();
4452 if (objc_interface_type &&
4454 const_cast<clang::ObjCInterfaceType *
>(objc_interface_type)))) {
4455 clang::ObjCInterfaceDecl *class_interface_decl =
4456 objc_interface_type->getDecl();
4457 if (class_interface_decl) {
4458 auto method_iter = class_interface_decl->meth_begin();
4459 auto method_end = class_interface_decl->meth_end();
4461 static_cast<size_t>(std::distance(method_iter, method_end))) {
4462 std::advance(method_iter, idx);
4463 clang::ObjCMethodDecl *objc_method_decl =
4464 method_iter->getCanonicalDecl();
4465 if (objc_method_decl) {
4467 name = objc_method_decl->getSelector().getAsString();
4468 if (objc_method_decl->isClassMethod())
4479 case clang::Type::ObjCObject:
4480 case clang::Type::ObjCInterface:
4482 const clang::ObjCObjectType *objc_class_type =
4483 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4484 if (objc_class_type) {
4485 clang::ObjCInterfaceDecl *class_interface_decl =
4486 objc_class_type->getInterface();
4487 if (class_interface_decl) {
4488 auto method_iter = class_interface_decl->meth_begin();
4489 auto method_end = class_interface_decl->meth_end();
4491 static_cast<size_t>(std::distance(method_iter, method_end))) {
4492 std::advance(method_iter, idx);
4493 clang::ObjCMethodDecl *objc_method_decl =
4494 method_iter->getCanonicalDecl();
4495 if (objc_method_decl) {
4497 name = objc_method_decl->getSelector().getAsString();
4498 if (objc_method_decl->isClassMethod())
4531 return GetType(qual_type.getTypePtr()->getPointeeType());
4541 switch (qual_type.getDesugaredType(
getASTContext())->getTypeClass()) {
4542 case clang::Type::ObjCObject:
4543 case clang::Type::ObjCInterface:
4589 result.addVolatile();
4599 result.addRestrict();
4608 if (type && typedef_name && typedef_name[0]) {
4612 clang::DeclContext *decl_ctx =
4617 clang::TypedefDecl *decl =
4618 clang::TypedefDecl::CreateDeserialized(clang_ast, 0);
4619 decl->setDeclContext(decl_ctx);
4620 decl->setDeclName(&clang_ast.Idents.get(typedef_name));
4621 decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type));
4622 decl_ctx->addDecl(decl);
4625 clang::TagDecl *tdecl =
nullptr;
4626 if (!qual_type.isNull()) {
4627 if (
const clang::RecordType *rt = qual_type->getAs<clang::RecordType>())
4628 tdecl = rt->getDecl();
4629 if (
const clang::EnumType *et = qual_type->getAs<clang::EnumType>())
4630 tdecl = et->getDecl();
4636 if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl())
4637 tdecl->setTypedefNameForAnonDecl(decl);
4639 decl->setAccess(clang::AS_public);
4642 return GetType(clang_ast.getTypedefType(decl));
4650 const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(
4653 return GetType(typedef_type->getDecl()->getUnderlyingType());
4665 const llvm::fltSemantics &
4668 const size_t bit_size = byte_size * 8;
4669 if (bit_size == ast.getTypeSize(ast.FloatTy))
4670 return ast.getFloatTypeSemantics(ast.FloatTy);
4671 else if (bit_size == ast.getTypeSize(ast.DoubleTy))
4672 return ast.getFloatTypeSemantics(ast.DoubleTy);
4673 else if (bit_size == ast.getTypeSize(ast.LongDoubleTy))
4674 return ast.getFloatTypeSemantics(ast.LongDoubleTy);
4675 else if (bit_size == ast.getTypeSize(ast.HalfTy))
4676 return ast.getFloatTypeSemantics(ast.HalfTy);
4677 return llvm::APFloatBase::Bogus();
4685 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4686 switch (type_class) {
4687 case clang::Type::Record:
4694 case clang::Type::ObjCInterface:
4695 case clang::Type::ObjCObject: {
4701 uint64_t bit_size = 0;
4706 static bool g_printed =
false;
4711 llvm::outs() <<
"warning: trying to determine the size of type ";
4713 llvm::outs() <<
"without a valid ExecutionContext. this is not "
4714 "reliable. please file a bug against LLDB.\n";
4715 llvm::outs() <<
"backtrace:\n";
4716 llvm::sys::PrintStackTrace(llvm::outs());
4717 llvm::outs() <<
"\n";
4725 if (bit_size == 0) {
4726 if (qual_type->isIncompleteArrayType())
4728 qual_type->getArrayElementTypeNoTypeQual()
4729 ->getCanonicalTypeUnqualified());
4731 if (qual_type->isObjCObjectOrInterfaceType())
4735 if (qual_type->isFunctionProtoType())
4744 llvm::Optional<size_t>
4760 switch (qual_type->getTypeClass()) {
4761 case clang::Type::Atomic:
4762 case clang::Type::Auto:
4763 case clang::Type::Decltype:
4764 case clang::Type::Elaborated:
4765 case clang::Type::Paren:
4766 case clang::Type::Typedef:
4767 case clang::Type::TypeOf:
4768 case clang::Type::TypeOfExpr:
4769 case clang::Type::Using:
4770 llvm_unreachable(
"Handled in RemoveWrappingTypes!");
4772 case clang::Type::UnaryTransform:
4775 case clang::Type::FunctionNoProto:
4776 case clang::Type::FunctionProto:
4779 case clang::Type::IncompleteArray:
4780 case clang::Type::VariableArray:
4783 case clang::Type::ConstantArray:
4786 case clang::Type::DependentVector:
4787 case clang::Type::ExtVector:
4788 case clang::Type::Vector:
4792 case clang::Type::BitInt:
4793 case clang::Type::DependentBitInt:
4797 case clang::Type::Builtin:
4798 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4799 case clang::BuiltinType::Void:
4802 case clang::BuiltinType::Char_S:
4803 case clang::BuiltinType::SChar:
4804 case clang::BuiltinType::WChar_S:
4805 case clang::BuiltinType::Short:
4806 case clang::BuiltinType::Int:
4807 case clang::BuiltinType::Long:
4808 case clang::BuiltinType::LongLong:
4809 case clang::BuiltinType::Int128:
4812 case clang::BuiltinType::Bool:
4813 case clang::BuiltinType::Char_U:
4814 case clang::BuiltinType::UChar:
4815 case clang::BuiltinType::WChar_U:
4816 case clang::BuiltinType::Char8:
4817 case clang::BuiltinType::Char16:
4818 case clang::BuiltinType::Char32:
4819 case clang::BuiltinType::UShort:
4821 case clang::BuiltinType::ULong:
4822 case clang::BuiltinType::ULongLong:
4823 case clang::BuiltinType::UInt128:
4827 case clang::BuiltinType::ShortAccum:
4828 case clang::BuiltinType::Accum:
4829 case clang::BuiltinType::LongAccum:
4830 case clang::BuiltinType::UShortAccum:
4831 case clang::BuiltinType::UAccum:
4832 case clang::BuiltinType::ULongAccum:
4833 case clang::BuiltinType::ShortFract:
4834 case clang::BuiltinType::Fract:
4835 case clang::BuiltinType::LongFract:
4836 case clang::BuiltinType::UShortFract:
4837 case clang::BuiltinType::UFract:
4838 case clang::BuiltinType::ULongFract:
4839 case clang::BuiltinType::SatShortAccum:
4840 case clang::BuiltinType::SatAccum:
4841 case clang::BuiltinType::SatLongAccum:
4842 case clang::BuiltinType::SatUShortAccum:
4843 case clang::BuiltinType::SatUAccum:
4844 case clang::BuiltinType::SatULongAccum:
4845 case clang::BuiltinType::SatShortFract:
4846 case clang::BuiltinType::SatFract:
4847 case clang::BuiltinType::SatLongFract:
4848 case clang::BuiltinType::SatUShortFract:
4849 case clang::BuiltinType::SatUFract:
4850 case clang::BuiltinType::SatULongFract:
4853 case clang::BuiltinType::Half:
4854 case clang::BuiltinType::Float:
4855 case clang::BuiltinType::Float16:
4856 case clang::BuiltinType::Float128:
4857 case clang::BuiltinType::Double:
4858 case clang::BuiltinType::LongDouble:
4859 case clang::BuiltinType::BFloat16:
4860 case clang::BuiltinType::Ibm128:
4863 case clang::BuiltinType::ObjCClass:
4864 case clang::BuiltinType::ObjCId:
4865 case clang::BuiltinType::ObjCSel:
4868 case clang::BuiltinType::NullPtr:
4871 case clang::BuiltinType::Kind::ARCUnbridgedCast:
4872 case clang::BuiltinType::Kind::BoundMember:
4873 case clang::BuiltinType::Kind::BuiltinFn:
4874 case clang::BuiltinType::Kind::Dependent:
4875 case clang::BuiltinType::Kind::OCLClkEvent:
4876 case clang::BuiltinType::Kind::OCLEvent:
4877 case clang::BuiltinType::Kind::OCLImage1dRO:
4878 case clang::BuiltinType::Kind::OCLImage1dWO:
4879 case clang::BuiltinType::Kind::OCLImage1dRW:
4880 case clang::BuiltinType::Kind::OCLImage1dArrayRO:
4881 case clang::BuiltinType::Kind::OCLImage1dArrayWO:
4882 case clang::BuiltinType::Kind::OCLImage1dArrayRW:
4883 case clang::BuiltinType::Kind::OCLImage1dBufferRO:
4884 case clang::BuiltinType::Kind::OCLImage1dBufferWO:
4885 case clang::BuiltinType::Kind::OCLImage1dBufferRW:
4886 case clang::BuiltinType::Kind::OCLImage2dRO:
4887 case clang::BuiltinType::Kind::OCLImage2dWO:
4888 case clang::BuiltinType::Kind::OCLImage2dRW:
4889 case clang::BuiltinType::Kind::OCLImage2dArrayRO:
4890 case clang::BuiltinType::Kind::OCLImage2dArrayWO:
4891 case clang::BuiltinType::Kind::OCLImage2dArrayRW:
4892 case clang::BuiltinType::Kind::OCLImage2dArrayDepthRO:
4893 case clang::BuiltinType::Kind::OCLImage2dArrayDepthWO:
4894 case clang::BuiltinType::Kind::OCLImage2dArrayDepthRW:
4895 case clang::BuiltinType::Kind::OCLImage2dArrayMSAARO:
4896 case clang::BuiltinType::Kind::OCLImage2dArrayMSAAWO:
4897 case clang::BuiltinType::Kind::OCLImage2dArrayMSAARW:
4898 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRO:
4899 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthWO:
4900 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRW:
4901 case clang::BuiltinType::Kind::OCLImage2dDepthRO:
4902 case clang::BuiltinType::Kind::OCLImage2dDepthWO:
4903 case clang::BuiltinType::Kind::OCLImage2dDepthRW:
4904 case clang::BuiltinType::Kind::OCLImage2dMSAARO:
4905 case clang::BuiltinType::Kind::OCLImage2dMSAAWO:
4906 case clang::BuiltinType::Kind::OCLImage2dMSAARW:
4907 case clang::BuiltinType::Kind::OCLImage2dMSAADepthRO:
4908 case clang::BuiltinType::Kind::OCLImage2dMSAADepthWO:
4909 case clang::BuiltinType::Kind::OCLImage2dMSAADepthRW:
4910 case clang::BuiltinType::Kind::OCLImage3dRO:
4911 case clang::BuiltinType::Kind::OCLImage3dWO:
4912 case clang::BuiltinType::Kind::OCLImage3dRW:
4913 case clang::BuiltinType::Kind::OCLQueue:
4914 case clang::BuiltinType::Kind::OCLReserveID:
4915 case clang::BuiltinType::Kind::OCLSampler:
4916 case clang::BuiltinType::Kind::OMPArraySection:
4917 case clang::BuiltinType::Kind::OMPArrayShaping:
4918 case clang::BuiltinType::Kind::OMPIterator:
4919 case clang::BuiltinType::Kind::Overload:
4920 case clang::BuiltinType::Kind::PseudoObject:
4921 case clang::BuiltinType::Kind::UnknownAny:
4924 case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload:
4925 case clang::BuiltinType::OCLIntelSubgroupAVCImePayload:
4926 case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload:
4927 case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload:
4928 case clang::BuiltinType::OCLIntelSubgroupAVCMceResult:
4929 case clang::BuiltinType::OCLIntelSubgroupAVCImeResult:
4930 case clang::BuiltinType::OCLIntelSubgroupAVCRefResult:
4931 case clang::BuiltinType::OCLIntelSubgroupAVCSicResult:
4932 case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout:
4933 case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout:
4934 case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin:
4935 case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin:
4939 case clang::BuiltinType::VectorPair:
4940 case clang::BuiltinType::VectorQuad:
4944 case clang::BuiltinType::SveBool:
4945 case clang::BuiltinType::SveInt8:
4946 case clang::BuiltinType::SveInt8x2:
4947 case clang::BuiltinType::SveInt8x3:
4948 case clang::BuiltinType::SveInt8x4:
4949 case clang::BuiltinType::SveInt16:
4950 case clang::BuiltinType::SveInt16x2:
4951 case clang::BuiltinType::SveInt16x3:
4952 case clang::BuiltinType::SveInt16x4:
4953 case clang::BuiltinType::SveInt32:
4954 case clang::BuiltinType::SveInt32x2:
4955 case clang::BuiltinType::SveInt32x3:
4956 case clang::BuiltinType::SveInt32x4:
4957 case clang::BuiltinType::SveInt64:
4958 case clang::BuiltinType::SveInt64x2:
4959 case clang::BuiltinType::SveInt64x3:
4960 case clang::BuiltinType::SveInt64x4:
4961 case clang::BuiltinType::SveUint8:
4962 case clang::BuiltinType::SveUint8x2:
4963 case clang::BuiltinType::SveUint8x3:
4964 case clang::BuiltinType::SveUint8x4:
4965 case clang::BuiltinType::SveUint16:
4966 case clang::BuiltinType::SveUint16x2:
4967 case clang::BuiltinType::SveUint16x3:
4968 case clang::BuiltinType::SveUint16x4:
4969 case clang::BuiltinType::SveUint32:
4970 case clang::BuiltinType::SveUint32x2:
4971 case clang::BuiltinType::SveUint32x3:
4972 case clang::BuiltinType::SveUint32x4:
4973 case clang::BuiltinType::SveUint64:
4974 case clang::BuiltinType::SveUint64x2:
4975 case clang::BuiltinType::SveUint64x3:
4976 case clang::BuiltinType::SveUint64x4:
4977 case clang::BuiltinType::SveFloat16:
4978 case clang::BuiltinType::SveBFloat16:
4979 case clang::BuiltinType::SveBFloat16x2:
4980 case clang::BuiltinType::SveBFloat16x3:
4981 case clang::BuiltinType::SveBFloat16x4:
4982 case clang::BuiltinType::SveFloat16x2:
4983 case clang::BuiltinType::SveFloat16x3:
4984 case clang::BuiltinType::SveFloat16x4:
4985 case clang::BuiltinType::SveFloat32:
4986 case clang::BuiltinType::SveFloat32x2:
4987 case clang::BuiltinType::SveFloat32x3:
4988 case clang::BuiltinType::SveFloat32x4:
4989 case clang::BuiltinType::SveFloat64:
4990 case clang::BuiltinType::SveFloat64x2:
4991 case clang::BuiltinType::SveFloat64x3:
4992 case clang::BuiltinType::SveFloat64x4:
4996 case clang::BuiltinType::RvvInt8mf8:
4997 case clang::BuiltinType::RvvInt8mf4:
4998 case clang::BuiltinType::RvvInt8mf2:
4999 case clang::BuiltinType::RvvInt8m1:
5000 case clang::BuiltinType::RvvInt8m2:
5001 case clang::BuiltinType::RvvInt8m4:
5002 case clang::BuiltinType::RvvInt8m8:
5003 case clang::BuiltinType::RvvUint8mf8:
5004 case clang::BuiltinType::RvvUint8mf4:
5005 case clang::BuiltinType::RvvUint8mf2:
5006 case clang::BuiltinType::RvvUint8m1:
5007 case clang::BuiltinType::RvvUint8m2:
5008 case clang::BuiltinType::RvvUint8m4:
5009 case clang::BuiltinType::RvvUint8m8:
5010 case clang::BuiltinType::RvvInt16mf4:
5011 case clang::BuiltinType::RvvInt16mf2:
5012 case clang::BuiltinType::RvvInt16m1:
5013 case clang::BuiltinType::RvvInt16m2:
5014 case clang::BuiltinType::RvvInt16m4:
5015 case clang::BuiltinType::RvvInt16m8:
5016 case clang::BuiltinType::RvvUint16mf4:
5017 case clang::BuiltinType::RvvUint16mf2:
5018 case clang::BuiltinType::RvvUint16m1:
5019 case clang::BuiltinType::RvvUint16m2:
5020 case clang::BuiltinType::RvvUint16m4:
5021 case clang::BuiltinType::RvvUint16m8:
5022 case clang::BuiltinType::RvvInt32mf2:
5023 case clang::BuiltinType::RvvInt32m1:
5024 case clang::BuiltinType::RvvInt32m2:
5025 case clang::BuiltinType::RvvInt32m4:
5026 case clang::BuiltinType::RvvInt32m8:
5027 case clang::BuiltinType::RvvUint32mf2:
5028 case clang::BuiltinType::RvvUint32m1:
5029 case clang::BuiltinType::RvvUint32m2:
5030 case clang::BuiltinType::RvvUint32m4:
5031 case clang::BuiltinType::RvvUint32m8:
5032 case clang::BuiltinType::RvvInt64m1:
5033 case clang::BuiltinType::RvvInt64m2:
5034 case clang::BuiltinType::RvvInt64m4:
5035 case clang::BuiltinType::RvvInt64m8:
5036 case clang::BuiltinType::RvvUint64m1:
5037 case clang::BuiltinType::RvvUint64m2:
5038 case clang::BuiltinType::RvvUint64m4:
5039 case clang::BuiltinType::RvvUint64m8:
5040 case clang::BuiltinType::RvvFloat16mf4:
5041 case clang::BuiltinType::RvvFloat16mf2:
5042 case clang::BuiltinType::RvvFloat16m1:
5043 case clang::BuiltinType::RvvFloat16m2:
5044 case clang::BuiltinType::RvvFloat16m4:
5045 case clang::BuiltinType::RvvFloat16m8:
5046 case clang::BuiltinType::RvvFloat32mf2:
5047 case clang::BuiltinType::RvvFloat32m1:
5048 case clang::BuiltinType::RvvFloat32m2:
5049 case clang::BuiltinType::RvvFloat32m4:
5050 case clang::BuiltinType::RvvFloat32m8:
5051 case clang::BuiltinType::RvvFloat64m1:
5052 case clang::BuiltinType::RvvFloat64m2:
5053 case clang::BuiltinType::RvvFloat64m4:
5054 case clang::BuiltinType::RvvFloat64m8:
5055 case clang::BuiltinType::RvvBool1:
5056 case clang::BuiltinType::RvvBool2:
5057 case clang::BuiltinType::RvvBool4:
5058 case clang::BuiltinType::RvvBool8:
5059 case clang::BuiltinType::RvvBool16:
5060 case clang::BuiltinType::RvvBool32:
5061 case clang::BuiltinType::RvvBool64:
5064 case clang::BuiltinType::IncompleteMatrixIdx:
5070 case clang::Type::ObjCObjectPointer:
5071 case clang::Type::BlockPointer:
5072 case clang::Type::Pointer:
5073 case clang::Type::LValueReference:
5074 case clang::Type::RValueReference:
5075 case clang::Type::MemberPointer:
5077 case clang::Type::Complex: {
5079 if (qual_type->isComplexType())
5082 const clang::ComplexType *complex_type =
5083 qual_type->getAsComplexIntegerType();
5093 case clang::Type::ObjCInterface:
5095 case clang::Type::Record:
5097 case clang::Type::Enum:
5099 case clang::Type::DependentSizedArray:
5100 case clang::Type::DependentSizedExtVector:
5101 case clang::Type::UnresolvedUsing:
5102 case clang::Type::Attributed:
5103 case clang::Type::BTFTagAttributed:
5104 case clang::Type::TemplateTypeParm:
5105 case clang::Type::SubstTemplateTypeParm:
5106 case clang::Type::SubstTemplateTypeParmPack:
5107 case clang::Type::InjectedClassName:
5108 case clang::Type::DependentName:
5109 case clang::Type::DependentTemplateSpecialization:
5110 case clang::Type::PackExpansion:
5111 case clang::Type::ObjCObject:
5113 case clang::Type::TemplateSpecialization:
5114 case clang::Type::DeducedTemplateSpecialization:
5115 case clang::Type::Adjusted:
5120 case clang::Type::Decayed:
5122 case clang::Type::ObjCTypeParam:
5125 case clang::Type::DependentAddressSpace:
5127 case clang::Type::MacroQualified:
5130 case clang::Type::ConstantMatrix:
5131 case clang::Type::DependentSizedMatrix:
5144 switch (qual_type->getTypeClass()) {
5145 case clang::Type::Atomic:
5146 case clang::Type::Auto:
5147 case clang::Type::Decltype:
5148 case clang::Type::Elaborated:
5149 case clang::Type::Paren:
5150 case clang::Type::Typedef:
5151 case clang::Type::TypeOf:
5152 case clang::Type::TypeOfExpr:
5153 case clang::Type::Using:
5154 llvm_unreachable(
"Handled in RemoveWrappingTypes!");
5155 case clang::Type::UnaryTransform:
5158 case clang::Type::FunctionNoProto:
5159 case clang::Type::FunctionProto:
5162 case clang::Type::IncompleteArray:
5163 case clang::Type::VariableArray:
5166 case clang::Type::ConstantArray:
5169 case clang::Type::DependentVector:
5170 case clang::Type::ExtVector:
5171 case clang::Type::Vector:
5174 case clang::Type::BitInt:
5175 case clang::Type::DependentBitInt:
5179 case clang::Type::Builtin:
5180 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5181 case clang::BuiltinType::UnknownAny:
5182 case clang::BuiltinType::Void:
5183 case clang::BuiltinType::BoundMember:
5186 case clang::BuiltinType::Bool:
5188 case clang::BuiltinType::Char_S:
5189 case clang::BuiltinType::SChar:
5190 case clang::BuiltinType::WChar_S:
5191 case clang::BuiltinType::Char_U:
5192 case clang::BuiltinType::UChar:
5193 case clang::BuiltinType::WChar_U:
5195 case clang::BuiltinType::Char8:
5197 case clang::BuiltinType::Char16:
5199 case clang::BuiltinType::Char32:
5201 case clang::BuiltinType::UShort:
5203 case clang::BuiltinType::Short:
5207 case clang::BuiltinType::Int:
5209 case clang::BuiltinType::ULong:
5211 case clang::BuiltinType::Long:
5213 case clang::BuiltinType::ULongLong:
5215 case clang::BuiltinType::LongLong:
5217 case clang::BuiltinType::UInt128:
5219 case clang::BuiltinType::Int128:
5221 case clang::BuiltinType::Half:
5222 case clang::BuiltinType::Float:
5223 case clang::BuiltinType::Double:
5224 case clang::BuiltinType::LongDouble:
5230 case clang::Type::ObjCObjectPointer:
5232 case clang::Type::BlockPointer:
5234 case clang::Type::Pointer:
5236 case clang::Type::LValueReference:
5237 case clang::Type::RValueReference:
5239 case clang::Type::MemberPointer:
5241 case clang::Type::Complex: {
5242 if (qual_type->isComplexType())
5247 case clang::Type::ObjCInterface:
5249 case clang::Type::Record:
5251 case clang::Type::Enum:
5253 case clang::Type::DependentSizedArray:
5254 case clang::Type::DependentSizedExtVector:
5255 case clang::Type::UnresolvedUsing:
5256 case clang::Type::Attributed:
5257 case clang::Type::BTFTagAttributed:
5258 case clang::Type::TemplateTypeParm:
5259 case clang::Type::SubstTemplateTypeParm:
5260 case clang::Type::SubstTemplateTypeParmPack:
5261 case clang::Type::InjectedClassName:
5262 case clang::Type::DependentName:
5263 case clang::Type::DependentTemplateSpecialization:
5264 case clang::Type::PackExpansion:
5265 case clang::Type::ObjCObject:
5267 case clang::Type::TemplateSpecialization:
5268 case clang::Type::DeducedTemplateSpecialization:
5269 case clang::Type::Adjusted:
5274 case clang::Type::Decayed:
5276 case clang::Type::ObjCTypeParam:
5279 case clang::Type::DependentAddressSpace:
5281 case clang::Type::MacroQualified:
5285 case clang::Type::ConstantMatrix:
5286 case clang::Type::DependentSizedMatrix:
5294 bool check_superclass) {
5295 while (class_interface_decl) {
5296 if (class_interface_decl->ivar_size() > 0)
5299 if (check_superclass)
5300 class_interface_decl = class_interface_decl->getSuperClass();
5307 static Optional<SymbolFile::ArrayInfo>
5309 clang::QualType qual_type,
5311 if (qual_type->isIncompleteArrayType())
5312 if (
auto *metadata = ast.
GetMetadata(qual_type.getTypePtr()))
5319 bool omit_empty_base_classes,
5326 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5327 switch (type_class) {
5328 case clang::Type::Builtin:
5329 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5330 case clang::BuiltinType::ObjCId:
5331 case clang::BuiltinType::ObjCClass:
5340 case clang::Type::Complex:
5342 case clang::Type::Record:
5344 const clang::RecordType *record_type =
5345 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5346 const clang::RecordDecl *record_decl = record_type->getDecl();
5347 assert(record_decl);
5348 const clang::CXXRecordDecl *cxx_record_decl =
5349 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
5350 if (cxx_record_decl) {
5351 if (omit_empty_base_classes) {
5355 clang::CXXRecordDecl::base_class_const_iterator base_class,
5357 for (base_class = cxx_record_decl->bases_begin(),
5358 base_class_end = cxx_record_decl->bases_end();
5359 base_class != base_class_end; ++base_class) {
5360 const clang::CXXRecordDecl *base_class_decl =
5361 llvm::cast<clang::CXXRecordDecl>(
5362 base_class->getType()
5363 ->getAs<clang::RecordType>()
5374 num_children += cxx_record_decl->getNumBases();
5377 clang::RecordDecl::field_iterator field, field_end;
5378 for (field = record_decl->field_begin(),
5379 field_end = record_decl->field_end();
5380 field != field_end; ++field)
5385 case clang::Type::ObjCObject:
5386 case clang::Type::ObjCInterface:
5388 const clang::ObjCObjectType *objc_class_type =
5389 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5390 assert(objc_class_type);
5391 if (objc_class_type) {
5392 clang::ObjCInterfaceDecl *class_interface_decl =
5393 objc_class_type->getInterface();
5395 if (class_interface_decl) {
5397 clang::ObjCInterfaceDecl *superclass_interface_decl =
5398 class_interface_decl->getSuperClass();
5399 if (superclass_interface_decl) {
5400 if (omit_empty_base_classes) {
5407 num_children += class_interface_decl->ivar_size();
5413 case clang::Type::LValueReference:
5414 case clang::Type::RValueReference:
5415 case clang::Type::ObjCObjectPointer: {
5420 num_pointee_children =
5421 pointee_clang_type.
GetNumChildren(omit_empty_base_classes, exe_ctx);
5423 if (num_pointee_children == 0)
5426 num_children = num_pointee_children;
5429 case clang::Type::Vector:
5430 case clang::Type::ExtVector:
5432 llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
5435 case clang::Type::ConstantArray:
5436 num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())
5440 case clang::Type::IncompleteArray:
5441 if (
auto array_info =
5444 num_children = array_info->element_orders.size()
5445 ? array_info->element_orders.back()
5449 case clang::Type::Pointer: {
5450 const clang::PointerType *pointer_type =
5451 llvm::cast<clang::PointerType>(qual_type.getTypePtr());
5452 clang::QualType pointee_type(pointer_type->getPointeeType());
5456 num_pointee_children =
5457 pointee_clang_type.
GetNumChildren(omit_empty_base_classes, exe_ctx);
5458 if (num_pointee_children == 0) {
5463 num_children = num_pointee_children;
5469 return num_children;
5480 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5481 if (type_class == clang::Type::Builtin) {
5482 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5483 case clang::BuiltinType::Void:
5485 case clang::BuiltinType::Bool:
5487 case clang::BuiltinType::Char_S:
5489 case clang::BuiltinType::Char_U:
5491 case clang::BuiltinType::Char8:
5493 case clang::BuiltinType::Char16:
5495 case clang::BuiltinType::Char32:
5497 case clang::BuiltinType::UChar:
5499 case clang::BuiltinType::SChar:
5501 case clang::BuiltinType::WChar_S:
5503 case clang::BuiltinType::WChar_U:
5505 case clang::BuiltinType::Short:
5507 case clang::BuiltinType::UShort:
5509 case clang::BuiltinType::Int:
5513 case clang::BuiltinType::Long:
5515 case clang::BuiltinType::ULong:
5517 case clang::BuiltinType::LongLong:
5519 case clang::BuiltinType::ULongLong:
5521 case clang::BuiltinType::Int128:
5523 case clang::BuiltinType::UInt128:
5526 case clang::BuiltinType::Half:
5528 case clang::BuiltinType::Float:
5530 case clang::BuiltinType::Double:
5532 case clang::BuiltinType::LongDouble:
5535 case clang::BuiltinType::NullPtr:
5537 case clang::BuiltinType::ObjCId:
5539 case clang::BuiltinType::ObjCClass:
5541 case clang::BuiltinType::ObjCSel:
5555 const llvm::APSInt &value)>
const &callback) {
5556 const clang::EnumType *enum_type =
5559 const clang::EnumDecl *enum_decl = enum_type->getDecl();
5563 clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
5564 for (enum_pos = enum_decl->enumerator_begin(),
5565 enum_end_pos = enum_decl->enumerator_end();
5566 enum_pos != enum_end_pos; ++enum_pos) {
5567 ConstString name(enum_pos->getNameAsString().c_str());
5568 if (!callback(integer_type, name, enum_pos->getInitVal()))
5575 #pragma mark Aggregate Types
5583 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5584 switch (type_class) {
5585 case clang::Type::Record:
5587 const clang::RecordType *record_type =
5588 llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
5590 clang::RecordDecl *record_decl = record_type->getDecl();
5593 clang::RecordDecl::field_iterator field, field_end;
5594 for (field = record_decl->field_begin(),
5595 field_end = record_decl->field_end();
5596 field != field_end; ++field)
5604 case clang::Type::ObjCObjectPointer: {
5605 const clang::ObjCObjectPointerType *objc_class_type =
5606 qual_type->castAs<clang::ObjCObjectPointerType>();
5607 const clang::ObjCInterfaceType *objc_interface_type =
5608 objc_class_type->getInterfaceType();
5609 if (objc_interface_type &&
5611 const_cast<clang::ObjCInterfaceType *
>(objc_interface_type)))) {
5612 clang::ObjCInterfaceDecl *class_interface_decl =
5613 objc_interface_type->getDecl();
5614 if (class_interface_decl) {
5615 count = class_interface_decl->ivar_size();
5621 case clang::Type::ObjCObject:
5622 case clang::Type::ObjCInterface:
5624 const clang::ObjCObjectType *objc_class_type =
5625 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5626 if (objc_class_type) {
5627 clang::ObjCInterfaceDecl *class_interface_decl =
5628 objc_class_type->getInterface();
5630 if (class_interface_decl)
5631 count = class_interface_decl->ivar_size();
5644 clang::ObjCInterfaceDecl *class_interface_decl,
size_t idx,
5646 uint32_t *bitfield_bit_size_ptr,
bool *is_bitfield_ptr) {
5647 if (class_interface_decl) {
5648 if (idx < (class_interface_decl->ivar_size())) {
5649 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
5650 ivar_end = class_interface_decl->ivar_end();
5653 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end;
5654 ++ivar_pos, ++ivar_idx) {
5655 if (ivar_idx == idx) {
5656 const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
5658 clang::QualType ivar_qual_type(ivar_decl->getType());
5660 name.assign(ivar_decl->getNameAsString());
5662 if (bit_offset_ptr) {
5663 const clang::ASTRecordLayout &interface_layout =
5664 ast->getASTObjCInterfaceLayout(class_interface_decl);
5665 *bit_offset_ptr = interface_layout.getFieldOffset(ivar_idx);
5668 const bool is_bitfield = ivar_pos->isBitField();
5670 if (bitfield_bit_size_ptr) {
5671 *bitfield_bit_size_ptr = 0;
5673 if (is_bitfield && ast) {
5674 clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
5675 clang::Expr::EvalResult result;
5676 if (bitfield_bit_size_expr &&
5677 bitfield_bit_size_expr->EvaluateAsInt(result, *ast)) {
5678 llvm::APSInt bitfield_apsint = result.Val.getInt();
5679 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5683 if (is_bitfield_ptr)
5684 *is_bitfield_ptr = is_bitfield;
5686 return ivar_qual_type.getAsOpaquePtr();
5696 uint64_t *bit_offset_ptr,
5698 bool *is_bitfield_ptr) {
5703 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5704 switch (type_class) {
5705 case clang::Type::Record:
5707 const clang::RecordType *record_type =
5708 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5709 const clang::RecordDecl *record_decl = record_type->getDecl();
5711 clang::RecordDecl::field_iterator field, field_end;
5712 for (field = record_decl->field_begin(),
5713 field_end = record_decl->field_end();
5714 field != field_end; ++field, ++field_idx) {
5715 if (idx == field_idx) {
5718 name.assign(field->getNameAsString());
5722 if (bit_offset_ptr) {
5723 const clang::ASTRecordLayout &record_layout =
5725 *bit_offset_ptr = record_layout.getFieldOffset(field_idx);
5728 const bool is_bitfield = field->isBitField();
5730 if (bitfield_bit_size_ptr) {
5731 *bitfield_bit_size_ptr = 0;
5734 clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
5735 clang::Expr::EvalResult result;
5736 if (bitfield_bit_size_expr &&
5737 bitfield_bit_size_expr->EvaluateAsInt(result,
5739 llvm::APSInt bitfield_apsint = result.Val.getInt();
5740 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5744 if (is_bitfield_ptr)
5745 *is_bitfield_ptr = is_bitfield;
5747 return GetType(field->getType());
5753 case clang::Type::ObjCObjectPointer: {
5754 const clang::ObjCObjectPointerType *objc_class_type =
5755 qual_type->castAs<clang::ObjCObjectPointerType>();
5756 const clang::ObjCInterfaceType *objc_interface_type =
5757 objc_class_type->getInterfaceType();
5758 if (objc_interface_type &&
5760 const_cast<clang::ObjCInterfaceType *
>(objc_interface_type)))) {
5761 clang::ObjCInterfaceDecl *class_interface_decl =
5762 objc_interface_type->getDecl();
5763 if (class_interface_decl) {
5766 idx, name, bit_offset_ptr,
5767 bitfield_bit_size_ptr, is_bitfield_ptr));
5773 case clang::Type::ObjCObject:
5774 case clang::Type::ObjCInterface:
5776 const clang::ObjCObjectType *objc_class_type =
5777 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5778 assert(objc_class_type);
5779 if (objc_class_type) {
5780 clang::ObjCInterfaceDecl *class_interface_decl =
5781 objc_class_type->getInterface();
5784 idx, name, bit_offset_ptr,
5785 bitfield_bit_size_ptr, is_bitfield_ptr));
5800 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5801 switch (type_class) {
5802 case clang::Type::Record:
5804 const clang::CXXRecordDecl *cxx_record_decl =
5805 qual_type->getAsCXXRecordDecl();
5806 if (cxx_record_decl)
5807 count = cxx_record_decl->getNumBases();
5811 case clang::Type::ObjCObjectPointer:
5815 case clang::Type::ObjCObject:
5817 const clang::ObjCObjectType *objc_class_type =
5818 qual_type->getAsObjCQualifiedInterfaceType();
5819 if (objc_class_type) {
5820 clang::ObjCInterfaceDecl *class_interface_decl =
5821 objc_class_type->getInterface();
5823 if (class_interface_decl && class_interface_decl->getSuperClass())
5828 case clang::Type::ObjCInterface:
5830 const clang::ObjCInterfaceType *objc_interface_type =
5831 qual_type->getAs<clang::ObjCInterfaceType>();
5832 if (objc_interface_type) {
5833 clang::ObjCInterfaceDecl *class_interface_decl =
5834 objc_interface_type->getInterface();
5836 if (class_interface_decl && class_interface_decl->getSuperClass())
5852 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5853 switch (type_class) {
5854 case clang::Type::Record:
5856 const clang::CXXRecordDecl *cxx_record_decl =
5857 qual_type->getAsCXXRecordDecl();
5858 if (cxx_record_decl)
5859 count = cxx_record_decl->getNumVBases();
5872 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5873 switch (type_class) {
5874 case clang::Type::Record:
5876 const clang::CXXRecordDecl *cxx_record_decl =
5877 qual_type->getAsCXXRecordDecl();
5878 if (cxx_record_decl) {
5880 clang::CXXRecordDecl::base_class_const_iterator base_class,
5882 for (base_class = cxx_record_decl->bases_begin(),
5883 base_class_end = cxx_record_decl->bases_end();
5884 base_class != base_class_end; ++base_class, ++curr_idx) {
5885 if (curr_idx == idx) {
5886 if (bit_offset_ptr) {
5887 const clang::ASTRecordLayout &record_layout =
5889 const clang::CXXRecordDecl *base_class_decl =
5890 llvm::cast<clang::CXXRecordDecl>(
5891 base_class->getType()
5892 ->castAs<clang::RecordType>()
5894 if (base_class->isVirtual())
5896 record_layout.getVBaseClassOffset(base_class_decl)
5901 record_layout.getBaseClassOffset(base_class_decl)
5905 return GetType(base_class->getType());
5912 case clang::Type::ObjCObjectPointer:
5915 case clang::Type::ObjCObject:
5917 const clang::ObjCObjectType *objc_class_type =
5918 qual_type->getAsObjCQualifiedInterfaceType();
5919 if (objc_class_type) {
5920 clang::ObjCInterfaceDecl *class_interface_decl =
5921 objc_class_type->getInterface();
5923 if (class_interface_decl) {
5924 clang::ObjCInterfaceDecl *superclass_interface_decl =
5925 class_interface_decl->getSuperClass();
5926 if (superclass_interface_decl) {
5928 *bit_offset_ptr = 0;
5930 superclass_interface_decl));
5936 case clang::Type::ObjCInterface:
5938 const clang::ObjCObjectType *objc_interface_type =
5939 qual_type->getAs<clang::ObjCInterfaceType>();
5940 if (objc_interface_type) {
5941 clang::ObjCInterfaceDecl *class_interface_decl =
5942 objc_interface_type->getInterface();
5944 if (class_interface_decl) {
5945 clang::ObjCInterfaceDecl *superclass_interface_decl =
5946 class_interface_decl->getSuperClass();
5947 if (superclass_interface_decl) {
5949 *bit_offset_ptr = 0;
5951 superclass_interface_decl));
5967 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5968 switch (type_class) {
5969 case clang::Type::Record:
5971 const clang::CXXRecordDecl *cxx_record_decl =
5972 qual_type->getAsCXXRecordDecl();
5973 if (cxx_record_decl) {
5975 clang::CXXRecordDecl::base_class_const_iterator base_class,
5977 for (base_class = cxx_record_decl->vbases_begin(),
5978 base_class_end = cxx_record_decl->vbases_end();
5979 base_class != base_class_end; ++base_class, ++curr_idx) {
5980 if (curr_idx == idx) {
5981 if (bit_offset_ptr) {
5982 const clang::ASTRecordLayout &record_layout =
5984 const clang::CXXRecordDecl *base_class_decl =
5985 llvm::cast<clang::CXXRecordDecl>(
5986 base_class->getType()
5987 ->castAs<clang::RecordType>()
5990 record_layout.getVBaseClassOffset(base_class_decl)
5994 return GetType(base_class->getType());
6017 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6018 switch (type_class) {
6019 case clang::Type::Builtin:
6020 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
6021 case clang::BuiltinType::UnknownAny:
6022 case clang::BuiltinType::Void:
6023 case clang::BuiltinType::NullPtr:
6024 case clang::BuiltinType::OCLEvent:
6025 case clang::BuiltinType::OCLImage1dRO:
6026 case clang::BuiltinType::OCLImage1dWO:
6027 case clang::BuiltinType::OCLImage1dRW:
6028 case clang::BuiltinType::OCLImage1dArrayRO:
6029 case clang::BuiltinType::OCLImage1dArrayWO:
6030 case clang::BuiltinType::OCLImage1dArrayRW:
6031 case clang::BuiltinType::OCLImage1dBufferRO:
6032 case clang::BuiltinType::OCLImage1dBufferWO:
6033 case clang::BuiltinType::OCLImage1dBufferRW:
6034 case clang::BuiltinType::OCLImage2dRO:
6035 case clang::BuiltinType::OCLImage2dWO:
6036 case clang::BuiltinType::OCLImage2dRW:
6037 case clang::BuiltinType::OCLImage2dArrayRO:
6038 case clang::BuiltinType::OCLImage2dArrayWO:
6039 case clang::BuiltinType::OCLImage2dArrayRW:
6040 case clang::BuiltinType::OCLImage3dRO:
6041 case clang::BuiltinType::OCLImage3dWO:
6042 case clang::BuiltinType::OCLImage3dRW:
6043 case clang::BuiltinType::OCLSampler:
6045 case clang::BuiltinType::Bool:
6046 case clang::BuiltinType::Char_U:
6047 case clang::BuiltinType::UChar:
6048 case clang::BuiltinType::WChar_U:
6049 case clang::BuiltinType::Char16:
6050 case clang::BuiltinType::Char32:
6051 case clang::BuiltinType::UShort:
6053 case clang::BuiltinType::ULong:
6054 case clang::BuiltinType::ULongLong:
6055 case clang::BuiltinType::UInt128:
6056 case clang::BuiltinType::Char_S:
6057 case clang::BuiltinType::SChar:
6058 case clang::BuiltinType::WChar_S:
6059 case clang::BuiltinType::Short:
6060 case clang::BuiltinType::Int:
6061 case clang::BuiltinType::Long:
6062 case clang::BuiltinType::LongLong:
6063 case clang::BuiltinType::Int128:
6064 case clang::BuiltinType::Float:
6065 case clang::BuiltinType::Double:
6066 case clang::BuiltinType::LongDouble:
6067 case clang::BuiltinType::Dependent:
6068 case clang::BuiltinType::Overload:
6069 case clang::BuiltinType::ObjCId:
6070 case clang::BuiltinType::ObjCClass:
6071 case clang::BuiltinType::ObjCSel:
6072 case clang::BuiltinType::BoundMember:
6073 case clang::BuiltinType::Half:
6074 case clang::BuiltinType::ARCUnbridgedCast:
6075 case clang::BuiltinType::PseudoObject:
6076 case clang::BuiltinType::BuiltinFn:
6077 case clang::BuiltinType::OMPArraySection:
6084 case clang::Type::Complex:
6086 case clang::Type::Pointer:
6088 case clang::Type::BlockPointer:
6091 case clang::Type::LValueReference:
6093 case clang::Type::RValueReference:
6095 case clang::Type::MemberPointer:
6097 case clang::Type::ConstantArray:
6099 case clang::Type::IncompleteArray:
6101 case clang::Type::VariableArray:
6103 case clang::Type::DependentSizedArray:
6105 case clang::Type::DependentSizedExtVector:
6107 case clang::Type::Vector:
6109 case clang::Type::ExtVector:
6111 case clang::Type::FunctionProto:
6113 case clang::Type::FunctionNoProto:
6115 case clang::Type::UnresolvedUsing:
6117 case clang::Type::Record:
6119 case clang::Type::Enum:
6121 case clang::Type::TemplateTypeParm:
6123 case clang::Type::SubstTemplateTypeParm:
6125 case clang::Type::TemplateSpecialization:
6127 case clang::Type::InjectedClassName:
6129 case clang::Type::DependentName:
6131 case clang::Type::DependentTemplateSpecialization:
6133 case clang::Type::ObjCObject:
6135 case clang::Type::ObjCInterface:
6137 case clang::Type::ObjCObjectPointer: