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()->getAs<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 path.Decls = baseDtorDecl;
167 decls.push_back(baseDtorDecl);
174 for (path.Decls = base_record->lookup(name); !path.Decls.empty();
175 path.Decls = path.Decls.slice(1)) {
176 if (
auto *method_decl =
177 llvm::dyn_cast<clang::CXXMethodDecl>(path.Decls.front()))
178 if (method_decl->isVirtual() && !isOverload(decl, method_decl)) {
179 path.Decls = method_decl;
180 decls.push_back(method_decl);
189 if (decl->getParent()->lookupInBases(find_overridden_methods, paths)) {
190 for (
auto *overridden_decl : decls)
191 decl->addOverriddenMethod(
192 llvm::cast<clang::CXXMethodDecl>(overridden_decl));
198 VTableContextBase &vtable_ctx,
200 const ASTRecordLayout &record_layout) {
209 bool ptr_or_ref =
false;
210 if (type_info & (eTypeIsPointer | eTypeIsReference)) {
216 const uint32_t cpp_class = eTypeIsClass | eTypeIsCPlusPlus;
217 if ((type_info & cpp_class) != cpp_class)
222 vtable_ctx.isMicrosoft() ? record_layout.getVBPtrOffset().getQuantity()
236 vbtable_ptr_addr += vbtable_ptr_offset;
247 auto size = valobj.
GetData(data, err);
255 VTableContextBase &vtable_ctx,
257 const CXXRecordDecl *cxx_record_decl,
258 const CXXRecordDecl *base_class_decl) {
259 if (vtable_ctx.isMicrosoft()) {
260 clang::MicrosoftVTableContext &msoft_vtable_ctx =
261 static_cast<clang::MicrosoftVTableContext &
>(vtable_ctx);
265 const unsigned vbtable_index =
266 msoft_vtable_ctx.getVBTableIndex(cxx_record_decl, base_class_decl);
267 const lldb::addr_t base_offset_addr = vtable_ptr + vbtable_index * 4;
273 clang::ItaniumVTableContext &itanium_vtable_ctx =
274 static_cast<clang::ItaniumVTableContext &
>(vtable_ctx);
276 clang::CharUnits base_offset_offset =
277 itanium_vtable_ctx.getVirtualBaseOffsetOffset(cxx_record_decl,
280 vtable_ptr + base_offset_offset.getQuantity();
289 const ASTRecordLayout &record_layout,
290 const CXXRecordDecl *cxx_record_decl,
291 const CXXRecordDecl *base_class_decl,
292 int32_t &bit_offset) {
304 *process, vtable_ctx, vtable_ptr, cxx_record_decl, base_class_decl);
305 if (base_offset == INT64_MAX)
308 bit_offset = base_offset * 8;
318 static llvm::once_flag g_once_flag;
319 llvm::call_once(g_once_flag, []() {
326 bool is_complete_objc_class)
327 : m_payload(owning_module.GetValue()) {
339 const clang::Decl *parent) {
340 if (!member || !parent)
347 member->setFromASTFile();
348 member->setOwningModuleID(
id.GetValue());
349 member->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
350 if (llvm::isa<clang::NamedDecl>(member))
351 if (
auto *dc = llvm::dyn_cast<clang::DeclContext>(parent)) {
352 dc->setHasExternalVisibleStorage(
true);
355 dc->setHasExternalLexicalStorage(
true);
362 clang::OverloadedOperatorKind &op_kind) {
364 if (!name.consume_front(
"operator"))
369 bool space_after_operator = name.consume_front(
" ");
371 op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
372 .Case(
"+", clang::OO_Plus)
373 .Case(
"+=", clang::OO_PlusEqual)
374 .Case(
"++", clang::OO_PlusPlus)
375 .Case(
"-", clang::OO_Minus)
376 .Case(
"-=", clang::OO_MinusEqual)
377 .Case(
"--", clang::OO_MinusMinus)
378 .Case(
"->", clang::OO_Arrow)
379 .Case(
"->*", clang::OO_ArrowStar)
380 .Case(
"*", clang::OO_Star)
381 .Case(
"*=", clang::OO_StarEqual)
382 .Case(
"/", clang::OO_Slash)
383 .Case(
"/=", clang::OO_SlashEqual)
384 .Case(
"%", clang::OO_Percent)
385 .Case(
"%=", clang::OO_PercentEqual)
386 .Case(
"^", clang::OO_Caret)
387 .Case(
"^=", clang::OO_CaretEqual)
388 .Case(
"&", clang::OO_Amp)
389 .Case(
"&=", clang::OO_AmpEqual)
390 .Case(
"&&", clang::OO_AmpAmp)
391 .Case(
"|", clang::OO_Pipe)
392 .Case(
"|=", clang::OO_PipeEqual)
393 .Case(
"||", clang::OO_PipePipe)
394 .Case(
"~", clang::OO_Tilde)
395 .Case(
"!", clang::OO_Exclaim)
396 .Case(
"!=", clang::OO_ExclaimEqual)
397 .Case(
"=", clang::OO_Equal)
398 .Case(
"==", clang::OO_EqualEqual)
399 .Case(
"<", clang::OO_Less)
400 .Case(
"<<", clang::OO_LessLess)
401 .Case(
"<<=", clang::OO_LessLessEqual)
402 .Case(
"<=", clang::OO_LessEqual)
403 .Case(
">", clang::OO_Greater)
404 .Case(
">>", clang::OO_GreaterGreater)
405 .Case(
">>=", clang::OO_GreaterGreaterEqual)
406 .Case(
">=", clang::OO_GreaterEqual)
407 .Case(
"()", clang::OO_Call)
408 .Case(
"[]", clang::OO_Subscript)
409 .Case(
",", clang::OO_Comma)
410 .Default(clang::NUM_OVERLOADED_OPERATORS);
413 if (op_kind != clang::NUM_OVERLOADED_OPERATORS)
425 if (!space_after_operator)
430 op_kind = StringSwitch<clang::OverloadedOperatorKind>(name)
431 .Case(
"new", clang::OO_New)
432 .Case(
"new[]", clang::OO_Array_New)
433 .Case(
"delete", clang::OO_Delete)
434 .Case(
"delete[]", clang::OO_Array_Delete)
436 .Default(clang::NUM_OVERLOADED_OPERATORS);
441 clang::AccessSpecifier
458 static void ParseLangArgs(LangOptions &Opts, InputKind IK,
const char *triple) {
464 if (IK.getLanguage() == clang::Language::Asm) {
465 Opts.AsmPreprocessor = 1;
466 }
else if (IK.isObjectiveC()) {
470 LangStandard::Kind LangStd = LangStandard::lang_unspecified;
472 if (LangStd == LangStandard::lang_unspecified) {
474 switch (IK.getLanguage()) {
475 case clang::Language::Unknown:
476 case clang::Language::LLVM_IR:
477 case clang::Language::RenderScript:
478 llvm_unreachable(
"Invalid input kind!");
479 case clang::Language::OpenCL:
480 LangStd = LangStandard::lang_opencl10;
482 case clang::Language::CUDA:
483 LangStd = LangStandard::lang_cuda;
485 case clang::Language::Asm:
486 case clang::Language::C:
487 case clang::Language::ObjC:
488 LangStd = LangStandard::lang_gnu99;
490 case clang::Language::CXX:
491 case clang::Language::ObjCXX:
492 LangStd = LangStandard::lang_gnucxx98;
494 case clang::Language::HIP:
495 LangStd = LangStandard::lang_hip;
500 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
501 Opts.LineComment = Std.hasLineComments();
502 Opts.C99 = Std.isC99();
503 Opts.CPlusPlus = Std.isCPlusPlus();
504 Opts.CPlusPlus11 = Std.isCPlusPlus11();
505 Opts.Digraphs = Std.hasDigraphs();
506 Opts.GNUMode = Std.isGNUMode();
507 Opts.GNUInline = !Std.isC99();
508 Opts.HexFloats = Std.hasHexFloats();
509 Opts.ImplicitInt = Std.hasImplicitInt();
514 if (LangStd == LangStandard::lang_opencl10) {
517 Opts.CXXOperatorNames = 1;
518 Opts.setLaxVectorConversions(LangOptions::LaxVectorConversionKind::All);
522 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
524 Opts.setValueVisibilityMode(DefaultVisibility);
528 Opts.Trigraphs = !Opts.GNUMode;
530 Opts.OptimizeSize = 0;
543 Opts.NoInlineDefine = !Opt;
547 Opts.ModulesLocalVisibility = 1;
551 llvm::Triple target_triple) {
553 if (!target_triple.str().empty())
561 ASTContext &existing_ctxt) {
585 if (!TypeSystemClangSupportsLanguage(language))
586 return lldb::TypeSystemSP();
594 return lldb::TypeSystemSP();
599 if (triple.getVendor() == llvm::Triple::Apple &&
600 triple.getOS() == llvm::Triple::UnknownOS) {
601 if (triple.getArch() == llvm::Triple::arm ||
602 triple.getArch() == llvm::Triple::aarch64 ||
603 triple.getArch() == llvm::Triple::aarch64_32 ||
604 triple.getArch() == llvm::Triple::thumb) {
605 triple.setOS(llvm::Triple::IOS);
607 triple.setOS(llvm::Triple::MacOSX);
614 return std::make_shared<TypeSystemClang>(ast_name, triple);
615 }
else if (target && target->
IsValid())
616 return std::make_shared<ScratchTypeSystemClang>(*target, triple);
617 return lldb::TypeSystemSP();
674 assert(s ==
nullptr || &s->getASTContext() ==
m_ast_up.get());
687 llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_up) {
689 ast.setExternalSource(ast_source_up);
690 ast.getTranslationUnitDecl()->setHasExternalLexicalStorage(
true);
705 const clang::Diagnostic &info)
override {
707 llvm::SmallVector<char, 32> diag_str(10);
708 info.FormatDiagnostic(diag_str);
709 diag_str.push_back(
'\0');
710 LLDB_LOGF(m_log,
"Compiler diagnostic: %s\n", diag_str.data());
714 DiagnosticConsumer *
clone(DiagnosticsEngine &Diags)
const {
736 clang::FileSystemOptions file_system_options;
740 llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(
new DiagnosticIDs());
742 std::make_unique<DiagnosticsEngine>(diag_id_sp,
new DiagnosticOptions());
746 m_ast_up = std::make_unique<ASTContext>(
758 m_ast_up->InitBuiltinTypes(*target_info);
762 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_up(
795 #pragma mark Basic Types
798 ASTContext &ast, QualType qual_type) {
799 uint64_t qual_type_bit_size = ast.getTypeSize(qual_type);
800 return qual_type_bit_size == bit_size;
815 return GetType(ast.UnsignedCharTy);
817 return GetType(ast.UnsignedShortTy);
819 return GetType(ast.UnsignedIntTy);
821 return GetType(ast.UnsignedLongTy);
823 return GetType(ast.UnsignedLongLongTy);
825 return GetType(ast.UnsignedInt128Ty);
830 return GetType(ast.SignedCharTy);
838 return GetType(ast.LongLongTy);
849 return GetType(ast.LongDoubleTy);
856 if (bit_size && !(bit_size & 0x7u))
857 return GetType(ast.getExtVectorType(ast.UnsignedCharTy, bit_size / 8));
868 static TypeNameToBasicTypeMap g_type_map;
869 static llvm::once_flag g_once_flag;
870 llvm::call_once(g_once_flag, []() {
886 g_type_map.Append(
ConstString(
"unsigned short int"),
899 g_type_map.Append(
ConstString(
"unsigned long int"),
905 g_type_map.Append(
ConstString(
"unsigned long long"),
907 g_type_map.Append(
ConstString(
"unsigned long long int"),
967 return GetType(ast.UnsignedCharTy);
969 return GetType(ast.UnsignedShortTy);
971 return GetType(ast.UnsignedIntTy);
976 if (type_name.contains(
"complex")) {
985 case DW_ATE_complex_float:
987 return GetType(ast.FloatComplexTy);
989 return GetType(ast.DoubleComplexTy);
991 return GetType(ast.LongDoubleComplexTy);
1002 if (type_name ==
"float" &&
1005 if (type_name ==
"double" &&
1008 if (type_name ==
"long double" &&
1010 return GetType(ast.LongDoubleTy);
1017 return GetType(ast.LongDoubleTy);
1023 if (!type_name.empty()) {
1024 if (type_name ==
"wchar_t" &&
1029 if (type_name ==
"void" &&
1032 if (type_name.contains(
"long long") &&
1034 return GetType(ast.LongLongTy);
1035 if (type_name.contains(
"long") &&
1038 if (type_name.contains(
"short") &&
1041 if (type_name.contains(
"char")) {
1045 return GetType(ast.SignedCharTy);
1047 if (type_name.contains(
"int")) {
1064 return GetType(ast.LongLongTy);
1069 case DW_ATE_signed_char:
1070 if (ast.getLangOpts().CharIsSigned && type_name ==
"char") {
1075 return GetType(ast.SignedCharTy);
1078 case DW_ATE_unsigned:
1079 if (!type_name.empty()) {
1080 if (type_name ==
"wchar_t") {
1087 if (type_name.contains(
"long long")) {
1089 return GetType(ast.UnsignedLongLongTy);
1090 }
else if (type_name.contains(
"long")) {
1092 return GetType(ast.UnsignedLongTy);
1093 }
else if (type_name.contains(
"short")) {
1095 return GetType(ast.UnsignedShortTy);
1096 }
else if (type_name.contains(
"char")) {
1098 return GetType(ast.UnsignedCharTy);
1099 }
else if (type_name.contains(
"int")) {
1101 return GetType(ast.UnsignedIntTy);
1103 return GetType(ast.UnsignedInt128Ty);
1108 return GetType(ast.UnsignedCharTy);
1110 return GetType(ast.UnsignedShortTy);
1112 return GetType(ast.UnsignedIntTy);
1114 return GetType(ast.UnsignedLongTy);
1116 return GetType(ast.UnsignedLongLongTy);
1118 return GetType(ast.UnsignedInt128Ty);
1121 case DW_ATE_unsigned_char:
1122 if (!ast.getLangOpts().CharIsSigned && type_name ==
"char") {
1127 return GetType(ast.UnsignedCharTy);
1129 return GetType(ast.UnsignedShortTy);
1132 case DW_ATE_imaginary_float:
1144 if (!type_name.empty()) {
1145 if (type_name ==
"char16_t")
1147 if (type_name ==
"char32_t")
1149 if (type_name ==
"char8_t")
1157 if (!type_name.empty()) {
1160 "error: need to add support for DW_TAG_base_type '%s' "
1161 "encoded with DW_ATE = 0x%x, bit_size = %u\n",
1162 type_name_str.c_str(), dw_ate, bit_size);
1165 "DW_TAG_base_type encoded with "
1166 "DW_ATE = 0x%x, bit_size = %u\n",
1174 QualType char_type(ast.CharTy);
1177 char_type.addConst();
1179 return GetType(ast.getPointerType(char_type));
1183 bool ignore_qualifiers) {
1185 llvm::dyn_cast_or_null<TypeSystemClang>(type1.
GetTypeSystem());
1195 if (ignore_qualifiers) {
1196 type1_qual = type1_qual.getUnqualifiedType();
1197 type2_qual = type2_qual.getUnqualifiedType();
1200 return ast->
getASTContext().hasSameType(type1_qual, type2_qual);
1207 clang::Decl *decl =
static_cast<clang::Decl *
>(opaque_decl);
1208 if (
auto *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl))
1220 if (clang::ObjCInterfaceDecl *interface_decl =
1221 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
1223 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
1236 #pragma mark Structure, Unions, Classes
1240 if (!decl || !owning_module.
HasValue())
1243 decl->setFromASTFile();
1244 decl->setOwningModuleID(owning_module.
GetValue());
1245 decl->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
1251 bool is_framework,
bool is_explicit) {
1253 auto *ast_source = llvm::dyn_cast_or_null<ClangExternalASTSourceCallbacks>(
1255 assert(ast_source &&
"external ast source was lost");
1261 auto HSOpts = std::make_shared<clang::HeaderSearchOptions>();
1272 clang::Module *module;
1273 auto parent_desc = ast_source->getSourceDescriptor(parent.
GetValue());
1275 name, parent_desc ? parent_desc->getModuleOrNull() :
nullptr,
1276 is_framework, is_explicit);
1278 return ast_source->GetIDForModule(module);
1280 return ast_source->RegisterModule(module);
1285 AccessType access_type, llvm::StringRef name,
int kind,
1289 if (decl_ctx ==
nullptr)
1290 decl_ctx = ast.getTranslationUnitDecl();
1294 bool isForwardDecl =
true;
1295 bool isInternal =
false;
1297 isInternal, metadata);
1306 bool has_name = !name.empty();
1307 CXXRecordDecl *decl = CXXRecordDecl::CreateDeserialized(ast, 0);
1308 decl->setTagKind(
static_cast<TagDecl::TagKind
>(kind));
1309 decl->setDeclContext(decl_ctx);
1311 decl->setDeclName(&ast.Idents.get(name));
1339 if (isa<CXXRecordDecl>(decl_ctx) && exports_symbols)
1340 decl->setAnonymousStructOrUnion(
true);
1351 decl_ctx->addDecl(decl);
1353 return GetType(ast.getTagDeclType(decl));
1359 bool IsValueParam(
const clang::TemplateArgument &argument) {
1360 return argument.getKind() == TemplateArgument::Integral;
1367 llvm::SmallVector<NamedDecl *, 8> &template_param_decls) {
1368 const bool parameter_pack =
false;
1369 const bool is_typename =
false;
1370 const unsigned depth = 0;
1371 const size_t num_template_params = template_param_infos.
args.size();
1372 DeclContext *
const decl_context =
1373 ast.getTranslationUnitDecl();
1374 for (
size_t i = 0; i < num_template_params; ++i) {
1375 const char *name = template_param_infos.
names[i];
1377 IdentifierInfo *identifier_info =
nullptr;
1378 if (name && name[0])
1379 identifier_info = &ast.Idents.get(name);
1380 if (IsValueParam(template_param_infos.
args[i])) {
1381 QualType template_param_type =
1382 template_param_infos.
args[i].getIntegralType();
1383 template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1384 ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
1385 identifier_info, template_param_type, parameter_pack,
1386 ast.getTrivialTypeSourceInfo(template_param_type)));
1388 template_param_decls.push_back(TemplateTypeParmDecl::Create(
1389 ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
1390 identifier_info, is_typename, parameter_pack));
1395 IdentifierInfo *identifier_info =
nullptr;
1397 identifier_info = &ast.Idents.get(template_param_infos.
pack_name);
1398 const bool parameter_pack_true =
true;
1400 if (!template_param_infos.
packed_args->args.empty() &&
1401 IsValueParam(template_param_infos.
packed_args->args[0])) {
1402 QualType template_param_type =
1403 template_param_infos.
packed_args->args[0].getIntegralType();
1404 template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1405 ast, decl_context, SourceLocation(), SourceLocation(), depth,
1406 num_template_params, identifier_info, template_param_type,
1407 parameter_pack_true,
1408 ast.getTrivialTypeSourceInfo(template_param_type)));
1410 template_param_decls.push_back(TemplateTypeParmDecl::Create(
1411 ast, decl_context, SourceLocation(), SourceLocation(), depth,
1412 num_template_params, identifier_info, is_typename,
1413 parameter_pack_true));
1416 clang::Expr *
const requires_clause =
nullptr;
1417 TemplateParameterList *template_param_list = TemplateParameterList::Create(
1418 ast, SourceLocation(), SourceLocation(), template_param_decls,
1419 SourceLocation(), requires_clause);
1420 return template_param_list;
1425 clang::FunctionDecl *func_decl,
1430 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1432 ast, template_param_infos, template_param_decls);
1433 FunctionTemplateDecl *func_tmpl_decl =
1434 FunctionTemplateDecl::CreateDeserialized(ast, 0);
1435 func_tmpl_decl->setDeclContext(decl_ctx);
1436 func_tmpl_decl->setLocation(func_decl->getLocation());
1437 func_tmpl_decl->setDeclName(func_decl->getDeclName());
1438 func_tmpl_decl->init(func_decl, template_param_list);
1441 for (
size_t i = 0, template_param_decl_count = template_param_decls.size();
1442 i < template_param_decl_count; ++i) {
1444 template_param_decls[i]->setDeclContext(func_decl);
1449 if (decl_ctx->isRecord())
1450 func_tmpl_decl->setAccess(clang::AccessSpecifier::AS_public);
1452 return func_tmpl_decl;
1456 FunctionDecl *func_decl, clang::FunctionTemplateDecl *func_tmpl_decl,
1458 TemplateArgumentList *template_args_ptr =
1459 TemplateArgumentList::CreateCopy(func_decl->getASTContext(), infos.
args);
1461 func_decl->setFunctionTemplateSpecialization(func_tmpl_decl,
1462 template_args_ptr,
nullptr);
1471 ClassTemplateDecl *class_template_decl =
nullptr;
1472 if (decl_ctx ==
nullptr)
1473 decl_ctx = ast.getTranslationUnitDecl();
1475 IdentifierInfo &identifier_info = ast.Idents.get(class_name);
1476 DeclarationName decl_name(&identifier_info);
1478 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1480 for (NamedDecl *decl : result) {
1481 class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
1482 if (class_template_decl)
1483 return class_template_decl;
1486 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1489 ast, template_param_infos, template_param_decls);
1491 CXXRecordDecl *template_cxx_decl = CXXRecordDecl::CreateDeserialized(ast, 0);
1492 template_cxx_decl->setTagKind(
static_cast<TagDecl::TagKind
>(kind));
1494 template_cxx_decl->setDeclContext(decl_ctx);
1495 template_cxx_decl->setDeclName(decl_name);
1498 for (
size_t i = 0, template_param_decl_count = template_param_decls.size();
1499 i < template_param_decl_count; ++i) {
1500 template_param_decls[i]->setDeclContext(template_cxx_decl);
1508 class_template_decl = ClassTemplateDecl::CreateDeserialized(ast, 0);
1510 class_template_decl->setDeclContext(decl_ctx);
1511 class_template_decl->setDeclName(decl_name);
1512 class_template_decl->init(template_cxx_decl, template_param_list);
1513 template_cxx_decl->setDescribedClassTemplate(class_template_decl);
1516 if (class_template_decl) {
1518 class_template_decl->setAccess(
1521 decl_ctx->addDecl(class_template_decl);
1523 VerifyDecl(class_template_decl);
1526 return class_template_decl;
1529 TemplateTemplateParmDecl *
1533 auto *decl_ctx = ast.getTranslationUnitDecl();
1535 IdentifierInfo &identifier_info = ast.Idents.get(template_name);
1536 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1540 ast, template_param_infos, template_param_decls);
1546 return TemplateTemplateParmDecl::Create(
1547 ast, decl_ctx, SourceLocation(),
1549 false, &identifier_info, template_param_list);
1552 ClassTemplateSpecializationDecl *
1555 ClassTemplateDecl *class_template_decl,
int kind,
1558 llvm::SmallVector<clang::TemplateArgument, 2> args(
1559 template_param_infos.
args.size() +
1561 std::copy(template_param_infos.
args.begin(), template_param_infos.
args.end(),
1564 args[args.size() - 1] = TemplateArgument::CreatePackCopy(
1567 ClassTemplateSpecializationDecl *class_template_specialization_decl =
1568 ClassTemplateSpecializationDecl::CreateDeserialized(ast, 0);
1569 class_template_specialization_decl->setTagKind(
1570 static_cast<TagDecl::TagKind
>(kind));
1571 class_template_specialization_decl->setDeclContext(decl_ctx);
1572 class_template_specialization_decl->setInstantiationOf(class_template_decl);
1573 class_template_specialization_decl->setTemplateArgs(
1574 TemplateArgumentList::CreateCopy(ast, args));
1575 ast.getTypeDeclType(class_template_specialization_decl,
nullptr);
1576 class_template_specialization_decl->setDeclName(
1577 class_template_decl->getDeclName());
1579 decl_ctx->addDecl(class_template_specialization_decl);
1581 class_template_specialization_decl->setSpecializationKind(
1582 TSK_ExplicitSpecialization);
1584 return class_template_specialization_decl;
1588 ClassTemplateSpecializationDecl *class_template_specialization_decl) {
1589 if (class_template_specialization_decl) {
1591 return GetType(ast.getTagDeclType(class_template_specialization_decl));
1597 clang::OverloadedOperatorKind op_kind,
1598 bool unary,
bool binary,
1601 if (op_kind == OO_Call)
1607 if (num_params == 1)
1609 if (num_params == 2)
1616 bool is_method, clang::OverloadedOperatorKind op_kind,
1625 case OO_Array_Delete:
1629 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
1631 return check_op_param(is_method, op_kind, Unary, Binary, num_params);
1633 #include "clang/Basic/OperatorKinds.def"
1640 clang::AccessSpecifier
1642 clang::AccessSpecifier rhs) {
1645 if (lhs == AS_none || rhs == AS_none)
1647 if (lhs == AS_private || rhs == AS_private)
1649 if (lhs == AS_protected || rhs == AS_protected)
1650 return AS_protected;
1657 if (field ==
nullptr)
1660 if (field->isBitField()) {
1661 Expr *bit_width_expr = field->getBitWidth();
1662 if (bit_width_expr) {
1663 if (Optional<llvm::APSInt> bit_width_apsint =
1664 bit_width_expr->getIntegerConstantExpr(ast)) {
1665 bitfield_bit_size = bit_width_apsint->getLimitedValue(
UINT32_MAX);
1674 if (record_decl ==
nullptr)
1677 if (!record_decl->field_empty())
1681 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1682 if (cxx_record_decl) {
1683 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1684 for (base_class = cxx_record_decl->bases_begin(),
1685 base_class_end = cxx_record_decl->bases_end();
1686 base_class != base_class_end; ++base_class) {
1687 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(
1688 base_class->getType()->getAs<RecordType>()->getDecl());
1696 #pragma mark Objective-C Classes
1699 llvm::StringRef name, clang::DeclContext *decl_ctx,
1703 assert(!name.empty());
1705 decl_ctx = ast.getTranslationUnitDecl();
1707 ObjCInterfaceDecl *decl = ObjCInterfaceDecl::CreateDeserialized(ast, 0);
1708 decl->setDeclContext(decl_ctx);
1709 decl->setDeclName(&ast.Idents.get(name));
1711 decl->setImplicit(isInternal);
1714 if (decl && metadata)
1717 return GetType(ast.getObjCInterfaceType(decl));
1726 bool omit_empty_base_classes) {
1728 if (cxx_record_decl) {
1729 if (omit_empty_base_classes) {
1730 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1731 for (base_class = cxx_record_decl->bases_begin(),
1732 base_class_end = cxx_record_decl->bases_end();
1733 base_class != base_class_end; ++base_class) {
1740 num_bases = cxx_record_decl->getNumBases();
1745 #pragma mark Namespace Declarations
1748 const char *name, clang::DeclContext *decl_ctx,
1750 NamespaceDecl *namespace_decl =
nullptr;
1752 TranslationUnitDecl *translation_unit_decl = ast.getTranslationUnitDecl();
1754 decl_ctx = translation_unit_decl;
1757 IdentifierInfo &identifier_info = ast.Idents.get(name);
1758 DeclarationName decl_name(&identifier_info);
1759 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1760 for (NamedDecl *decl : result) {
1761 namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
1763 return namespace_decl;
1767 NamespaceDecl::Create(ast, decl_ctx, is_inline, SourceLocation(),
1768 SourceLocation(), &identifier_info,
nullptr);
1770 decl_ctx->addDecl(namespace_decl);
1772 if (decl_ctx == translation_unit_decl) {
1773 namespace_decl = translation_unit_decl->getAnonymousNamespace();
1775 return namespace_decl;
1778 NamespaceDecl::Create(ast, decl_ctx,
false, SourceLocation(),
1779 SourceLocation(),
nullptr,
nullptr);
1780 translation_unit_decl->setAnonymousNamespace(namespace_decl);
1781 translation_unit_decl->addDecl(namespace_decl);
1782 assert(namespace_decl == translation_unit_decl->getAnonymousNamespace());
1784 NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
1785 if (parent_namespace_decl) {
1786 namespace_decl = parent_namespace_decl->getAnonymousNamespace();
1788 return namespace_decl;
1790 NamespaceDecl::Create(ast, decl_ctx,
false, SourceLocation(),
1791 SourceLocation(),
nullptr,
nullptr);
1792 parent_namespace_decl->setAnonymousNamespace(namespace_decl);
1793 parent_namespace_decl->addDecl(namespace_decl);
1794 assert(namespace_decl ==
1795 parent_namespace_decl->getAnonymousNamespace());
1797 assert(
false &&
"GetUniqueNamespaceDeclaration called with no name and "
1798 "no namespace as decl_ctx");
1806 VerifyDecl(namespace_decl);
1807 return namespace_decl;
1814 clang::BlockDecl *decl =
1816 decl->setDeclContext(ctx);
1825 clang::DeclContext *right,
1826 clang::DeclContext *root) {
1827 if (root ==
nullptr)
1830 std::set<clang::DeclContext *> path_left;
1831 for (clang::DeclContext *d = left; d !=
nullptr; d = d->getParent())
1832 path_left.insert(d);
1834 for (clang::DeclContext *d = right; d !=
nullptr; d = d->getParent())
1835 if (path_left.find(d) != path_left.end())
1843 clang::NamespaceDecl *ns_decl) {
1844 if (decl_ctx && ns_decl) {
1845 auto *translation_unit =
getASTContext().getTranslationUnitDecl();
1846 clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(
1848 clang::SourceLocation(), clang::NestedNameSpecifierLoc(),
1849 clang::SourceLocation(), ns_decl,
1852 decl_ctx->addDecl(using_decl);
1862 clang::NamedDecl *target) {
1863 if (current_decl_ctx && target) {
1864 clang::UsingDecl *using_decl = clang::UsingDecl::Create(
1866 clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(),
false);
1868 clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
1869 getASTContext(), current_decl_ctx, clang::SourceLocation(), using_decl,
1872 using_decl->addShadowDecl(shadow_decl);
1873 current_decl_ctx->addDecl(using_decl);
1881 const char *name, clang::QualType type) {
1883 clang::VarDecl *var_decl =
1885 var_decl->setDeclContext(decl_context);
1886 if (name && name[0])
1887 var_decl->setDeclName(&
getASTContext().Idents.getOwn(name));
1888 var_decl->setType(type);
1890 var_decl->setAccess(clang::AS_public);
1891 decl_context->addDecl(var_decl);
1900 switch (basic_type) {
1902 return ast->VoidTy.getAsOpaquePtr();
1904 return ast->CharTy.getAsOpaquePtr();
1906 return ast->SignedCharTy.getAsOpaquePtr();
1908 return ast->UnsignedCharTy.getAsOpaquePtr();
1910 return ast->getWCharType().getAsOpaquePtr();
1912 return ast->getSignedWCharType().getAsOpaquePtr();
1914 return ast->getUnsignedWCharType().getAsOpaquePtr();
1916 return ast->Char16Ty.getAsOpaquePtr();
1918 return ast->Char32Ty.getAsOpaquePtr();
1920 return ast->ShortTy.getAsOpaquePtr();
1922 return ast->UnsignedShortTy.getAsOpaquePtr();
1924 return ast->IntTy.getAsOpaquePtr();
1926 return ast->UnsignedIntTy.getAsOpaquePtr();
1928 return ast->LongTy.getAsOpaquePtr();
1930 return ast->UnsignedLongTy.getAsOpaquePtr();
1932 return ast->LongLongTy.getAsOpaquePtr();
1934 return ast->UnsignedLongLongTy.getAsOpaquePtr();
1936 return ast->Int128Ty.getAsOpaquePtr();
1938 return ast->UnsignedInt128Ty.getAsOpaquePtr();
1940 return ast->BoolTy.getAsOpaquePtr();
1942 return ast->HalfTy.getAsOpaquePtr();
1944 return ast->FloatTy.getAsOpaquePtr();
1946 return ast->DoubleTy.getAsOpaquePtr();
1948 return ast->LongDoubleTy.getAsOpaquePtr();
1950 return ast->FloatComplexTy.getAsOpaquePtr();
1952 return ast->DoubleComplexTy.getAsOpaquePtr();
1954 return ast->LongDoubleComplexTy.getAsOpaquePtr();
1956 return ast->getObjCIdType().getAsOpaquePtr();
1958 return ast->getObjCClassType().getAsOpaquePtr();
1960 return ast->getObjCSelType().getAsOpaquePtr();
1962 return ast->NullPtrTy.getAsOpaquePtr();
1968 #pragma mark Function Types
1970 clang::DeclarationName
1973 clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
1974 if (!
IsOperator(name, op_kind) || op_kind == clang::NUM_OVERLOADED_OPERATORS)
1983 const clang::FunctionProtoType *function_type =
1984 llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr());
1985 if (function_type ==
nullptr)
1986 return clang::DeclarationName();
1988 const bool is_method =
false;
1989 const unsigned int num_params = function_type->getNumParams();
1991 is_method, op_kind, num_params))
1992 return clang::DeclarationName();
1994 return getASTContext().DeclarationNames.getCXXOperatorName(op_kind);
1998 clang::PrintingPolicy printing_policy(
getASTContext().getPrintingPolicy());
1999 printing_policy.SuppressTagKeyword =
true;
2002 printing_policy.SuppressInlineNamespace =
false;
2003 printing_policy.SuppressUnwrittenScope =
false;
2015 printing_policy.SuppressDefaultTemplateArgs =
false;
2016 return printing_policy;
2022 llvm::raw_string_ostream os(result);
2023 named_decl->printQualifiedName(os, printing_policy);
2029 llvm::StringRef name,
const CompilerType &function_clang_type,
2030 clang::StorageClass storage,
bool is_inline) {
2031 FunctionDecl *func_decl =
nullptr;
2034 decl_ctx = ast.getTranslationUnitDecl();
2036 const bool hasWrittenPrototype =
true;
2037 const bool isConstexprSpecified =
false;
2039 clang::DeclarationName declarationName =
2041 func_decl = FunctionDecl::CreateDeserialized(ast, 0);
2042 func_decl->setDeclContext(decl_ctx);
2043 func_decl->setDeclName(declarationName);
2045 func_decl->setStorageClass(storage);
2046 func_decl->setInlineSpecified(is_inline);
2047 func_decl->setHasWrittenPrototype(hasWrittenPrototype);
2048 func_decl->setConstexprKind(isConstexprSpecified
2049 ? ConstexprSpecKind::Constexpr
2050 : ConstexprSpecKind::Unspecified);
2053 decl_ctx->addDecl(func_decl);
2055 VerifyDecl(func_decl);
2063 bool is_variadic,
unsigned type_quals,
2064 clang::CallingConv cc) {
2068 std::vector<QualType> qual_type_args;
2069 if (num_args > 0 && args ==
nullptr)
2073 for (
unsigned i = 0; i < num_args; ++i) {
2088 FunctionProtoType::ExtProtoInfo proto_info;
2089 proto_info.ExtInfo = cc;
2090 proto_info.Variadic = is_variadic;
2091 proto_info.ExceptionSpec = EST_None;
2092 proto_info.TypeQuals = clang::Qualifiers::fromFastMask(type_quals);
2093 proto_info.RefQualifier = RQ_None;
2101 const char *name,
const CompilerType ¶m_type,
int storage,
2104 auto *decl = ParmVarDecl::CreateDeserialized(ast, 0);
2105 decl->setDeclContext(decl_ctx);
2106 if (name && name[0])
2107 decl->setDeclName(&ast.Idents.get(name));
2109 decl->setStorageClass(
static_cast<clang::StorageClass
>(storage));
2112 decl_ctx->addDecl(decl);
2118 ParmVarDecl **params,
2119 unsigned num_params) {
2121 function_decl->setParams(ArrayRef<ParmVarDecl *>(params, num_params));
2126 QualType block_type =
m_ast_up->getBlockPointerType(
2132 #pragma mark Array Types
2135 size_t element_count,
2145 llvm::APInt ap_element_count(64, element_count);
2146 if (element_count == 0) {
2147 return GetType(ast.getIncompleteArrayType(
2150 return GetType(ast.getConstantArrayType(
2152 clang::ArrayType::Normal, 0));
2161 const std::initializer_list<std::pair<const char *, CompilerType>>
2166 (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name))
2168 lldbassert(0 &&
"Trying to create a type for an existing name");
2176 for (
const auto &field : type_fields)
2187 const std::initializer_list<std::pair<const char *, CompilerType>>
2191 if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
2197 #pragma mark Enumeration Types
2200 const char *name, clang::DeclContext *decl_ctx,
2202 const CompilerType &integer_clang_type,
bool is_scoped) {
2209 EnumDecl *enum_decl = EnumDecl::CreateDeserialized(ast, 0);
2210 enum_decl->setDeclContext(decl_ctx);
2211 if (name && name[0])
2212 enum_decl->setDeclName(&ast.Idents.get(name));
2213 enum_decl->setScoped(is_scoped);
2214 enum_decl->setScopedUsingClassTag(is_scoped);
2215 enum_decl->setFixed(
false);
2219 decl_ctx->addDecl(enum_decl);
2224 enum_decl->setAccess(AS_public);
2226 return GetType(ast.getTagDeclType(enum_decl));
2236 if (bit_size == ast.getTypeSize(ast.SignedCharTy))
2237 return GetType(ast.SignedCharTy);
2239 if (bit_size == ast.getTypeSize(ast.ShortTy))
2242 if (bit_size == ast.getTypeSize(ast.IntTy))
2245 if (bit_size == ast.getTypeSize(ast.LongTy))
2248 if (bit_size == ast.getTypeSize(ast.LongLongTy))
2249 return GetType(ast.LongLongTy);
2251 if (bit_size == ast.getTypeSize(ast.Int128Ty))
2254 if (bit_size == ast.getTypeSize(ast.UnsignedCharTy))
2255 return GetType(ast.UnsignedCharTy);
2257 if (bit_size == ast.getTypeSize(ast.UnsignedShortTy))
2258 return GetType(ast.UnsignedShortTy);
2260 if (bit_size == ast.getTypeSize(ast.UnsignedIntTy))
2261 return GetType(ast.UnsignedIntTy);
2263 if (bit_size == ast.getTypeSize(ast.UnsignedLongTy))
2264 return GetType(ast.UnsignedLongTy);
2266 if (bit_size == ast.getTypeSize(ast.UnsignedLongLongTy))
2267 return GetType(ast.UnsignedLongLongTy);
2269 if (bit_size == ast.getTypeSize(ast.UnsignedInt128Ty))
2270 return GetType(ast.UnsignedInt128Ty);
2284 clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx);
2286 printf(
"%20s: %s\n", decl_ctx->getDeclKindName(),
2287 named_decl->getDeclName().getAsString().c_str());
2289 printf(
"%20s\n", decl_ctx->getDeclKindName());
2295 if (decl ==
nullptr)
2299 clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl);
2301 printf(
"%20s: %s%s\n", decl->getDeclKindName(),
2302 record_decl->getDeclName().getAsString().c_str(),
2303 record_decl->isInjectedClassName() ?
" (injected class name)" :
"");
2306 clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl);
2308 printf(
"%20s: %s\n", decl->getDeclKindName(),
2309 named_decl->getDeclName().getAsString().c_str());
2311 printf(
"%20s\n", decl->getDeclKindName());
2317 clang::Decl *rhs_decl) {
2318 if (lhs_decl && rhs_decl) {
2320 const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind();
2321 const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind();
2323 if (lhs_decl_kind == rhs_decl_kind) {
2326 clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
2327 clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
2328 if (lhs_decl_ctx && rhs_decl_ctx) {
2330 if (lhs_decl_ctx && rhs_decl_ctx) {
2331 const clang::Decl::Kind lhs_decl_ctx_kind =
2332 lhs_decl_ctx->getDeclKind();
2333 const clang::Decl::Kind rhs_decl_ctx_kind =
2334 rhs_decl_ctx->getDeclKind();
2335 if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) {
2336 lhs_decl_ctx = lhs_decl_ctx->getParent();
2337 rhs_decl_ctx = rhs_decl_ctx->getParent();
2339 if (lhs_decl_ctx ==
nullptr && rhs_decl_ctx ==
nullptr)
2348 clang::NamedDecl *lhs_named_decl =
2349 llvm::dyn_cast<clang::NamedDecl>(lhs_decl);
2350 clang::NamedDecl *rhs_named_decl =
2351 llvm::dyn_cast<clang::NamedDecl>(rhs_decl);
2352 if (lhs_named_decl && rhs_named_decl) {
2353 clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
2354 clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
2355 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2356 if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2365 lhs_decl_ctx = lhs_decl->getDeclContext();
2366 rhs_decl_ctx = rhs_decl->getDeclContext();
2368 switch (lhs_decl_ctx->getDeclKind()) {
2369 case clang::Decl::TranslationUnit:
2373 clang::NamedDecl *lhs_named_decl =
2374 llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
2375 clang::NamedDecl *rhs_named_decl =
2376 llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx);
2377 if (lhs_named_decl && rhs_named_decl) {
2378 clang::DeclarationName lhs_decl_name =
2379 lhs_named_decl->getDeclName();
2380 clang::DeclarationName rhs_decl_name =
2381 rhs_named_decl->getDeclName();
2382 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2383 if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2391 lhs_decl_ctx = lhs_decl_ctx->getParent();
2392 rhs_decl_ctx = rhs_decl_ctx->getParent();
2400 clang::Decl *decl) {
2404 ExternalASTSource *ast_source = ast->getExternalSource();
2409 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) {
2410 if (tag_decl->isCompleteDefinition())
2413 if (!tag_decl->hasExternalLexicalStorage())
2416 ast_source->CompleteType(tag_decl);
2418 return !tag_decl->getTypeForDecl()->isIncompleteType();
2419 }
else if (clang::ObjCInterfaceDecl *objc_interface_decl =
2420 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) {
2421 if (objc_interface_decl->getDefinition())
2424 if (!objc_interface_decl->hasExternalLexicalStorage())
2427 ast_source->CompleteType(objc_interface_decl);
2429 return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
2475 const clang::Type *clang_type = tag_qual_type.getTypePtr();
2477 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type);
2479 clang::TagDecl *tag_decl =
2480 llvm::dyn_cast<clang::TagDecl>(tag_type->getDecl());
2482 tag_decl->setTagKind((clang::TagDecl::TagKind)kind);
2491 clang::RecordDecl *record_decl,
int default_accessibility,
2492 int *assigned_accessibilities,
size_t num_assigned_accessibilities) {
2495 clang::RecordDecl::field_iterator field, field_end;
2496 for (field = record_decl->field_begin(),
2497 field_end = record_decl->field_end(), field_idx = 0;
2498 field != field_end; ++field, ++field_idx) {
2500 if (field_idx < num_assigned_accessibilities &&
2501 assigned_accessibilities[field_idx] == clang::AS_none)
2502 field->setAccess((clang::AccessSpecifier)default_accessibility);
2509 clang::DeclContext *
2521 if (find(mask, type->getTypeClass()) != mask.end())
2523 switch (type->getTypeClass()) {
2526 case clang::Type::Atomic:
2527 type = cast<clang::AtomicType>(type)->getValueType();
2529 case clang::Type::Auto:
2530 case clang::Type::Decltype:
2531 case clang::Type::Elaborated:
2532 case clang::Type::Paren:
2533 case clang::Type::SubstTemplateTypeParm:
2534 case clang::Type::TemplateSpecialization:
2535 case clang::Type::Typedef:
2536 case clang::Type::TypeOf:
2537 case clang::Type::TypeOfExpr:
2538 type = type->getLocallyUnqualifiedSingleStepDesugaredType();
2546 clang::DeclContext *
2552 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2553 switch (type_class) {
2554 case clang::Type::ObjCInterface:
2555 return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())
2557 case clang::Type::ObjCObjectPointer:
2559 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
2560 ->getPointeeType());
2561 case clang::Type::Record:
2562 return llvm::cast<clang::RecordType>(qual_type)->getDecl();
2563 case clang::Type::Enum:
2564 return llvm::cast<clang::EnumType>(qual_type)->getDecl();
2573 clang::QualType qual_type,
2574 bool allow_completion =
true) {
2576 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2577 switch (type_class) {
2578 case clang::Type::ConstantArray:
2579 case clang::Type::IncompleteArray:
2580 case clang::Type::VariableArray: {
2581 const clang::ArrayType *array_type =
2582 llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
2588 case clang::Type::Record: {
2589 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2590 if (cxx_record_decl) {
2591 if (cxx_record_decl->hasExternalLexicalStorage()) {
2592 const bool is_complete = cxx_record_decl->isCompleteDefinition();
2593 const bool fields_loaded =
2594 cxx_record_decl->hasLoadedFieldsFromExternalStorage();
2595 if (is_complete && fields_loaded)
2598 if (!allow_completion)
2603 clang::ExternalASTSource *external_ast_source =
2604 ast->getExternalSource();
2605 if (external_ast_source) {
2606 external_ast_source->CompleteType(cxx_record_decl);
2607 if (cxx_record_decl->isCompleteDefinition()) {
2608 cxx_record_decl->field_begin();
2609 cxx_record_decl->setHasLoadedFieldsFromExternalStorage(
true);
2614 const clang::TagType *tag_type =
2615 llvm::cast<clang::TagType>(qual_type.getTypePtr());
2616 return !tag_type->isIncompleteType();
2619 case clang::Type::Enum: {
2620 const clang::TagType *tag_type =
2621 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
2623 clang::TagDecl *tag_decl = tag_type->getDecl();
2625 if (tag_decl->getDefinition())
2628 if (!allow_completion)
2631 if (tag_decl->hasExternalLexicalStorage()) {
2633 clang::ExternalASTSource *external_ast_source =
2634 ast->getExternalSource();
2635 if (external_ast_source) {
2636 external_ast_source->CompleteType(tag_decl);
2637 return !tag_type->isIncompleteType();
2646 case clang::Type::ObjCObject:
2647 case clang::Type::ObjCInterface: {
2648 const clang::ObjCObjectType *objc_class_type =
2649 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
2650 if (objc_class_type) {
2651 clang::ObjCInterfaceDecl *class_interface_decl =
2652 objc_class_type->getInterface();
2655 if (class_interface_decl) {
2656 if (class_interface_decl->getDefinition())
2659 if (!allow_completion)
2662 if (class_interface_decl->hasExternalLexicalStorage()) {
2664 clang::ExternalASTSource *external_ast_source =
2665 ast->getExternalSource();
2666 if (external_ast_source) {
2667 external_ast_source->CompleteType(class_interface_decl);
2668 return !objc_class_type->isIncompleteType();
2677 case clang::Type::Attributed:
2679 ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(),
2689 static clang::ObjCIvarDecl::AccessControl
2693 return clang::ObjCIvarDecl::None;
2695 return clang::ObjCIvarDecl::Public;
2697 return clang::ObjCIvarDecl::Private;
2699 return clang::ObjCIvarDecl::Protected;
2701 return clang::ObjCIvarDecl::Package;
2703 return clang::ObjCIvarDecl::None;
2710 return !type || llvm::isa<clang::Type>(
GetQualType(type).getTypePtr());
2717 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2718 switch (type_class) {
2719 case clang::Type::IncompleteArray:
2720 case clang::Type::VariableArray:
2721 case clang::Type::ConstantArray:
2722 case clang::Type::ExtVector:
2723 case clang::Type::Vector:
2724 case clang::Type::Record:
2725 case clang::Type::ObjCObject:
2726 case clang::Type::ObjCInterface:
2738 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2739 switch (type_class) {
2740 case clang::Type::Record: {
2741 if (
const clang::RecordType *record_type =
2742 llvm::dyn_cast_or_null<clang::RecordType>(
2743 qual_type.getTypePtrOrNull())) {
2744 if (
const clang::RecordDecl *record_decl = record_type->getDecl()) {
2745 return record_decl->isAnonymousStructOrUnion();
2759 uint64_t *size,
bool *is_incomplete) {
2762 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2763 switch (type_class) {
2767 case clang::Type::ConstantArray:
2768 if (element_type_ptr)
2770 this, llvm::cast<clang::ConstantArrayType>(qual_type)
2774 *size = llvm::cast<clang::ConstantArrayType>(qual_type)
2776 .getLimitedValue(ULLONG_MAX);
2778 *is_incomplete =
false;
2781 case clang::Type::IncompleteArray:
2782 if (element_type_ptr)
2784 this, llvm::cast<clang::IncompleteArrayType>(qual_type)
2790 *is_incomplete =
true;
2793 case clang::Type::VariableArray:
2794 if (element_type_ptr)
2796 this, llvm::cast<clang::VariableArrayType>(qual_type)
2802 *is_incomplete =
false;
2805 case clang::Type::DependentSizedArray:
2806 if (element_type_ptr)
2808 this, llvm::cast<clang::DependentSizedArrayType>(qual_type)
2814 *is_incomplete =
false;
2817 if (element_type_ptr)
2818 element_type_ptr->
Clear();
2822 *is_incomplete =
false;
2830 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2831 switch (type_class) {
2832 case clang::Type::Vector: {
2833 const clang::VectorType *vector_type =
2834 qual_type->getAs<clang::VectorType>();
2837 *size = vector_type->getNumElements();
2839 *element_type =
GetType(vector_type->getElementType());
2843 case clang::Type::ExtVector: {
2844 const clang::ExtVectorType *ext_vector_type =
2845 qual_type->getAs<clang::ExtVectorType>();
2846 if (ext_vector_type) {
2848 *size = ext_vector_type->getNumElements();
2851 CompilerType(
this, ext_vector_type->getElementType().getAsOpaquePtr());
2867 if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
2870 clang::ObjCInterfaceDecl *result_iface_decl =
2871 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
2876 return (ast_metadata->
GetISAPtr() != 0);
2880 return GetQualType(type).getUnqualifiedType()->isCharType();
2884 const bool allow_completion =
false;
2899 if (!pointee_or_element_clang_type.
IsValid())
2902 if (type_flags.
AnySet(eTypeIsArray | eTypeIsPointer)) {
2903 if (pointee_or_element_clang_type.
IsCharType()) {
2904 if (type_flags.
Test(eTypeIsArray)) {
2907 length = llvm::cast<clang::ConstantArrayType>(
2922 if (qual_type->isFunctionType()) {
2926 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2927 switch (type_class) {
2930 case clang::Type::LValueReference:
2931 case clang::Type::RValueReference: {
2932 const clang::ReferenceType *reference_type =
2933 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
2936 reference_type->getPointeeType().getAsOpaquePtr());
2951 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2952 switch (type_class) {
2953 case clang::Type::Record:
2955 const clang::CXXRecordDecl *cxx_record_decl =
2956 qual_type->getAsCXXRecordDecl();
2957 if (cxx_record_decl) {
2958 if (cxx_record_decl->getNumBases() || cxx_record_decl->isDynamicClass())
2961 const clang::RecordType *record_type =
2962 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
2964 const clang::RecordDecl *record_decl = record_type->getDecl();
2968 clang::RecordDecl::field_iterator field_pos,
2969 field_end = record_decl->field_end();
2971 bool is_hva =
false;
2972 bool is_hfa =
false;
2973 clang::QualType base_qual_type;
2974 uint64_t base_bitwidth = 0;
2975 for (field_pos = record_decl->field_begin(); field_pos != field_end;
2977 clang::QualType field_qual_type = field_pos->getType();
2978 uint64_t field_bitwidth =
getASTContext().getTypeSize(qual_type);
2979 if (field_qual_type->isFloatingType()) {
2980 if (field_qual_type->isComplexType())
2983 if (num_fields == 0)
2984 base_qual_type = field_qual_type;
2989 if (field_qual_type.getTypePtr() !=
2990 base_qual_type.getTypePtr())
2994 }
else if (field_qual_type->isVectorType() ||
2995 field_qual_type->isExtVectorType()) {
2996 if (num_fields == 0) {
2997 base_qual_type = field_qual_type;
2998 base_bitwidth = field_bitwidth;
3003 if (base_bitwidth != field_bitwidth)
3005 if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
3013 *base_type_ptr =
CompilerType(
this, base_qual_type.getAsOpaquePtr());
3030 const clang::FunctionProtoType *func =
3031 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3033 return func->getNumParams();
3040 const size_t index) {
3043 const clang::FunctionProtoType *func =
3044 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3046 if (index < func->getNumParams())
3047 return CompilerType(
this, func->getParamType(index).getAsOpaquePtr());
3057 if (qual_type->isFunctionPointerType())
3060 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3061 switch (type_class) {
3065 case clang::Type::LValueReference:
3066 case clang::Type::RValueReference: {
3067 const clang::ReferenceType *reference_type =
3068 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3071 reference_type->getPointeeType().getAsOpaquePtr());
3084 if (qual_type->isBlockPointerType()) {
3085 if (function_pointer_type_ptr) {
3086 const clang::BlockPointerType *block_pointer_type =
3087 qual_type->getAs<clang::BlockPointerType>();
3088 QualType pointee_type = block_pointer_type->getPointeeType();
3089 QualType function_pointer_type =
m_ast_up->getPointerType(pointee_type);
3090 *function_pointer_type_ptr =
3091 CompilerType(
this, function_pointer_type.getAsOpaquePtr());
3096 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3097 switch (type_class) {
3101 case clang::Type::LValueReference:
3102 case clang::Type::RValueReference: {
3103 const clang::ReferenceType *reference_type =
3104 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3107 reference_type->getPointeeType().getAsOpaquePtr(),
3108 function_pointer_type_ptr);
3121 const clang::BuiltinType *builtin_type =
3122 llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
3125 if (builtin_type->isInteger()) {
3126 is_signed = builtin_type->isSignedInteger();
3137 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3141 IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(),
3153 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3157 return enum_type->isScopedEnumeralType();
3168 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3169 switch (type_class) {
3170 case clang::Type::Builtin:
3171 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3174 case clang::BuiltinType::ObjCId:
3175 case clang::BuiltinType::ObjCClass:
3179 case clang::Type::ObjCObjectPointer:
3182 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3186 case clang::Type::BlockPointer:
3189 this, llvm::cast<clang::BlockPointerType>(qual_type)
3193 case clang::Type::Pointer:
3196 llvm::cast<clang::PointerType>(qual_type)
3200 case clang::Type::MemberPointer:
3203 this, llvm::cast<clang::MemberPointerType>(qual_type)
3212 pointee_type->
Clear();
3220 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3221 switch (type_class) {
3222 case clang::Type::Builtin:
3223 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3226 case clang::BuiltinType::ObjCId:
3227 case clang::BuiltinType::ObjCClass:
3231 case clang::Type::ObjCObjectPointer:
3234 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3235 ->getPointeeType().getAsOpaquePtr());
3237 case clang::Type::BlockPointer:
3240 this, llvm::cast<clang::BlockPointerType>(qual_type)
3244 case clang::Type::Pointer:
3247 llvm::cast<clang::PointerType>(qual_type)
3251 case clang::Type::MemberPointer:
3254 this, llvm::cast<clang::MemberPointerType>(qual_type)
3258 case clang::Type::LValueReference:
3261 this, llvm::cast<clang::LValueReferenceType>(qual_type)
3265 case clang::Type::RValueReference:
3268 this, llvm::cast<clang::RValueReferenceType>(qual_type)
3277 pointee_type->
Clear();
3286 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3288 switch (type_class) {
3289 case clang::Type::LValueReference:
3292 this, llvm::cast<clang::LValueReferenceType>(qual_type)
3298 case clang::Type::RValueReference:
3301 this, llvm::cast<clang::RValueReferenceType>(qual_type)
3313 pointee_type->
Clear();
3318 uint32_t &count,
bool &is_complex) {
3322 if (
const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(
3323 qual_type->getCanonicalTypeInternal())) {
3324 clang::BuiltinType::Kind kind = BT->getKind();
3325 if (kind >= clang::BuiltinType::Float &&
3326 kind <= clang::BuiltinType::LongDouble) {
3331 }
else if (
const clang::ComplexType *CT =
3332 llvm::dyn_cast<clang::ComplexType>(
3333 qual_type->getCanonicalTypeInternal())) {
3340 }
else if (
const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(
3341 qual_type->getCanonicalTypeInternal())) {
3344 count = VT->getNumElements();
3360 const clang::TagType *tag_type =
3361 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
3363 clang::TagDecl *tag_decl = tag_type->getDecl();
3365 return tag_decl->isCompleteDefinition();
3368 const clang::ObjCObjectType *objc_class_type =
3369 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
3370 if (objc_class_type) {
3371 clang::ObjCInterfaceDecl *class_interface_decl =
3372 objc_class_type->getInterface();
3373 if (class_interface_decl)
3374 return class_interface_decl->getDefinition() !=
nullptr;
3385 const clang::ObjCObjectPointerType *obj_pointer_type =
3386 llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3388 if (obj_pointer_type)
3389 return obj_pointer_type->isObjCClassType();
3404 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3405 return (type_class == clang::Type::Record);
3412 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3413 return (type_class == clang::Type::Enum);
3419 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3420 switch (type_class) {
3421 case clang::Type::Record:
3423 const clang::RecordType *record_type =
3424 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3425 const clang::RecordDecl *record_decl = record_type->getDecl();
3427 const clang::CXXRecordDecl *cxx_record_decl =
3428 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3429 if (cxx_record_decl)
3430 return cxx_record_decl->isPolymorphic();
3444 bool check_cplusplus,
3446 clang::QualType pointee_qual_type;
3449 bool success =
false;
3450 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3451 switch (type_class) {
3452 case clang::Type::Builtin:
3454 llvm::cast<clang::BuiltinType>(qual_type)->getKind() ==
3455 clang::BuiltinType::ObjCId) {
3456 if (dynamic_pointee_type)
3462 case clang::Type::ObjCObjectPointer:
3464 if (
const auto *objc_pointee_type =
3465 qual_type->getPointeeType().getTypePtrOrNull()) {
3466 if (
const auto *objc_object_type =
3467 llvm::dyn_cast_or_null<clang::ObjCObjectType>(
3468 objc_pointee_type)) {
3469 if (objc_object_type->isObjCClass())
3473 if (dynamic_pointee_type)
3475 this, llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3482 case clang::Type::Pointer:
3484 llvm::cast<clang::PointerType>(qual_type)->getPointeeType();
3488 case clang::Type::LValueReference:
3489 case clang::Type::RValueReference:
3491 llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType();
3503 const clang::Type::TypeClass pointee_type_class =
3504 pointee_qual_type.getCanonicalType()->getTypeClass();
3505 switch (pointee_type_class) {
3506 case clang::Type::Builtin:
3507 switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind()) {
3508 case clang::BuiltinType::UnknownAny:
3509 case clang::BuiltinType::Void:
3510 if (dynamic_pointee_type)
3512 this, pointee_qual_type.getAsOpaquePtr());
3519 case clang::Type::Record:
3520 if (check_cplusplus) {
3521 clang::CXXRecordDecl *cxx_record_decl =
3522 pointee_qual_type->getAsCXXRecordDecl();
3523 if (cxx_record_decl) {
3524 bool is_complete = cxx_record_decl->isCompleteDefinition();
3527 success = cxx_record_decl->isDynamicClass();
3535 success = cxx_record_decl->isDynamicClass();
3542 if (dynamic_pointee_type)
3544 this, pointee_qual_type.getAsOpaquePtr());
3551 case clang::Type::ObjCObject:
3552 case clang::Type::ObjCInterface:
3554 if (dynamic_pointee_type)
3556 this, pointee_qual_type.getAsOpaquePtr());
3566 if (dynamic_pointee_type)
3567 dynamic_pointee_type->
Clear();
3575 return (
GetTypeInfo(type,
nullptr) & eTypeIsScalar) != 0;
3582 ->getTypeClass() == clang::Type::Typedef;
3592 if (
auto *record_decl =
3594 return record_decl->canPassInRegisters();
3600 return TypeSystemClangSupportsLanguage(language);
3603 Optional<std::string>
3609 if (qual_type.isNull())
3612 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3613 if (!cxx_record_decl)
3616 return std::string(cxx_record_decl->getIdentifier()->getNameStart());
3624 return !qual_type.isNull() && qual_type->getAsCXXRecordDecl() !=
nullptr;
3631 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
3633 return tag_type->isBeingDefined();
3644 if (!qual_type.isNull() && qual_type->isObjCObjectPointerType()) {
3645 if (class_type_ptr) {
3646 if (!qual_type->isObjCClassType() && !qual_type->isObjCIdType()) {
3647 const clang::ObjCObjectPointerType *obj_pointer_type =
3648 llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3649 if (obj_pointer_type ==
nullptr)
3650 class_type_ptr->
Clear();
3654 clang::QualType(obj_pointer_type->getInterfaceType(), 0)
3661 class_type_ptr->
Clear();
3670 const bool allow_completion =
true;
3689 {clang::Type::Typedef, clang::Type::Atomic});
3692 if (
const auto *typedef_type = qual_type->getAs<clang::TypedefType>()) {
3693 const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
3706 clang::PrintingPolicy printing_policy(
getASTContext().getPrintingPolicy());
3707 printing_policy.SuppressTagKeyword =
true;
3708 printing_policy.SuppressScope =
false;
3709 printing_policy.SuppressUnwrittenScope =
true;
3710 printing_policy.SuppressInlineNamespace =
true;
3711 return ConstString(qual_type.getAsString(printing_policy));
3720 if (pointee_or_element_clang_type)
3721 pointee_or_element_clang_type->
Clear();
3723 clang::QualType qual_type =
3726 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3727 switch (type_class) {
3728 case clang::Type::Attributed:
3730 qual_type->getAs<clang::AttributedType>()
3731 ->getModifiedType().getAsOpaquePtr(),
3732 pointee_or_element_clang_type);
3733 case clang::Type::Builtin: {
3734 const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(
3735 qual_type->getCanonicalTypeInternal());
3737 uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
3738 switch (builtin_type->getKind()) {
3739 case clang::BuiltinType::ObjCId:
3740 case clang::BuiltinType::ObjCClass:
3741 if (pointee_or_element_clang_type)
3744 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3747 case clang::BuiltinType::ObjCSel:
3748 if (pointee_or_element_clang_type)
3751 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3754 case clang::BuiltinType::Bool:
3755 case clang::BuiltinType::Char_U:
3756 case clang::BuiltinType::UChar:
3757 case clang::BuiltinType::WChar_U:
3758 case clang::BuiltinType::Char16:
3759 case clang::BuiltinType::Char32:
3760 case clang::BuiltinType::UShort:
3762 case clang::BuiltinType::ULong:
3763 case clang::BuiltinType::ULongLong:
3764 case clang::BuiltinType::UInt128:
3765 case clang::BuiltinType::Char_S:
3766 case clang::BuiltinType::SChar:
3767 case clang::BuiltinType::WChar_S:
3768 case clang::BuiltinType::Short:
3769 case clang::BuiltinType::Int:
3770 case clang::BuiltinType::Long:
3771 case clang::BuiltinType::LongLong:
3772 case clang::BuiltinType::Int128:
3773 case clang::BuiltinType::Float:
3774 case clang::BuiltinType::Double:
3775 case clang::BuiltinType::LongDouble:
3776 builtin_type_flags |= eTypeIsScalar;
3777 if (builtin_type->isInteger()) {
3778 builtin_type_flags |= eTypeIsInteger;
3779 if (builtin_type->isSignedInteger())
3780 builtin_type_flags |= eTypeIsSigned;
3781 }
else if (builtin_type->isFloatingPoint())
3782 builtin_type_flags |= eTypeIsFloat;
3787 return builtin_type_flags;
3790 case clang::Type::BlockPointer:
3791 if (pointee_or_element_clang_type)
3793 this, qual_type->getPointeeType().getAsOpaquePtr());
3794 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
3796 case clang::Type::Complex: {
3798 eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
3799 const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(
3800 qual_type->getCanonicalTypeInternal());
3802 clang::QualType complex_element_type(complex_type->getElementType());
3803 if (complex_element_type->isIntegerType())
3804 complex_type_flags |= eTypeIsFloat;
3805 else if (complex_element_type->isFloatingType())
3806 complex_type_flags |= eTypeIsInteger;
3808 return complex_type_flags;
3811 case clang::Type::ConstantArray:
3812 case clang::Type::DependentSizedArray:
3813 case clang::Type::IncompleteArray:
3814 case clang::Type::VariableArray:
3815 if (pointee_or_element_clang_type)
3817 this, llvm::cast<clang::ArrayType>(qual_type.getTypePtr())
3820 return eTypeHasChildren | eTypeIsArray;
3822 case clang::Type::DependentName:
3824 case clang::Type::DependentSizedExtVector:
3825 return eTypeHasChildren | eTypeIsVector;
3826 case clang::Type::DependentTemplateSpecialization:
3827 return eTypeIsTemplate;
3829 case clang::Type::Enum:
3830 if (pointee_or_element_clang_type)
3832 this, llvm::cast<clang::EnumType>(qual_type)
3836 return eTypeIsEnumeration | eTypeHasValue;
3838 case clang::Type::FunctionProto:
3839 return eTypeIsFuncPrototype | eTypeHasValue;
3840 case clang::Type::FunctionNoProto:
3841 return eTypeIsFuncPrototype | eTypeHasValue;
3842 case clang::Type::InjectedClassName:
3845 case clang::Type::LValueReference:
3846 case clang::Type::RValueReference:
3847 if (pointee_or_element_clang_type)
3849 this, llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())
3852 return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
3854 case clang::Type::MemberPointer:
3855 return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
3857 case clang::Type::ObjCObjectPointer:
3858 if (pointee_or_element_clang_type)
3860 this, qual_type->getPointeeType().getAsOpaquePtr());
3861 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer |
3864 case clang::Type::ObjCObject:
3865 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3866 case clang::Type::ObjCInterface:
3867 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3869 case clang::Type::Pointer:
3870 if (pointee_or_element_clang_type)
3872 this, qual_type->getPointeeType().getAsOpaquePtr());
3873 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
3875 case clang::Type::Record:
3876 if (qual_type->getAsCXXRecordDecl())
3877 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
3879 return eTypeHasChildren | eTypeIsStructUnion;
3881 case clang::Type::SubstTemplateTypeParm:
3882 return eTypeIsTemplate;
3883 case clang::Type::TemplateTypeParm:
3884 return eTypeIsTemplate;
3885 case clang::Type::TemplateSpecialization:
3886 return eTypeIsTemplate;
3888 case clang::Type::Typedef:
3889 return eTypeIsTypedef |
GetType(llvm::cast<clang::TypedefType>(qual_type)
3891 ->getUnderlyingType())
3893 case clang::Type::UnresolvedUsing:
3896 case clang::Type::ExtVector:
3897 case clang::Type::Vector: {
3898 uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
3899 const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(
3900 qual_type->getCanonicalTypeInternal());
3902 if (vector_type->isIntegerType())
3903 vector_type_flags |= eTypeIsFloat;
3904 else if (vector_type->isFloatingType())
3905 vector_type_flags |= eTypeIsInteger;
3907 return vector_type_flags;
3922 if (qual_type->isAnyPointerType()) {
3923 if (qual_type->isObjCObjectPointerType())
3925 if (qual_type->getPointeeCXXRecordDecl())
3928 clang::QualType pointee_type(qual_type->getPointeeType());
3929 if (pointee_type->getPointeeCXXRecordDecl())
3931 if (pointee_type->isObjCObjectOrInterfaceType())
3933 if (pointee_type->isObjCClassType())
3935 if (pointee_type.getTypePtr() ==
3939 if (qual_type->isObjCObjectOrInterfaceType())
3941 if (qual_type->getAsCXXRecordDecl())
3943 switch (qual_type->getTypeClass()) {
3946 case clang::Type::Builtin:
3947 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3949 case clang::BuiltinType::Void:
3950 case clang::BuiltinType::Bool:
3951 case clang::BuiltinType::Char_U:
3952 case clang::BuiltinType::UChar:
3953 case clang::BuiltinType::WChar_U:
3954 case clang::BuiltinType::Char16:
3955 case clang::BuiltinType::Char32:
3956 case clang::BuiltinType::UShort:
3958 case clang::BuiltinType::ULong:
3959 case clang::BuiltinType::ULongLong:
3960 case clang::BuiltinType::UInt128:
3961 case clang::BuiltinType::Char_S:
3962 case clang::BuiltinType::SChar:
3963 case clang::BuiltinType::WChar_S:
3964 case clang::BuiltinType::Short:
3965 case clang::BuiltinType::Int:
3966 case clang::BuiltinType::Long:
3967 case clang::BuiltinType::LongLong:
3968 case clang::BuiltinType::Int128:
3969 case clang::BuiltinType::Float:
3970 case clang::BuiltinType::Double:
3971 case clang::BuiltinType::LongDouble:
3974 case clang::BuiltinType::NullPtr:
3977 case clang::BuiltinType::ObjCId:
3978 case clang::BuiltinType::ObjCClass:
3979 case clang::BuiltinType::ObjCSel:
3982 case clang::BuiltinType::Dependent:
3983 case clang::BuiltinType::Overload:
3984 case clang::BuiltinType::BoundMember:
3985 case clang::BuiltinType::UnknownAny:
3989 case clang::Type::Typedef:
3990 return GetType(llvm::cast<clang::TypedefType>(qual_type)
3992 ->getUnderlyingType())
4002 return lldb::eTypeClassInvalid;
4004 clang::QualType qual_type =
4007 switch (qual_type->getTypeClass()) {
4008 case clang::Type::Atomic:
4009 case clang::Type::Auto:
4010 case clang::Type::Decltype:
4011 case clang::Type::Elaborated:
4012 case clang::Type::Paren:
4013 case clang::Type::TypeOf:
4014 case clang::Type::TypeOfExpr:
4015 llvm_unreachable(
"Handled in RemoveWrappingTypes!");
4016 case clang::Type::UnaryTransform:
4018 case clang::Type::FunctionNoProto:
4019 return lldb::eTypeClassFunction;
4020 case clang::Type::FunctionProto:
4021 return lldb::eTypeClassFunction;
4022 case clang::Type::IncompleteArray:
4023 return lldb::eTypeClassArray;
4024 case clang::Type::VariableArray:
4025 return lldb::eTypeClassArray;
4026 case clang::Type::ConstantArray:
4027 return lldb::eTypeClassArray;
4028 case clang::Type::DependentSizedArray:
4029 return lldb::eTypeClassArray;
4030 case clang::Type::DependentSizedExtVector:
4031 return lldb::eTypeClassVector;
4032 case clang::Type::DependentVector:
4033 return lldb::eTypeClassVector;
4034 case clang::Type::ExtVector:
4035 return lldb::eTypeClassVector;
4036 case clang::Type::Vector:
4037 return lldb::eTypeClassVector;
4038 case clang::Type::Builtin:
4040 case clang::Type::ExtInt:
4041 case clang::Type::DependentExtInt:
4042 return lldb::eTypeClassBuiltin;
4043 case clang::Type::ObjCObjectPointer:
4044 return lldb::eTypeClassObjCObjectPointer;
4045 case clang::Type::BlockPointer:
4046 return lldb::eTypeClassBlockPointer;
4047 case clang::Type::Pointer:
4048 return lldb::eTypeClassPointer;
4049 case clang::Type::LValueReference:
4050 return lldb::eTypeClassReference;
4051 case clang::Type::RValueReference:
4052 return lldb::eTypeClassReference;
4053 case clang::Type::MemberPointer:
4054 return lldb::eTypeClassMemberPointer;
4055 case clang::Type::Complex:
4056 if (qual_type->isComplexType())
4057 return lldb::eTypeClassComplexFloat;
4059 return lldb::eTypeClassComplexInteger;
4060 case clang::Type::ObjCObject:
4061 return lldb::eTypeClassObjCObject;
4062 case clang::Type::ObjCInterface:
4063 return lldb::eTypeClassObjCInterface;
4064 case clang::Type::Record: {
4065 const clang::RecordType *record_type =
4066 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4067 const clang::RecordDecl *record_decl = record_type->getDecl();
4068 if (record_decl->isUnion())
4069 return lldb::eTypeClassUnion;
4070 else if (record_decl->isStruct())
4071 return lldb::eTypeClassStruct;
4073 return lldb::eTypeClassClass;
4075 case clang::Type::Enum:
4076 return lldb::eTypeClassEnumeration;
4077 case clang::Type::Typedef:
4078 return lldb::eTypeClassTypedef;
4079 case clang::Type::UnresolvedUsing:
4082 case clang::Type::Attributed:
4084 case clang::Type::TemplateTypeParm:
4086 case clang::Type::SubstTemplateTypeParm:
4088 case clang::Type::SubstTemplateTypeParmPack:
4090 case clang::Type::InjectedClassName:
4092 case clang::Type::DependentName:
4094 case clang::Type::DependentTemplateSpecialization:
4096 case clang::Type::PackExpansion:
4099 case clang::Type::TemplateSpecialization:
4101 case clang::Type::DeducedTemplateSpecialization:
4107 case clang::Type::Decayed:
4109 case clang::Type::Adjusted:
4111 case clang::Type::ObjCTypeParam:
4114 case clang::Type::DependentAddressSpace:
4116 case clang::Type::MacroQualified:
4120 case clang::Type::ConstantMatrix:
4121 case clang::Type::DependentSizedMatrix:
4125 return lldb::eTypeClassOther;
4130 return GetQualType(type).getQualifiers().getCVRQualifiers();
4142 const clang::Type *array_eletype =
4143 qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
4148 return GetType(clang::QualType(array_eletype, 0));
4159 return GetType(ast_ctx.getConstantArrayType(
4160 qual_type, llvm::APInt(64, size),
nullptr,
4161 clang::ArrayType::ArraySizeModifier::Normal, 0));
4163 return GetType(ast_ctx.getIncompleteArrayType(
4164 qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0));
4178 clang::QualType qual_type) {
4179 if (qual_type->isPointerType())
4180 qual_type = ast->getPointerType(
4183 qual_type = qual_type.getUnqualifiedType();
4184 qual_type.removeLocalConst();
4185 qual_type.removeLocalRestrict();
4186 qual_type.removeLocalVolatile();
4208 const clang::FunctionProtoType *func =
4211 return func->getNumParams();
4219 const clang::FunctionProtoType *func =
4220 llvm::dyn_cast<clang::FunctionProtoType>(
GetQualType(type));
4222 const uint32_t num_args = func->getNumParams();
4224 return GetType(func->getParamType(idx));
4234 const clang::FunctionProtoType *func =
4235 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
4237 return GetType(func->getReturnType());
4244 size_t num_functions = 0;
4247 switch (qual_type->getTypeClass()) {
4248 case clang::Type::Record:
4250 const clang::RecordType *record_type =
4251 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4252 const clang::RecordDecl *record_decl = record_type->getDecl();
4253 assert(record_decl);
4254 const clang::CXXRecordDecl *cxx_record_decl =
4255 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4256 if (cxx_record_decl)
4257 num_functions = std::distance(cxx_record_decl->method_begin(),
4258 cxx_record_decl->method_end());
4262 case clang::Type::ObjCObjectPointer: {
4263 const clang::ObjCObjectPointerType *objc_class_type =
4264 qual_type->getAs<clang::ObjCObjectPointerType>();
4265 const clang::ObjCInterfaceType *objc_interface_type =
4266 objc_class_type->getInterfaceType();
4267 if (objc_interface_type &&
4269 const_cast<clang::ObjCInterfaceType *
>(objc_interface_type)))) {
4270 clang::ObjCInterfaceDecl *class_interface_decl =
4271 objc_interface_type->getDecl();
4272 if (class_interface_decl) {
4273 num_functions = std::distance(class_interface_decl->meth_begin(),
4274 class_interface_decl->meth_end());
4280 case clang::Type::ObjCObject:
4281 case clang::Type::ObjCInterface:
4283 const clang::ObjCObjectType *objc_class_type =
4284 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4285 if (objc_class_type) {
4286 clang::ObjCInterfaceDecl *class_interface_decl =
4287 objc_class_type->getInterface();
4288 if (class_interface_decl)
4289 num_functions = std::distance(class_interface_decl->meth_begin(),
4290 class_interface_decl->meth_end());
4299 return num_functions;
4311 switch (qual_type->getTypeClass()) {
4312 case clang::Type::Record:
4314 const clang::RecordType *record_type =
4315 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4316 const clang::RecordDecl *record_decl = record_type->getDecl();
4317 assert(record_decl);
4318 const clang::CXXRecordDecl *cxx_record_decl =
4319 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4320 if (cxx_record_decl) {
4321 auto method_iter = cxx_record_decl->method_begin();
4322 auto method_end = cxx_record_decl->method_end();
4324 static_cast<size_t>(std::distance(method_iter, method_end))) {
4325 std::advance(method_iter, idx);
4326 clang::CXXMethodDecl *cxx_method_decl =
4327 method_iter->getCanonicalDecl();
4328 if (cxx_method_decl) {
4329 name = cxx_method_decl->getDeclName().getAsString();
4330 if (cxx_method_decl->isStatic())
4332 else if (llvm::isa<clang::CXXConstructorDecl>(cxx_method_decl))
4334 else if (llvm::isa<clang::CXXDestructorDecl>(cxx_method_decl))
4338 clang_type =
GetType(cxx_method_decl->getType());
4346 case clang::Type::ObjCObjectPointer: {
4347 const clang::ObjCObjectPointerType *objc_class_type =
4348 qual_type->getAs<clang::ObjCObjectPointerType>();
4349 const clang::ObjCInterfaceType *objc_interface_type =
4350 objc_class_type->getInterfaceType();
4351 if (objc_interface_type &&
4353 const_cast<clang::ObjCInterfaceType *
>(objc_interface_type)))) {
4354 clang::ObjCInterfaceDecl *class_interface_decl =
4355 objc_interface_type->getDecl();
4356 if (class_interface_decl) {
4357 auto method_iter = class_interface_decl->meth_begin();
4358 auto method_end = class_interface_decl->meth_end();
4360 static_cast<size_t>(std::distance(method_iter, method_end))) {
4361 std::advance(method_iter, idx);
4362 clang::ObjCMethodDecl *objc_method_decl =
4363 method_iter->getCanonicalDecl();
4364 if (objc_method_decl) {
4366 name = objc_method_decl->getSelector().getAsString();
4367 if (objc_method_decl->isClassMethod())
4378 case clang::Type::ObjCObject:
4379 case clang::Type::ObjCInterface:
4381 const clang::ObjCObjectType *objc_class_type =
4382 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4383 if (objc_class_type) {
4384 clang::ObjCInterfaceDecl *class_interface_decl =
4385 objc_class_type->getInterface();
4386 if (class_interface_decl) {
4387 auto method_iter = class_interface_decl->meth_begin();
4388 auto method_end = class_interface_decl->meth_end();
4390 static_cast<size_t>(std::distance(method_iter, method_end))) {
4391 std::advance(method_iter, idx);
4392 clang::ObjCMethodDecl *objc_method_decl =
4393 method_iter->getCanonicalDecl();
4394 if (objc_method_decl) {
4396 name = objc_method_decl->getSelector().getAsString();
4397 if (objc_method_decl->isClassMethod())
4430 return GetType(qual_type.getTypePtr()->getPointeeType());
4440 switch (qual_type.getDesugaredType(
getASTContext())->getTypeClass()) {
4441 case clang::Type::ObjCObject:
4442 case clang::Type::ObjCInterface:
4488 result.addVolatile();
4498 result.addRestrict();
4507 if (type && typedef_name && typedef_name[0]) {
4511 clang::DeclContext *decl_ctx =
4516 clang::TypedefDecl *decl =
4517 clang::TypedefDecl::CreateDeserialized(clang_ast, 0);
4518 decl->setDeclContext(decl_ctx);
4519 decl->setDeclName(&clang_ast.Idents.get(typedef_name));
4520 decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type));
4521 decl_ctx->addDecl(decl);
4524 clang::TagDecl *tdecl =
nullptr;
4525 if (!qual_type.isNull()) {
4526 if (
const clang::RecordType *rt = qual_type->getAs<clang::RecordType>())
4527 tdecl = rt->getDecl();
4528 if (
const clang::EnumType *et = qual_type->getAs<clang::EnumType>())
4529 tdecl = et->getDecl();
4535 if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl())
4536 tdecl->setTypedefNameForAnonDecl(decl);
4538 decl->setAccess(clang::AS_public);
4541 return GetType(clang_ast.getTypedefType(decl));
4549 const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(
4552 return GetType(typedef_type->getDecl()->getUnderlyingType());
4564 const llvm::fltSemantics &
4567 const size_t bit_size = byte_size * 8;
4568 if (bit_size == ast.getTypeSize(ast.FloatTy))
4569 return ast.getFloatTypeSemantics(ast.FloatTy);
4570 else if (bit_size == ast.getTypeSize(ast.DoubleTy))
4571 return ast.getFloatTypeSemantics(ast.DoubleTy);
4572 else if (bit_size == ast.getTypeSize(ast.LongDoubleTy))
4573 return ast.getFloatTypeSemantics(ast.LongDoubleTy);
4574 else if (bit_size == ast.getTypeSize(ast.HalfTy))
4575 return ast.getFloatTypeSemantics(ast.HalfTy);
4576 return llvm::APFloatBase::Bogus();
4584 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4585 switch (type_class) {
4586 case clang::Type::Record:
4593 case clang::Type::ObjCInterface:
4594 case clang::Type::ObjCObject: {
4600 uint64_t bit_size = 0;
4605 static bool g_printed =
false;
4610 llvm::outs() <<
"warning: trying to determine the size of type ";
4612 llvm::outs() <<
"without a valid ExecutionContext. this is not "
4613 "reliable. please file a bug against LLDB.\n";
4614 llvm::outs() <<
"backtrace:\n";
4615 llvm::sys::PrintStackTrace(llvm::outs());
4616 llvm::outs() <<
"\n";
4624 if (bit_size == 0) {
4625 if (qual_type->isIncompleteArrayType())
4627 qual_type->getArrayElementTypeNoTypeQual()
4628 ->getCanonicalTypeUnqualified());
4630 if (qual_type->isObjCObjectOrInterfaceType())
4634 if (qual_type->isFunctionProtoType())
4643 llvm::Optional<size_t>
4659 switch (qual_type->getTypeClass()) {
4660 case clang::Type::Atomic:
4661 case clang::Type::Auto:
4662 case clang::Type::Decltype:
4663 case clang::Type::Elaborated:
4664 case clang::Type::Paren:
4665 case clang::Type::Typedef:
4666 case clang::Type::TypeOf:
4667 case clang::Type::TypeOfExpr:
4668 llvm_unreachable(
"Handled in RemoveWrappingTypes!");
4670 case clang::Type::UnaryTransform:
4673 case clang::Type::FunctionNoProto:
4674 case clang::Type::FunctionProto:
4677 case clang::Type::IncompleteArray:
4678 case clang::Type::VariableArray:
4681 case clang::Type::ConstantArray:
4684 case clang::Type::DependentVector:
4685 case clang::Type::ExtVector:
4686 case clang::Type::Vector:
4690 case clang::Type::ExtInt:
4691 case clang::Type::DependentExtInt:
4695 case clang::Type::Builtin:
4696 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4697 case clang::BuiltinType::Void:
4700 case clang::BuiltinType::Bool:
4701 case clang::BuiltinType::Char_S:
4702 case clang::BuiltinType::SChar:
4703 case clang::BuiltinType::WChar_S:
4704 case clang::BuiltinType::Short:
4705 case clang::BuiltinType::Int:
4706 case clang::BuiltinType::Long:
4707 case clang::BuiltinType::LongLong:
4708 case clang::BuiltinType::Int128:
4711 case clang::BuiltinType::Char_U:
4712 case clang::BuiltinType::UChar:
4713 case clang::BuiltinType::WChar_U:
4714 case clang::BuiltinType::Char8:
4715 case clang::BuiltinType::Char16:
4716 case clang::BuiltinType::Char32:
4717 case clang::BuiltinType::UShort:
4719 case clang::BuiltinType::ULong:
4720 case clang::BuiltinType::ULongLong:
4721 case clang::BuiltinType::UInt128:
4725 case clang::BuiltinType::ShortAccum:
4726 case clang::BuiltinType::Accum:
4727 case clang::BuiltinType::LongAccum:
4728 case clang::BuiltinType::UShortAccum:
4729 case clang::BuiltinType::UAccum:
4730 case clang::BuiltinType::ULongAccum:
4731 case clang::BuiltinType::ShortFract:
4732 case clang::BuiltinType::Fract:
4733 case clang::BuiltinType::LongFract:
4734 case clang::BuiltinType::UShortFract:
4735 case clang::BuiltinType::UFract:
4736 case clang::BuiltinType::ULongFract:
4737 case clang::BuiltinType::SatShortAccum:
4738 case clang::BuiltinType::SatAccum:
4739 case clang::BuiltinType::SatLongAccum:
4740 case clang::BuiltinType::SatUShortAccum:
4741 case clang::BuiltinType::SatUAccum:
4742 case clang::BuiltinType::SatULongAccum:
4743 case clang::BuiltinType::SatShortFract:
4744 case clang::BuiltinType::SatFract:
4745 case clang::BuiltinType::SatLongFract:
4746 case clang::BuiltinType::SatUShortFract:
4747 case clang::BuiltinType::SatUFract:
4748 case clang::BuiltinType::SatULongFract:
4751 case clang::BuiltinType::Half:
4752 case clang::BuiltinType::Float:
4753 case clang::BuiltinType::Float16:
4754 case clang::BuiltinType::Float128:
4755 case clang::BuiltinType::Double:
4756 case clang::BuiltinType::LongDouble:
4757 case clang::BuiltinType::BFloat16:
4760 case clang::BuiltinType::ObjCClass:
4761 case clang::BuiltinType::ObjCId:
4762 case clang::BuiltinType::ObjCSel:
4765 case clang::BuiltinType::NullPtr:
4768 case clang::BuiltinType::Kind::ARCUnbridgedCast:
4769 case clang::BuiltinType::Kind::BoundMember:
4770 case clang::BuiltinType::Kind::BuiltinFn:
4771 case clang::BuiltinType::Kind::Dependent:
4772 case clang::BuiltinType::Kind::OCLClkEvent:
4773 case clang::BuiltinType::Kind::OCLEvent:
4774 case clang::BuiltinType::Kind::OCLImage1dRO:
4775 case clang::BuiltinType::Kind::OCLImage1dWO:
4776 case clang::BuiltinType::Kind::OCLImage1dRW:
4777 case clang::BuiltinType::Kind::OCLImage1dArrayRO:
4778 case clang::BuiltinType::Kind::OCLImage1dArrayWO:
4779 case clang::BuiltinType::Kind::OCLImage1dArrayRW:
4780 case clang::BuiltinType::Kind::OCLImage1dBufferRO:
4781 case clang::BuiltinType::Kind::OCLImage1dBufferWO:
4782 case clang::BuiltinType::Kind::OCLImage1dBufferRW:
4783 case clang::BuiltinType::Kind::OCLImage2dRO:
4784 case clang::BuiltinType::Kind::OCLImage2dWO:
4785 case clang::BuiltinType::Kind::OCLImage2dRW:
4786 case clang::BuiltinType::Kind::OCLImage2dArrayRO:
4787 case clang::BuiltinType::Kind::OCLImage2dArrayWO:
4788 case clang::BuiltinType::Kind::OCLImage2dArrayRW:
4789 case clang::BuiltinType::Kind::OCLImage2dArrayDepthRO:
4790 case clang::BuiltinType::Kind::OCLImage2dArrayDepthWO:
4791 case clang::BuiltinType::Kind::OCLImage2dArrayDepthRW:
4792 case clang::BuiltinType::Kind::OCLImage2dArrayMSAARO:
4793 case clang::BuiltinType::Kind::OCLImage2dArrayMSAAWO:
4794 case clang::BuiltinType::Kind::OCLImage2dArrayMSAARW:
4795 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRO:
4796 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthWO:
4797 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRW:
4798 case clang::BuiltinType::Kind::OCLImage2dDepthRO:
4799 case clang::BuiltinType::Kind::OCLImage2dDepthWO:
4800 case clang::BuiltinType::Kind::OCLImage2dDepthRW:
4801 case clang::BuiltinType::Kind::OCLImage2dMSAARO:
4802 case clang::BuiltinType::Kind::OCLImage2dMSAAWO:
4803 case clang::BuiltinType::Kind::OCLImage2dMSAARW:
4804 case clang::BuiltinType::Kind::OCLImage2dMSAADepthRO:
4805 case clang::BuiltinType::Kind::OCLImage2dMSAADepthWO:
4806 case clang::BuiltinType::Kind::OCLImage2dMSAADepthRW:
4807 case clang::BuiltinType::Kind::OCLImage3dRO:
4808 case clang::BuiltinType::Kind::OCLImage3dWO:
4809 case clang::BuiltinType::Kind::OCLImage3dRW:
4810 case clang::BuiltinType::Kind::OCLQueue:
4811 case clang::BuiltinType::Kind::OCLReserveID:
4812 case clang::BuiltinType::Kind::OCLSampler:
4813 case clang::BuiltinType::Kind::OMPArraySection:
4814 case clang::BuiltinType::Kind::OMPArrayShaping:
4815 case clang::BuiltinType::Kind::OMPIterator:
4816 case clang::BuiltinType::Kind::Overload:
4817 case clang::BuiltinType::Kind::PseudoObject:
4818 case clang::BuiltinType::Kind::UnknownAny:
4821 case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload:
4822 case clang::BuiltinType::OCLIntelSubgroupAVCImePayload:
4823 case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload:
4824 case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload:
4825 case clang::BuiltinType::OCLIntelSubgroupAVCMceResult:
4826 case clang::BuiltinType::OCLIntelSubgroupAVCImeResult:
4827 case clang::BuiltinType::OCLIntelSubgroupAVCRefResult:
4828 case clang::BuiltinType::OCLIntelSubgroupAVCSicResult:
4829 case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout:
4830 case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout:
4831 case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin:
4832 case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin:
4836 case clang::BuiltinType::VectorPair:
4837 case clang::BuiltinType::VectorQuad:
4841 case clang::BuiltinType::SveBool:
4842 case clang::BuiltinType::SveInt8:
4843 case clang::BuiltinType::SveInt8x2:
4844 case clang::BuiltinType::SveInt8x3:
4845 case clang::BuiltinType::SveInt8x4:
4846 case clang::BuiltinType::SveInt16:
4847 case clang::BuiltinType::SveInt16x2:
4848 case clang::BuiltinType::SveInt16x3:
4849 case clang::BuiltinType::SveInt16x4:
4850 case clang::BuiltinType::SveInt32:
4851 case clang::BuiltinType::SveInt32x2:
4852 case clang::BuiltinType::SveInt32x3:
4853 case clang::BuiltinType::SveInt32x4:
4854 case clang::BuiltinType::SveInt64:
4855 case clang::BuiltinType::SveInt64x2:
4856 case clang::BuiltinType::SveInt64x3:
4857 case clang::BuiltinType::SveInt64x4:
4858 case clang::BuiltinType::SveUint8:
4859 case clang::BuiltinType::SveUint8x2:
4860 case clang::BuiltinType::SveUint8x3:
4861 case clang::BuiltinType::SveUint8x4:
4862 case clang::BuiltinType::SveUint16:
4863 case clang::BuiltinType::SveUint16x2:
4864 case clang::BuiltinType::SveUint16x3:
4865 case clang::BuiltinType::SveUint16x4:
4866 case clang::BuiltinType::SveUint32:
4867 case clang::BuiltinType::SveUint32x2:
4868 case clang::BuiltinType::SveUint32x3:
4869 case clang::BuiltinType::SveUint32x4:
4870 case clang::BuiltinType::SveUint64:
4871 case clang::BuiltinType::SveUint64x2:
4872 case clang::BuiltinType::SveUint64x3:
4873 case clang::BuiltinType::SveUint64x4:
4874 case clang::BuiltinType::SveFloat16:
4875 case clang::BuiltinType::SveBFloat16:
4876 case clang::BuiltinType::SveBFloat16x2:
4877 case clang::BuiltinType::SveBFloat16x3:
4878 case clang::BuiltinType::SveBFloat16x4:
4879 case clang::BuiltinType::SveFloat16x2:
4880 case clang::BuiltinType::SveFloat16x3:
4881 case clang::BuiltinType::SveFloat16x4:
4882 case clang::BuiltinType::SveFloat32:
4883 case clang::BuiltinType::SveFloat32x2:
4884 case clang::BuiltinType::SveFloat32x3:
4885 case clang::BuiltinType::SveFloat32x4:
4886 case clang::BuiltinType::SveFloat64:
4887 case clang::BuiltinType::SveFloat64x2:
4888 case clang::BuiltinType::SveFloat64x3:
4889 case clang::BuiltinType::SveFloat64x4:
4893 case clang::BuiltinType::RvvInt8mf8:
4894 case clang::BuiltinType::RvvInt8mf4:
4895 case clang::BuiltinType::RvvInt8mf2:
4896 case clang::BuiltinType::RvvInt8m1:
4897 case clang::BuiltinType::RvvInt8m2:
4898 case clang::BuiltinType::RvvInt8m4:
4899 case clang::BuiltinType::RvvInt8m8:
4900 case clang::BuiltinType::RvvUint8mf8:
4901 case clang::BuiltinType::RvvUint8mf4:
4902 case clang::BuiltinType::RvvUint8mf2:
4903 case clang::BuiltinType::RvvUint8m1:
4904 case clang::BuiltinType::RvvUint8m2:
4905 case clang::BuiltinType::RvvUint8m4:
4906 case clang::BuiltinType::RvvUint8m8:
4907 case clang::BuiltinType::RvvInt16mf4:
4908 case clang::BuiltinType::RvvInt16mf2:
4909 case clang::BuiltinType::RvvInt16m1:
4910 case clang::BuiltinType::RvvInt16m2:
4911 case clang::BuiltinType::RvvInt16m4:
4912 case clang::BuiltinType::RvvInt16m8:
4913 case clang::BuiltinType::RvvUint16mf4:
4914 case clang::BuiltinType::RvvUint16mf2:
4915 case clang::BuiltinType::RvvUint16m1:
4916 case clang::BuiltinType::RvvUint16m2:
4917 case clang::BuiltinType::RvvUint16m4:
4918 case clang::BuiltinType::RvvUint16m8:
4919 case clang::BuiltinType::RvvInt32mf2:
4920 case clang::BuiltinType::RvvInt32m1:
4921 case clang::BuiltinType::RvvInt32m2:
4922 case clang::BuiltinType::RvvInt32m4:
4923 case clang::BuiltinType::RvvInt32m8:
4924 case clang::BuiltinType::RvvUint32mf2:
4925 case clang::BuiltinType::RvvUint32m1:
4926 case clang::BuiltinType::RvvUint32m2:
4927 case clang::BuiltinType::RvvUint32m4:
4928 case clang::BuiltinType::RvvUint32m8:
4929 case clang::BuiltinType::RvvInt64m1:
4930 case clang::BuiltinType::RvvInt64m2:
4931 case clang::BuiltinType::RvvInt64m4:
4932 case clang::BuiltinType::RvvInt64m8:
4933 case clang::BuiltinType::RvvUint64m1:
4934 case clang::BuiltinType::RvvUint64m2:
4935 case clang::BuiltinType::RvvUint64m4:
4936 case clang::BuiltinType::RvvUint64m8:
4937 case clang::BuiltinType::RvvFloat16mf4:
4938 case clang::BuiltinType::RvvFloat16mf2:
4939 case clang::BuiltinType::RvvFloat16m1:
4940 case clang::BuiltinType::RvvFloat16m2:
4941 case clang::BuiltinType::RvvFloat16m4:
4942 case clang::BuiltinType::RvvFloat16m8:
4943 case clang::BuiltinType::RvvFloat32mf2:
4944 case clang::BuiltinType::RvvFloat32m1:
4945 case clang::BuiltinType::RvvFloat32m2:
4946 case clang::BuiltinType::RvvFloat32m4:
4947 case clang::BuiltinType::RvvFloat32m8:
4948 case clang::BuiltinType::RvvFloat64m1:
4949 case clang::BuiltinType::RvvFloat64m2:
4950 case clang::BuiltinType::RvvFloat64m4:
4951 case clang::BuiltinType::RvvFloat64m8:
4952 case clang::BuiltinType::RvvBool1:
4953 case clang::BuiltinType::RvvBool2:
4954 case clang::BuiltinType::RvvBool4:
4955 case clang::BuiltinType::RvvBool8:
4956 case clang::BuiltinType::RvvBool16:
4957 case clang::BuiltinType::RvvBool32:
4958 case clang::BuiltinType::RvvBool64:
4961 case clang::BuiltinType::IncompleteMatrixIdx:
4967 case clang::Type::ObjCObjectPointer:
4968 case clang::Type::BlockPointer:
4969 case clang::Type::Pointer:
4970 case clang::Type::LValueReference:
4971 case clang::Type::RValueReference:
4972 case clang::Type::MemberPointer:
4974 case clang::Type::Complex: {
4976 if (qual_type->isComplexType())
4979 const clang::ComplexType *complex_type =
4980 qual_type->getAsComplexIntegerType();
4990 case clang::Type::ObjCInterface:
4992 case clang::Type::Record:
4994 case clang::Type::Enum:
4996 case clang::Type::DependentSizedArray:
4997 case clang::Type::DependentSizedExtVector:
4998 case clang::Type::UnresolvedUsing:
4999 case clang::Type::Attributed:
5000 case clang::Type::TemplateTypeParm:
5001 case clang::Type::SubstTemplateTypeParm:
5002 case clang::Type::SubstTemplateTypeParmPack:
5003 case clang::Type::InjectedClassName:
5004 case clang::Type::DependentName:
5005 case clang::Type::DependentTemplateSpecialization:
5006 case clang::Type::PackExpansion:
5007 case clang::Type::ObjCObject:
5009 case clang::Type::TemplateSpecialization:
5010 case clang::Type::DeducedTemplateSpecialization:
5011 case clang::Type::Adjusted:
5016 case clang::Type::Decayed:
5018 case clang::Type::ObjCTypeParam:
5021 case clang::Type::DependentAddressSpace:
5023 case clang::Type::MacroQualified:
5026 case clang::Type::ConstantMatrix:
5027 case clang::Type::DependentSizedMatrix:
5040 switch (qual_type->getTypeClass()) {
5041 case clang::Type::Atomic:
5042 case clang::Type::Auto:
5043 case clang::Type::Decltype:
5044 case clang::Type::Elaborated:
5045 case clang::Type::Paren:
5046 case clang::Type::Typedef:
5047 case clang::Type::TypeOf:
5048 case clang::Type::TypeOfExpr:
5049 llvm_unreachable(
"Handled in RemoveWrappingTypes!");
5050 case clang::Type::UnaryTransform:
5053 case clang::Type::FunctionNoProto:
5054 case clang::Type::FunctionProto:
5057 case clang::Type::IncompleteArray:
5058 case clang::Type::VariableArray:
5061 case clang::Type::ConstantArray:
5064 case clang::Type::DependentVector:
5065 case clang::Type::ExtVector:
5066 case clang::Type::Vector:
5069 case clang::Type::ExtInt:
5070 case clang::Type::DependentExtInt:
5074 case clang::Type::Builtin:
5075 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5076 case clang::BuiltinType::UnknownAny:
5077 case clang::BuiltinType::Void:
5078 case clang::BuiltinType::BoundMember:
5081 case clang::BuiltinType::Bool:
5083 case clang::BuiltinType::Char_S:
5084 case clang::BuiltinType::SChar:
5085 case clang::BuiltinType::WChar_S:
5086 case clang::BuiltinType::Char_U:
5087 case clang::BuiltinType::UChar:
5088 case clang::BuiltinType::WChar_U:
5090 case clang::BuiltinType::Char16:
5092 case clang::BuiltinType::Char32:
5094 case clang::BuiltinType::UShort:
5096 case clang::BuiltinType::Short:
5100 case clang::BuiltinType::Int:
5102 case clang::BuiltinType::ULong:
5104 case clang::BuiltinType::Long:
5106 case clang::BuiltinType::ULongLong:
5108 case clang::BuiltinType::LongLong:
5110 case clang::BuiltinType::UInt128:
5112 case clang::BuiltinType::Int128:
5114 case clang::BuiltinType::Half:
5115 case clang::BuiltinType::Float:
5116 case clang::BuiltinType::Double:
5117 case clang::BuiltinType::LongDouble:
5123 case clang::Type::ObjCObjectPointer:
5125 case clang::Type::BlockPointer:
5127 case clang::Type::Pointer:
5129 case clang::Type::LValueReference:
5130 case clang::Type::RValueReference:
5132 case clang::Type::MemberPointer:
5134 case clang::Type::Complex: {
5135 if (qual_type->isComplexType())
5140 case clang::Type::ObjCInterface:
5142 case clang::Type::Record:
5144 case clang::Type::Enum:
5146 case clang::Type::DependentSizedArray:
5147 case clang::Type::DependentSizedExtVector:
5148 case clang::Type::UnresolvedUsing:
5149 case clang::Type::Attributed:
5150 case clang::Type::TemplateTypeParm:
5151 case clang::Type::SubstTemplateTypeParm:
5152 case clang::Type::SubstTemplateTypeParmPack:
5153 case clang::Type::InjectedClassName:
5154 case clang::Type::DependentName:
5155 case clang::Type::DependentTemplateSpecialization:
5156 case clang::Type::PackExpansion:
5157 case clang::Type::ObjCObject:
5159 case clang::Type::TemplateSpecialization:
5160 case clang::Type::DeducedTemplateSpecialization:
5161 case clang::Type::Adjusted:
5166 case clang::Type::Decayed:
5168 case clang::Type::ObjCTypeParam:
5171 case clang::Type::DependentAddressSpace:
5173 case clang::Type::MacroQualified:
5177 case clang::Type::ConstantMatrix:
5178 case clang::Type::DependentSizedMatrix:
5186 bool check_superclass) {
5187 while (class_interface_decl) {
5188 if (class_interface_decl->ivar_size() > 0)
5191 if (check_superclass)
5192 class_interface_decl = class_interface_decl->getSuperClass();
5199 static Optional<SymbolFile::ArrayInfo>
5201 clang::QualType qual_type,
5203 if (qual_type->isIncompleteArrayType())
5204 if (
auto *metadata = ast.
GetMetadata(qual_type.getTypePtr()))
5211 bool omit_empty_base_classes,
5218 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5219 switch (type_class) {
5220 case clang::Type::Builtin:
5221 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5222 case clang::BuiltinType::ObjCId:
5223 case clang::BuiltinType::ObjCClass:
5232 case clang::Type::Complex:
5234 case clang::Type::Record:
5236 const clang::RecordType *record_type =
5237 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5238 const clang::RecordDecl *record_decl = record_type->getDecl();
5239 assert(record_decl);
5240 const clang::CXXRecordDecl *cxx_record_decl =
5241 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
5242 if (cxx_record_decl) {
5243 if (omit_empty_base_classes) {
5247 clang::CXXRecordDecl::base_class_const_iterator base_class,
5249 for (base_class = cxx_record_decl->bases_begin(),
5250 base_class_end = cxx_record_decl->bases_end();
5251 base_class != base_class_end; ++base_class) {
5252 const clang::CXXRecordDecl *base_class_decl =
5253 llvm::cast<clang::CXXRecordDecl>(
5254 base_class->getType()
5255 ->getAs<clang::RecordType>()
5266 num_children += cxx_record_decl->getNumBases();
5269 clang::RecordDecl::field_iterator field, field_end;
5270 for (field = record_decl->field_begin(),
5271 field_end = record_decl->field_end();
5272 field != field_end; ++field)
5277 case clang::Type::ObjCObject:
5278 case clang::Type::ObjCInterface:
5280 const clang::ObjCObjectType *objc_class_type =
5281 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5282 assert(objc_class_type);
5283 if (objc_class_type) {
5284 clang::ObjCInterfaceDecl *class_interface_decl =
5285 objc_class_type->getInterface();
5287 if (class_interface_decl) {
5289 clang::ObjCInterfaceDecl *superclass_interface_decl =
5290 class_interface_decl->getSuperClass();
5291 if (superclass_interface_decl) {
5292 if (omit_empty_base_classes) {
5299 num_children += class_interface_decl->ivar_size();
5305 case clang::Type::LValueReference:
5306 case clang::Type::RValueReference:
5307 case clang::Type::ObjCObjectPointer: {
5312 num_pointee_children =
5313 pointee_clang_type.
GetNumChildren(omit_empty_base_classes, exe_ctx);
5315 if (num_pointee_children == 0)
5318 num_children = num_pointee_children;
5321 case clang::Type::Vector:
5322 case clang::Type::ExtVector:
5324 llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
5327 case clang::Type::ConstantArray:
5328 num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())
5332 case clang::Type::IncompleteArray:
5333 if (
auto array_info =
5336 num_children = array_info->element_orders.size()
5337 ? array_info->element_orders.back()
5341 case clang::Type::Pointer: {
5342 const clang::PointerType *pointer_type =
5343 llvm::cast<clang::PointerType>(qual_type.getTypePtr());
5344 clang::QualType pointee_type(pointer_type->getPointeeType());
5348 num_pointee_children =
5349 pointee_clang_type.
GetNumChildren(omit_empty_base_classes, exe_ctx);
5350 if (num_pointee_children == 0) {
5355 num_children = num_pointee_children;
5361 return num_children;
5372 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5373 if (type_class == clang::Type::Builtin) {
5374 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5375 case clang::BuiltinType::Void:
5377 case clang::BuiltinType::Bool:
5379 case clang::BuiltinType::Char_S:
5381 case clang::BuiltinType::Char_U:
5383 case clang::BuiltinType::Char16:
5385 case clang::BuiltinType::Char32:
5387 case clang::BuiltinType::UChar:
5389 case clang::BuiltinType::SChar:
5391 case clang::BuiltinType::WChar_S:
5393 case clang::BuiltinType::WChar_U:
5395 case clang::BuiltinType::Short:
5397 case clang::BuiltinType::UShort:
5399 case clang::BuiltinType::Int:
5403 case clang::BuiltinType::Long:
5405 case clang::BuiltinType::ULong:
5407 case clang::BuiltinType::LongLong:
5409 case clang::BuiltinType::ULongLong:
5411 case clang::BuiltinType::Int128:
5413 case clang::BuiltinType::UInt128:
5416 case clang::BuiltinType::Half:
5418 case clang::BuiltinType::Float:
5420 case clang::BuiltinType::Double:
5422 case clang::BuiltinType::LongDouble:
5425 case clang::BuiltinType::NullPtr:
5427 case clang::BuiltinType::ObjCId:
5429 case clang::BuiltinType::ObjCClass:
5431 case clang::BuiltinType::ObjCSel:
5445 const llvm::APSInt &value)>
const &callback) {
5446 const clang::EnumType *enum_type =
5449 const clang::EnumDecl *enum_decl = enum_type->getDecl();
5453 clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
5454 for (enum_pos = enum_decl->enumerator_begin(),
5455 enum_end_pos = enum_decl->enumerator_end();
5456 enum_pos != enum_end_pos; ++enum_pos) {
5457 ConstString name(enum_pos->getNameAsString().c_str());
5458 if (!callback(integer_type, name, enum_pos->getInitVal()))
5465 #pragma mark Aggregate Types
5473 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5474 switch (type_class) {
5475 case clang::Type::Record:
5477 const clang::RecordType *record_type =
5478 llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
5480 clang::RecordDecl *record_decl = record_type->getDecl();
5483 clang::RecordDecl::field_iterator field, field_end;
5484 for (field = record_decl->field_begin(),
5485 field_end = record_decl->field_end();
5486 field != field_end; ++field)
5494 case clang::Type::ObjCObjectPointer: {
5495 const clang::ObjCObjectPointerType *objc_class_type =
5496 qual_type->getAs<clang::ObjCObjectPointerType>();
5497 const clang::ObjCInterfaceType *objc_interface_type =
5498 objc_class_type->getInterfaceType();
5499 if (objc_interface_type &&
5501 const_cast<clang::ObjCInterfaceType *
>(objc_interface_type)))) {
5502 clang::ObjCInterfaceDecl *class_interface_decl =
5503 objc_interface_type->getDecl();
5504 if (class_interface_decl) {
5505 count = class_interface_decl->ivar_size();
5511 case clang::Type::ObjCObject:
5512 case clang::Type::ObjCInterface:
5514 const clang::ObjCObjectType *objc_class_type =
5515 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5516 if (objc_class_type) {
5517 clang::ObjCInterfaceDecl *class_interface_decl =
5518 objc_class_type->getInterface();
5520 if (class_interface_decl)
5521 count = class_interface_decl->ivar_size();
5534 clang::ObjCInterfaceDecl *class_interface_decl,
size_t idx,
5536 uint32_t *bitfield_bit_size_ptr,
bool *is_bitfield_ptr) {
5537 if (class_interface_decl) {
5538 if (idx < (class_interface_decl->ivar_size())) {
5539 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
5540 ivar_end = class_interface_decl->ivar_end();
5543 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end;
5544 ++ivar_pos, ++ivar_idx) {
5545 if (ivar_idx == idx) {
5546 const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
5548 clang::QualType ivar_qual_type(ivar_decl->getType());
5550 name.assign(ivar_decl->getNameAsString());
5552 if (bit_offset_ptr) {
5553 const clang::ASTRecordLayout &interface_layout =
5554 ast->getASTObjCInterfaceLayout(class_interface_decl);
5555 *bit_offset_ptr = interface_layout.getFieldOffset(ivar_idx);
5558 const bool is_bitfield = ivar_pos->isBitField();
5560 if (bitfield_bit_size_ptr) {
5561 *bitfield_bit_size_ptr = 0;
5563 if (is_bitfield && ast) {
5564 clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
5565 clang::Expr::EvalResult result;
5566 if (bitfield_bit_size_expr &&
5567 bitfield_bit_size_expr->EvaluateAsInt(result, *ast)) {
5568 llvm::APSInt bitfield_apsint = result.Val.getInt();
5569 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5573 if (is_bitfield_ptr)
5574 *is_bitfield_ptr = is_bitfield;
5576 return ivar_qual_type.getAsOpaquePtr();
5586 uint64_t *bit_offset_ptr,
5588 bool *is_bitfield_ptr) {
5593 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5594 switch (type_class) {
5595 case clang::Type::Record:
5597 const clang::RecordType *record_type =
5598 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5599 const clang::RecordDecl *record_decl = record_type->getDecl();
5601 clang::RecordDecl::field_iterator field, field_end;
5602 for (field = record_decl->field_begin(),
5603 field_end = record_decl->field_end();
5604 field != field_end; ++field, ++field_idx) {
5605 if (idx == field_idx) {
5608 name.assign(field->getNameAsString());
5612 if (bit_offset_ptr) {
5613 const clang::ASTRecordLayout &record_layout =
5615 *bit_offset_ptr = record_layout.getFieldOffset(field_idx);
5618 const bool is_bitfield = field->isBitField();
5620 if (bitfield_bit_size_ptr) {
5621 *bitfield_bit_size_ptr = 0;
5624 clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
5625 clang::Expr::EvalResult result;
5626 if (bitfield_bit_size_expr &&
5627 bitfield_bit_size_expr->EvaluateAsInt(result,
5629 llvm::APSInt bitfield_apsint = result.Val.getInt();
5630 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5634 if (is_bitfield_ptr)
5635 *is_bitfield_ptr = is_bitfield;
5637 return GetType(field->getType());
5643 case clang::Type::ObjCObjectPointer: {
5644 const clang::ObjCObjectPointerType *objc_class_type =
5645 qual_type->getAs<clang::ObjCObjectPointerType>();
5646 const clang::ObjCInterfaceType *objc_interface_type =
5647 objc_class_type->getInterfaceType();
5648 if (objc_interface_type &&
5650 const_cast<clang::ObjCInterfaceType *
>(objc_interface_type)))) {
5651 clang::ObjCInterfaceDecl *class_interface_decl =
5652 objc_interface_type->getDecl();
5653 if (class_interface_decl) {
5656 idx, name, bit_offset_ptr,
5657 bitfield_bit_size_ptr, is_bitfield_ptr));
5663 case clang::Type::ObjCObject:
5664 case clang::Type::ObjCInterface:
5666 const clang::ObjCObjectType *objc_class_type =
5667 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5668 assert(objc_class_type);
5669 if (objc_class_type) {
5670 clang::ObjCInterfaceDecl *class_interface_decl =
5671 objc_class_type->getInterface();
5674 idx, name, bit_offset_ptr,
5675 bitfield_bit_size_ptr, is_bitfield_ptr));
5690 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5691 switch (type_class) {
5692 case clang::Type::Record:
5694 const clang::CXXRecordDecl *cxx_record_decl =
5695 qual_type->getAsCXXRecordDecl();
5696 if (cxx_record_decl)
5697 count = cxx_record_decl->getNumBases();
5701 case clang::Type::ObjCObjectPointer:
5705 case clang::Type::ObjCObject:
5707 const clang::ObjCObjectType *objc_class_type =
5708 qual_type->getAsObjCQualifiedInterfaceType();
5709 if (objc_class_type) {
5710 clang::ObjCInterfaceDecl *class_interface_decl =
5711 objc_class_type->getInterface();
5713 if (class_interface_decl && class_interface_decl->getSuperClass())
5718 case clang::Type::ObjCInterface:
5720 const clang::ObjCInterfaceType *objc_interface_type =
5721 qual_type->getAs<clang::ObjCInterfaceType>();
5722 if (objc_interface_type) {
5723 clang::ObjCInterfaceDecl *class_interface_decl =
5724 objc_interface_type->getInterface();
5726 if (class_interface_decl && class_interface_decl->getSuperClass())
5742 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5743 switch (type_class) {
5744 case clang::Type::Record:
5746 const clang::CXXRecordDecl *cxx_record_decl =
5747 qual_type->getAsCXXRecordDecl();
5748 if (cxx_record_decl)
5749 count = cxx_record_decl->getNumVBases();
5762 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5763 switch (type_class) {
5764 case clang::Type::Record:
5766 const clang::CXXRecordDecl *cxx_record_decl =
5767 qual_type->getAsCXXRecordDecl();
5768 if (cxx_record_decl) {
5770 clang::CXXRecordDecl::base_class_const_iterator base_class,
5772 for (base_class = cxx_record_decl->bases_begin(),
5773 base_class_end = cxx_record_decl->bases_end();
5774 base_class != base_class_end; ++base_class, ++curr_idx) {
5775 if (curr_idx == idx) {
5776 if (bit_offset_ptr) {
5777 const clang::ASTRecordLayout &record_layout =
5779 const clang::CXXRecordDecl *base_class_decl =
5780 llvm::cast<clang::CXXRecordDecl>(
5781 base_class->getType()
5782 ->getAs<clang::RecordType>()
5784 if (base_class->isVirtual())
5786 record_layout.getVBaseClassOffset(base_class_decl)
5791 record_layout.getBaseClassOffset(base_class_decl)
5795 return GetType(base_class->getType());
5802 case clang::Type::ObjCObjectPointer:
5805 case clang::Type::ObjCObject:
5807 const clang::ObjCObjectType *objc_class_type =
5808 qual_type->getAsObjCQualifiedInterfaceType();
5809 if (objc_class_type) {
5810 clang::ObjCInterfaceDecl *class_interface_decl =
5811 objc_class_type->getInterface();
5813 if (class_interface_decl) {
5814 clang::ObjCInterfaceDecl *superclass_interface_decl =
5815 class_interface_decl->getSuperClass();
5816 if (superclass_interface_decl) {
5818 *bit_offset_ptr = 0;
5820 superclass_interface_decl));
5826 case clang::Type::ObjCInterface:
5828 const clang::ObjCObjectType *objc_interface_type =
5829 qual_type->getAs<clang::ObjCInterfaceType>();
5830 if (objc_interface_type) {
5831 clang::ObjCInterfaceDecl *class_interface_decl =
5832 objc_interface_type->getInterface();
5834 if (class_interface_decl) {
5835 clang::ObjCInterfaceDecl *superclass_interface_decl =
5836 class_interface_decl->getSuperClass();
5837 if (superclass_interface_decl) {
5839 *bit_offset_ptr = 0;
5841 superclass_interface_decl));
5857 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5858 switch (type_class) {
5859 case clang::Type::Record:
5861 const clang::CXXRecordDecl *cxx_record_decl =
5862 qual_type->getAsCXXRecordDecl();
5863 if (cxx_record_decl) {
5865 clang::CXXRecordDecl::base_class_const_iterator base_class,
5867 for (base_class = cxx_record_decl->vbases_begin(),
5868 base_class_end = cxx_record_decl->vbases_end();
5869 base_class != base_class_end; ++base_class, ++curr_idx) {
5870 if (curr_idx == idx) {
5871 if (bit_offset_ptr) {
5872 const clang::ASTRecordLayout &record_layout =
5874 const clang::CXXRecordDecl *base_class_decl =
5875 llvm::cast<clang::CXXRecordDecl>(
5876 base_class->getType()
5877 ->getAs<clang::RecordType>()
5880 record_layout.getVBaseClassOffset(base_class_decl)
5884 return GetType(base_class->getType());
5907 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5908 switch (type_class) {
5909 case clang::Type::Builtin:
5910 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5911 case clang::BuiltinType::UnknownAny:
5912 case clang::BuiltinType::Void:
5913 case clang::BuiltinType::NullPtr:
5914 case clang::BuiltinType::OCLEvent:
5915 case clang::BuiltinType::OCLImage1dRO:
5916 case clang::BuiltinType::OCLImage1dWO:
5917 case clang::BuiltinType::OCLImage1dRW:
5918 case clang::BuiltinType::OCLImage1dArrayRO:
5919 case clang::BuiltinType::OCLImage1dArrayWO:
5920 case clang::BuiltinType::OCLImage1dArrayRW:
5921 case clang::BuiltinType::OCLImage1dBufferRO:
5922 case clang::BuiltinType::OCLImage1dBufferWO:
5923 case clang::BuiltinType::OCLImage1dBufferRW:
5924 case clang::BuiltinType::OCLImage2dRO:
5925 case clang::BuiltinType::OCLImage2dWO:
5926 case clang::BuiltinType::OCLImage2dRW:
5927 case clang::BuiltinType::OCLImage2dArrayRO:
5928 case clang::BuiltinType::OCLImage2dArrayWO:
5929 case clang::BuiltinType::OCLImage2dArrayRW:
5930 case clang::BuiltinType::OCLImage3dRO:
5931 case clang::BuiltinType::OCLImage3dWO:
5932 case clang::BuiltinType::OCLImage3dRW:
5933 case clang::BuiltinType::OCLSampler:
5935 case clang::BuiltinType::Bool:
5936 case clang::BuiltinType::Char_U:
5937 case clang::BuiltinType::UChar:
5938 case clang::BuiltinType::WChar_U:
5939 case clang::BuiltinType::Char16:
5940 case clang::BuiltinType::Char32:
5941 case clang::BuiltinType::UShort:
5943 case clang::BuiltinType::ULong:
5944 case clang::BuiltinType::ULongLong:
5945 case clang::BuiltinType::UInt128:
5946 case clang::BuiltinType::Char_S:
5947 case clang::BuiltinType::SChar:
5948 case clang::BuiltinType::WChar_S:
5949 case clang::BuiltinType::Short:
5950 case clang::BuiltinType::Int:
5951 case clang::BuiltinType::Long:
5952 case clang::BuiltinType::LongLong:
5953 case clang::BuiltinType::Int128:
5954 case clang::BuiltinType::Float:
5955 case clang::BuiltinType::Double:
5956 case clang::BuiltinType::LongDouble:
5957 case clang::BuiltinType::Dependent:
5958 case clang::BuiltinType::Overload:
5959 case clang::BuiltinType::ObjCId:
5960 case clang::BuiltinType::ObjCClass:
5961 case clang::BuiltinType::ObjCSel:
5962 case clang::BuiltinType::BoundMember:
5963 case clang::BuiltinType::Half:
5964 case clang::BuiltinType::ARCUnbridgedCast:
5965 case clang::BuiltinType::PseudoObject:
5966 case clang::BuiltinType::BuiltinFn:
5967 case clang::BuiltinType::OMPArraySection:
5974 case clang::Type::Complex:
5976 case clang::Type::Pointer:
5978 case clang::Type::BlockPointer:
5981 case clang::Type::LValueReference:
5983 case clang::Type::RValueReference:
5985 case clang::Type::MemberPointer:
5987 case clang::Type::ConstantArray:
5989 case clang::Type::IncompleteArray:
5991 case clang::Type::VariableArray:
5993 case clang::Type::DependentSizedArray:
5995 case clang::Type::DependentSizedExtVector:
5997 case clang::Type::Vector:
5999 case clang::Type::ExtVector:
6001 case clang::Type::FunctionProto:
6003 case clang::Type::FunctionNoProto:
6005 case clang::Type::UnresolvedUsing:
6007 case clang::Type::Record:
6009 case clang::Type::Enum:
6011 case clang::Type::TemplateTypeParm:
6013 case clang::Type::SubstTemplateTypeParm:
6015 case clang::Type::TemplateSpecialization:
6017 case clang::Type::InjectedClassName:
6019 case clang::Type::DependentName:
6021 case clang::Type::DependentTemplateSpecialization:
6023 case clang::Type::ObjCObject:
6025 case clang::Type::ObjCInterface:
6027 case clang::Type::ObjCObjectPointer:
6037 bool transparent_pointers,
bool omit_empty_base_classes,
6038 bool ignore_array_bounds,
std::string &child_name,
6039 uint32_t &child_byte_size, int32_t &child_byte_offset,
6041 bool &child_is_base_class,
bool &child_is_deref_of_parent,
6046 auto get_exe_scope = [&exe_ctx]() {
6050 clang::QualType parent_qual_type(
6052 const clang::Type::TypeClass parent_type_class =
6053 parent_qual_type->getTypeClass();
6054 child_bitfield_bit_size = 0;
6055 child_bitfield_bit_offset = 0;
6056 child_is_base_class =
false;
6059 const bool idx_is_valid =
6062 switch (parent_type_class) {
6063 case clang::Type::Builtin:
6065 switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind()) {
6066 case clang::BuiltinType::ObjCId:
6067 case clang::BuiltinType::ObjCClass:
6080 case clang::Type::Record:
6082 const clang::RecordType *record_type =
6083 llvm::cast<clang::RecordType>(parent_qual_type.getTypePtr());
6084 const clang::RecordDecl *record_decl = record_type->getDecl();
6085 assert(record_decl);
6086 const clang::ASTRecordLayout &record_layout =
6090 const clang::CXXRecordDecl *cxx_record_decl =
6091 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6092 if (cxx_record_decl) {
6094 clang::CXXRecordDecl::base_class_const_iterator base_class,
6096 for (base_class = cxx_record_decl->bases_begin(),
6097 base_class_end = cxx_record_decl->bases_end();
6098 base_class != base_class_end; ++base_class) {
6099 const clang::CXXRecordDecl *base_class_decl =
nullptr;
6102 if (omit_empty_base_classes) {
6103 base_class_decl = llvm::cast<clang::CXXRecordDecl>(
6104 base_class->getType()->getAs<clang::RecordType>()->getDecl());
6109 if (idx == child_idx) {
6110 if (base_class_decl ==
nullptr)
6111 base_class_decl = llvm::cast<clang::CXXRecordDecl>(
6112 base_class->getType()->getAs<clang::RecordType>()->getDecl());
6114 if (base_class->isVirtual()) {
6115 bool handled =
false;
6117 clang::VTableContextBase *vtable_ctx =
6121 record_layout, cxx_record_decl,
6122 base_class_decl, bit_offset);
6125 bit_offset = record_layout.getVBaseClassOffset(base_class_decl)
6129 bit_offset = record_layout.getBaseClassOffset(base_class_decl)
6134 child_byte_offset = bit_offset / 8;
6137 Optional<uint64_t> size =
6138 base_class_clang_type.
GetBitSize(get_exe_scope());
6141 uint64_t base_class_clang_type_bit_size = *size;
6144 assert(base_class_clang_type_bit_size % 8 == 0);