Bug Summary

File:tools/lldb/source/Symbol/ClangASTContext.cpp
Warning:line 138, column 3
Returning null reference

Annotated Source Code

1//===-- ClangASTContext.cpp -------------------------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/Symbol/ClangASTContext.h"
11
12#include "llvm/Support/FormatAdapters.h"
13#include "llvm/Support/FormatVariadic.h"
14
15// C Includes
16// C++ Includes
17#include <mutex>
18#include <string>
19#include <vector>
20
21// Other libraries and framework includes
22
23// Clang headers like to use NDEBUG inside of them to enable/disable debug
24// related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
25// or another. This is bad because it means that if clang was built in release
26// mode, it assumes that you are building in release mode which is not always
27// the case. You can end up with functions that are defined as empty in header
28// files when NDEBUG is not defined, and this can cause link errors with the
29// clang .a files that you have since you might be missing functions in the .a
30// file. So we have to define NDEBUG when including clang headers to avoid any
31// mismatches. This is covered by rdar://problem/8691220
32
33#if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF)
34#define LLDB_DEFINED_NDEBUG_FOR_CLANG
35#define NDEBUG
36// Need to include assert.h so it is as clang would expect it to be (disabled)
37#include <assert.h>
38#endif
39
40#include "clang/AST/ASTContext.h"
41#include "clang/AST/ASTImporter.h"
42#include "clang/AST/Attr.h"
43#include "clang/AST/CXXInheritance.h"
44#include "clang/AST/DeclObjC.h"
45#include "clang/AST/DeclTemplate.h"
46#include "clang/AST/Mangle.h"
47#include "clang/AST/RecordLayout.h"
48#include "clang/AST/Type.h"
49#include "clang/AST/VTableBuilder.h"
50#include "clang/Basic/Builtins.h"
51#include "clang/Basic/Diagnostic.h"
52#include "clang/Basic/FileManager.h"
53#include "clang/Basic/FileSystemOptions.h"
54#include "clang/Basic/SourceManager.h"
55#include "clang/Basic/TargetInfo.h"
56#include "clang/Basic/TargetOptions.h"
57#include "clang/Frontend/FrontendOptions.h"
58#include "clang/Frontend/LangStandard.h"
59
60#ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
61#undef NDEBUG
62#undef LLDB_DEFINED_NDEBUG_FOR_CLANG
63// Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
64#include <assert.h>
65#endif
66
67#include "llvm/Support/Signals.h"
68#include "llvm/Support/Threading.h"
69
70#include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
71#include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
72#include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
73#include "lldb/Core/ArchSpec.h"
74#include "lldb/Utility/Flags.h"
75
76#include "lldb/Core/DumpDataExtractor.h"
77#include "lldb/Core/Module.h"
78#include "lldb/Core/PluginManager.h"
79#include "lldb/Core/Scalar.h"
80#include "lldb/Core/StreamFile.h"
81#include "lldb/Core/ThreadSafeDenseMap.h"
82#include "lldb/Core/UniqueCStringMap.h"
83#include "lldb/Symbol/ClangASTContext.h"
84#include "lldb/Symbol/ClangASTImporter.h"
85#include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
86#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
87#include "lldb/Symbol/ClangUtil.h"
88#include "lldb/Symbol/ObjectFile.h"
89#include "lldb/Symbol/SymbolFile.h"
90#include "lldb/Symbol/VerifyDecl.h"
91#include "lldb/Target/ExecutionContext.h"
92#include "lldb/Target/Language.h"
93#include "lldb/Target/ObjCLanguageRuntime.h"
94#include "lldb/Target/Process.h"
95#include "lldb/Target/Target.h"
96#include "lldb/Utility/DataExtractor.h"
97#include "lldb/Utility/LLDBAssert.h"
98#include "lldb/Utility/Log.h"
99#include "lldb/Utility/RegularExpression.h"
100
101#include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
102#include "Plugins/SymbolFile/PDB/PDBASTParser.h"
103
104#include <stdio.h>
105
106#include <mutex>
107
108using namespace lldb;
109using namespace lldb_private;
110using namespace llvm;
111using namespace clang;
112
113namespace {
114static inline bool
115ClangASTContextSupportsLanguage(lldb::LanguageType language) {
116 return language == eLanguageTypeUnknown || // Clang is the default type system
117 Language::LanguageIsC(language) ||
118 Language::LanguageIsCPlusPlus(language) ||
119 Language::LanguageIsObjC(language) ||
120 Language::LanguageIsPascal(language) ||
121 // Use Clang for Rust until there is a proper language plugin for it
122 language == eLanguageTypeRust ||
123 language == eLanguageTypeExtRenderScript ||
124 // Use Clang for D until there is a proper language plugin for it
125 language == eLanguageTypeD;
126}
127}
128
129typedef lldb_private::ThreadSafeDenseMap<clang::ASTContext *, ClangASTContext *>
130 ClangASTMap;
131
132static ClangASTMap &GetASTMap() {
133 static ClangASTMap *g_map_ptr = nullptr;
3
'g_map_ptr' initialized to a null pointer value
134 static llvm::once_flag g_once_flag;
135 llvm::call_once(g_once_flag, []() {
136 g_map_ptr = new ClangASTMap(); // leaked on purpose to avoid spins
137 });
138 return *g_map_ptr;
4
Returning null reference
139}
140
141static bool IsOperator(const char *name,
142 clang::OverloadedOperatorKind &op_kind) {
143 if (name == nullptr || name[0] == '\0')
144 return false;
145
146#define OPERATOR_PREFIX "operator"
147#define OPERATOR_PREFIX_LENGTH (sizeof(OPERATOR_PREFIX) - 1)
148
149 const char *post_op_name = nullptr;
150
151 bool no_space = true;
152
153 if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
154 return false;
155
156 post_op_name = name + OPERATOR_PREFIX_LENGTH;
157
158 if (post_op_name[0] == ' ') {
159 post_op_name++;
160 no_space = false;
161 }
162
163#undef OPERATOR_PREFIX
164#undef OPERATOR_PREFIX_LENGTH
165
166 // This is an operator, set the overloaded operator kind to invalid
167 // in case this is a conversion operator...
168 op_kind = clang::NUM_OVERLOADED_OPERATORS;
169
170 switch (post_op_name[0]) {
171 default:
172 if (no_space)
173 return false;
174 break;
175 case 'n':
176 if (no_space)
177 return false;
178 if (strcmp(post_op_name, "new") == 0)
179 op_kind = clang::OO_New;
180 else if (strcmp(post_op_name, "new[]") == 0)
181 op_kind = clang::OO_Array_New;
182 break;
183
184 case 'd':
185 if (no_space)
186 return false;
187 if (strcmp(post_op_name, "delete") == 0)
188 op_kind = clang::OO_Delete;
189 else if (strcmp(post_op_name, "delete[]") == 0)
190 op_kind = clang::OO_Array_Delete;
191 break;
192
193 case '+':
194 if (post_op_name[1] == '\0')
195 op_kind = clang::OO_Plus;
196 else if (post_op_name[2] == '\0') {
197 if (post_op_name[1] == '=')
198 op_kind = clang::OO_PlusEqual;
199 else if (post_op_name[1] == '+')
200 op_kind = clang::OO_PlusPlus;
201 }
202 break;
203
204 case '-':
205 if (post_op_name[1] == '\0')
206 op_kind = clang::OO_Minus;
207 else if (post_op_name[2] == '\0') {
208 switch (post_op_name[1]) {
209 case '=':
210 op_kind = clang::OO_MinusEqual;
211 break;
212 case '-':
213 op_kind = clang::OO_MinusMinus;
214 break;
215 case '>':
216 op_kind = clang::OO_Arrow;
217 break;
218 }
219 } else if (post_op_name[3] == '\0') {
220 if (post_op_name[2] == '*')
221 op_kind = clang::OO_ArrowStar;
222 break;
223 }
224 break;
225
226 case '*':
227 if (post_op_name[1] == '\0')
228 op_kind = clang::OO_Star;
229 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
230 op_kind = clang::OO_StarEqual;
231 break;
232
233 case '/':
234 if (post_op_name[1] == '\0')
235 op_kind = clang::OO_Slash;
236 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
237 op_kind = clang::OO_SlashEqual;
238 break;
239
240 case '%':
241 if (post_op_name[1] == '\0')
242 op_kind = clang::OO_Percent;
243 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
244 op_kind = clang::OO_PercentEqual;
245 break;
246
247 case '^':
248 if (post_op_name[1] == '\0')
249 op_kind = clang::OO_Caret;
250 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
251 op_kind = clang::OO_CaretEqual;
252 break;
253
254 case '&':
255 if (post_op_name[1] == '\0')
256 op_kind = clang::OO_Amp;
257 else if (post_op_name[2] == '\0') {
258 switch (post_op_name[1]) {
259 case '=':
260 op_kind = clang::OO_AmpEqual;
261 break;
262 case '&':
263 op_kind = clang::OO_AmpAmp;
264 break;
265 }
266 }
267 break;
268
269 case '|':
270 if (post_op_name[1] == '\0')
271 op_kind = clang::OO_Pipe;
272 else if (post_op_name[2] == '\0') {
273 switch (post_op_name[1]) {
274 case '=':
275 op_kind = clang::OO_PipeEqual;
276 break;
277 case '|':
278 op_kind = clang::OO_PipePipe;
279 break;
280 }
281 }
282 break;
283
284 case '~':
285 if (post_op_name[1] == '\0')
286 op_kind = clang::OO_Tilde;
287 break;
288
289 case '!':
290 if (post_op_name[1] == '\0')
291 op_kind = clang::OO_Exclaim;
292 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
293 op_kind = clang::OO_ExclaimEqual;
294 break;
295
296 case '=':
297 if (post_op_name[1] == '\0')
298 op_kind = clang::OO_Equal;
299 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
300 op_kind = clang::OO_EqualEqual;
301 break;
302
303 case '<':
304 if (post_op_name[1] == '\0')
305 op_kind = clang::OO_Less;
306 else if (post_op_name[2] == '\0') {
307 switch (post_op_name[1]) {
308 case '<':
309 op_kind = clang::OO_LessLess;
310 break;
311 case '=':
312 op_kind = clang::OO_LessEqual;
313 break;
314 }
315 } else if (post_op_name[3] == '\0') {
316 if (post_op_name[2] == '=')
317 op_kind = clang::OO_LessLessEqual;
318 }
319 break;
320
321 case '>':
322 if (post_op_name[1] == '\0')
323 op_kind = clang::OO_Greater;
324 else if (post_op_name[2] == '\0') {
325 switch (post_op_name[1]) {
326 case '>':
327 op_kind = clang::OO_GreaterGreater;
328 break;
329 case '=':
330 op_kind = clang::OO_GreaterEqual;
331 break;
332 }
333 } else if (post_op_name[1] == '>' && post_op_name[2] == '=' &&
334 post_op_name[3] == '\0') {
335 op_kind = clang::OO_GreaterGreaterEqual;
336 }
337 break;
338
339 case ',':
340 if (post_op_name[1] == '\0')
341 op_kind = clang::OO_Comma;
342 break;
343
344 case '(':
345 if (post_op_name[1] == ')' && post_op_name[2] == '\0')
346 op_kind = clang::OO_Call;
347 break;
348
349 case '[':
350 if (post_op_name[1] == ']' && post_op_name[2] == '\0')
351 op_kind = clang::OO_Subscript;
352 break;
353 }
354
355 return true;
356}
357
358clang::AccessSpecifier
359ClangASTContext::ConvertAccessTypeToAccessSpecifier(AccessType access) {
360 switch (access) {
361 default:
362 break;
363 case eAccessNone:
364 return AS_none;
365 case eAccessPublic:
366 return AS_public;
367 case eAccessPrivate:
368 return AS_private;
369 case eAccessProtected:
370 return AS_protected;
371 }
372 return AS_none;
373}
374
375static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) {
376 // FIXME: Cleanup per-file based stuff.
377
378 // Set some properties which depend solely on the input kind; it would be nice
379 // to move these to the language standard, and have the driver resolve the
380 // input kind + language standard.
381 if (IK.getLanguage() == InputKind::Asm) {
382 Opts.AsmPreprocessor = 1;
383 } else if (IK.isObjectiveC()) {
384 Opts.ObjC1 = Opts.ObjC2 = 1;
385 }
386
387 LangStandard::Kind LangStd = LangStandard::lang_unspecified;
388
389 if (LangStd == LangStandard::lang_unspecified) {
390 // Based on the base language, pick one.
391 switch (IK.getLanguage()) {
392 case InputKind::Unknown:
393 case InputKind::LLVM_IR:
394 case InputKind::RenderScript:
395 llvm_unreachable("Invalid input kind!")::llvm::llvm_unreachable_internal("Invalid input kind!", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 395)
;
396 case InputKind::OpenCL:
397 LangStd = LangStandard::lang_opencl10;
398 break;
399 case InputKind::CUDA:
400 LangStd = LangStandard::lang_cuda;
401 break;
402 case InputKind::Asm:
403 case InputKind::C:
404 case InputKind::ObjC:
405 LangStd = LangStandard::lang_gnu99;
406 break;
407 case InputKind::CXX:
408 case InputKind::ObjCXX:
409 LangStd = LangStandard::lang_gnucxx98;
410 break;
411 }
412 }
413
414 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
415 Opts.LineComment = Std.hasLineComments();
416 Opts.C99 = Std.isC99();
417 Opts.CPlusPlus = Std.isCPlusPlus();
418 Opts.CPlusPlus11 = Std.isCPlusPlus11();
419 Opts.Digraphs = Std.hasDigraphs();
420 Opts.GNUMode = Std.isGNUMode();
421 Opts.GNUInline = !Std.isC99();
422 Opts.HexFloats = Std.hasHexFloats();
423 Opts.ImplicitInt = Std.hasImplicitInt();
424
425 Opts.WChar = true;
426
427 // OpenCL has some additional defaults.
428 if (LangStd == LangStandard::lang_opencl10) {
429 Opts.OpenCL = 1;
430 Opts.AltiVec = 1;
431 Opts.CXXOperatorNames = 1;
432 Opts.LaxVectorConversions = 1;
433 }
434
435 // OpenCL and C++ both have bool, true, false keywords.
436 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
437
438 // if (Opts.CPlusPlus)
439 // Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
440 //
441 // if (Args.hasArg(OPT_fobjc_gc_only))
442 // Opts.setGCMode(LangOptions::GCOnly);
443 // else if (Args.hasArg(OPT_fobjc_gc))
444 // Opts.setGCMode(LangOptions::HybridGC);
445 //
446 // if (Args.hasArg(OPT_print_ivar_layout))
447 // Opts.ObjCGCBitmapPrint = 1;
448 //
449 // if (Args.hasArg(OPT_faltivec))
450 // Opts.AltiVec = 1;
451 //
452 // if (Args.hasArg(OPT_pthread))
453 // Opts.POSIXThreads = 1;
454 //
455 // llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
456 // "default");
457 // if (Vis == "default")
458 Opts.setValueVisibilityMode(DefaultVisibility);
459 // else if (Vis == "hidden")
460 // Opts.setVisibilityMode(LangOptions::Hidden);
461 // else if (Vis == "protected")
462 // Opts.setVisibilityMode(LangOptions::Protected);
463 // else
464 // Diags.Report(diag::err_drv_invalid_value)
465 // << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
466
467 // Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
468
469 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
470 // is specified, or -std is set to a conforming mode.
471 Opts.Trigraphs = !Opts.GNUMode;
472 // if (Args.hasArg(OPT_trigraphs))
473 // Opts.Trigraphs = 1;
474 //
475 // Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
476 // OPT_fno_dollars_in_identifiers,
477 // !Opts.AsmPreprocessor);
478 // Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
479 // Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
480 // Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
481 // if (Args.hasArg(OPT_fno_lax_vector_conversions))
482 // Opts.LaxVectorConversions = 0;
483 // Opts.Exceptions = Args.hasArg(OPT_fexceptions);
484 // Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
485 // Opts.Blocks = Args.hasArg(OPT_fblocks);
486 Opts.CharIsSigned = ArchSpec(triple).CharIsSignedByDefault();
487 // Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
488 // Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
489 // Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
490 // Opts.AssumeSaneOperatorNew =
491 // !Args.hasArg(OPT_fno_assume_sane_operator_new);
492 // Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
493 // Opts.AccessControl = Args.hasArg(OPT_faccess_control);
494 // Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
495 // Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno);
496 // Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth,
497 // 99,
498 // Diags);
499 // Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
500 // Opts.ObjCConstantStringClass = getLastArgValue(Args,
501 // OPT_fconstant_string_class);
502 // Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
503 // Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
504 // Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
505 // Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
506 // Opts.Static = Args.hasArg(OPT_static_define);
507 Opts.OptimizeSize = 0;
508
509 // FIXME: Eliminate this dependency.
510 // unsigned Opt =
511 // Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
512 // Opts.Optimize = Opt != 0;
513 unsigned Opt = 0;
514
515 // This is the __NO_INLINE__ define, which just depends on things like the
516 // optimization level and -fno-inline, not actually whether the backend has
517 // inlining enabled.
518 //
519 // FIXME: This is affected by other options (-fno-inline).
520 Opts.NoInlineDefine = !Opt;
521
522 // unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
523 // switch (SSP) {
524 // default:
525 // Diags.Report(diag::err_drv_invalid_value)
526 // << Args.getLastArg(OPT_stack_protector)->getAsString(Args) <<
527 // SSP;
528 // break;
529 // case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
530 // case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break;
531 // case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
532 // }
533}
534
535ClangASTContext::ClangASTContext(const char *target_triple)
536 : TypeSystem(TypeSystem::eKindClang), m_target_triple(), m_ast_ap(),
537 m_language_options_ap(), m_source_manager_ap(), m_diagnostics_engine_ap(),
538 m_target_options_rp(), m_target_info_ap(), m_identifier_table_ap(),
539 m_selector_table_ap(), m_builtins_ap(), m_callback_tag_decl(nullptr),
540 m_callback_objc_decl(nullptr), m_callback_baton(nullptr),
541 m_pointer_byte_size(0), m_ast_owned(false) {
542 if (target_triple && target_triple[0])
543 SetTargetTriple(target_triple);
544}
545
546//----------------------------------------------------------------------
547// Destructor
548//----------------------------------------------------------------------
549ClangASTContext::~ClangASTContext() { Finalize(); }
550
551ConstString ClangASTContext::GetPluginNameStatic() {
552 return ConstString("clang");
553}
554
555ConstString ClangASTContext::GetPluginName() {
556 return ClangASTContext::GetPluginNameStatic();
557}
558
559uint32_t ClangASTContext::GetPluginVersion() { return 1; }
560
561lldb::TypeSystemSP ClangASTContext::CreateInstance(lldb::LanguageType language,
562 lldb_private::Module *module,
563 Target *target) {
564 if (ClangASTContextSupportsLanguage(language)) {
565 ArchSpec arch;
566 if (module)
567 arch = module->GetArchitecture();
568 else if (target)
569 arch = target->GetArchitecture();
570
571 if (arch.IsValid()) {
572 ArchSpec fixed_arch = arch;
573 // LLVM wants this to be set to iOS or MacOSX; if we're working on
574 // a bare-boards type image, change the triple for llvm's benefit.
575 if (fixed_arch.GetTriple().getVendor() == llvm::Triple::Apple &&
576 fixed_arch.GetTriple().getOS() == llvm::Triple::UnknownOS) {
577 if (fixed_arch.GetTriple().getArch() == llvm::Triple::arm ||
578 fixed_arch.GetTriple().getArch() == llvm::Triple::aarch64 ||
579 fixed_arch.GetTriple().getArch() == llvm::Triple::thumb) {
580 fixed_arch.GetTriple().setOS(llvm::Triple::IOS);
581 } else {
582 fixed_arch.GetTriple().setOS(llvm::Triple::MacOSX);
583 }
584 }
585
586 if (module) {
587 std::shared_ptr<ClangASTContext> ast_sp(new ClangASTContext);
588 if (ast_sp) {
589 ast_sp->SetArchitecture(fixed_arch);
590 }
591 return ast_sp;
592 } else if (target && target->IsValid()) {
593 std::shared_ptr<ClangASTContextForExpressions> ast_sp(
594 new ClangASTContextForExpressions(*target));
595 if (ast_sp) {
596 ast_sp->SetArchitecture(fixed_arch);
597 ast_sp->m_scratch_ast_source_ap.reset(
598 new ClangASTSource(target->shared_from_this()));
599 ast_sp->m_scratch_ast_source_ap->InstallASTContext(
600 ast_sp->getASTContext());
601 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source(
602 ast_sp->m_scratch_ast_source_ap->CreateProxy());
603 ast_sp->SetExternalSource(proxy_ast_source);
604 return ast_sp;
605 }
606 }
607 }
608 }
609 return lldb::TypeSystemSP();
610}
611
612void ClangASTContext::EnumerateSupportedLanguages(
613 std::set<lldb::LanguageType> &languages_for_types,
614 std::set<lldb::LanguageType> &languages_for_expressions) {
615 static std::vector<lldb::LanguageType> s_supported_languages_for_types(
616 {lldb::eLanguageTypeC89, lldb::eLanguageTypeC, lldb::eLanguageTypeC11,
617 lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeC99,
618 lldb::eLanguageTypeObjC, lldb::eLanguageTypeObjC_plus_plus,
619 lldb::eLanguageTypeC_plus_plus_03, lldb::eLanguageTypeC_plus_plus_11,
620 lldb::eLanguageTypeC11, lldb::eLanguageTypeC_plus_plus_14});
621
622 static std::vector<lldb::LanguageType> s_supported_languages_for_expressions(
623 {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC_plus_plus,
624 lldb::eLanguageTypeC_plus_plus_03, lldb::eLanguageTypeC_plus_plus_11,
625 lldb::eLanguageTypeC_plus_plus_14});
626
627 languages_for_types.insert(s_supported_languages_for_types.begin(),
628 s_supported_languages_for_types.end());
629 languages_for_expressions.insert(
630 s_supported_languages_for_expressions.begin(),
631 s_supported_languages_for_expressions.end());
632}
633
634void ClangASTContext::Initialize() {
635 PluginManager::RegisterPlugin(GetPluginNameStatic(),
636 "clang base AST context plug-in",
637 CreateInstance, EnumerateSupportedLanguages);
638}
639
640void ClangASTContext::Terminate() {
641 PluginManager::UnregisterPlugin(CreateInstance);
642}
643
644void ClangASTContext::Finalize() {
645 if (m_ast_ap.get()) {
646 GetASTMap().Erase(m_ast_ap.get());
647 if (!m_ast_owned)
648 m_ast_ap.release();
649 }
650
651 m_builtins_ap.reset();
652 m_selector_table_ap.reset();
653 m_identifier_table_ap.reset();
654 m_target_info_ap.reset();
655 m_target_options_rp.reset();
656 m_diagnostics_engine_ap.reset();
657 m_source_manager_ap.reset();
658 m_language_options_ap.reset();
659 m_ast_ap.reset();
660 m_scratch_ast_source_ap.reset();
661}
662
663void ClangASTContext::Clear() {
664 m_ast_ap.reset();
665 m_language_options_ap.reset();
666 m_source_manager_ap.reset();
667 m_diagnostics_engine_ap.reset();
668 m_target_options_rp.reset();
669 m_target_info_ap.reset();
670 m_identifier_table_ap.reset();
671 m_selector_table_ap.reset();
672 m_builtins_ap.reset();
673 m_pointer_byte_size = 0;
674}
675
676const char *ClangASTContext::GetTargetTriple() {
677 return m_target_triple.c_str();
678}
679
680void ClangASTContext::SetTargetTriple(const char *target_triple) {
681 Clear();
682 m_target_triple.assign(target_triple);
683}
684
685void ClangASTContext::SetArchitecture(const ArchSpec &arch) {
686 SetTargetTriple(arch.GetTriple().str().c_str());
687}
688
689bool ClangASTContext::HasExternalSource() {
690 ASTContext *ast = getASTContext();
691 if (ast)
692 return ast->getExternalSource() != nullptr;
693 return false;
694}
695
696void ClangASTContext::SetExternalSource(
697 llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_ap) {
698 ASTContext *ast = getASTContext();
699 if (ast) {
700 ast->setExternalSource(ast_source_ap);
701 ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
702 // ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true);
703 }
704}
705
706void ClangASTContext::RemoveExternalSource() {
707 ASTContext *ast = getASTContext();
708
709 if (ast) {
710 llvm::IntrusiveRefCntPtr<ExternalASTSource> empty_ast_source_ap;
711 ast->setExternalSource(empty_ast_source_ap);
712 ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false);
713 // ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false);
714 }
715}
716
717void ClangASTContext::setASTContext(clang::ASTContext *ast_ctx) {
718 if (!m_ast_owned) {
719 m_ast_ap.release();
720 }
721 m_ast_owned = false;
722 m_ast_ap.reset(ast_ctx);
723 GetASTMap().Insert(ast_ctx, this);
724}
725
726ASTContext *ClangASTContext::getASTContext() {
727 if (m_ast_ap.get() == nullptr) {
728 m_ast_owned = true;
729 m_ast_ap.reset(new ASTContext(*getLanguageOptions(), *getSourceManager(),
730 *getIdentifierTable(), *getSelectorTable(),
731 *getBuiltinContext()));
732
733 m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false);
734
735 // This can be NULL if we don't know anything about the architecture or if
736 // the
737 // target for an architecture isn't enabled in the llvm/clang that we built
738 TargetInfo *target_info = getTargetInfo();
739 if (target_info)
740 m_ast_ap->InitBuiltinTypes(*target_info);
741
742 if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton) {
743 m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage();
744 // m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage();
745 }
746
747 GetASTMap().Insert(m_ast_ap.get(), this);
748
749 llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_ap(
750 new ClangExternalASTSourceCallbacks(
751 ClangASTContext::CompleteTagDecl,
752 ClangASTContext::CompleteObjCInterfaceDecl, nullptr,
753 ClangASTContext::LayoutRecordType, this));
754 SetExternalSource(ast_source_ap);
755 }
756 return m_ast_ap.get();
757}
758
759ClangASTContext *ClangASTContext::GetASTContext(clang::ASTContext *ast) {
760 ClangASTContext *clang_ast = GetASTMap().Lookup(ast);
2
Calling 'GetASTMap'
761 return clang_ast;
762}
763
764Builtin::Context *ClangASTContext::getBuiltinContext() {
765 if (m_builtins_ap.get() == nullptr)
766 m_builtins_ap.reset(new Builtin::Context());
767 return m_builtins_ap.get();
768}
769
770IdentifierTable *ClangASTContext::getIdentifierTable() {
771 if (m_identifier_table_ap.get() == nullptr)
772 m_identifier_table_ap.reset(
773 new IdentifierTable(*ClangASTContext::getLanguageOptions(), nullptr));
774 return m_identifier_table_ap.get();
775}
776
777LangOptions *ClangASTContext::getLanguageOptions() {
778 if (m_language_options_ap.get() == nullptr) {
779 m_language_options_ap.reset(new LangOptions());
780 ParseLangArgs(*m_language_options_ap, InputKind::ObjCXX, GetTargetTriple());
781 // InitializeLangOptions(*m_language_options_ap, InputKind::ObjCXX);
782 }
783 return m_language_options_ap.get();
784}
785
786SelectorTable *ClangASTContext::getSelectorTable() {
787 if (m_selector_table_ap.get() == nullptr)
788 m_selector_table_ap.reset(new SelectorTable());
789 return m_selector_table_ap.get();
790}
791
792clang::FileManager *ClangASTContext::getFileManager() {
793 if (m_file_manager_ap.get() == nullptr) {
794 clang::FileSystemOptions file_system_options;
795 m_file_manager_ap.reset(new clang::FileManager(file_system_options));
796 }
797 return m_file_manager_ap.get();
798}
799
800clang::SourceManager *ClangASTContext::getSourceManager() {
801 if (m_source_manager_ap.get() == nullptr)
802 m_source_manager_ap.reset(
803 new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager()));
804 return m_source_manager_ap.get();
805}
806
807clang::DiagnosticsEngine *ClangASTContext::getDiagnosticsEngine() {
808 if (m_diagnostics_engine_ap.get() == nullptr) {
809 llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
810 m_diagnostics_engine_ap.reset(
811 new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions()));
812 }
813 return m_diagnostics_engine_ap.get();
814}
815
816clang::MangleContext *ClangASTContext::getMangleContext() {
817 if (m_mangle_ctx_ap.get() == nullptr)
818 m_mangle_ctx_ap.reset(getASTContext()->createMangleContext());
819 return m_mangle_ctx_ap.get();
820}
821
822class NullDiagnosticConsumer : public DiagnosticConsumer {
823public:
824 NullDiagnosticConsumer() {
825 m_log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8));
826 }
827
828 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
829 const clang::Diagnostic &info) {
830 if (m_log) {
831 llvm::SmallVector<char, 32> diag_str(10);
832 info.FormatDiagnostic(diag_str);
833 diag_str.push_back('\0');
834 m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
835 }
836 }
837
838 DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
839 return new NullDiagnosticConsumer();
840 }
841
842private:
843 Log *m_log;
844};
845
846DiagnosticConsumer *ClangASTContext::getDiagnosticConsumer() {
847 if (m_diagnostic_consumer_ap.get() == nullptr)
848 m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer);
849
850 return m_diagnostic_consumer_ap.get();
851}
852
853std::shared_ptr<clang::TargetOptions> &ClangASTContext::getTargetOptions() {
854 if (m_target_options_rp.get() == nullptr && !m_target_triple.empty()) {
855 m_target_options_rp = std::make_shared<clang::TargetOptions>();
856 if (m_target_options_rp.get() != nullptr)
857 m_target_options_rp->Triple = m_target_triple;
858 }
859 return m_target_options_rp;
860}
861
862TargetInfo *ClangASTContext::getTargetInfo() {
863 // target_triple should be something like "x86_64-apple-macosx"
864 if (m_target_info_ap.get() == nullptr && !m_target_triple.empty())
865 m_target_info_ap.reset(TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(),
866 getTargetOptions()));
867 return m_target_info_ap.get();
868}
869
870#pragma mark Basic Types
871
872static inline bool QualTypeMatchesBitSize(const uint64_t bit_size,
873 ASTContext *ast, QualType qual_type) {
874 uint64_t qual_type_bit_size = ast->getTypeSize(qual_type);
875 if (qual_type_bit_size == bit_size)
876 return true;
877 return false;
878}
879
880CompilerType
881ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(Encoding encoding,
882 size_t bit_size) {
883 return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(
884 getASTContext(), encoding, bit_size);
885}
886
887CompilerType ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(
888 ASTContext *ast, Encoding encoding, uint32_t bit_size) {
889 if (!ast)
890 return CompilerType();
891 switch (encoding) {
892 case eEncodingInvalid:
893 if (QualTypeMatchesBitSize(bit_size, ast, ast->VoidPtrTy))
894 return CompilerType(ast, ast->VoidPtrTy);
895 break;
896
897 case eEncodingUint:
898 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
899 return CompilerType(ast, ast->UnsignedCharTy);
900 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
901 return CompilerType(ast, ast->UnsignedShortTy);
902 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy))
903 return CompilerType(ast, ast->UnsignedIntTy);
904 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy))
905 return CompilerType(ast, ast->UnsignedLongTy);
906 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy))
907 return CompilerType(ast, ast->UnsignedLongLongTy);
908 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty))
909 return CompilerType(ast, ast->UnsignedInt128Ty);
910 break;
911
912 case eEncodingSint:
913 if (QualTypeMatchesBitSize(bit_size, ast, ast->SignedCharTy))
914 return CompilerType(ast, ast->SignedCharTy);
915 if (QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy))
916 return CompilerType(ast, ast->ShortTy);
917 if (QualTypeMatchesBitSize(bit_size, ast, ast->IntTy))
918 return CompilerType(ast, ast->IntTy);
919 if (QualTypeMatchesBitSize(bit_size, ast, ast->LongTy))
920 return CompilerType(ast, ast->LongTy);
921 if (QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy))
922 return CompilerType(ast, ast->LongLongTy);
923 if (QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty))
924 return CompilerType(ast, ast->Int128Ty);
925 break;
926
927 case eEncodingIEEE754:
928 if (QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy))
929 return CompilerType(ast, ast->FloatTy);
930 if (QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy))
931 return CompilerType(ast, ast->DoubleTy);
932 if (QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy))
933 return CompilerType(ast, ast->LongDoubleTy);
934 if (QualTypeMatchesBitSize(bit_size, ast, ast->HalfTy))
935 return CompilerType(ast, ast->HalfTy);
936 break;
937
938 case eEncodingVector:
939 // Sanity check that bit_size is a multiple of 8's.
940 if (bit_size && !(bit_size & 0x7u))
941 return CompilerType(
942 ast, ast->getExtVectorType(ast->UnsignedCharTy, bit_size / 8));
943 break;
944 }
945
946 return CompilerType();
947}
948
949lldb::BasicType
950ClangASTContext::GetBasicTypeEnumeration(const ConstString &name) {
951 if (name) {
952 typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
953 static TypeNameToBasicTypeMap g_type_map;
954 static llvm::once_flag g_once_flag;
955 llvm::call_once(g_once_flag, []() {
956 // "void"
957 g_type_map.Append(ConstString("void"), eBasicTypeVoid);
958
959 // "char"
960 g_type_map.Append(ConstString("char"), eBasicTypeChar);
961 g_type_map.Append(ConstString("signed char"), eBasicTypeSignedChar);
962 g_type_map.Append(ConstString("unsigned char"), eBasicTypeUnsignedChar);
963 g_type_map.Append(ConstString("wchar_t"), eBasicTypeWChar);
964 g_type_map.Append(ConstString("signed wchar_t"), eBasicTypeSignedWChar);
965 g_type_map.Append(ConstString("unsigned wchar_t"),
966 eBasicTypeUnsignedWChar);
967 // "short"
968 g_type_map.Append(ConstString("short"), eBasicTypeShort);
969 g_type_map.Append(ConstString("short int"), eBasicTypeShort);
970 g_type_map.Append(ConstString("unsigned short"), eBasicTypeUnsignedShort);
971 g_type_map.Append(ConstString("unsigned short int"),
972 eBasicTypeUnsignedShort);
973
974 // "int"
975 g_type_map.Append(ConstString("int"), eBasicTypeInt);
976 g_type_map.Append(ConstString("signed int"), eBasicTypeInt);
977 g_type_map.Append(ConstString("unsigned int"), eBasicTypeUnsignedInt);
978 g_type_map.Append(ConstString("unsigned"), eBasicTypeUnsignedInt);
979
980 // "long"
981 g_type_map.Append(ConstString("long"), eBasicTypeLong);
982 g_type_map.Append(ConstString("long int"), eBasicTypeLong);
983 g_type_map.Append(ConstString("unsigned long"), eBasicTypeUnsignedLong);
984 g_type_map.Append(ConstString("unsigned long int"),
985 eBasicTypeUnsignedLong);
986
987 // "long long"
988 g_type_map.Append(ConstString("long long"), eBasicTypeLongLong);
989 g_type_map.Append(ConstString("long long int"), eBasicTypeLongLong);
990 g_type_map.Append(ConstString("unsigned long long"),
991 eBasicTypeUnsignedLongLong);
992 g_type_map.Append(ConstString("unsigned long long int"),
993 eBasicTypeUnsignedLongLong);
994
995 // "int128"
996 g_type_map.Append(ConstString("__int128_t"), eBasicTypeInt128);
997 g_type_map.Append(ConstString("__uint128_t"), eBasicTypeUnsignedInt128);
998
999 // Miscellaneous
1000 g_type_map.Append(ConstString("bool"), eBasicTypeBool);
1001 g_type_map.Append(ConstString("float"), eBasicTypeFloat);
1002 g_type_map.Append(ConstString("double"), eBasicTypeDouble);
1003 g_type_map.Append(ConstString("long double"), eBasicTypeLongDouble);
1004 g_type_map.Append(ConstString("id"), eBasicTypeObjCID);
1005 g_type_map.Append(ConstString("SEL"), eBasicTypeObjCSel);
1006 g_type_map.Append(ConstString("nullptr"), eBasicTypeNullPtr);
1007 g_type_map.Sort();
1008 });
1009
1010 return g_type_map.Find(name, eBasicTypeInvalid);
1011 }
1012 return eBasicTypeInvalid;
1013}
1014
1015CompilerType ClangASTContext::GetBasicType(ASTContext *ast,
1016 const ConstString &name) {
1017 if (ast) {
1018 lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration(name);
1019 return ClangASTContext::GetBasicType(ast, basic_type);
1020 }
1021 return CompilerType();
1022}
1023
1024uint32_t ClangASTContext::GetPointerByteSize() {
1025 if (m_pointer_byte_size == 0)
1026 m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid)
1027 .GetPointerType()
1028 .GetByteSize(nullptr);
1029 return m_pointer_byte_size;
1030}
1031
1032CompilerType ClangASTContext::GetBasicType(lldb::BasicType basic_type) {
1033 return GetBasicType(getASTContext(), basic_type);
1034}
1035
1036CompilerType ClangASTContext::GetBasicType(ASTContext *ast,
1037 lldb::BasicType basic_type) {
1038 if (!ast)
1039 return CompilerType();
1040 lldb::opaque_compiler_type_t clang_type =
1041 GetOpaqueCompilerType(ast, basic_type);
1042
1043 if (clang_type)
1044 return CompilerType(GetASTContext(ast), clang_type);
1045 return CompilerType();
1046}
1047
1048CompilerType ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize(
1049 const char *type_name, uint32_t dw_ate, uint32_t bit_size) {
1050 ASTContext *ast = getASTContext();
1051
1052#define streq(a, b)strcmp(a, b) == 0 strcmp(a, b) == 0
1053 assert(ast != nullptr)((ast != nullptr) ? static_cast<void> (0) : __assert_fail
("ast != nullptr", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 1053, __PRETTY_FUNCTION__))
;
1054 if (ast) {
1055 switch (dw_ate) {
1056 default:
1057 break;
1058
1059 case DW_ATE_address:
1060 if (QualTypeMatchesBitSize(bit_size, ast, ast->VoidPtrTy))
1061 return CompilerType(ast, ast->VoidPtrTy);
1062 break;
1063
1064 case DW_ATE_boolean:
1065 if (QualTypeMatchesBitSize(bit_size, ast, ast->BoolTy))
1066 return CompilerType(ast, ast->BoolTy);
1067 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
1068 return CompilerType(ast, ast->UnsignedCharTy);
1069 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
1070 return CompilerType(ast, ast->UnsignedShortTy);
1071 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy))
1072 return CompilerType(ast, ast->UnsignedIntTy);
1073 break;
1074
1075 case DW_ATE_lo_user:
1076 // This has been seen to mean DW_AT_complex_integer
1077 if (type_name) {
1078 if (::strstr(type_name, "complex")) {
1079 CompilerType complex_int_clang_type =
1080 GetBuiltinTypeForDWARFEncodingAndBitSize("int", DW_ATE_signed,
1081 bit_size / 2);
1082 return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType(
1083 complex_int_clang_type)));
1084 }
1085 }
1086 break;
1087
1088 case DW_ATE_complex_float:
1089 if (QualTypeMatchesBitSize(bit_size, ast, ast->FloatComplexTy))
1090 return CompilerType(ast, ast->FloatComplexTy);
1091 else if (QualTypeMatchesBitSize(bit_size, ast, ast->DoubleComplexTy))
1092 return CompilerType(ast, ast->DoubleComplexTy);
1093 else if (QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleComplexTy))
1094 return CompilerType(ast, ast->LongDoubleComplexTy);
1095 else {
1096 CompilerType complex_float_clang_type =
1097 GetBuiltinTypeForDWARFEncodingAndBitSize("float", DW_ATE_float,
1098 bit_size / 2);
1099 return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType(
1100 complex_float_clang_type)));
1101 }
1102 break;
1103
1104 case DW_ATE_float:
1105 if (streq(type_name, "float")strcmp(type_name, "float") == 0 &&
1106 QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy))
1107 return CompilerType(ast, ast->FloatTy);
1108 if (streq(type_name, "double")strcmp(type_name, "double") == 0 &&
1109 QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy))
1110 return CompilerType(ast, ast->DoubleTy);
1111 if (streq(type_name, "long double")strcmp(type_name, "long double") == 0 &&
1112 QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy))
1113 return CompilerType(ast, ast->LongDoubleTy);
1114 // Fall back to not requiring a name match
1115 if (QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy))
1116 return CompilerType(ast, ast->FloatTy);
1117 if (QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy))
1118 return CompilerType(ast, ast->DoubleTy);
1119 if (QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy))
1120 return CompilerType(ast, ast->LongDoubleTy);
1121 if (QualTypeMatchesBitSize(bit_size, ast, ast->HalfTy))
1122 return CompilerType(ast, ast->HalfTy);
1123 break;
1124
1125 case DW_ATE_signed:
1126 if (type_name) {
1127 if (streq(type_name, "wchar_t")strcmp(type_name, "wchar_t") == 0 &&
1128 QualTypeMatchesBitSize(bit_size, ast, ast->WCharTy) &&
1129 (getTargetInfo() &&
1130 TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
1131 return CompilerType(ast, ast->WCharTy);
1132 if (streq(type_name, "void")strcmp(type_name, "void") == 0 &&
1133 QualTypeMatchesBitSize(bit_size, ast, ast->VoidTy))
1134 return CompilerType(ast, ast->VoidTy);
1135 if (strstr(type_name, "long long") &&
1136 QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy))
1137 return CompilerType(ast, ast->LongLongTy);
1138 if (strstr(type_name, "long") &&
1139 QualTypeMatchesBitSize(bit_size, ast, ast->LongTy))
1140 return CompilerType(ast, ast->LongTy);
1141 if (strstr(type_name, "short") &&
1142 QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy))
1143 return CompilerType(ast, ast->ShortTy);
1144 if (strstr(type_name, "char")) {
1145 if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
1146 return CompilerType(ast, ast->CharTy);
1147 if (QualTypeMatchesBitSize(bit_size, ast, ast->SignedCharTy))
1148 return CompilerType(ast, ast->SignedCharTy);
1149 }
1150 if (strstr(type_name, "int")) {
1151 if (QualTypeMatchesBitSize(bit_size, ast, ast->IntTy))
1152 return CompilerType(ast, ast->IntTy);
1153 if (QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty))
1154 return CompilerType(ast, ast->Int128Ty);
1155 }
1156 }
1157 // We weren't able to match up a type name, just search by size
1158 if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
1159 return CompilerType(ast, ast->CharTy);
1160 if (QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy))
1161 return CompilerType(ast, ast->ShortTy);
1162 if (QualTypeMatchesBitSize(bit_size, ast, ast->IntTy))
1163 return CompilerType(ast, ast->IntTy);
1164 if (QualTypeMatchesBitSize(bit_size, ast, ast->LongTy))
1165 return CompilerType(ast, ast->LongTy);
1166 if (QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy))
1167 return CompilerType(ast, ast->LongLongTy);
1168 if (QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty))
1169 return CompilerType(ast, ast->Int128Ty);
1170 break;
1171
1172 case DW_ATE_signed_char:
1173 if (ast->getLangOpts().CharIsSigned && type_name &&
1174 streq(type_name, "char")strcmp(type_name, "char") == 0) {
1175 if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
1176 return CompilerType(ast, ast->CharTy);
1177 }
1178 if (QualTypeMatchesBitSize(bit_size, ast, ast->SignedCharTy))
1179 return CompilerType(ast, ast->SignedCharTy);
1180 break;
1181
1182 case DW_ATE_unsigned:
1183 if (type_name) {
1184 if (streq(type_name, "wchar_t")strcmp(type_name, "wchar_t") == 0) {
1185 if (QualTypeMatchesBitSize(bit_size, ast, ast->WCharTy)) {
1186 if (!(getTargetInfo() &&
1187 TargetInfo::isTypeSigned(getTargetInfo()->getWCharType())))
1188 return CompilerType(ast, ast->WCharTy);
1189 }
1190 }
1191 if (strstr(type_name, "long long")) {
1192 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy))
1193 return CompilerType(ast, ast->UnsignedLongLongTy);
1194 } else if (strstr(type_name, "long")) {
1195 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy))
1196 return CompilerType(ast, ast->UnsignedLongTy);
1197 } else if (strstr(type_name, "short")) {
1198 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
1199 return CompilerType(ast, ast->UnsignedShortTy);
1200 } else if (strstr(type_name, "char")) {
1201 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
1202 return CompilerType(ast, ast->UnsignedCharTy);
1203 } else if (strstr(type_name, "int")) {
1204 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy))
1205 return CompilerType(ast, ast->UnsignedIntTy);
1206 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty))
1207 return CompilerType(ast, ast->UnsignedInt128Ty);
1208 }
1209 }
1210 // We weren't able to match up a type name, just search by size
1211 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
1212 return CompilerType(ast, ast->UnsignedCharTy);
1213 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
1214 return CompilerType(ast, ast->UnsignedShortTy);
1215 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy))
1216 return CompilerType(ast, ast->UnsignedIntTy);
1217 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy))
1218 return CompilerType(ast, ast->UnsignedLongTy);
1219 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy))
1220 return CompilerType(ast, ast->UnsignedLongLongTy);
1221 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty))
1222 return CompilerType(ast, ast->UnsignedInt128Ty);
1223 break;
1224
1225 case DW_ATE_unsigned_char:
1226 if (!ast->getLangOpts().CharIsSigned && type_name &&
1227 streq(type_name, "char")strcmp(type_name, "char") == 0) {
1228 if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy))
1229 return CompilerType(ast, ast->CharTy);
1230 }
1231 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy))
1232 return CompilerType(ast, ast->UnsignedCharTy);
1233 if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy))
1234 return CompilerType(ast, ast->UnsignedShortTy);
1235 break;
1236
1237 case DW_ATE_imaginary_float:
1238 break;
1239
1240 case DW_ATE_UTF:
1241 if (type_name) {
1242 if (streq(type_name, "char16_t")strcmp(type_name, "char16_t") == 0) {
1243 return CompilerType(ast, ast->Char16Ty);
1244 } else if (streq(type_name, "char32_t")strcmp(type_name, "char32_t") == 0) {
1245 return CompilerType(ast, ast->Char32Ty);
1246 }
1247 }
1248 break;
1249 }
1250 }
1251 // This assert should fire for anything that we don't catch above so we know
1252 // to fix any issues we run into.
1253 if (type_name) {
1254 Host::SystemLog(Host::eSystemLogError, "error: need to add support for "
1255 "DW_TAG_base_type '%s' encoded with "
1256 "DW_ATE = 0x%x, bit_size = %u\n",
1257 type_name, dw_ate, bit_size);
1258 } else {
1259 Host::SystemLog(Host::eSystemLogError, "error: need to add support for "
1260 "DW_TAG_base_type encoded with "
1261 "DW_ATE = 0x%x, bit_size = %u\n",
1262 dw_ate, bit_size);
1263 }
1264 return CompilerType();
1265}
1266
1267CompilerType ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast) {
1268 if (ast)
1269 return CompilerType(ast, ast->UnknownAnyTy);
1270 return CompilerType();
1271}
1272
1273CompilerType ClangASTContext::GetCStringType(bool is_const) {
1274 ASTContext *ast = getASTContext();
1275 QualType char_type(ast->CharTy);
1276
1277 if (is_const)
1278 char_type.addConst();
1279
1280 return CompilerType(ast, ast->getPointerType(char_type));
1281}
1282
1283clang::DeclContext *
1284ClangASTContext::GetTranslationUnitDecl(clang::ASTContext *ast) {
1285 return ast->getTranslationUnitDecl();
1286}
1287
1288clang::Decl *ClangASTContext::CopyDecl(ASTContext *dst_ast, ASTContext *src_ast,
1289 clang::Decl *source_decl) {
1290 FileSystemOptions file_system_options;
1291 FileManager file_manager(file_system_options);
1292 ASTImporter importer(*dst_ast, file_manager, *src_ast, file_manager, false);
1293
1294 return importer.Import(source_decl);
1295}
1296
1297bool ClangASTContext::AreTypesSame(CompilerType type1, CompilerType type2,
1298 bool ignore_qualifiers) {
1299 ClangASTContext *ast =
1300 llvm::dyn_cast_or_null<ClangASTContext>(type1.GetTypeSystem());
1301 if (!ast || ast != type2.GetTypeSystem())
1302 return false;
1303
1304 if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType())
1305 return true;
1306
1307 QualType type1_qual = ClangUtil::GetQualType(type1);
1308 QualType type2_qual = ClangUtil::GetQualType(type2);
1309
1310 if (ignore_qualifiers) {
1311 type1_qual = type1_qual.getUnqualifiedType();
1312 type2_qual = type2_qual.getUnqualifiedType();
1313 }
1314
1315 return ast->getASTContext()->hasSameType(type1_qual, type2_qual);
1316}
1317
1318CompilerType ClangASTContext::GetTypeForDecl(clang::NamedDecl *decl) {
1319 if (clang::ObjCInterfaceDecl *interface_decl =
1320 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
1321 return GetTypeForDecl(interface_decl);
1322 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
1323 return GetTypeForDecl(tag_decl);
1324 return CompilerType();
1325}
1326
1327CompilerType ClangASTContext::GetTypeForDecl(TagDecl *decl) {
1328 // No need to call the getASTContext() accessor (which can create the AST
1329 // if it isn't created yet, because we can't have created a decl in this
1330 // AST if our AST didn't already exist...
1331 ASTContext *ast = &decl->getASTContext();
1332 if (ast)
1333 return CompilerType(ast, ast->getTagDeclType(decl));
1334 return CompilerType();
1335}
1336
1337CompilerType ClangASTContext::GetTypeForDecl(ObjCInterfaceDecl *decl) {
1338 // No need to call the getASTContext() accessor (which can create the AST
1339 // if it isn't created yet, because we can't have created a decl in this
1340 // AST if our AST didn't already exist...
1341 ASTContext *ast = &decl->getASTContext();
1342 if (ast)
1343 return CompilerType(ast, ast->getObjCInterfaceType(decl));
1344 return CompilerType();
1345}
1346
1347#pragma mark Structure, Unions, Classes
1348
1349CompilerType ClangASTContext::CreateRecordType(DeclContext *decl_ctx,
1350 AccessType access_type,
1351 const char *name, int kind,
1352 LanguageType language,
1353 ClangASTMetadata *metadata) {
1354 ASTContext *ast = getASTContext();
1355 assert(ast != nullptr)((ast != nullptr) ? static_cast<void> (0) : __assert_fail
("ast != nullptr", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 1355, __PRETTY_FUNCTION__))
;
1356
1357 if (decl_ctx == nullptr)
1358 decl_ctx = ast->getTranslationUnitDecl();
1359
1360 if (language == eLanguageTypeObjC ||
1361 language == eLanguageTypeObjC_plus_plus) {
1362 bool isForwardDecl = true;
1363 bool isInternal = false;
1364 return CreateObjCClass(name, decl_ctx, isForwardDecl, isInternal, metadata);
1365 }
1366
1367 // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1368 // we will need to update this code. I was told to currently always use
1369 // the CXXRecordDecl class since we often don't know from debug information
1370 // if something is struct or a class, so we default to always use the more
1371 // complete definition just in case.
1372
1373 bool is_anonymous = (!name) || (!name[0]);
1374
1375 CXXRecordDecl *decl = CXXRecordDecl::Create(
1376 *ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(),
1377 SourceLocation(), is_anonymous ? nullptr : &ast->Idents.get(name));
1378
1379 if (is_anonymous)
1380 decl->setAnonymousStructOrUnion(true);
1381
1382 if (decl) {
1383 if (metadata)
1384 SetMetadata(ast, decl, *metadata);
1385
1386 if (access_type != eAccessNone)
1387 decl->setAccess(ConvertAccessTypeToAccessSpecifier(access_type));
1388
1389 if (decl_ctx)
1390 decl_ctx->addDecl(decl);
1391
1392 return CompilerType(ast, ast->getTagDeclType(decl));
1393 }
1394 return CompilerType();
1395}
1396
1397namespace {
1398 bool IsValueParam(const clang::TemplateArgument &argument) {
1399 return argument.getKind() == TemplateArgument::Integral;
1400 }
1401}
1402
1403static TemplateParameterList *CreateTemplateParameterList(
1404 ASTContext *ast,
1405 const ClangASTContext::TemplateParameterInfos &template_param_infos,
1406 llvm::SmallVector<NamedDecl *, 8> &template_param_decls) {
1407 const bool parameter_pack = false;
1408 const bool is_typename = false;
1409 const unsigned depth = 0;
1410 const size_t num_template_params = template_param_infos.args.size();
1411 DeclContext *const decl_context =
1412 ast->getTranslationUnitDecl(); // Is this the right decl context?,
1413 for (size_t i = 0; i < num_template_params; ++i) {
1414 const char *name = template_param_infos.names[i];
1415
1416 IdentifierInfo *identifier_info = nullptr;
1417 if (name && name[0])
1418 identifier_info = &ast->Idents.get(name);
1419 if (IsValueParam(template_param_infos.args[i])) {
1420 template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1421 *ast, decl_context,
1422 SourceLocation(), SourceLocation(), depth, i, identifier_info,
1423 template_param_infos.args[i].getIntegralType(), parameter_pack,
1424 nullptr));
1425
1426 } else {
1427 template_param_decls.push_back(TemplateTypeParmDecl::Create(
1428 *ast, decl_context,
1429 SourceLocation(), SourceLocation(), depth, i, identifier_info,
1430 is_typename, parameter_pack));
1431 }
1432 }
1433
1434 if (template_param_infos.packed_args &&
1435 template_param_infos.packed_args->args.size()) {
1436 IdentifierInfo *identifier_info = nullptr;
1437 if (template_param_infos.pack_name && template_param_infos.pack_name[0])
1438 identifier_info = &ast->Idents.get(template_param_infos.pack_name);
1439 const bool parameter_pack_true = true;
1440 if (IsValueParam(template_param_infos.packed_args->args[0])) {
1441 template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
1442 *ast, decl_context,
1443 SourceLocation(), SourceLocation(), depth, num_template_params,
1444 identifier_info,
1445 template_param_infos.packed_args->args[0].getIntegralType(),
1446 parameter_pack_true, nullptr));
1447 } else {
1448 template_param_decls.push_back(TemplateTypeParmDecl::Create(
1449 *ast, decl_context,
1450 SourceLocation(), SourceLocation(), depth, num_template_params,
1451 identifier_info,
1452 is_typename, parameter_pack_true));
1453 }
1454 }
1455 clang::Expr *const requires_clause = nullptr; // TODO: Concepts
1456 TemplateParameterList *template_param_list = TemplateParameterList::Create(
1457 *ast, SourceLocation(), SourceLocation(), template_param_decls,
1458 SourceLocation(), requires_clause);
1459 return template_param_list;
1460}
1461
1462clang::FunctionTemplateDecl *ClangASTContext::CreateFunctionTemplateDecl(
1463 clang::DeclContext *decl_ctx, clang::FunctionDecl *func_decl,
1464 const char *name, const TemplateParameterInfos &template_param_infos) {
1465 // /// \brief Create a function template node.
1466 ASTContext *ast = getASTContext();
1467
1468 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1469
1470 TemplateParameterList *template_param_list = CreateTemplateParameterList(
1471 ast, template_param_infos, template_param_decls);
1472 FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create(
1473 *ast, decl_ctx, func_decl->getLocation(), func_decl->getDeclName(),
1474 template_param_list, func_decl);
1475
1476 for (size_t i = 0, template_param_decl_count = template_param_decls.size();
1477 i < template_param_decl_count; ++i) {
1478 // TODO: verify which decl context we should put template_param_decls into..
1479 template_param_decls[i]->setDeclContext(func_decl);
1480 }
1481
1482 return func_tmpl_decl;
1483}
1484
1485void ClangASTContext::CreateFunctionTemplateSpecializationInfo(
1486 FunctionDecl *func_decl, clang::FunctionTemplateDecl *func_tmpl_decl,
1487 const TemplateParameterInfos &infos) {
1488 TemplateArgumentList template_args(TemplateArgumentList::OnStack, infos.args);
1489
1490 func_decl->setFunctionTemplateSpecialization(func_tmpl_decl, &template_args,
1491 nullptr);
1492}
1493
1494ClassTemplateDecl *ClangASTContext::CreateClassTemplateDecl(
1495 DeclContext *decl_ctx, lldb::AccessType access_type, const char *class_name,
1496 int kind, const TemplateParameterInfos &template_param_infos) {
1497 ASTContext *ast = getASTContext();
1498
1499 ClassTemplateDecl *class_template_decl = nullptr;
1500 if (decl_ctx == nullptr)
1501 decl_ctx = ast->getTranslationUnitDecl();
1502
1503 IdentifierInfo &identifier_info = ast->Idents.get(class_name);
1504 DeclarationName decl_name(&identifier_info);
1505
1506 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1507
1508 for (NamedDecl *decl : result) {
1509 class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
1510 if (class_template_decl)
1511 return class_template_decl;
1512 }
1513
1514 llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1515
1516 TemplateParameterList *template_param_list = CreateTemplateParameterList(
1517 ast, template_param_infos, template_param_decls);
1518
1519 CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create(
1520 *ast, (TagDecl::TagKind)kind,
1521 decl_ctx, // What decl context do we use here? TU? The actual decl
1522 // context?
1523 SourceLocation(), SourceLocation(), &identifier_info);
1524
1525 for (size_t i = 0, template_param_decl_count = template_param_decls.size();
1526 i < template_param_decl_count; ++i) {
1527 template_param_decls[i]->setDeclContext(template_cxx_decl);
1528 }
1529
1530 // With templated classes, we say that a class is templated with
1531 // specializations, but that the bare class has no functions.
1532 // template_cxx_decl->startDefinition();
1533 // template_cxx_decl->completeDefinition();
1534
1535 class_template_decl = ClassTemplateDecl::Create(
1536 *ast,
1537 decl_ctx, // What decl context do we use here? TU? The actual decl
1538 // context?
1539 SourceLocation(), decl_name, template_param_list, template_cxx_decl);
1540
1541 if (class_template_decl) {
1542 if (access_type != eAccessNone)
1543 class_template_decl->setAccess(
1544 ConvertAccessTypeToAccessSpecifier(access_type));
1545
1546 // if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx))
1547 // CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl));
1548
1549 decl_ctx->addDecl(class_template_decl);
1550
1551#ifdef LLDB_CONFIGURATION_DEBUG
1552 VerifyDecl(class_template_decl);
1553#endif
1554 }
1555
1556 return class_template_decl;
1557}
1558
1559ClassTemplateSpecializationDecl *
1560ClangASTContext::CreateClassTemplateSpecializationDecl(
1561 DeclContext *decl_ctx, ClassTemplateDecl *class_template_decl, int kind,
1562 const TemplateParameterInfos &template_param_infos) {
1563 ASTContext *ast = getASTContext();
1564 llvm::SmallVector<clang::TemplateArgument, 2> args(
1565 template_param_infos.args.size() +
1566 (template_param_infos.packed_args ? 1 : 0));
1567 std::copy(template_param_infos.args.begin(), template_param_infos.args.end(),
1568 args.begin());
1569 if (template_param_infos.packed_args) {
1570 args[args.size() - 1] = TemplateArgument::CreatePackCopy(
1571 *ast, template_param_infos.packed_args->args);
1572 }
1573 ClassTemplateSpecializationDecl *class_template_specialization_decl =
1574 ClassTemplateSpecializationDecl::Create(
1575 *ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(),
1576 SourceLocation(), class_template_decl, args,
1577 nullptr);
1578
1579 class_template_specialization_decl->setSpecializationKind(
1580 TSK_ExplicitSpecialization);
1581
1582 return class_template_specialization_decl;
1583}
1584
1585CompilerType ClangASTContext::CreateClassTemplateSpecializationType(
1586 ClassTemplateSpecializationDecl *class_template_specialization_decl) {
1587 if (class_template_specialization_decl) {
1588 ASTContext *ast = getASTContext();
1589 if (ast)
1590 return CompilerType(
1591 ast, ast->getTagDeclType(class_template_specialization_decl));
1592 }
1593 return CompilerType();
1594}
1595
1596static inline bool check_op_param(bool is_method,
1597 clang::OverloadedOperatorKind op_kind,
1598 bool unary, bool binary,
1599 uint32_t num_params) {
1600 // Special-case call since it can take any number of operands
1601 if (op_kind == OO_Call)
1602 return true;
1603
1604 // The parameter count doesn't include "this"
1605 if (is_method)
1606 ++num_params;
1607 if (num_params == 1)
1608 return unary;
1609 if (num_params == 2)
1610 return binary;
1611 else
1612 return false;
1613}
1614
1615bool ClangASTContext::CheckOverloadedOperatorKindParameterCount(
1616 bool is_method, clang::OverloadedOperatorKind op_kind,
1617 uint32_t num_params) {
1618 switch (op_kind) {
1619 default:
1620 break;
1621 // C++ standard allows any number of arguments to new/delete
1622 case OO_New:
1623 case OO_Array_New:
1624 case OO_Delete:
1625 case OO_Array_Delete:
1626 return true;
1627 }
1628
1629#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
1630 case OO_##Name: \
1631 return check_op_param(is_method, op_kind, Unary, Binary, num_params);
1632 switch (op_kind) {
1633#include "clang/Basic/OperatorKinds.def"
1634 default:
1635 break;
1636 }
1637 return false;
1638}
1639
1640clang::AccessSpecifier
1641ClangASTContext::UnifyAccessSpecifiers(clang::AccessSpecifier lhs,
1642 clang::AccessSpecifier rhs) {
1643 // Make the access equal to the stricter of the field and the nested field's
1644 // access
1645 if (lhs == AS_none || rhs == AS_none)
1646 return AS_none;
1647 if (lhs == AS_private || rhs == AS_private)
1648 return AS_private;
1649 if (lhs == AS_protected || rhs == AS_protected)
1650 return AS_protected;
1651 return AS_public;
1652}
1653
1654bool ClangASTContext::FieldIsBitfield(FieldDecl *field,
1655 uint32_t &bitfield_bit_size) {
1656 return FieldIsBitfield(getASTContext(), field, bitfield_bit_size);
1657}
1658
1659bool ClangASTContext::FieldIsBitfield(ASTContext *ast, FieldDecl *field,
1660 uint32_t &bitfield_bit_size) {
1661 if (ast == nullptr || field == nullptr)
1662 return false;
1663
1664 if (field->isBitField()) {
1665 Expr *bit_width_expr = field->getBitWidth();
1666 if (bit_width_expr) {
1667 llvm::APSInt bit_width_apsint;
1668 if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast)) {
1669 bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX(4294967295U));
1670 return true;
1671 }
1672 }
1673 }
1674 return false;
1675}
1676
1677bool ClangASTContext::RecordHasFields(const RecordDecl *record_decl) {
1678 if (record_decl == nullptr)
1679 return false;
1680
1681 if (!record_decl->field_empty())
1682 return true;
1683
1684 // No fields, lets check this is a CXX record and check the base classes
1685 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1686 if (cxx_record_decl) {
1687 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1688 for (base_class = cxx_record_decl->bases_begin(),
1689 base_class_end = cxx_record_decl->bases_end();
1690 base_class != base_class_end; ++base_class) {
1691 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(
1692 base_class->getType()->getAs<RecordType>()->getDecl());
1693 if (RecordHasFields(base_class_decl))
1694 return true;
1695 }
1696 }
1697 return false;
1698}
1699
1700#pragma mark Objective C Classes
1701
1702CompilerType ClangASTContext::CreateObjCClass(const char *name,
1703 DeclContext *decl_ctx,
1704 bool isForwardDecl,
1705 bool isInternal,
1706 ClangASTMetadata *metadata) {
1707 ASTContext *ast = getASTContext();
1708 assert(ast != nullptr)((ast != nullptr) ? static_cast<void> (0) : __assert_fail
("ast != nullptr", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 1708, __PRETTY_FUNCTION__))
;
1709 assert(name && name[0])((name && name[0]) ? static_cast<void> (0) : __assert_fail
("name && name[0]", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 1709, __PRETTY_FUNCTION__))
;
1710 if (decl_ctx == nullptr)
1711 decl_ctx = ast->getTranslationUnitDecl();
1712
1713 ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create(
1714 *ast, decl_ctx, SourceLocation(), &ast->Idents.get(name), nullptr,
1715 nullptr, SourceLocation(),
1716 /*isForwardDecl,*/
1717 isInternal);
1718
1719 if (decl && metadata)
1720 SetMetadata(ast, decl, *metadata);
1721
1722 return CompilerType(ast, ast->getObjCInterfaceType(decl));
1723}
1724
1725static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) {
1726 return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) ==
1727 false;
1728}
1729
1730uint32_t
1731ClangASTContext::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl,
1732 bool omit_empty_base_classes) {
1733 uint32_t num_bases = 0;
1734 if (cxx_record_decl) {
1735 if (omit_empty_base_classes) {
1736 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1737 for (base_class = cxx_record_decl->bases_begin(),
1738 base_class_end = cxx_record_decl->bases_end();
1739 base_class != base_class_end; ++base_class) {
1740 // Skip empty base classes
1741 if (omit_empty_base_classes) {
1742 if (BaseSpecifierIsEmpty(base_class))
1743 continue;
1744 }
1745 ++num_bases;
1746 }
1747 } else
1748 num_bases = cxx_record_decl->getNumBases();
1749 }
1750 return num_bases;
1751}
1752
1753#pragma mark Namespace Declarations
1754
1755NamespaceDecl *
1756ClangASTContext::GetUniqueNamespaceDeclaration(const char *name,
1757 DeclContext *decl_ctx) {
1758 NamespaceDecl *namespace_decl = nullptr;
1759 ASTContext *ast = getASTContext();
1760 TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl();
1761 if (decl_ctx == nullptr)
1762 decl_ctx = translation_unit_decl;
1763
1764 if (name) {
1765 IdentifierInfo &identifier_info = ast->Idents.get(name);
1766 DeclarationName decl_name(&identifier_info);
1767 clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1768 for (NamedDecl *decl : result) {
1769 namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
1770 if (namespace_decl)
1771 return namespace_decl;
1772 }
1773
1774 namespace_decl =
1775 NamespaceDecl::Create(*ast, decl_ctx, false, SourceLocation(),
1776 SourceLocation(), &identifier_info, nullptr);
1777
1778 decl_ctx->addDecl(namespace_decl);
1779 } else {
1780 if (decl_ctx == translation_unit_decl) {
1781 namespace_decl = translation_unit_decl->getAnonymousNamespace();
1782 if (namespace_decl)
1783 return namespace_decl;
1784
1785 namespace_decl =
1786 NamespaceDecl::Create(*ast, decl_ctx, false, SourceLocation(),
1787 SourceLocation(), nullptr, nullptr);
1788 translation_unit_decl->setAnonymousNamespace(namespace_decl);
1789 translation_unit_decl->addDecl(namespace_decl);
1790 assert(namespace_decl == translation_unit_decl->getAnonymousNamespace())((namespace_decl == translation_unit_decl->getAnonymousNamespace
()) ? static_cast<void> (0) : __assert_fail ("namespace_decl == translation_unit_decl->getAnonymousNamespace()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 1790, __PRETTY_FUNCTION__))
;
1791 } else {
1792 NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
1793 if (parent_namespace_decl) {
1794 namespace_decl = parent_namespace_decl->getAnonymousNamespace();
1795 if (namespace_decl)
1796 return namespace_decl;
1797 namespace_decl =
1798 NamespaceDecl::Create(*ast, decl_ctx, false, SourceLocation(),
1799 SourceLocation(), nullptr, nullptr);
1800 parent_namespace_decl->setAnonymousNamespace(namespace_decl);
1801 parent_namespace_decl->addDecl(namespace_decl);
1802 assert(namespace_decl ==((namespace_decl == parent_namespace_decl->getAnonymousNamespace
()) ? static_cast<void> (0) : __assert_fail ("namespace_decl == parent_namespace_decl->getAnonymousNamespace()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 1803, __PRETTY_FUNCTION__))
1803 parent_namespace_decl->getAnonymousNamespace())((namespace_decl == parent_namespace_decl->getAnonymousNamespace
()) ? static_cast<void> (0) : __assert_fail ("namespace_decl == parent_namespace_decl->getAnonymousNamespace()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 1803, __PRETTY_FUNCTION__))
;
1804 } else {
1805 // BAD!!!
1806 }
1807 }
1808 }
1809#ifdef LLDB_CONFIGURATION_DEBUG
1810 VerifyDecl(namespace_decl);
1811#endif
1812 return namespace_decl;
1813}
1814
1815NamespaceDecl *ClangASTContext::GetUniqueNamespaceDeclaration(
1816 clang::ASTContext *ast, const char *name, clang::DeclContext *decl_ctx) {
1817 ClangASTContext *ast_ctx = ClangASTContext::GetASTContext(ast);
1818 if (ast_ctx == nullptr)
1819 return nullptr;
1820
1821 return ast_ctx->GetUniqueNamespaceDeclaration(name, decl_ctx);
1822}
1823
1824clang::BlockDecl *
1825ClangASTContext::CreateBlockDeclaration(clang::DeclContext *ctx) {
1826 if (ctx != nullptr) {
1827 clang::BlockDecl *decl = clang::BlockDecl::Create(*getASTContext(), ctx,
1828 clang::SourceLocation());
1829 ctx->addDecl(decl);
1830 return decl;
1831 }
1832 return nullptr;
1833}
1834
1835clang::DeclContext *FindLCABetweenDecls(clang::DeclContext *left,
1836 clang::DeclContext *right,
1837 clang::DeclContext *root) {
1838 if (root == nullptr)
1839 return nullptr;
1840
1841 std::set<clang::DeclContext *> path_left;
1842 for (clang::DeclContext *d = left; d != nullptr; d = d->getParent())
1843 path_left.insert(d);
1844
1845 for (clang::DeclContext *d = right; d != nullptr; d = d->getParent())
1846 if (path_left.find(d) != path_left.end())
1847 return d;
1848
1849 return nullptr;
1850}
1851
1852clang::UsingDirectiveDecl *ClangASTContext::CreateUsingDirectiveDeclaration(
1853 clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl) {
1854 if (decl_ctx != nullptr && ns_decl != nullptr) {
1855 clang::TranslationUnitDecl *translation_unit =
1856 (clang::TranslationUnitDecl *)GetTranslationUnitDecl(getASTContext());
1857 clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(
1858 *getASTContext(), decl_ctx, clang::SourceLocation(),
1859 clang::SourceLocation(), clang::NestedNameSpecifierLoc(),
1860 clang::SourceLocation(), ns_decl,
1861 FindLCABetweenDecls(decl_ctx, ns_decl, translation_unit));
1862 decl_ctx->addDecl(using_decl);
1863 return using_decl;
1864 }
1865 return nullptr;
1866}
1867
1868clang::UsingDecl *
1869ClangASTContext::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx,
1870 clang::NamedDecl *target) {
1871 if (current_decl_ctx != nullptr && target != nullptr) {
1872 clang::UsingDecl *using_decl = clang::UsingDecl::Create(
1873 *getASTContext(), current_decl_ctx, clang::SourceLocation(),
1874 clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(), false);
1875 clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
1876 *getASTContext(), current_decl_ctx, clang::SourceLocation(), using_decl,
1877 target);
1878 using_decl->addShadowDecl(shadow_decl);
1879 current_decl_ctx->addDecl(using_decl);
1880 return using_decl;
1881 }
1882 return nullptr;
1883}
1884
1885clang::VarDecl *ClangASTContext::CreateVariableDeclaration(
1886 clang::DeclContext *decl_context, const char *name, clang::QualType type) {
1887 if (decl_context != nullptr) {
1888 clang::VarDecl *var_decl = clang::VarDecl::Create(
1889 *getASTContext(), decl_context, clang::SourceLocation(),
1890 clang::SourceLocation(),
1891 name && name[0] ? &getASTContext()->Idents.getOwn(name) : nullptr, type,
1892 nullptr, clang::SC_None);
1893 var_decl->setAccess(clang::AS_public);
1894 decl_context->addDecl(var_decl);
1895 return var_decl;
1896 }
1897 return nullptr;
1898}
1899
1900lldb::opaque_compiler_type_t
1901ClangASTContext::GetOpaqueCompilerType(clang::ASTContext *ast,
1902 lldb::BasicType basic_type) {
1903 switch (basic_type) {
1904 case eBasicTypeVoid:
1905 return ast->VoidTy.getAsOpaquePtr();
1906 case eBasicTypeChar:
1907 return ast->CharTy.getAsOpaquePtr();
1908 case eBasicTypeSignedChar:
1909 return ast->SignedCharTy.getAsOpaquePtr();
1910 case eBasicTypeUnsignedChar:
1911 return ast->UnsignedCharTy.getAsOpaquePtr();
1912 case eBasicTypeWChar:
1913 return ast->getWCharType().getAsOpaquePtr();
1914 case eBasicTypeSignedWChar:
1915 return ast->getSignedWCharType().getAsOpaquePtr();
1916 case eBasicTypeUnsignedWChar:
1917 return ast->getUnsignedWCharType().getAsOpaquePtr();
1918 case eBasicTypeChar16:
1919 return ast->Char16Ty.getAsOpaquePtr();
1920 case eBasicTypeChar32:
1921 return ast->Char32Ty.getAsOpaquePtr();
1922 case eBasicTypeShort:
1923 return ast->ShortTy.getAsOpaquePtr();
1924 case eBasicTypeUnsignedShort:
1925 return ast->UnsignedShortTy.getAsOpaquePtr();
1926 case eBasicTypeInt:
1927 return ast->IntTy.getAsOpaquePtr();
1928 case eBasicTypeUnsignedInt:
1929 return ast->UnsignedIntTy.getAsOpaquePtr();
1930 case eBasicTypeLong:
1931 return ast->LongTy.getAsOpaquePtr();
1932 case eBasicTypeUnsignedLong:
1933 return ast->UnsignedLongTy.getAsOpaquePtr();
1934 case eBasicTypeLongLong:
1935 return ast->LongLongTy.getAsOpaquePtr();
1936 case eBasicTypeUnsignedLongLong:
1937 return ast->UnsignedLongLongTy.getAsOpaquePtr();
1938 case eBasicTypeInt128:
1939 return ast->Int128Ty.getAsOpaquePtr();
1940 case eBasicTypeUnsignedInt128:
1941 return ast->UnsignedInt128Ty.getAsOpaquePtr();
1942 case eBasicTypeBool:
1943 return ast->BoolTy.getAsOpaquePtr();
1944 case eBasicTypeHalf:
1945 return ast->HalfTy.getAsOpaquePtr();
1946 case eBasicTypeFloat:
1947 return ast->FloatTy.getAsOpaquePtr();
1948 case eBasicTypeDouble:
1949 return ast->DoubleTy.getAsOpaquePtr();
1950 case eBasicTypeLongDouble:
1951 return ast->LongDoubleTy.getAsOpaquePtr();
1952 case eBasicTypeFloatComplex:
1953 return ast->FloatComplexTy.getAsOpaquePtr();
1954 case eBasicTypeDoubleComplex:
1955 return ast->DoubleComplexTy.getAsOpaquePtr();
1956 case eBasicTypeLongDoubleComplex:
1957 return ast->LongDoubleComplexTy.getAsOpaquePtr();
1958 case eBasicTypeObjCID:
1959 return ast->getObjCIdType().getAsOpaquePtr();
1960 case eBasicTypeObjCClass:
1961 return ast->getObjCClassType().getAsOpaquePtr();
1962 case eBasicTypeObjCSel:
1963 return ast->getObjCSelType().getAsOpaquePtr();
1964 case eBasicTypeNullPtr:
1965 return ast->NullPtrTy.getAsOpaquePtr();
1966 default:
1967 return nullptr;
1968 }
1969}
1970
1971#pragma mark Function Types
1972
1973clang::DeclarationName
1974ClangASTContext::GetDeclarationName(const char *name,
1975 const CompilerType &function_clang_type) {
1976 if (!name || !name[0])
1977 return clang::DeclarationName();
1978
1979 clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
1980 if (!IsOperator(name, op_kind) || op_kind == clang::NUM_OVERLOADED_OPERATORS)
1981 return DeclarationName(&getASTContext()->Idents.get(
1982 name)); // Not operator, but a regular function.
1983
1984 // Check the number of operator parameters. Sometimes we have
1985 // seen bad DWARF that doesn't correctly describe operators and
1986 // if we try to create a method and add it to the class, clang
1987 // will assert and crash, so we need to make sure things are
1988 // acceptable.
1989 clang::QualType method_qual_type(ClangUtil::GetQualType(function_clang_type));
1990 const clang::FunctionProtoType *function_type =
1991 llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr());
1992 if (function_type == nullptr)
1993 return clang::DeclarationName();
1994
1995 const bool is_method = false;
1996 const unsigned int num_params = function_type->getNumParams();
1997 if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount(
1998 is_method, op_kind, num_params))
1999 return clang::DeclarationName();
2000
2001 return getASTContext()->DeclarationNames.getCXXOperatorName(op_kind);
2002}
2003
2004FunctionDecl *ClangASTContext::CreateFunctionDeclaration(
2005 DeclContext *decl_ctx, const char *name,
2006 const CompilerType &function_clang_type, int storage, bool is_inline) {
2007 FunctionDecl *func_decl = nullptr;
2008 ASTContext *ast = getASTContext();
2009 if (decl_ctx == nullptr)
2010 decl_ctx = ast->getTranslationUnitDecl();
2011
2012 const bool hasWrittenPrototype = true;
2013 const bool isConstexprSpecified = false;
2014
2015 clang::DeclarationName declarationName =
2016 GetDeclarationName(name, function_clang_type);
2017 func_decl = FunctionDecl::Create(
2018 *ast, decl_ctx, SourceLocation(), SourceLocation(), declarationName,
2019 ClangUtil::GetQualType(function_clang_type), nullptr,
2020 (clang::StorageClass)storage, is_inline, hasWrittenPrototype,
2021 isConstexprSpecified);
2022 if (func_decl)
2023 decl_ctx->addDecl(func_decl);
2024
2025#ifdef LLDB_CONFIGURATION_DEBUG
2026 VerifyDecl(func_decl);
2027#endif
2028
2029 return func_decl;
2030}
2031
2032CompilerType ClangASTContext::CreateFunctionType(
2033 ASTContext *ast, const CompilerType &result_type, const CompilerType *args,
2034 unsigned num_args, bool is_variadic, unsigned type_quals) {
2035 if (ast == nullptr)
2036 return CompilerType(); // invalid AST
2037
2038 if (!result_type || !ClangUtil::IsClangType(result_type))
2039 return CompilerType(); // invalid return type
2040
2041 std::vector<QualType> qual_type_args;
2042 if (num_args > 0 && args == nullptr)
2043 return CompilerType(); // invalid argument array passed in
2044
2045 // Verify that all arguments are valid and the right type
2046 for (unsigned i = 0; i < num_args; ++i) {
2047 if (args[i]) {
2048 // Make sure we have a clang type in args[i] and not a type from another
2049 // language whose name might match
2050 const bool is_clang_type = ClangUtil::IsClangType(args[i]);
2051 lldbassert(is_clang_type)lldb_private::lldb_assert(is_clang_type, "is_clang_type", __FUNCTION__
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 2051)
;
2052 if (is_clang_type)
2053 qual_type_args.push_back(ClangUtil::GetQualType(args[i]));
2054 else
2055 return CompilerType(); // invalid argument type (must be a clang type)
2056 } else
2057 return CompilerType(); // invalid argument type (empty)
2058 }
2059
2060 // TODO: Detect calling convention in DWARF?
2061 FunctionProtoType::ExtProtoInfo proto_info;
2062 proto_info.Variadic = is_variadic;
2063 proto_info.ExceptionSpec = EST_None;
2064 proto_info.TypeQuals = type_quals;
2065 proto_info.RefQualifier = RQ_None;
2066
2067 return CompilerType(ast,
2068 ast->getFunctionType(ClangUtil::GetQualType(result_type),
2069 qual_type_args, proto_info));
2070}
2071
2072ParmVarDecl *ClangASTContext::CreateParameterDeclaration(
2073 const char *name, const CompilerType &param_type, int storage) {
2074 ASTContext *ast = getASTContext();
2075 assert(ast != nullptr)((ast != nullptr) ? static_cast<void> (0) : __assert_fail
("ast != nullptr", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 2075, __PRETTY_FUNCTION__))
;
2076 return ParmVarDecl::Create(*ast, ast->getTranslationUnitDecl(),
2077 SourceLocation(), SourceLocation(),
2078 name && name[0] ? &ast->Idents.get(name) : nullptr,
2079 ClangUtil::GetQualType(param_type), nullptr,
2080 (clang::StorageClass)storage, nullptr);
2081}
2082
2083void ClangASTContext::SetFunctionParameters(FunctionDecl *function_decl,
2084 ParmVarDecl **params,
2085 unsigned num_params) {
2086 if (function_decl)
2087 function_decl->setParams(ArrayRef<ParmVarDecl *>(params, num_params));
2088}
2089
2090CompilerType
2091ClangASTContext::CreateBlockPointerType(const CompilerType &function_type) {
2092 QualType block_type = m_ast_ap->getBlockPointerType(
2093 clang::QualType::getFromOpaquePtr(function_type.GetOpaqueQualType()));
2094
2095 return CompilerType(this, block_type.getAsOpaquePtr());
2096}
2097
2098#pragma mark Array Types
2099
2100CompilerType ClangASTContext::CreateArrayType(const CompilerType &element_type,
2101 size_t element_count,
2102 bool is_vector) {
2103 if (element_type.IsValid()) {
2104 ASTContext *ast = getASTContext();
2105 assert(ast != nullptr)((ast != nullptr) ? static_cast<void> (0) : __assert_fail
("ast != nullptr", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 2105, __PRETTY_FUNCTION__))
;
2106
2107 if (is_vector) {
2108 return CompilerType(
2109 ast, ast->getExtVectorType(ClangUtil::GetQualType(element_type),
2110 element_count));
2111 } else {
2112
2113 llvm::APInt ap_element_count(64, element_count);
2114 if (element_count == 0) {
2115 return CompilerType(ast, ast->getIncompleteArrayType(
2116 ClangUtil::GetQualType(element_type),
2117 clang::ArrayType::Normal, 0));
2118 } else {
2119 return CompilerType(
2120 ast, ast->getConstantArrayType(ClangUtil::GetQualType(element_type),
2121 ap_element_count,
2122 clang::ArrayType::Normal, 0));
2123 }
2124 }
2125 }
2126 return CompilerType();
2127}
2128
2129CompilerType ClangASTContext::CreateStructForIdentifier(
2130 const ConstString &type_name,
2131 const std::initializer_list<std::pair<const char *, CompilerType>>
2132 &type_fields,
2133 bool packed) {
2134 CompilerType type;
2135 if (!type_name.IsEmpty() &&
2136 (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name))
2137 .IsValid()) {
2138 lldbassert(0 && "Trying to create a type for an existing name")lldb_private::lldb_assert(0 && "Trying to create a type for an existing name"
, "0 && \"Trying to create a type for an existing name\""
, __FUNCTION__, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 2138)
;
2139 return type;
2140 }
2141
2142 type = CreateRecordType(nullptr, lldb::eAccessPublic, type_name.GetCString(),
2143 clang::TTK_Struct, lldb::eLanguageTypeC);
2144 StartTagDeclarationDefinition(type);
2145 for (const auto &field : type_fields)
2146 AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic,
2147 0);
2148 if (packed)
2149 SetIsPacked(type);
2150 CompleteTagDeclarationDefinition(type);
2151 return type;
2152}
2153
2154CompilerType ClangASTContext::GetOrCreateStructForIdentifier(
2155 const ConstString &type_name,
2156 const std::initializer_list<std::pair<const char *, CompilerType>>
2157 &type_fields,
2158 bool packed) {
2159 CompilerType type;
2160 if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
2161 return type;
2162
2163 return CreateStructForIdentifier(type_name, type_fields, packed);
2164}
2165
2166#pragma mark Enumeration Types
2167
2168CompilerType
2169ClangASTContext::CreateEnumerationType(const char *name, DeclContext *decl_ctx,
2170 const Declaration &decl,
2171 const CompilerType &integer_clang_type) {
2172 // TODO: Do something intelligent with the Declaration object passed in
2173 // like maybe filling in the SourceLocation with it...
2174 ASTContext *ast = getASTContext();
2175
2176 // TODO: ask about these...
2177 // const bool IsScoped = false;
2178 // const bool IsFixed = false;
2179
2180 EnumDecl *enum_decl = EnumDecl::Create(
2181 *ast, decl_ctx, SourceLocation(), SourceLocation(),
2182 name && name[0] ? &ast->Idents.get(name) : nullptr, nullptr,
2183 false, // IsScoped
2184 false, // IsScopedUsingClassTag
2185 false); // IsFixed
2186
2187 if (enum_decl) {
2188 // TODO: check if we should be setting the promotion type too?
2189 enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type));
2190
2191 enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
2192
2193 return CompilerType(ast, ast->getTagDeclType(enum_decl));
2194 }
2195 return CompilerType();
2196}
2197
2198// Disable this for now since I can't seem to get a nicely formatted float
2199// out of the APFloat class without just getting the float, double or quad
2200// and then using a formatted print on it which defeats the purpose. We ideally
2201// would like to get perfect string values for any kind of float semantics
2202// so we can support remote targets. The code below also requires a patch to
2203// llvm::APInt.
2204// bool
2205// ClangASTContext::ConvertFloatValueToString (ASTContext *ast,
2206// lldb::opaque_compiler_type_t clang_type, const uint8_t* bytes, size_t
2207// byte_size, int apint_byte_order, std::string &float_str)
2208//{
2209// uint32_t count = 0;
2210// bool is_complex = false;
2211// if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
2212// {
2213// unsigned num_bytes_per_float = byte_size / count;
2214// unsigned num_bits_per_float = num_bytes_per_float * 8;
2215//
2216// float_str.clear();
2217// uint32_t i;
2218// for (i=0; i<count; i++)
2219// {
2220// APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float,
2221// (APInt::ByteOrder)apint_byte_order);
2222// bool is_ieee = false;
2223// APFloat ap_float(ap_int, is_ieee);
2224// char s[1024];
2225// unsigned int hex_digits = 0;
2226// bool upper_case = false;
2227//
2228// if (ap_float.convertToHexString(s, hex_digits, upper_case,
2229// APFloat::rmNearestTiesToEven) > 0)
2230// {
2231// if (i > 0)
2232// float_str.append(", ");
2233// float_str.append(s);
2234// if (i == 1 && is_complex)
2235// float_str.append(1, 'i');
2236// }
2237// }
2238// return !float_str.empty();
2239// }
2240// return false;
2241//}
2242
2243CompilerType ClangASTContext::GetIntTypeFromBitSize(clang::ASTContext *ast,
2244 size_t bit_size,
2245 bool is_signed) {
2246 if (ast) {
2247 if (is_signed) {
2248 if (bit_size == ast->getTypeSize(ast->SignedCharTy))
2249 return CompilerType(ast, ast->SignedCharTy);
2250
2251 if (bit_size == ast->getTypeSize(ast->ShortTy))
2252 return CompilerType(ast, ast->ShortTy);
2253
2254 if (bit_size == ast->getTypeSize(ast->IntTy))
2255 return CompilerType(ast, ast->IntTy);
2256
2257 if (bit_size == ast->getTypeSize(ast->LongTy))
2258 return CompilerType(ast, ast->LongTy);
2259
2260 if (bit_size == ast->getTypeSize(ast->LongLongTy))
2261 return CompilerType(ast, ast->LongLongTy);
2262
2263 if (bit_size == ast->getTypeSize(ast->Int128Ty))
2264 return CompilerType(ast, ast->Int128Ty);
2265 } else {
2266 if (bit_size == ast->getTypeSize(ast->UnsignedCharTy))
2267 return CompilerType(ast, ast->UnsignedCharTy);
2268
2269 if (bit_size == ast->getTypeSize(ast->UnsignedShortTy))
2270 return CompilerType(ast, ast->UnsignedShortTy);
2271
2272 if (bit_size == ast->getTypeSize(ast->UnsignedIntTy))
2273 return CompilerType(ast, ast->UnsignedIntTy);
2274
2275 if (bit_size == ast->getTypeSize(ast->UnsignedLongTy))
2276 return CompilerType(ast, ast->UnsignedLongTy);
2277
2278 if (bit_size == ast->getTypeSize(ast->UnsignedLongLongTy))
2279 return CompilerType(ast, ast->UnsignedLongLongTy);
2280
2281 if (bit_size == ast->getTypeSize(ast->UnsignedInt128Ty))
2282 return CompilerType(ast, ast->UnsignedInt128Ty);
2283 }
2284 }
2285 return CompilerType();
2286}
2287
2288CompilerType ClangASTContext::GetPointerSizedIntType(clang::ASTContext *ast,
2289 bool is_signed) {
2290 if (ast)
2291 return GetIntTypeFromBitSize(ast, ast->getTypeSize(ast->VoidPtrTy),
2292 is_signed);
2293 return CompilerType();
2294}
2295
2296void ClangASTContext::DumpDeclContextHiearchy(clang::DeclContext *decl_ctx) {
2297 if (decl_ctx) {
2298 DumpDeclContextHiearchy(decl_ctx->getParent());
2299
2300 clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx);
2301 if (named_decl) {
2302 printf("%20s: %s\n", decl_ctx->getDeclKindName(),
2303 named_decl->getDeclName().getAsString().c_str());
2304 } else {
2305 printf("%20s\n", decl_ctx->getDeclKindName());
2306 }
2307 }
2308}
2309
2310void ClangASTContext::DumpDeclHiearchy(clang::Decl *decl) {
2311 if (decl == nullptr)
2312 return;
2313 DumpDeclContextHiearchy(decl->getDeclContext());
2314
2315 clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl);
2316 if (record_decl) {
2317 printf("%20s: %s%s\n", decl->getDeclKindName(),
2318 record_decl->getDeclName().getAsString().c_str(),
2319 record_decl->isInjectedClassName() ? " (injected class name)" : "");
2320
2321 } else {
2322 clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl);
2323 if (named_decl) {
2324 printf("%20s: %s\n", decl->getDeclKindName(),
2325 named_decl->getDeclName().getAsString().c_str());
2326 } else {
2327 printf("%20s\n", decl->getDeclKindName());
2328 }
2329 }
2330}
2331
2332bool ClangASTContext::DeclsAreEquivalent(clang::Decl *lhs_decl,
2333 clang::Decl *rhs_decl) {
2334 if (lhs_decl && rhs_decl) {
2335 //----------------------------------------------------------------------
2336 // Make sure the decl kinds match first
2337 //----------------------------------------------------------------------
2338 const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind();
2339 const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind();
2340
2341 if (lhs_decl_kind == rhs_decl_kind) {
2342 //------------------------------------------------------------------
2343 // Now check that the decl contexts kinds are all equivalent
2344 // before we have to check any names of the decl contexts...
2345 //------------------------------------------------------------------
2346 clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
2347 clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
2348 if (lhs_decl_ctx && rhs_decl_ctx) {
2349 while (1) {
2350 if (lhs_decl_ctx && rhs_decl_ctx) {
2351 const clang::Decl::Kind lhs_decl_ctx_kind =
2352 lhs_decl_ctx->getDeclKind();
2353 const clang::Decl::Kind rhs_decl_ctx_kind =
2354 rhs_decl_ctx->getDeclKind();
2355 if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) {
2356 lhs_decl_ctx = lhs_decl_ctx->getParent();
2357 rhs_decl_ctx = rhs_decl_ctx->getParent();
2358
2359 if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr)
2360 break;
2361 } else
2362 return false;
2363 } else
2364 return false;
2365 }
2366
2367 //--------------------------------------------------------------
2368 // Now make sure the name of the decls match
2369 //--------------------------------------------------------------
2370 clang::NamedDecl *lhs_named_decl =
2371 llvm::dyn_cast<clang::NamedDecl>(lhs_decl);
2372 clang::NamedDecl *rhs_named_decl =
2373 llvm::dyn_cast<clang::NamedDecl>(rhs_decl);
2374 if (lhs_named_decl && rhs_named_decl) {
2375 clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
2376 clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
2377 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2378 if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2379 return false;
2380 } else
2381 return false;
2382 } else
2383 return false;
2384
2385 //--------------------------------------------------------------
2386 // We know that the decl context kinds all match, so now we need
2387 // to make sure the names match as well
2388 //--------------------------------------------------------------
2389 lhs_decl_ctx = lhs_decl->getDeclContext();
2390 rhs_decl_ctx = rhs_decl->getDeclContext();
2391 while (1) {
2392 switch (lhs_decl_ctx->getDeclKind()) {
2393 case clang::Decl::TranslationUnit:
2394 // We don't care about the translation unit names
2395 return true;
2396 default: {
2397 clang::NamedDecl *lhs_named_decl =
2398 llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
2399 clang::NamedDecl *rhs_named_decl =
2400 llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx);
2401 if (lhs_named_decl && rhs_named_decl) {
2402 clang::DeclarationName lhs_decl_name =
2403 lhs_named_decl->getDeclName();
2404 clang::DeclarationName rhs_decl_name =
2405 rhs_named_decl->getDeclName();
2406 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) {
2407 if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2408 return false;
2409 } else
2410 return false;
2411 } else
2412 return false;
2413 } break;
2414 }
2415 lhs_decl_ctx = lhs_decl_ctx->getParent();
2416 rhs_decl_ctx = rhs_decl_ctx->getParent();
2417 }
2418 }
2419 }
2420 }
2421 return false;
2422}
2423bool ClangASTContext::GetCompleteDecl(clang::ASTContext *ast,
2424 clang::Decl *decl) {
2425 if (!decl)
2426 return false;
2427
2428 ExternalASTSource *ast_source = ast->getExternalSource();
2429
2430 if (!ast_source)
2431 return false;
2432
2433 if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) {
2434 if (tag_decl->isCompleteDefinition())
2435 return true;
2436
2437 if (!tag_decl->hasExternalLexicalStorage())
2438 return false;
2439
2440 ast_source->CompleteType(tag_decl);
2441
2442 return !tag_decl->getTypeForDecl()->isIncompleteType();
2443 } else if (clang::ObjCInterfaceDecl *objc_interface_decl =
2444 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) {
2445 if (objc_interface_decl->getDefinition())
2446 return true;
2447
2448 if (!objc_interface_decl->hasExternalLexicalStorage())
2449 return false;
2450
2451 ast_source->CompleteType(objc_interface_decl);
2452
2453 return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
2454 } else {
2455 return false;
2456 }
2457}
2458
2459void ClangASTContext::SetMetadataAsUserID(const void *object,
2460 user_id_t user_id) {
2461 ClangASTMetadata meta_data;
2462 meta_data.SetUserID(user_id);
2463 SetMetadata(object, meta_data);
2464}
2465
2466void ClangASTContext::SetMetadata(clang::ASTContext *ast, const void *object,
2467 ClangASTMetadata &metadata) {
2468 ClangExternalASTSourceCommon *external_source =
2469 ClangExternalASTSourceCommon::Lookup(ast->getExternalSource());
2470
2471 if (external_source)
2472 external_source->SetMetadata(object, metadata);
2473}
2474
2475ClangASTMetadata *ClangASTContext::GetMetadata(clang::ASTContext *ast,
2476 const void *object) {
2477 ClangExternalASTSourceCommon *external_source =
2478 ClangExternalASTSourceCommon::Lookup(ast->getExternalSource());
2479
2480 if (external_source && external_source->HasMetadata(object))
2481 return external_source->GetMetadata(object);
2482 else
2483 return nullptr;
2484}
2485
2486clang::DeclContext *
2487ClangASTContext::GetAsDeclContext(clang::CXXMethodDecl *cxx_method_decl) {
2488 return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl);
2489}
2490
2491clang::DeclContext *
2492ClangASTContext::GetAsDeclContext(clang::ObjCMethodDecl *objc_method_decl) {
2493 return llvm::dyn_cast<clang::DeclContext>(objc_method_decl);
2494}
2495
2496bool ClangASTContext::SetTagTypeKind(clang::QualType tag_qual_type,
2497 int kind) const {
2498 const clang::Type *clang_type = tag_qual_type.getTypePtr();
2499 if (clang_type) {
2500 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type);
2501 if (tag_type) {
2502 clang::TagDecl *tag_decl =
2503 llvm::dyn_cast<clang::TagDecl>(tag_type->getDecl());
2504 if (tag_decl) {
2505 tag_decl->setTagKind((clang::TagDecl::TagKind)kind);
2506 return true;
2507 }
2508 }
2509 }
2510 return false;
2511}
2512
2513bool ClangASTContext::SetDefaultAccessForRecordFields(
2514 clang::RecordDecl *record_decl, int default_accessibility,
2515 int *assigned_accessibilities, size_t num_assigned_accessibilities) {
2516 if (record_decl) {
2517 uint32_t field_idx;
2518 clang::RecordDecl::field_iterator field, field_end;
2519 for (field = record_decl->field_begin(),
2520 field_end = record_decl->field_end(), field_idx = 0;
2521 field != field_end; ++field, ++field_idx) {
2522 // If no accessibility was assigned, assign the correct one
2523 if (field_idx < num_assigned_accessibilities &&
2524 assigned_accessibilities[field_idx] == clang::AS_none)
2525 field->setAccess((clang::AccessSpecifier)default_accessibility);
2526 }
2527 return true;
2528 }
2529 return false;
2530}
2531
2532clang::DeclContext *
2533ClangASTContext::GetDeclContextForType(const CompilerType &type) {
2534 return GetDeclContextForType(ClangUtil::GetQualType(type));
2535}
2536
2537clang::DeclContext *
2538ClangASTContext::GetDeclContextForType(clang::QualType type) {
2539 if (type.isNull())
2540 return nullptr;
2541
2542 clang::QualType qual_type = type.getCanonicalType();
2543 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2544 switch (type_class) {
2545 case clang::Type::ObjCInterface:
2546 return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())
2547 ->getInterface();
2548 case clang::Type::ObjCObjectPointer:
2549 return GetDeclContextForType(
2550 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
2551 ->getPointeeType());
2552 case clang::Type::Record:
2553 return llvm::cast<clang::RecordType>(qual_type)->getDecl();
2554 case clang::Type::Enum:
2555 return llvm::cast<clang::EnumType>(qual_type)->getDecl();
2556 case clang::Type::Typedef:
2557 return GetDeclContextForType(llvm::cast<clang::TypedefType>(qual_type)
2558 ->getDecl()
2559 ->getUnderlyingType());
2560 case clang::Type::Auto:
2561 return GetDeclContextForType(
2562 llvm::cast<clang::AutoType>(qual_type)->getDeducedType());
2563 case clang::Type::Elaborated:
2564 return GetDeclContextForType(
2565 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType());
2566 case clang::Type::Paren:
2567 return GetDeclContextForType(
2568 llvm::cast<clang::ParenType>(qual_type)->desugar());
2569 default:
2570 break;
2571 }
2572 // No DeclContext in this type...
2573 return nullptr;
2574}
2575
2576static bool GetCompleteQualType(clang::ASTContext *ast,
2577 clang::QualType qual_type,
2578 bool allow_completion = true) {
2579 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2580 switch (type_class) {
2581 case clang::Type::ConstantArray:
2582 case clang::Type::IncompleteArray:
2583 case clang::Type::VariableArray: {
2584 const clang::ArrayType *array_type =
2585 llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
2586
2587 if (array_type)
2588 return GetCompleteQualType(ast, array_type->getElementType(),
2589 allow_completion);
2590 } break;
2591 case clang::Type::Record: {
2592 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2593 if (cxx_record_decl) {
2594 if (cxx_record_decl->hasExternalLexicalStorage()) {
2595 const bool is_complete = cxx_record_decl->isCompleteDefinition();
2596 const bool fields_loaded =
2597 cxx_record_decl->hasLoadedFieldsFromExternalStorage();
2598 if (is_complete && fields_loaded)
2599 return true;
2600
2601 if (!allow_completion)
2602 return false;
2603
2604 // Call the field_begin() accessor to for it to use the external source
2605 // to load the fields...
2606 clang::ExternalASTSource *external_ast_source =
2607 ast->getExternalSource();
2608 if (external_ast_source) {
2609 external_ast_source->CompleteType(cxx_record_decl);
2610 if (cxx_record_decl->isCompleteDefinition()) {
2611 cxx_record_decl->field_begin();
2612 cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true);
2613 }
2614 }
2615 }
2616 }
2617 const clang::TagType *tag_type =
2618 llvm::cast<clang::TagType>(qual_type.getTypePtr());
2619 return !tag_type->isIncompleteType();
2620 } break;
2621
2622 case clang::Type::Enum: {
2623 const clang::TagType *tag_type =
2624 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
2625 if (tag_type) {
2626 clang::TagDecl *tag_decl = tag_type->getDecl();
2627 if (tag_decl) {
2628 if (tag_decl->getDefinition())
2629 return true;
2630
2631 if (!allow_completion)
2632 return false;
2633
2634 if (tag_decl->hasExternalLexicalStorage()) {
2635 if (ast) {
2636 clang::ExternalASTSource *external_ast_source =
2637 ast->getExternalSource();
2638 if (external_ast_source) {
2639 external_ast_source->CompleteType(tag_decl);
2640 return !tag_type->isIncompleteType();
2641 }
2642 }
2643 }
2644 return false;
2645 }
2646 }
2647
2648 } break;
2649 case clang::Type::ObjCObject:
2650 case clang::Type::ObjCInterface: {
2651 const clang::ObjCObjectType *objc_class_type =
2652 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
2653 if (objc_class_type) {
2654 clang::ObjCInterfaceDecl *class_interface_decl =
2655 objc_class_type->getInterface();
2656 // We currently can't complete objective C types through the newly added
2657 // ASTContext
2658 // because it only supports TagDecl objects right now...
2659 if (class_interface_decl) {
2660 if (class_interface_decl->getDefinition())
2661 return true;
2662
2663 if (!allow_completion)
2664 return false;
2665
2666 if (class_interface_decl->hasExternalLexicalStorage()) {
2667 if (ast) {
2668 clang::ExternalASTSource *external_ast_source =
2669 ast->getExternalSource();
2670 if (external_ast_source) {
2671 external_ast_source->CompleteType(class_interface_decl);
2672 return !objc_class_type->isIncompleteType();
2673 }
2674 }
2675 }
2676 return false;
2677 }
2678 }
2679 } break;
2680
2681 case clang::Type::Typedef:
2682 return GetCompleteQualType(ast, llvm::cast<clang::TypedefType>(qual_type)
2683 ->getDecl()
2684 ->getUnderlyingType(),
2685 allow_completion);
2686
2687 case clang::Type::Auto:
2688 return GetCompleteQualType(
2689 ast, llvm::cast<clang::AutoType>(qual_type)->getDeducedType(),
2690 allow_completion);
2691
2692 case clang::Type::Elaborated:
2693 return GetCompleteQualType(
2694 ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType(),
2695 allow_completion);
2696
2697 case clang::Type::Paren:
2698 return GetCompleteQualType(
2699 ast, llvm::cast<clang::ParenType>(qual_type)->desugar(),
2700 allow_completion);
2701
2702 case clang::Type::Attributed:
2703 return GetCompleteQualType(
2704 ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(),
2705 allow_completion);
2706
2707 default:
2708 break;
2709 }
2710
2711 return true;
2712}
2713
2714static clang::ObjCIvarDecl::AccessControl
2715ConvertAccessTypeToObjCIvarAccessControl(AccessType access) {
2716 switch (access) {
2717 case eAccessNone:
2718 return clang::ObjCIvarDecl::None;
2719 case eAccessPublic:
2720 return clang::ObjCIvarDecl::Public;
2721 case eAccessPrivate:
2722 return clang::ObjCIvarDecl::Private;
2723 case eAccessProtected:
2724 return clang::ObjCIvarDecl::Protected;
2725 case eAccessPackage:
2726 return clang::ObjCIvarDecl::Package;
2727 }
2728 return clang::ObjCIvarDecl::None;
2729}
2730
2731//----------------------------------------------------------------------
2732// Tests
2733//----------------------------------------------------------------------
2734
2735bool ClangASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) {
2736 clang::QualType qual_type(GetCanonicalQualType(type));
2737
2738 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2739 switch (type_class) {
2740 case clang::Type::IncompleteArray:
2741 case clang::Type::VariableArray:
2742 case clang::Type::ConstantArray:
2743 case clang::Type::ExtVector:
2744 case clang::Type::Vector:
2745 case clang::Type::Record:
2746 case clang::Type::ObjCObject:
2747 case clang::Type::ObjCInterface:
2748 return true;
2749 case clang::Type::Auto:
2750 return IsAggregateType(llvm::cast<clang::AutoType>(qual_type)
2751 ->getDeducedType()
2752 .getAsOpaquePtr());
2753 case clang::Type::Elaborated:
2754 return IsAggregateType(llvm::cast<clang::ElaboratedType>(qual_type)
2755 ->getNamedType()
2756 .getAsOpaquePtr());
2757 case clang::Type::Typedef:
2758 return IsAggregateType(llvm::cast<clang::TypedefType>(qual_type)
2759 ->getDecl()
2760 ->getUnderlyingType()
2761 .getAsOpaquePtr());
2762 case clang::Type::Paren:
2763 return IsAggregateType(
2764 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
2765 default:
2766 break;
2767 }
2768 // The clang type does have a value
2769 return false;
2770}
2771
2772bool ClangASTContext::IsAnonymousType(lldb::opaque_compiler_type_t type) {
2773 clang::QualType qual_type(GetCanonicalQualType(type));
2774
2775 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2776 switch (type_class) {
2777 case clang::Type::Record: {
2778 if (const clang::RecordType *record_type =
2779 llvm::dyn_cast_or_null<clang::RecordType>(
2780 qual_type.getTypePtrOrNull())) {
2781 if (const clang::RecordDecl *record_decl = record_type->getDecl()) {
2782 return record_decl->isAnonymousStructOrUnion();
2783 }
2784 }
2785 break;
2786 }
2787 case clang::Type::Auto:
2788 return IsAnonymousType(llvm::cast<clang::AutoType>(qual_type)
2789 ->getDeducedType()
2790 .getAsOpaquePtr());
2791 case clang::Type::Elaborated:
2792 return IsAnonymousType(llvm::cast<clang::ElaboratedType>(qual_type)
2793 ->getNamedType()
2794 .getAsOpaquePtr());
2795 case clang::Type::Typedef:
2796 return IsAnonymousType(llvm::cast<clang::TypedefType>(qual_type)
2797 ->getDecl()
2798 ->getUnderlyingType()
2799 .getAsOpaquePtr());
2800 case clang::Type::Paren:
2801 return IsAnonymousType(
2802 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
2803 default:
2804 break;
2805 }
2806 // The clang type does have a value
2807 return false;
2808}
2809
2810bool ClangASTContext::IsArrayType(lldb::opaque_compiler_type_t type,
2811 CompilerType *element_type_ptr,
2812 uint64_t *size, bool *is_incomplete) {
2813 clang::QualType qual_type(GetCanonicalQualType(type));
2814
2815 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2816 switch (type_class) {
2817 default:
2818 break;
2819
2820 case clang::Type::ConstantArray:
2821 if (element_type_ptr)
2822 element_type_ptr->SetCompilerType(
2823 getASTContext(),
2824 llvm::cast<clang::ConstantArrayType>(qual_type)->getElementType());
2825 if (size)
2826 *size = llvm::cast<clang::ConstantArrayType>(qual_type)
2827 ->getSize()
2828 .getLimitedValue(ULLONG_MAX(9223372036854775807LL*2ULL+1ULL));
2829 if (is_incomplete)
2830 *is_incomplete = false;
2831 return true;
2832
2833 case clang::Type::IncompleteArray:
2834 if (element_type_ptr)
2835 element_type_ptr->SetCompilerType(
2836 getASTContext(),
2837 llvm::cast<clang::IncompleteArrayType>(qual_type)->getElementType());
2838 if (size)
2839 *size = 0;
2840 if (is_incomplete)
2841 *is_incomplete = true;
2842 return true;
2843
2844 case clang::Type::VariableArray:
2845 if (element_type_ptr)
2846 element_type_ptr->SetCompilerType(
2847 getASTContext(),
2848 llvm::cast<clang::VariableArrayType>(qual_type)->getElementType());
2849 if (size)
2850 *size = 0;
2851 if (is_incomplete)
2852 *is_incomplete = false;
2853 return true;
2854
2855 case clang::Type::DependentSizedArray:
2856 if (element_type_ptr)
2857 element_type_ptr->SetCompilerType(
2858 getASTContext(), llvm::cast<clang::DependentSizedArrayType>(qual_type)
2859 ->getElementType());
2860 if (size)
2861 *size = 0;
2862 if (is_incomplete)
2863 *is_incomplete = false;
2864 return true;
2865
2866 case clang::Type::Typedef:
2867 return IsArrayType(llvm::cast<clang::TypedefType>(qual_type)
2868 ->getDecl()
2869 ->getUnderlyingType()
2870 .getAsOpaquePtr(),
2871 element_type_ptr, size, is_incomplete);
2872 case clang::Type::Auto:
2873 return IsArrayType(llvm::cast<clang::AutoType>(qual_type)
2874 ->getDeducedType()
2875 .getAsOpaquePtr(),
2876 element_type_ptr, size, is_incomplete);
2877 case clang::Type::Elaborated:
2878 return IsArrayType(llvm::cast<clang::ElaboratedType>(qual_type)
2879 ->getNamedType()
2880 .getAsOpaquePtr(),
2881 element_type_ptr, size, is_incomplete);
2882 case clang::Type::Paren:
2883 return IsArrayType(
2884 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
2885 element_type_ptr, size, is_incomplete);
2886 }
2887 if (element_type_ptr)
2888 element_type_ptr->Clear();
2889 if (size)
2890 *size = 0;
2891 if (is_incomplete)
2892 *is_incomplete = false;
2893 return false;
2894}
2895
2896bool ClangASTContext::IsVectorType(lldb::opaque_compiler_type_t type,
2897 CompilerType *element_type, uint64_t *size) {
2898 clang::QualType qual_type(GetCanonicalQualType(type));
2899
2900 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2901 switch (type_class) {
2902 case clang::Type::Vector: {
2903 const clang::VectorType *vector_type =
2904 qual_type->getAs<clang::VectorType>();
2905 if (vector_type) {
2906 if (size)
2907 *size = vector_type->getNumElements();
2908 if (element_type)
2909 *element_type =
2910 CompilerType(getASTContext(), vector_type->getElementType());
2911 }
2912 return true;
2913 } break;
2914 case clang::Type::ExtVector: {
2915 const clang::ExtVectorType *ext_vector_type =
2916 qual_type->getAs<clang::ExtVectorType>();
2917 if (ext_vector_type) {
2918 if (size)
2919 *size = ext_vector_type->getNumElements();
2920 if (element_type)
2921 *element_type =
2922 CompilerType(getASTContext(), ext_vector_type->getElementType());
2923 }
2924 return true;
2925 }
2926 default:
2927 break;
2928 }
2929 return false;
2930}
2931
2932bool ClangASTContext::IsRuntimeGeneratedType(
2933 lldb::opaque_compiler_type_t type) {
2934 clang::DeclContext *decl_ctx = ClangASTContext::GetASTContext(getASTContext())
1
Calling 'ClangASTContext::GetASTContext'
2935 ->GetDeclContextForType(GetQualType(type));
2936 if (!decl_ctx)
2937 return false;
2938
2939 if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
2940 return false;
2941
2942 clang::ObjCInterfaceDecl *result_iface_decl =
2943 llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
2944
2945 ClangASTMetadata *ast_metadata =
2946 ClangASTContext::GetMetadata(getASTContext(), result_iface_decl);
2947 if (!ast_metadata)
2948 return false;
2949 return (ast_metadata->GetISAPtr() != 0);
2950}
2951
2952bool ClangASTContext::IsCharType(lldb::opaque_compiler_type_t type) {
2953 return GetQualType(type).getUnqualifiedType()->isCharType();
2954}
2955
2956bool ClangASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) {
2957 const bool allow_completion = false;
2958 return GetCompleteQualType(getASTContext(), GetQualType(type),
2959 allow_completion);
2960}
2961
2962bool ClangASTContext::IsConst(lldb::opaque_compiler_type_t type) {
2963 return GetQualType(type).isConstQualified();
2964}
2965
2966bool ClangASTContext::IsCStringType(lldb::opaque_compiler_type_t type,
2967 uint32_t &length) {
2968 CompilerType pointee_or_element_clang_type;
2969 length = 0;
2970 Flags type_flags(GetTypeInfo(type, &pointee_or_element_clang_type));
2971
2972 if (!pointee_or_element_clang_type.IsValid())
2973 return false;
2974
2975 if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer)) {
2976 if (pointee_or_element_clang_type.IsCharType()) {
2977 if (type_flags.Test(eTypeIsArray)) {
2978 // We know the size of the array and it could be a C string
2979 // since it is an array of characters
2980 length = llvm::cast<clang::ConstantArrayType>(
2981 GetCanonicalQualType(type).getTypePtr())
2982 ->getSize()
2983 .getLimitedValue();
2984 }
2985 return true;
2986 }
2987 }
2988 return false;
2989}
2990
2991bool ClangASTContext::IsFunctionType(lldb::opaque_compiler_type_t type,
2992 bool *is_variadic_ptr) {
2993 if (type) {
2994 clang::QualType qual_type(GetCanonicalQualType(type));
2995
2996 if (qual_type->isFunctionType()) {
2997 if (is_variadic_ptr) {
2998 const clang::FunctionProtoType *function_proto_type =
2999 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3000 if (function_proto_type)
3001 *is_variadic_ptr = function_proto_type->isVariadic();
3002 else
3003 *is_variadic_ptr = false;
3004 }
3005 return true;
3006 }
3007
3008 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3009 switch (type_class) {
3010 default:
3011 break;
3012 case clang::Type::Typedef:
3013 return IsFunctionType(llvm::cast<clang::TypedefType>(qual_type)
3014 ->getDecl()
3015 ->getUnderlyingType()
3016 .getAsOpaquePtr(),
3017 nullptr);
3018 case clang::Type::Auto:
3019 return IsFunctionType(llvm::cast<clang::AutoType>(qual_type)
3020 ->getDeducedType()
3021 .getAsOpaquePtr(),
3022 nullptr);
3023 case clang::Type::Elaborated:
3024 return IsFunctionType(llvm::cast<clang::ElaboratedType>(qual_type)
3025 ->getNamedType()
3026 .getAsOpaquePtr(),
3027 nullptr);
3028 case clang::Type::Paren:
3029 return IsFunctionType(
3030 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
3031 nullptr);
3032 case clang::Type::LValueReference:
3033 case clang::Type::RValueReference: {
3034 const clang::ReferenceType *reference_type =
3035 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3036 if (reference_type)
3037 return IsFunctionType(reference_type->getPointeeType().getAsOpaquePtr(),
3038 nullptr);
3039 } break;
3040 }
3041 }
3042 return false;
3043}
3044
3045// Used to detect "Homogeneous Floating-point Aggregates"
3046uint32_t
3047ClangASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type,
3048 CompilerType *base_type_ptr) {
3049 if (!type)
3050 return 0;
3051
3052 clang::QualType qual_type(GetCanonicalQualType(type));
3053 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3054 switch (type_class) {
3055 case clang::Type::Record:
3056 if (GetCompleteType(type)) {
3057 const clang::CXXRecordDecl *cxx_record_decl =
3058 qual_type->getAsCXXRecordDecl();
3059 if (cxx_record_decl) {
3060 if (cxx_record_decl->getNumBases() || cxx_record_decl->isDynamicClass())
3061 return 0;
3062 }
3063 const clang::RecordType *record_type =
3064 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3065 if (record_type) {
3066 const clang::RecordDecl *record_decl = record_type->getDecl();
3067 if (record_decl) {
3068 // We are looking for a structure that contains only floating point
3069 // types
3070 clang::RecordDecl::field_iterator field_pos,
3071 field_end = record_decl->field_end();
3072 uint32_t num_fields = 0;
3073 bool is_hva = false;
3074 bool is_hfa = false;
3075 clang::QualType base_qual_type;
3076 uint64_t base_bitwidth = 0;
3077 for (field_pos = record_decl->field_begin(); field_pos != field_end;
3078 ++field_pos) {
3079 clang::QualType field_qual_type = field_pos->getType();
3080 uint64_t field_bitwidth = getASTContext()->getTypeSize(qual_type);
3081 if (field_qual_type->isFloatingType()) {
3082 if (field_qual_type->isComplexType())
3083 return 0;
3084 else {
3085 if (num_fields == 0)
3086 base_qual_type = field_qual_type;
3087 else {
3088 if (is_hva)
3089 return 0;
3090 is_hfa = true;
3091 if (field_qual_type.getTypePtr() !=
3092 base_qual_type.getTypePtr())
3093 return 0;
3094 }
3095 }
3096 } else if (field_qual_type->isVectorType() ||
3097 field_qual_type->isExtVectorType()) {
3098 if (num_fields == 0) {
3099 base_qual_type = field_qual_type;
3100 base_bitwidth = field_bitwidth;
3101 } else {
3102 if (is_hfa)
3103 return 0;
3104 is_hva = true;
3105 if (base_bitwidth != field_bitwidth)
3106 return 0;
3107 if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
3108 return 0;
3109 }
3110 } else
3111 return 0;
3112 ++num_fields;
3113 }
3114 if (base_type_ptr)
3115 *base_type_ptr = CompilerType(getASTContext(), base_qual_type);
3116 return num_fields;
3117 }
3118 }
3119 }
3120 break;
3121
3122 case clang::Type::Typedef:
3123 return IsHomogeneousAggregate(llvm::cast<clang::TypedefType>(qual_type)
3124 ->getDecl()
3125 ->getUnderlyingType()
3126 .getAsOpaquePtr(),
3127 base_type_ptr);
3128
3129 case clang::Type::Auto:
3130 return IsHomogeneousAggregate(llvm::cast<clang::AutoType>(qual_type)
3131 ->getDeducedType()
3132 .getAsOpaquePtr(),
3133 base_type_ptr);
3134
3135 case clang::Type::Elaborated:
3136 return IsHomogeneousAggregate(llvm::cast<clang::ElaboratedType>(qual_type)
3137 ->getNamedType()
3138 .getAsOpaquePtr(),
3139 base_type_ptr);
3140 default:
3141 break;
3142 }
3143 return 0;
3144}
3145
3146size_t ClangASTContext::GetNumberOfFunctionArguments(
3147 lldb::opaque_compiler_type_t type) {
3148 if (type) {
3149 clang::QualType qual_type(GetCanonicalQualType(type));
3150 const clang::FunctionProtoType *func =
3151 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3152 if (func)
3153 return func->getNumParams();
3154 }
3155 return 0;
3156}
3157
3158CompilerType
3159ClangASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
3160 const size_t index) {
3161 if (type) {
3162 clang::QualType qual_type(GetQualType(type));
3163 const clang::FunctionProtoType *func =
3164 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3165 if (func) {
3166 if (index < func->getNumParams())
3167 return CompilerType(getASTContext(), func->getParamType(index));
3168 }
3169 }
3170 return CompilerType();
3171}
3172
3173bool ClangASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
3174 if (type) {
3175 clang::QualType qual_type(GetCanonicalQualType(type));
3176
3177 if (qual_type->isFunctionPointerType())
3178 return true;
3179
3180 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3181 switch (type_class) {
3182 default:
3183 break;
3184 case clang::Type::Typedef:
3185 return IsFunctionPointerType(llvm::cast<clang::TypedefType>(qual_type)
3186 ->getDecl()
3187 ->getUnderlyingType()
3188 .getAsOpaquePtr());
3189 case clang::Type::Auto:
3190 return IsFunctionPointerType(llvm::cast<clang::AutoType>(qual_type)
3191 ->getDeducedType()
3192 .getAsOpaquePtr());
3193 case clang::Type::Elaborated:
3194 return IsFunctionPointerType(llvm::cast<clang::ElaboratedType>(qual_type)
3195 ->getNamedType()
3196 .getAsOpaquePtr());
3197 case clang::Type::Paren:
3198 return IsFunctionPointerType(
3199 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
3200
3201 case clang::Type::LValueReference:
3202 case clang::Type::RValueReference: {
3203 const clang::ReferenceType *reference_type =
3204 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3205 if (reference_type)
3206 return IsFunctionPointerType(
3207 reference_type->getPointeeType().getAsOpaquePtr());
3208 } break;
3209 }
3210 }
3211 return false;
3212}
3213
3214bool ClangASTContext::IsBlockPointerType(
3215 lldb::opaque_compiler_type_t type,
3216 CompilerType *function_pointer_type_ptr) {
3217 if (type) {
3218 clang::QualType qual_type(GetCanonicalQualType(type));
3219
3220 if (qual_type->isBlockPointerType()) {
3221 if (function_pointer_type_ptr) {
3222 const clang::BlockPointerType *block_pointer_type =
3223 qual_type->getAs<clang::BlockPointerType>();
3224 QualType pointee_type = block_pointer_type->getPointeeType();
3225 QualType function_pointer_type = m_ast_ap->getPointerType(pointee_type);
3226 *function_pointer_type_ptr =
3227 CompilerType(getASTContext(), function_pointer_type);
3228 }
3229 return true;
3230 }
3231
3232 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3233 switch (type_class) {
3234 default:
3235 break;
3236 case clang::Type::Typedef:
3237 return IsBlockPointerType(llvm::cast<clang::TypedefType>(qual_type)
3238 ->getDecl()
3239 ->getUnderlyingType()
3240 .getAsOpaquePtr(),
3241 function_pointer_type_ptr);
3242 case clang::Type::Auto:
3243 return IsBlockPointerType(llvm::cast<clang::AutoType>(qual_type)
3244 ->getDeducedType()
3245 .getAsOpaquePtr(),
3246 function_pointer_type_ptr);
3247 case clang::Type::Elaborated:
3248 return IsBlockPointerType(llvm::cast<clang::ElaboratedType>(qual_type)
3249 ->getNamedType()
3250 .getAsOpaquePtr(),
3251 function_pointer_type_ptr);
3252 case clang::Type::Paren:
3253 return IsBlockPointerType(
3254 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
3255 function_pointer_type_ptr);
3256
3257 case clang::Type::LValueReference:
3258 case clang::Type::RValueReference: {
3259 const clang::ReferenceType *reference_type =
3260 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3261 if (reference_type)
3262 return IsBlockPointerType(
3263 reference_type->getPointeeType().getAsOpaquePtr(),
3264 function_pointer_type_ptr);
3265 } break;
3266 }
3267 }
3268 return false;
3269}
3270
3271bool ClangASTContext::IsIntegerType(lldb::opaque_compiler_type_t type,
3272 bool &is_signed) {
3273 if (!type)
3274 return false;
3275
3276 clang::QualType qual_type(GetCanonicalQualType(type));
3277 const clang::BuiltinType *builtin_type =
3278 llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
3279
3280 if (builtin_type) {
3281 if (builtin_type->isInteger()) {
3282 is_signed = builtin_type->isSignedInteger();
3283 return true;
3284 }
3285 }
3286
3287 return false;
3288}
3289
3290bool ClangASTContext::IsEnumerationType(lldb::opaque_compiler_type_t type,
3291 bool &is_signed) {
3292 if (type) {
3293 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
3294 GetCanonicalQualType(type)->getCanonicalTypeInternal());
3295
3296 if (enum_type) {
3297 IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(),
3298 is_signed);
3299 return true;
3300 }
3301 }
3302
3303 return false;
3304}
3305
3306bool ClangASTContext::IsPointerType(lldb::opaque_compiler_type_t type,
3307 CompilerType *pointee_type) {
3308 if (type) {
3309 clang::QualType qual_type(GetCanonicalQualType(type));
3310 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3311 switch (type_class) {
3312 case clang::Type::Builtin:
3313 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3314 default:
3315 break;
3316 case clang::BuiltinType::ObjCId:
3317 case clang::BuiltinType::ObjCClass:
3318 return true;
3319 }
3320 return false;
3321 case clang::Type::ObjCObjectPointer:
3322 if (pointee_type)
3323 pointee_type->SetCompilerType(
3324 getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3325 ->getPointeeType());
3326 return true;
3327 case clang::Type::BlockPointer:
3328 if (pointee_type)
3329 pointee_type->SetCompilerType(
3330 getASTContext(),
3331 llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType());
3332 return true;
3333 case clang::Type::Pointer:
3334 if (pointee_type)
3335 pointee_type->SetCompilerType(
3336 getASTContext(),
3337 llvm::cast<clang::PointerType>(qual_type)->getPointeeType());
3338 return true;
3339 case clang::Type::MemberPointer:
3340 if (pointee_type)
3341 pointee_type->SetCompilerType(
3342 getASTContext(),
3343 llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType());
3344 return true;
3345 case clang::Type::Typedef:
3346 return IsPointerType(llvm::cast<clang::TypedefType>(qual_type)
3347 ->getDecl()
3348 ->getUnderlyingType()
3349 .getAsOpaquePtr(),
3350 pointee_type);
3351 case clang::Type::Auto:
3352 return IsPointerType(llvm::cast<clang::AutoType>(qual_type)
3353 ->getDeducedType()
3354 .getAsOpaquePtr(),
3355 pointee_type);
3356 case clang::Type::Elaborated:
3357 return IsPointerType(llvm::cast<clang::ElaboratedType>(qual_type)
3358 ->getNamedType()
3359 .getAsOpaquePtr(),
3360 pointee_type);
3361 case clang::Type::Paren:
3362 return IsPointerType(
3363 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
3364 pointee_type);
3365 default:
3366 break;
3367 }
3368 }
3369 if (pointee_type)
3370 pointee_type->Clear();
3371 return false;
3372}
3373
3374bool ClangASTContext::IsPointerOrReferenceType(
3375 lldb::opaque_compiler_type_t type, CompilerType *pointee_type) {
3376 if (type) {
3377 clang::QualType qual_type(GetCanonicalQualType(type));
3378 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3379 switch (type_class) {
3380 case clang::Type::Builtin:
3381 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
3382 default:
3383 break;
3384 case clang::BuiltinType::ObjCId:
3385 case clang::BuiltinType::ObjCClass:
3386 return true;
3387 }
3388 return false;
3389 case clang::Type::ObjCObjectPointer:
3390 if (pointee_type)
3391 pointee_type->SetCompilerType(
3392 getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3393 ->getPointeeType());
3394 return true;
3395 case clang::Type::BlockPointer:
3396 if (pointee_type)
3397 pointee_type->SetCompilerType(
3398 getASTContext(),
3399 llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType());
3400 return true;
3401 case clang::Type::Pointer:
3402 if (pointee_type)
3403 pointee_type->SetCompilerType(
3404 getASTContext(),
3405 llvm::cast<clang::PointerType>(qual_type)->getPointeeType());
3406 return true;
3407 case clang::Type::MemberPointer:
3408 if (pointee_type)
3409 pointee_type->SetCompilerType(
3410 getASTContext(),
3411 llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType());
3412 return true;
3413 case clang::Type::LValueReference:
3414 if (pointee_type)
3415 pointee_type->SetCompilerType(
3416 getASTContext(),
3417 llvm::cast<clang::LValueReferenceType>(qual_type)->desugar());
3418 return true;
3419 case clang::Type::RValueReference:
3420 if (pointee_type)
3421 pointee_type->SetCompilerType(
3422 getASTContext(),
3423 llvm::cast<clang::RValueReferenceType>(qual_type)->desugar());
3424 return true;
3425 case clang::Type::Typedef:
3426 return IsPointerOrReferenceType(llvm::cast<clang::TypedefType>(qual_type)
3427 ->getDecl()
3428 ->getUnderlyingType()
3429 .getAsOpaquePtr(),
3430 pointee_type);
3431 case clang::Type::Auto:
3432 return IsPointerOrReferenceType(llvm::cast<clang::AutoType>(qual_type)
3433 ->getDeducedType()
3434 .getAsOpaquePtr(),
3435 pointee_type);
3436 case clang::Type::Elaborated:
3437 return IsPointerOrReferenceType(
3438 llvm::cast<clang::ElaboratedType>(qual_type)
3439 ->getNamedType()
3440 .getAsOpaquePtr(),
3441 pointee_type);
3442 case clang::Type::Paren:
3443 return IsPointerOrReferenceType(
3444 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
3445 pointee_type);
3446 default:
3447 break;
3448 }
3449 }
3450 if (pointee_type)
3451 pointee_type->Clear();
3452 return false;
3453}
3454
3455bool ClangASTContext::IsReferenceType(lldb::opaque_compiler_type_t type,
3456 CompilerType *pointee_type,
3457 bool *is_rvalue) {
3458 if (type) {
3459 clang::QualType qual_type(GetCanonicalQualType(type));
3460 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3461
3462 switch (type_class) {
3463 case clang::Type::LValueReference:
3464 if (pointee_type)
3465 pointee_type->SetCompilerType(
3466 getASTContext(),
3467 llvm::cast<clang::LValueReferenceType>(qual_type)->desugar());
3468 if (is_rvalue)
3469 *is_rvalue = false;
3470 return true;
3471 case clang::Type::RValueReference:
3472 if (pointee_type)
3473 pointee_type->SetCompilerType(
3474 getASTContext(),
3475 llvm::cast<clang::RValueReferenceType>(qual_type)->desugar());
3476 if (is_rvalue)
3477 *is_rvalue = true;
3478 return true;
3479 case clang::Type::Typedef:
3480 return IsReferenceType(llvm::cast<clang::TypedefType>(qual_type)
3481 ->getDecl()
3482 ->getUnderlyingType()
3483 .getAsOpaquePtr(),
3484 pointee_type, is_rvalue);
3485 case clang::Type::Auto:
3486 return IsReferenceType(llvm::cast<clang::AutoType>(qual_type)
3487 ->getDeducedType()
3488 .getAsOpaquePtr(),
3489 pointee_type, is_rvalue);
3490 case clang::Type::Elaborated:
3491 return IsReferenceType(llvm::cast<clang::ElaboratedType>(qual_type)
3492 ->getNamedType()
3493 .getAsOpaquePtr(),
3494 pointee_type, is_rvalue);
3495 case clang::Type::Paren:
3496 return IsReferenceType(
3497 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
3498 pointee_type, is_rvalue);
3499
3500 default:
3501 break;
3502 }
3503 }
3504 if (pointee_type)
3505 pointee_type->Clear();
3506 return false;
3507}
3508
3509bool ClangASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type,
3510 uint32_t &count, bool &is_complex) {
3511 if (type) {
3512 clang::QualType qual_type(GetCanonicalQualType(type));
3513
3514 if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(
3515 qual_type->getCanonicalTypeInternal())) {
3516 clang::BuiltinType::Kind kind = BT->getKind();
3517 if (kind >= clang::BuiltinType::Float &&
3518 kind <= clang::BuiltinType::LongDouble) {
3519 count = 1;
3520 is_complex = false;
3521 return true;
3522 }
3523 } else if (const clang::ComplexType *CT =
3524 llvm::dyn_cast<clang::ComplexType>(
3525 qual_type->getCanonicalTypeInternal())) {
3526 if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count,
3527 is_complex)) {
3528 count = 2;
3529 is_complex = true;
3530 return true;
3531 }
3532 } else if (const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(
3533 qual_type->getCanonicalTypeInternal())) {
3534 if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count,
3535 is_complex)) {
3536 count = VT->getNumElements();
3537 is_complex = false;
3538 return true;
3539 }
3540 }
3541 }
3542 count = 0;
3543 is_complex = false;
3544 return false;
3545}
3546
3547bool ClangASTContext::IsDefined(lldb::opaque_compiler_type_t type) {
3548 if (!type)
3549 return false;
3550
3551 clang::QualType qual_type(GetQualType(type));
3552 const clang::TagType *tag_type =
3553 llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
3554 if (tag_type) {
3555 clang::TagDecl *tag_decl = tag_type->getDecl();
3556 if (tag_decl)
3557 return tag_decl->isCompleteDefinition();
3558 return false;
3559 } else {
3560 const clang::ObjCObjectType *objc_class_type =
3561 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
3562 if (objc_class_type) {
3563 clang::ObjCInterfaceDecl *class_interface_decl =
3564 objc_class_type->getInterface();
3565 if (class_interface_decl)
3566 return class_interface_decl->getDefinition() != nullptr;
3567 return false;
3568 }
3569 }
3570 return true;
3571}
3572
3573bool ClangASTContext::IsObjCClassType(const CompilerType &type) {
3574 if (type) {
3575 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3576
3577 const clang::ObjCObjectPointerType *obj_pointer_type =
3578 llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3579
3580 if (obj_pointer_type)
3581 return obj_pointer_type->isObjCClassType();
3582 }
3583 return false;
3584}
3585
3586bool ClangASTContext::IsObjCObjectOrInterfaceType(const CompilerType &type) {
3587 if (ClangUtil::IsClangType(type))
3588 return ClangUtil::GetCanonicalQualType(type)->isObjCObjectOrInterfaceType();
3589 return false;
3590}
3591
3592bool ClangASTContext::IsClassType(lldb::opaque_compiler_type_t type) {
3593 if (!type)
3594 return false;
3595 clang::QualType qual_type(GetCanonicalQualType(type));
3596 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3597 return (type_class == clang::Type::Record);
3598}
3599
3600bool ClangASTContext::IsEnumType(lldb::opaque_compiler_type_t type) {
3601 if (!type)
3602 return false;
3603 clang::QualType qual_type(GetCanonicalQualType(type));
3604 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3605 return (type_class == clang::Type::Enum);
3606}
3607
3608bool ClangASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) {
3609 if (type) {
3610 clang::QualType qual_type(GetCanonicalQualType(type));
3611 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3612 switch (type_class) {
3613 case clang::Type::Record:
3614 if (GetCompleteType(type)) {
3615 const clang::RecordType *record_type =
3616 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3617 const clang::RecordDecl *record_decl = record_type->getDecl();
3618 if (record_decl) {
3619 const clang::CXXRecordDecl *cxx_record_decl =
3620 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3621 if (cxx_record_decl)
3622 return cxx_record_decl->isPolymorphic();
3623 }
3624 }
3625 break;
3626
3627 default:
3628 break;
3629 }
3630 }
3631 return false;
3632}
3633
3634bool ClangASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
3635 CompilerType *dynamic_pointee_type,
3636 bool check_cplusplus,
3637 bool check_objc) {
3638 clang::QualType pointee_qual_type;
3639 if (type) {
3640 clang::QualType qual_type(GetCanonicalQualType(type));
3641 bool success = false;
3642 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3643 switch (type_class) {
3644 case clang::Type::Builtin:
3645 if (check_objc &&
3646 llvm::cast<clang::BuiltinType>(qual_type)->getKind() ==
3647 clang::BuiltinType::ObjCId) {
3648 if (dynamic_pointee_type)
3649 dynamic_pointee_type->SetCompilerType(this, type);
3650 return true;
3651 }
3652 break;
3653
3654 case clang::Type::ObjCObjectPointer:
3655 if (check_objc) {
3656 if (auto objc_pointee_type =
3657 qual_type->getPointeeType().getTypePtrOrNull()) {
3658 if (auto objc_object_type =
3659 llvm::dyn_cast_or_null<clang::ObjCObjectType>(
3660 objc_pointee_type)) {
3661 if (objc_object_type->isObjCClass())
3662 return false;
3663 }
3664 }
3665 if (dynamic_pointee_type)
3666 dynamic_pointee_type->SetCompilerType(
3667 getASTContext(),
3668 llvm::cast<clang::ObjCObjectPointerType>(qual_type)
3669 ->getPointeeType());
3670 return true;
3671 }
3672 break;
3673
3674 case clang::Type::Pointer:
3675 pointee_qual_type =
3676 llvm::cast<clang::PointerType>(qual_type)->getPointeeType();
3677 success = true;
3678 break;
3679
3680 case clang::Type::LValueReference:
3681 case clang::Type::RValueReference:
3682 pointee_qual_type =
3683 llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType();
3684 success = true;
3685 break;
3686
3687 case clang::Type::Typedef:
3688 return IsPossibleDynamicType(llvm::cast<clang::TypedefType>(qual_type)
3689 ->getDecl()
3690 ->getUnderlyingType()
3691 .getAsOpaquePtr(),
3692 dynamic_pointee_type, check_cplusplus,
3693 check_objc);
3694
3695 case clang::Type::Auto:
3696 return IsPossibleDynamicType(llvm::cast<clang::AutoType>(qual_type)
3697 ->getDeducedType()
3698 .getAsOpaquePtr(),
3699 dynamic_pointee_type, check_cplusplus,
3700 check_objc);
3701
3702 case clang::Type::Elaborated:
3703 return IsPossibleDynamicType(llvm::cast<clang::ElaboratedType>(qual_type)
3704 ->getNamedType()
3705 .getAsOpaquePtr(),
3706 dynamic_pointee_type, check_cplusplus,
3707 check_objc);
3708
3709 case clang::Type::Paren:
3710 return IsPossibleDynamicType(
3711 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
3712 dynamic_pointee_type, check_cplusplus, check_objc);
3713 default:
3714 break;
3715 }
3716
3717 if (success) {
3718 // Check to make sure what we are pointing too is a possible dynamic C++
3719 // type
3720 // We currently accept any "void *" (in case we have a class that has been
3721 // watered down to an opaque pointer) and virtual C++ classes.
3722 const clang::Type::TypeClass pointee_type_class =
3723 pointee_qual_type.getCanonicalType()->getTypeClass();
3724 switch (pointee_type_class) {
3725 case clang::Type::Builtin:
3726 switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind()) {
3727 case clang::BuiltinType::UnknownAny:
3728 case clang::BuiltinType::Void:
3729 if (dynamic_pointee_type)
3730 dynamic_pointee_type->SetCompilerType(getASTContext(),
3731 pointee_qual_type);
3732 return true;
3733 default:
3734 break;
3735 }
3736 break;
3737
3738 case clang::Type::Record:
3739 if (check_cplusplus) {
3740 clang::CXXRecordDecl *cxx_record_decl =
3741 pointee_qual_type->getAsCXXRecordDecl();
3742 if (cxx_record_decl) {
3743 bool is_complete = cxx_record_decl->isCompleteDefinition();
3744
3745 if (is_complete)
3746 success = cxx_record_decl->isDynamicClass();
3747 else {
3748 ClangASTMetadata *metadata = ClangASTContext::GetMetadata(
3749 getASTContext(), cxx_record_decl);
3750 if (metadata)
3751 success = metadata->GetIsDynamicCXXType();
3752 else {
3753 is_complete = CompilerType(getASTContext(), pointee_qual_type)
3754 .GetCompleteType();
3755 if (is_complete)
3756 success = cxx_record_decl->isDynamicClass();
3757 else
3758 success = false;
3759 }
3760 }
3761
3762 if (success) {
3763 if (dynamic_pointee_type)
3764 dynamic_pointee_type->SetCompilerType(getASTContext(),
3765 pointee_qual_type);
3766 return true;
3767 }
3768 }
3769 }
3770 break;
3771
3772 case clang::Type::ObjCObject:
3773 case clang::Type::ObjCInterface:
3774 if (check_objc) {
3775 if (dynamic_pointee_type)
3776 dynamic_pointee_type->SetCompilerType(getASTContext(),
3777 pointee_qual_type);
3778 return true;
3779 }
3780 break;
3781
3782 default:
3783 break;
3784 }
3785 }
3786 }
3787 if (dynamic_pointee_type)
3788 dynamic_pointee_type->Clear();
3789 return false;
3790}
3791
3792bool ClangASTContext::IsScalarType(lldb::opaque_compiler_type_t type) {
3793 if (!type)
3794 return false;
3795
3796 return (GetTypeInfo(type, nullptr) & eTypeIsScalar) != 0;
3797}
3798
3799bool ClangASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) {
3800 if (!type)
3801 return false;
3802 return GetQualType(type)->getTypeClass() == clang::Type::Typedef;
3803}
3804
3805bool ClangASTContext::IsVoidType(lldb::opaque_compiler_type_t type) {
3806 if (!type)
3807 return false;
3808 return GetCanonicalQualType(type)->isVoidType();
3809}
3810
3811bool ClangASTContext::SupportsLanguage(lldb::LanguageType language) {
3812 return ClangASTContextSupportsLanguage(language);
3813}
3814
3815bool ClangASTContext::GetCXXClassName(const CompilerType &type,
3816 std::string &class_name) {
3817 if (type) {
3818 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3819 if (!qual_type.isNull()) {
3820 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3821 if (cxx_record_decl) {
3822 class_name.assign(cxx_record_decl->getIdentifier()->getNameStart());
3823 return true;
3824 }
3825 }
3826 }
3827 class_name.clear();
3828 return false;
3829}
3830
3831bool ClangASTContext::IsCXXClassType(const CompilerType &type) {
3832 if (!type)
3833 return false;
3834
3835 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3836 if (!qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr)
3837 return true;
3838 return false;
3839}
3840
3841bool ClangASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) {
3842 if (!type)
3843 return false;
3844 clang::QualType qual_type(GetCanonicalQualType(type));
3845 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
3846 if (tag_type)
3847 return tag_type->isBeingDefined();
3848 return false;
3849}
3850
3851bool ClangASTContext::IsObjCObjectPointerType(const CompilerType &type,
3852 CompilerType *class_type_ptr) {
3853 if (!type)
3854 return false;
3855
3856 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3857
3858 if (!qual_type.isNull() && qual_type->isObjCObjectPointerType()) {
3859 if (class_type_ptr) {
3860 if (!qual_type->isObjCClassType() && !qual_type->isObjCIdType()) {
3861 const clang::ObjCObjectPointerType *obj_pointer_type =
3862 llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3863 if (obj_pointer_type == nullptr)
3864 class_type_ptr->Clear();
3865 else
3866 class_type_ptr->SetCompilerType(
3867 type.GetTypeSystem(),
3868 clang::QualType(obj_pointer_type->getInterfaceType(), 0)
3869 .getAsOpaquePtr());
3870 }
3871 }
3872 return true;
3873 }
3874 if (class_type_ptr)
3875 class_type_ptr->Clear();
3876 return false;
3877}
3878
3879bool ClangASTContext::GetObjCClassName(const CompilerType &type,
3880 std::string &class_name) {
3881 if (!type)
3882 return false;
3883
3884 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
3885
3886 const clang::ObjCObjectType *object_type =
3887 llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
3888 if (object_type) {
3889 const clang::ObjCInterfaceDecl *interface = object_type->getInterface();
3890 if (interface) {
3891 class_name = interface->getNameAsString();
3892 return true;
3893 }
3894 }
3895 return false;
3896}
3897
3898//----------------------------------------------------------------------
3899// Type Completion
3900//----------------------------------------------------------------------
3901
3902bool ClangASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) {
3903 if (!type)
3904 return false;
3905 const bool allow_completion = true;
3906 return GetCompleteQualType(getASTContext(), GetQualType(type),
3907 allow_completion);
3908}
3909
3910ConstString ClangASTContext::GetTypeName(lldb::opaque_compiler_type_t type) {
3911 std::string type_name;
3912 if (type) {
3913 clang::PrintingPolicy printing_policy(getASTContext()->getPrintingPolicy());
3914 clang::QualType qual_type(GetQualType(type));
3915 printing_policy.SuppressTagKeyword = true;
3916 const clang::TypedefType *typedef_type =
3917 qual_type->getAs<clang::TypedefType>();
3918 if (typedef_type) {
3919 const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
3920 type_name = typedef_decl->getQualifiedNameAsString();
3921 } else {
3922 type_name = qual_type.getAsString(printing_policy);
3923 }
3924 }
3925 return ConstString(type_name);
3926}
3927
3928uint32_t
3929ClangASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
3930 CompilerType *pointee_or_element_clang_type) {
3931 if (!type)
3932 return 0;
3933
3934 if (pointee_or_element_clang_type)
3935 pointee_or_element_clang_type->Clear();
3936
3937 clang::QualType qual_type(GetQualType(type));
3938
3939 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3940 switch (type_class) {
3941 case clang::Type::Builtin: {
3942 const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(
3943 qual_type->getCanonicalTypeInternal());
3944
3945 uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
3946 switch (builtin_type->getKind()) {
3947 case clang::BuiltinType::ObjCId:
3948 case clang::BuiltinType::ObjCClass:
3949 if (pointee_or_element_clang_type)
3950 pointee_or_element_clang_type->SetCompilerType(
3951 getASTContext(), getASTContext()->ObjCBuiltinClassTy);
3952 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3953 break;
3954
3955 case clang::BuiltinType::ObjCSel:
3956 if (pointee_or_element_clang_type)
3957 pointee_or_element_clang_type->SetCompilerType(getASTContext(),
3958 getASTContext()->CharTy);
3959 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3960 break;
3961
3962 case clang::BuiltinType::Bool:
3963 case clang::BuiltinType::Char_U:
3964 case clang::BuiltinType::UChar:
3965 case clang::BuiltinType::WChar_U:
3966 case clang::BuiltinType::Char16:
3967 case clang::BuiltinType::Char32:
3968 case clang::BuiltinType::UShort:
3969 case clang::BuiltinType::UInt:
3970 case clang::BuiltinType::ULong:
3971 case clang::BuiltinType::ULongLong:
3972 case clang::BuiltinType::UInt128:
3973 case clang::BuiltinType::Char_S:
3974 case clang::BuiltinType::SChar:
3975 case clang::BuiltinType::WChar_S:
3976 case clang::BuiltinType::Short:
3977 case clang::BuiltinType::Int:
3978 case clang::BuiltinType::Long:
3979 case clang::BuiltinType::LongLong:
3980 case clang::BuiltinType::Int128:
3981 case clang::BuiltinType::Float:
3982 case clang::BuiltinType::Double:
3983 case clang::BuiltinType::LongDouble:
3984 builtin_type_flags |= eTypeIsScalar;
3985 if (builtin_type->isInteger()) {
3986 builtin_type_flags |= eTypeIsInteger;
3987 if (builtin_type->isSignedInteger())
3988 builtin_type_flags |= eTypeIsSigned;
3989 } else if (builtin_type->isFloatingPoint())
3990 builtin_type_flags |= eTypeIsFloat;
3991 break;
3992 default:
3993 break;
3994 }
3995 return builtin_type_flags;
3996 }
3997
3998 case clang::Type::BlockPointer:
3999 if (pointee_or_element_clang_type)
4000 pointee_or_element_clang_type->SetCompilerType(
4001 getASTContext(), qual_type->getPointeeType());
4002 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
4003
4004 case clang::Type::Complex: {
4005 uint32_t complex_type_flags =
4006 eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
4007 const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(
4008 qual_type->getCanonicalTypeInternal());
4009 if (complex_type) {
4010 clang::QualType complex_element_type(complex_type->getElementType());
4011 if (complex_element_type->isIntegerType())
4012 complex_type_flags |= eTypeIsFloat;
4013 else if (complex_element_type->isFloatingType())
4014 complex_type_flags |= eTypeIsInteger;
4015 }
4016 return complex_type_flags;
4017 } break;
4018
4019 case clang::Type::ConstantArray:
4020 case clang::Type::DependentSizedArray:
4021 case clang::Type::IncompleteArray:
4022 case clang::Type::VariableArray:
4023 if (pointee_or_element_clang_type)
4024 pointee_or_element_clang_type->SetCompilerType(
4025 getASTContext(), llvm::cast<clang::ArrayType>(qual_type.getTypePtr())
4026 ->getElementType());
4027 return eTypeHasChildren | eTypeIsArray;
4028
4029 case clang::Type::DependentName:
4030 return 0;
4031 case clang::Type::DependentSizedExtVector:
4032 return eTypeHasChildren | eTypeIsVector;
4033 case clang::Type::DependentTemplateSpecialization:
4034 return eTypeIsTemplate;
4035 case clang::Type::Decltype:
4036 return 0;
4037
4038 case clang::Type::Enum:
4039 if (pointee_or_element_clang_type)
4040 pointee_or_element_clang_type->SetCompilerType(
4041 getASTContext(),
4042 llvm::cast<clang::EnumType>(qual_type)->getDecl()->getIntegerType());
4043 return eTypeIsEnumeration | eTypeHasValue;
4044
4045 case clang::Type::Auto:
4046 return CompilerType(
4047 getASTContext(),
4048 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
4049 .GetTypeInfo(pointee_or_element_clang_type);
4050 case clang::Type::Elaborated:
4051 return CompilerType(
4052 getASTContext(),
4053 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
4054 .GetTypeInfo(pointee_or_element_clang_type);
4055 case clang::Type::Paren:
4056 return CompilerType(getASTContext(),
4057 llvm::cast<clang::ParenType>(qual_type)->desugar())
4058 .GetTypeInfo(pointee_or_element_clang_type);
4059
4060 case clang::Type::FunctionProto:
4061 return eTypeIsFuncPrototype | eTypeHasValue;
4062 case clang::Type::FunctionNoProto:
4063 return eTypeIsFuncPrototype | eTypeHasValue;
4064 case clang::Type::InjectedClassName:
4065 return 0;
4066
4067 case clang::Type::LValueReference:
4068 case clang::Type::RValueReference:
4069 if (pointee_or_element_clang_type)
4070 pointee_or_element_clang_type->SetCompilerType(
4071 getASTContext(),
4072 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())
4073 ->getPointeeType());
4074 return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
4075
4076 case clang::Type::MemberPointer:
4077 return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
4078
4079 case clang::Type::ObjCObjectPointer:
4080 if (pointee_or_element_clang_type)
4081 pointee_or_element_clang_type->SetCompilerType(
4082 getASTContext(), qual_type->getPointeeType());
4083 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer |
4084 eTypeHasValue;
4085
4086 case clang::Type::ObjCObject:
4087 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
4088 case clang::Type::ObjCInterface:
4089 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
4090
4091 case clang::Type::Pointer:
4092 if (pointee_or_element_clang_type)
4093 pointee_or_element_clang_type->SetCompilerType(
4094 getASTContext(), qual_type->getPointeeType());
4095 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
4096
4097 case clang::Type::Record:
4098 if (qual_type->getAsCXXRecordDecl())
4099 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
4100 else
4101 return eTypeHasChildren | eTypeIsStructUnion;
4102 break;
4103 case clang::Type::SubstTemplateTypeParm:
4104 return eTypeIsTemplate;
4105 case clang::Type::TemplateTypeParm:
4106 return eTypeIsTemplate;
4107 case clang::Type::TemplateSpecialization:
4108 return eTypeIsTemplate;
4109
4110 case clang::Type::Typedef:
4111 return eTypeIsTypedef |
4112 CompilerType(getASTContext(),
4113 llvm::cast<clang::TypedefType>(qual_type)
4114 ->getDecl()
4115 ->getUnderlyingType())
4116 .GetTypeInfo(pointee_or_element_clang_type);
4117 case clang::Type::TypeOfExpr:
4118 return 0;
4119 case clang::Type::TypeOf:
4120 return 0;
4121 case clang::Type::UnresolvedUsing:
4122 return 0;
4123
4124 case clang::Type::ExtVector:
4125 case clang::Type::Vector: {
4126 uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
4127 const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(
4128 qual_type->getCanonicalTypeInternal());
4129 if (vector_type) {
4130 if (vector_type->isIntegerType())
4131 vector_type_flags |= eTypeIsFloat;
4132 else if (vector_type->isFloatingType())
4133 vector_type_flags |= eTypeIsInteger;
4134 }
4135 return vector_type_flags;
4136 }
4137 default:
4138 return 0;
4139 }
4140 return 0;
4141}
4142
4143lldb::LanguageType
4144ClangASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) {
4145 if (!type)
4146 return lldb::eLanguageTypeC;
4147
4148 // If the type is a reference, then resolve it to what it refers to first:
4149 clang::QualType qual_type(GetCanonicalQualType(type).getNonReferenceType());
4150 if (qual_type->isAnyPointerType()) {
4151 if (qual_type->isObjCObjectPointerType())
4152 return lldb::eLanguageTypeObjC;
4153
4154 clang::QualType pointee_type(qual_type->getPointeeType());
4155 if (pointee_type->getPointeeCXXRecordDecl() != nullptr)
4156 return lldb::eLanguageTypeC_plus_plus;
4157 if (pointee_type->isObjCObjectOrInterfaceType())
4158 return lldb::eLanguageTypeObjC;
4159 if (pointee_type->isObjCClassType())
4160 return lldb::eLanguageTypeObjC;
4161 if (pointee_type.getTypePtr() ==
4162 getASTContext()->ObjCBuiltinIdTy.getTypePtr())
4163 return lldb::eLanguageTypeObjC;
4164 } else {
4165 if (qual_type->isObjCObjectOrInterfaceType())
4166 return lldb::eLanguageTypeObjC;
4167 if (qual_type->getAsCXXRecordDecl())
4168 return lldb::eLanguageTypeC_plus_plus;
4169 switch (qual_type->getTypeClass()) {
4170 default:
4171 break;
4172 case clang::Type::Builtin:
4173 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4174 default:
4175 case clang::BuiltinType::Void:
4176 case clang::BuiltinType::Bool:
4177 case clang::BuiltinType::Char_U:
4178 case clang::BuiltinType::UChar:
4179 case clang::BuiltinType::WChar_U:
4180 case clang::BuiltinType::Char16:
4181 case clang::BuiltinType::Char32:
4182 case clang::BuiltinType::UShort:
4183 case clang::BuiltinType::UInt:
4184 case clang::BuiltinType::ULong:
4185 case clang::BuiltinType::ULongLong:
4186 case clang::BuiltinType::UInt128:
4187 case clang::BuiltinType::Char_S:
4188 case clang::BuiltinType::SChar:
4189 case clang::BuiltinType::WChar_S:
4190 case clang::BuiltinType::Short:
4191 case clang::BuiltinType::Int:
4192 case clang::BuiltinType::Long:
4193 case clang::BuiltinType::LongLong:
4194 case clang::BuiltinType::Int128:
4195 case clang::BuiltinType::Float:
4196 case clang::BuiltinType::Double:
4197 case clang::BuiltinType::LongDouble:
4198 break;
4199
4200 case clang::BuiltinType::NullPtr:
4201 return eLanguageTypeC_plus_plus;
4202
4203 case clang::BuiltinType::ObjCId:
4204 case clang::BuiltinType::ObjCClass:
4205 case clang::BuiltinType::ObjCSel:
4206 return eLanguageTypeObjC;
4207
4208 case clang::BuiltinType::Dependent:
4209 case clang::BuiltinType::Overload:
4210 case clang::BuiltinType::BoundMember:
4211 case clang::BuiltinType::UnknownAny:
4212 break;
4213 }
4214 break;
4215 case clang::Type::Typedef:
4216 return CompilerType(getASTContext(),
4217 llvm::cast<clang::TypedefType>(qual_type)
4218 ->getDecl()
4219 ->getUnderlyingType())
4220 .GetMinimumLanguage();
4221 }
4222 }
4223 return lldb::eLanguageTypeC;
4224}
4225
4226lldb::TypeClass
4227ClangASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
4228 if (!type)
4229 return lldb::eTypeClassInvalid;
4230
4231 clang::QualType qual_type(GetQualType(type));
4232
4233 switch (qual_type->getTypeClass()) {
4234 case clang::Type::UnaryTransform:
4235 break;
4236 case clang::Type::FunctionNoProto:
4237 return lldb::eTypeClassFunction;
4238 case clang::Type::FunctionProto:
4239 return lldb::eTypeClassFunction;
4240 case clang::Type::IncompleteArray:
4241 return lldb::eTypeClassArray;
4242 case clang::Type::VariableArray:
4243 return lldb::eTypeClassArray;
4244 case clang::Type::ConstantArray:
4245 return lldb::eTypeClassArray;
4246 case clang::Type::DependentSizedArray:
4247 return lldb::eTypeClassArray;
4248 case clang::Type::DependentSizedExtVector:
4249 return lldb::eTypeClassVector;
4250 case clang::Type::ExtVector:
4251 return lldb::eTypeClassVector;
4252 case clang::Type::Vector:
4253 return lldb::eTypeClassVector;
4254 case clang::Type::Builtin:
4255 return lldb::eTypeClassBuiltin;
4256 case clang::Type::ObjCObjectPointer:
4257 return lldb::eTypeClassObjCObjectPointer;
4258 case clang::Type::BlockPointer:
4259 return lldb::eTypeClassBlockPointer;
4260 case clang::Type::Pointer:
4261 return lldb::eTypeClassPointer;
4262 case clang::Type::LValueReference:
4263 return lldb::eTypeClassReference;
4264 case clang::Type::RValueReference:
4265 return lldb::eTypeClassReference;
4266 case clang::Type::MemberPointer:
4267 return lldb::eTypeClassMemberPointer;
4268 case clang::Type::Complex:
4269 if (qual_type->isComplexType())
4270 return lldb::eTypeClassComplexFloat;
4271 else
4272 return lldb::eTypeClassComplexInteger;
4273 case clang::Type::ObjCObject:
4274 return lldb::eTypeClassObjCObject;
4275 case clang::Type::ObjCInterface:
4276 return lldb::eTypeClassObjCInterface;
4277 case clang::Type::Record: {
4278 const clang::RecordType *record_type =
4279 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4280 const clang::RecordDecl *record_decl = record_type->getDecl();
4281 if (record_decl->isUnion())
4282 return lldb::eTypeClassUnion;
4283 else if (record_decl->isStruct())
4284 return lldb::eTypeClassStruct;
4285 else
4286 return lldb::eTypeClassClass;
4287 } break;
4288 case clang::Type::Enum:
4289 return lldb::eTypeClassEnumeration;
4290 case clang::Type::Typedef:
4291 return lldb::eTypeClassTypedef;
4292 case clang::Type::UnresolvedUsing:
4293 break;
4294 case clang::Type::Paren:
4295 return CompilerType(getASTContext(),
4296 llvm::cast<clang::ParenType>(qual_type)->desugar())
4297 .GetTypeClass();
4298 case clang::Type::Auto:
4299 return CompilerType(
4300 getASTContext(),
4301 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
4302 .GetTypeClass();
4303 case clang::Type::Elaborated:
4304 return CompilerType(
4305 getASTContext(),
4306 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
4307 .GetTypeClass();
4308
4309 case clang::Type::Attributed:
4310 break;
4311 case clang::Type::TemplateTypeParm:
4312 break;
4313 case clang::Type::SubstTemplateTypeParm:
4314 break;
4315 case clang::Type::SubstTemplateTypeParmPack:
4316 break;
4317 case clang::Type::InjectedClassName:
4318 break;
4319 case clang::Type::DependentName:
4320 break;
4321 case clang::Type::DependentTemplateSpecialization:
4322 break;
4323 case clang::Type::PackExpansion:
4324 break;
4325
4326 case clang::Type::TypeOfExpr:
4327 break;
4328 case clang::Type::TypeOf:
4329 break;
4330 case clang::Type::Decltype:
4331 break;
4332 case clang::Type::TemplateSpecialization:
4333 break;
4334 case clang::Type::DeducedTemplateSpecialization:
4335 break;
4336 case clang::Type::Atomic:
4337 break;
4338 case clang::Type::Pipe:
4339 break;
4340
4341 // pointer type decayed from an array or function type.
4342 case clang::Type::Decayed:
4343 break;
4344 case clang::Type::Adjusted:
4345 break;
4346 case clang::Type::ObjCTypeParam:
4347 break;
4348 }
4349 // We don't know hot to display this type...
4350 return lldb::eTypeClassOther;
4351}
4352
4353unsigned ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
4354 if (type)
4355 return GetQualType(type).getQualifiers().getCVRQualifiers();
4356 return 0;
4357}
4358
4359//----------------------------------------------------------------------
4360// Creating related types
4361//----------------------------------------------------------------------
4362
4363CompilerType
4364ClangASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type,
4365 uint64_t *stride) {
4366 if (type) {
4367 clang::QualType qual_type(GetCanonicalQualType(type));
4368
4369 const clang::Type *array_eletype =
4370 qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
4371
4372 if (!array_eletype)
4373 return CompilerType();
4374
4375 CompilerType element_type(getASTContext(),
4376 array_eletype->getCanonicalTypeUnqualified());
4377
4378 // TODO: the real stride will be >= this value.. find the real one!
4379 if (stride)
4380 *stride = element_type.GetByteSize(nullptr);
4381
4382 return element_type;
4383 }
4384 return CompilerType();
4385}
4386
4387CompilerType ClangASTContext::GetArrayType(lldb::opaque_compiler_type_t type,
4388 uint64_t size) {
4389 if (type) {
4390 clang::QualType qual_type(GetCanonicalQualType(type));
4391 if (clang::ASTContext *ast_ctx = getASTContext()) {
4392 if (size != 0)
4393 return CompilerType(
4394 ast_ctx, ast_ctx->getConstantArrayType(
4395 qual_type, llvm::APInt(64, size),
4396 clang::ArrayType::ArraySizeModifier::Normal, 0));
4397 else
4398 return CompilerType(
4399 ast_ctx,
4400 ast_ctx->getIncompleteArrayType(
4401 qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0));
4402 }
4403 }
4404
4405 return CompilerType();
4406}
4407
4408CompilerType
4409ClangASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) {
4410 if (type)
4411 return CompilerType(getASTContext(), GetCanonicalQualType(type));
4412 return CompilerType();
4413}
4414
4415static clang::QualType GetFullyUnqualifiedType_Impl(clang::ASTContext *ast,
4416 clang::QualType qual_type) {
4417 if (qual_type->isPointerType())
4418 qual_type = ast->getPointerType(
4419 GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
4420 else
4421 qual_type = qual_type.getUnqualifiedType();
4422 qual_type.removeLocalConst();
4423 qual_type.removeLocalRestrict();
4424 qual_type.removeLocalVolatile();
4425 return qual_type;
4426}
4427
4428CompilerType
4429ClangASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) {
4430 if (type)
4431 return CompilerType(
4432 getASTContext(),
4433 GetFullyUnqualifiedType_Impl(getASTContext(), GetQualType(type)));
4434 return CompilerType();
4435}
4436
4437int ClangASTContext::GetFunctionArgumentCount(
4438 lldb::opaque_compiler_type_t type) {
4439 if (type) {
4440 const clang::FunctionProtoType *func =
4441 llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type));
4442 if (func)
4443 return func->getNumParams();
4444 }
4445 return -1;
4446}
4447
4448CompilerType ClangASTContext::GetFunctionArgumentTypeAtIndex(
4449 lldb::opaque_compiler_type_t type, size_t idx) {
4450 if (type) {
4451 const clang::FunctionProtoType *func =
4452 llvm::dyn_cast<clang::FunctionProtoType>(GetQualType(type));
4453 if (func) {
4454 const uint32_t num_args = func->getNumParams();
4455 if (idx < num_args)
4456 return CompilerType(getASTContext(), func->getParamType(idx));
4457 }
4458 }
4459 return CompilerType();
4460}
4461
4462CompilerType
4463ClangASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) {
4464 if (type) {
4465 clang::QualType qual_type(GetQualType(type));
4466 const clang::FunctionProtoType *func =
4467 llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
4468 if (func)
4469 return CompilerType(getASTContext(), func->getReturnType());
4470 }
4471 return CompilerType();
4472}
4473
4474size_t
4475ClangASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
4476 size_t num_functions = 0;
4477 if (type) {
4478 clang::QualType qual_type(GetCanonicalQualType(type));
4479 switch (qual_type->getTypeClass()) {
4480 case clang::Type::Record:
4481 if (GetCompleteQualType(getASTContext(), qual_type)) {
4482 const clang::RecordType *record_type =
4483 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4484 const clang::RecordDecl *record_decl = record_type->getDecl();
4485 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 4485, __PRETTY_FUNCTION__))
;
4486 const clang::CXXRecordDecl *cxx_record_decl =
4487 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4488 if (cxx_record_decl)
4489 num_functions = std::distance(cxx_record_decl->method_begin(),
4490 cxx_record_decl->method_end());
4491 }
4492 break;
4493
4494 case clang::Type::ObjCObjectPointer: {
4495 const clang::ObjCObjectPointerType *objc_class_type =
4496 qual_type->getAs<clang::ObjCObjectPointerType>();
4497 const clang::ObjCInterfaceType *objc_interface_type =
4498 objc_class_type->getInterfaceType();
4499 if (objc_interface_type &&
4500 GetCompleteType(static_cast<lldb::opaque_compiler_type_t>(
4501 const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
4502 clang::ObjCInterfaceDecl *class_interface_decl =
4503 objc_interface_type->getDecl();
4504 if (class_interface_decl) {
4505 num_functions = std::distance(class_interface_decl->meth_begin(),
4506 class_interface_decl->meth_end());
4507 }
4508 }
4509 break;
4510 }
4511
4512 case clang::Type::ObjCObject:
4513 case clang::Type::ObjCInterface:
4514 if (GetCompleteType(type)) {
4515 const clang::ObjCObjectType *objc_class_type =
4516 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4517 if (objc_class_type) {
4518 clang::ObjCInterfaceDecl *class_interface_decl =
4519 objc_class_type->getInterface();
4520 if (class_interface_decl)
4521 num_functions = std::distance(class_interface_decl->meth_begin(),
4522 class_interface_decl->meth_end());
4523 }
4524 }
4525 break;
4526
4527 case clang::Type::Typedef:
4528 return CompilerType(getASTContext(),
4529 llvm::cast<clang::TypedefType>(qual_type)
4530 ->getDecl()
4531 ->getUnderlyingType())
4532 .GetNumMemberFunctions();
4533
4534 case clang::Type::Auto:
4535 return CompilerType(
4536 getASTContext(),
4537 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
4538 .GetNumMemberFunctions();
4539
4540 case clang::Type::Elaborated:
4541 return CompilerType(
4542 getASTContext(),
4543 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
4544 .GetNumMemberFunctions();
4545
4546 case clang::Type::Paren:
4547 return CompilerType(getASTContext(),
4548 llvm::cast<clang::ParenType>(qual_type)->desugar())
4549 .GetNumMemberFunctions();
4550
4551 default:
4552 break;
4553 }
4554 }
4555 return num_functions;
4556}
4557
4558TypeMemberFunctionImpl
4559ClangASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
4560 size_t idx) {
4561 std::string name;
4562 MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown);
4563 CompilerType clang_type;
4564 CompilerDecl clang_decl;
4565 if (type) {
4566 clang::QualType qual_type(GetCanonicalQualType(type));
4567 switch (qual_type->getTypeClass()) {
4568 case clang::Type::Record:
4569 if (GetCompleteQualType(getASTContext(), qual_type)) {
4570 const clang::RecordType *record_type =
4571 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4572 const clang::RecordDecl *record_decl = record_type->getDecl();
4573 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 4573, __PRETTY_FUNCTION__))
;
4574 const clang::CXXRecordDecl *cxx_record_decl =
4575 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4576 if (cxx_record_decl) {
4577 auto method_iter = cxx_record_decl->method_begin();
4578 auto method_end = cxx_record_decl->method_end();
4579 if (idx <
4580 static_cast<size_t>(std::distance(method_iter, method_end))) {
4581 std::advance(method_iter, idx);
4582 clang::CXXMethodDecl *cxx_method_decl =
4583 method_iter->getCanonicalDecl();
4584 if (cxx_method_decl) {
4585 name = cxx_method_decl->getDeclName().getAsString();
4586 if (cxx_method_decl->isStatic())
4587 kind = lldb::eMemberFunctionKindStaticMethod;
4588 else if (llvm::isa<clang::CXXConstructorDecl>(cxx_method_decl))
4589 kind = lldb::eMemberFunctionKindConstructor;
4590 else if (llvm::isa<clang::CXXDestructorDecl>(cxx_method_decl))
4591 kind = lldb::eMemberFunctionKindDestructor;
4592 else
4593 kind = lldb::eMemberFunctionKindInstanceMethod;
4594 clang_type = CompilerType(
4595 this, cxx_method_decl->getType().getAsOpaquePtr());
4596 clang_decl = CompilerDecl(this, cxx_method_decl);
4597 }
4598 }
4599 }
4600 }
4601 break;
4602
4603 case clang::Type::ObjCObjectPointer: {
4604 const clang::ObjCObjectPointerType *objc_class_type =
4605 qual_type->getAs<clang::ObjCObjectPointerType>();
4606 const clang::ObjCInterfaceType *objc_interface_type =
4607 objc_class_type->getInterfaceType();
4608 if (objc_interface_type &&
4609 GetCompleteType(static_cast<lldb::opaque_compiler_type_t>(
4610 const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
4611 clang::ObjCInterfaceDecl *class_interface_decl =
4612 objc_interface_type->getDecl();
4613 if (class_interface_decl) {
4614 auto method_iter = class_interface_decl->meth_begin();
4615 auto method_end = class_interface_decl->meth_end();
4616 if (idx <
4617 static_cast<size_t>(std::distance(method_iter, method_end))) {
4618 std::advance(method_iter, idx);
4619 clang::ObjCMethodDecl *objc_method_decl =
4620 method_iter->getCanonicalDecl();
4621 if (objc_method_decl) {
4622 clang_decl = CompilerDecl(this, objc_method_decl);
4623 name = objc_method_decl->getSelector().getAsString();
4624 if (objc_method_decl->isClassMethod())
4625 kind = lldb::eMemberFunctionKindStaticMethod;
4626 else
4627 kind = lldb::eMemberFunctionKindInstanceMethod;
4628 }
4629 }
4630 }
4631 }
4632 break;
4633 }
4634
4635 case clang::Type::ObjCObject:
4636 case clang::Type::ObjCInterface:
4637 if (GetCompleteType(type)) {
4638 const clang::ObjCObjectType *objc_class_type =
4639 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4640 if (objc_class_type) {
4641 clang::ObjCInterfaceDecl *class_interface_decl =
4642 objc_class_type->getInterface();
4643 if (class_interface_decl) {
4644 auto method_iter = class_interface_decl->meth_begin();
4645 auto method_end = class_interface_decl->meth_end();
4646 if (idx <
4647 static_cast<size_t>(std::distance(method_iter, method_end))) {
4648 std::advance(method_iter, idx);
4649 clang::ObjCMethodDecl *objc_method_decl =
4650 method_iter->getCanonicalDecl();
4651 if (objc_method_decl) {
4652 clang_decl = CompilerDecl(this, objc_method_decl);
4653 name = objc_method_decl->getSelector().getAsString();
4654 if (objc_method_decl->isClassMethod())
4655 kind = lldb::eMemberFunctionKindStaticMethod;
4656 else
4657 kind = lldb::eMemberFunctionKindInstanceMethod;
4658 }
4659 }
4660 }
4661 }
4662 }
4663 break;
4664
4665 case clang::Type::Typedef:
4666 return GetMemberFunctionAtIndex(llvm::cast<clang::TypedefType>(qual_type)
4667 ->getDecl()
4668 ->getUnderlyingType()
4669 .getAsOpaquePtr(),
4670 idx);
4671
4672 case clang::Type::Auto:
4673 return GetMemberFunctionAtIndex(llvm::cast<clang::AutoType>(qual_type)
4674 ->getDeducedType()
4675 .getAsOpaquePtr(),
4676 idx);
4677
4678 case clang::Type::Elaborated:
4679 return GetMemberFunctionAtIndex(
4680 llvm::cast<clang::ElaboratedType>(qual_type)
4681 ->getNamedType()
4682 .getAsOpaquePtr(),
4683 idx);
4684
4685 case clang::Type::Paren:
4686 return GetMemberFunctionAtIndex(
4687 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
4688 idx);
4689
4690 default:
4691 break;
4692 }
4693 }
4694
4695 if (kind == eMemberFunctionKindUnknown)
4696 return TypeMemberFunctionImpl();
4697 else
4698 return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind);
4699}
4700
4701CompilerType
4702ClangASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) {
4703 if (type)
4704 return CompilerType(getASTContext(),
4705 GetQualType(type).getNonReferenceType());
4706 return CompilerType();
4707}
4708
4709CompilerType ClangASTContext::CreateTypedefType(
4710 const CompilerType &type, const char *typedef_name,
4711 const CompilerDeclContext &compiler_decl_ctx) {
4712 if (type && typedef_name && typedef_name[0]) {
4713 ClangASTContext *ast =
4714 llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
4715 if (!ast)
4716 return CompilerType();
4717 clang::ASTContext *clang_ast = ast->getASTContext();
4718 clang::QualType qual_type(ClangUtil::GetQualType(type));
4719
4720 clang::DeclContext *decl_ctx =
4721 ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx);
4722 if (decl_ctx == nullptr)
4723 decl_ctx = ast->getASTContext()->getTranslationUnitDecl();
4724
4725 clang::TypedefDecl *decl = clang::TypedefDecl::Create(
4726 *clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(),
4727 &clang_ast->Idents.get(typedef_name),
4728 clang_ast->getTrivialTypeSourceInfo(qual_type));
4729
4730 decl->setAccess(clang::AS_public); // TODO respect proper access specifier
4731
4732 // Get a uniqued clang::QualType for the typedef decl type
4733 return CompilerType(clang_ast, clang_ast->getTypedefType(decl));
4734 }
4735 return CompilerType();
4736}
4737
4738CompilerType
4739ClangASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) {
4740 if (type) {
4741 clang::QualType qual_type(GetQualType(type));
4742 return CompilerType(getASTContext(),
4743 qual_type.getTypePtr()->getPointeeType());
4744 }
4745 return CompilerType();
4746}
4747
4748CompilerType
4749ClangASTContext::GetPointerType(lldb::opaque_compiler_type_t type) {
4750 if (type) {
4751 clang::QualType qual_type(GetQualType(type));
4752
4753 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4754 switch (type_class) {
4755 case clang::Type::ObjCObject:
4756 case clang::Type::ObjCInterface:
4757 return CompilerType(getASTContext(),
4758 getASTContext()->getObjCObjectPointerType(qual_type));
4759
4760 default:
4761 return CompilerType(getASTContext(),
4762 getASTContext()->getPointerType(qual_type));
4763 }
4764 }
4765 return CompilerType();
4766}
4767
4768CompilerType
4769ClangASTContext::GetLValueReferenceType(lldb::opaque_compiler_type_t type) {
4770 if (type)
4771 return CompilerType(this, getASTContext()
4772 ->getLValueReferenceType(GetQualType(type))
4773 .getAsOpaquePtr());
4774 else
4775 return CompilerType();
4776}
4777
4778CompilerType
4779ClangASTContext::GetRValueReferenceType(lldb::opaque_compiler_type_t type) {
4780 if (type)
4781 return CompilerType(this, getASTContext()
4782 ->getRValueReferenceType(GetQualType(type))
4783 .getAsOpaquePtr());
4784 else
4785 return CompilerType();
4786}
4787
4788CompilerType
4789ClangASTContext::AddConstModifier(lldb::opaque_compiler_type_t type) {
4790 if (type) {
4791 clang::QualType result(GetQualType(type));
4792 result.addConst();
4793 return CompilerType(this, result.getAsOpaquePtr());
4794 }
4795 return CompilerType();
4796}
4797
4798CompilerType
4799ClangASTContext::AddVolatileModifier(lldb::opaque_compiler_type_t type) {
4800 if (type) {
4801 clang::QualType result(GetQualType(type));
4802 result.addVolatile();
4803 return CompilerType(this, result.getAsOpaquePtr());
4804 }
4805 return CompilerType();
4806}
4807
4808CompilerType
4809ClangASTContext::AddRestrictModifier(lldb::opaque_compiler_type_t type) {
4810 if (type) {
4811 clang::QualType result(GetQualType(type));
4812 result.addRestrict();
4813 return CompilerType(this, result.getAsOpaquePtr());
4814 }
4815 return CompilerType();
4816}
4817
4818CompilerType
4819ClangASTContext::CreateTypedef(lldb::opaque_compiler_type_t type,
4820 const char *typedef_name,
4821 const CompilerDeclContext &compiler_decl_ctx) {
4822 if (type) {
4823 clang::ASTContext *clang_ast = getASTContext();
4824 clang::QualType qual_type(GetQualType(type));
4825
4826 clang::DeclContext *decl_ctx =
4827 ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx);
4828 if (decl_ctx == nullptr)
4829 decl_ctx = getASTContext()->getTranslationUnitDecl();
4830
4831 clang::TypedefDecl *decl = clang::TypedefDecl::Create(
4832 *clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(),
4833 &clang_ast->Idents.get(typedef_name),
4834 clang_ast->getTrivialTypeSourceInfo(qual_type));
4835
4836 clang::TagDecl *tdecl = nullptr;
4837 if (!qual_type.isNull()) {
4838 if (const clang::RecordType *rt = qual_type->getAs<clang::RecordType>())
4839 tdecl = rt->getDecl();
4840 if (const clang::EnumType *et = qual_type->getAs<clang::EnumType>())
4841 tdecl = et->getDecl();
4842 }
4843
4844 // Check whether this declaration is an anonymous struct, union, or enum,
4845 // hidden behind a typedef. If so, we
4846 // try to check whether we have a typedef tag to attach to the original
4847 // record declaration
4848 if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl())
4849 tdecl->setTypedefNameForAnonDecl(decl);
4850
4851 decl->setAccess(clang::AS_public); // TODO respect proper access specifier
4852
4853 // Get a uniqued clang::QualType for the typedef decl type
4854 return CompilerType(this, clang_ast->getTypedefType(decl).getAsOpaquePtr());
4855 }
4856 return CompilerType();
4857}
4858
4859CompilerType
4860ClangASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) {
4861 if (type) {
4862 const clang::TypedefType *typedef_type =
4863 llvm::dyn_cast<clang::TypedefType>(GetQualType(type));
4864 if (typedef_type)
4865 return CompilerType(getASTContext(),
4866 typedef_type->getDecl()->getUnderlyingType());
4867 }
4868 return CompilerType();
4869}
4870
4871//----------------------------------------------------------------------
4872// Create related types using the current type's AST
4873//----------------------------------------------------------------------
4874
4875CompilerType ClangASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) {
4876 return ClangASTContext::GetBasicType(getASTContext(), basic_type);
4877}
4878//----------------------------------------------------------------------
4879// Exploring the type
4880//----------------------------------------------------------------------
4881
4882uint64_t ClangASTContext::GetBitSize(lldb::opaque_compiler_type_t type,
4883 ExecutionContextScope *exe_scope) {
4884 if (GetCompleteType(type)) {
4885 clang::QualType qual_type(GetCanonicalQualType(type));
4886 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4887 switch (type_class) {
4888 case clang::Type::Record:
4889 if (GetCompleteType(type))
4890 return getASTContext()->getTypeSize(qual_type);
4891 else
4892 return 0;
4893 break;
4894
4895 case clang::Type::ObjCInterface:
4896 case clang::Type::ObjCObject: {
4897 ExecutionContext exe_ctx(exe_scope);
4898 Process *process = exe_ctx.GetProcessPtr();
4899 if (process) {
4900 ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
4901 if (objc_runtime) {
4902 uint64_t bit_size = 0;
4903 if (objc_runtime->GetTypeBitSize(
4904 CompilerType(getASTContext(), qual_type), bit_size))
4905 return bit_size;
4906 }
4907 } else {
4908 static bool g_printed = false;
4909 if (!g_printed) {
4910 StreamString s;
4911 DumpTypeDescription(type, &s);
4912
4913 llvm::outs() << "warning: trying to determine the size of type ";
4914 llvm::outs() << s.GetString() << "\n";
4915 llvm::outs() << "without a valid ExecutionContext. this is not "
4916 "reliable. please file a bug against LLDB.\n";
4917 llvm::outs() << "backtrace:\n";
4918 llvm::sys::PrintStackTrace(llvm::outs());
4919 llvm::outs() << "\n";
4920 g_printed = true;
4921 }
4922 }
4923 }
4924 LLVM_FALLTHROUGH[[clang::fallthrough]];
4925 default:
4926 const uint32_t bit_size = getASTContext()->getTypeSize(qual_type);
4927 if (bit_size == 0) {
4928 if (qual_type->isIncompleteArrayType())
4929 return getASTContext()->getTypeSize(
4930 qual_type->getArrayElementTypeNoTypeQual()
4931 ->getCanonicalTypeUnqualified());
4932 }
4933 if (qual_type->isObjCObjectOrInterfaceType())
4934 return bit_size +
4935 getASTContext()->getTypeSize(
4936 getASTContext()->ObjCBuiltinClassTy);
4937 return bit_size;
4938 }
4939 }
4940 return 0;
4941}
4942
4943size_t ClangASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) {
4944 if (GetCompleteType(type))
4945 return getASTContext()->getTypeAlign(GetQualType(type));
4946 return 0;
4947}
4948
4949lldb::Encoding ClangASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
4950 uint64_t &count) {
4951 if (!type)
4952 return lldb::eEncodingInvalid;
4953
4954 count = 1;
4955 clang::QualType qual_type(GetCanonicalQualType(type));
4956
4957 switch (qual_type->getTypeClass()) {
4958 case clang::Type::UnaryTransform:
4959 break;
4960
4961 case clang::Type::FunctionNoProto:
4962 case clang::Type::FunctionProto:
4963 break;
4964
4965 case clang::Type::IncompleteArray:
4966 case clang::Type::VariableArray:
4967 break;
4968
4969 case clang::Type::ConstantArray:
4970 break;
4971
4972 case clang::Type::ExtVector:
4973 case clang::Type::Vector:
4974 // TODO: Set this to more than one???
4975 break;
4976
4977 case clang::Type::Builtin:
4978 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
4979 case clang::BuiltinType::Void:
4980 break;
4981
4982 case clang::BuiltinType::Bool:
4983 case clang::BuiltinType::Char_S:
4984 case clang::BuiltinType::SChar:
4985 case clang::BuiltinType::WChar_S:
4986 case clang::BuiltinType::Char16:
4987 case clang::BuiltinType::Char32:
4988 case clang::BuiltinType::Short:
4989 case clang::BuiltinType::Int:
4990 case clang::BuiltinType::Long:
4991 case clang::BuiltinType::LongLong:
4992 case clang::BuiltinType::Int128:
4993 return lldb::eEncodingSint;
4994
4995 case clang::BuiltinType::Char_U:
4996 case clang::BuiltinType::UChar:
4997 case clang::BuiltinType::WChar_U:
4998 case clang::BuiltinType::UShort:
4999 case clang::BuiltinType::UInt:
5000 case clang::BuiltinType::ULong:
5001 case clang::BuiltinType::ULongLong:
5002 case clang::BuiltinType::UInt128:
5003 return lldb::eEncodingUint;
5004
5005 case clang::BuiltinType::Half:
5006 case clang::BuiltinType::Float:
5007 case clang::BuiltinType::Float128:
5008 case clang::BuiltinType::Double:
5009 case clang::BuiltinType::LongDouble:
5010 return lldb::eEncodingIEEE754;
5011
5012 case clang::BuiltinType::ObjCClass:
5013 case clang::BuiltinType::ObjCId:
5014 case clang::BuiltinType::ObjCSel:
5015 return lldb::eEncodingUint;
5016
5017 case clang::BuiltinType::NullPtr:
5018 return lldb::eEncodingUint;
5019
5020 case clang::BuiltinType::Kind::ARCUnbridgedCast:
5021 case clang::BuiltinType::Kind::BoundMember:
5022 case clang::BuiltinType::Kind::BuiltinFn:
5023 case clang::BuiltinType::Kind::Dependent:
5024 case clang::BuiltinType::Kind::OCLClkEvent:
5025 case clang::BuiltinType::Kind::OCLEvent:
5026 case clang::BuiltinType::Kind::OCLImage1dRO:
5027 case clang::BuiltinType::Kind::OCLImage1dWO:
5028 case clang::BuiltinType::Kind::OCLImage1dRW:
5029 case clang::BuiltinType::Kind::OCLImage1dArrayRO:
5030 case clang::BuiltinType::Kind::OCLImage1dArrayWO:
5031 case clang::BuiltinType::Kind::OCLImage1dArrayRW:
5032 case clang::BuiltinType::Kind::OCLImage1dBufferRO:
5033 case clang::BuiltinType::Kind::OCLImage1dBufferWO:
5034 case clang::BuiltinType::Kind::OCLImage1dBufferRW:
5035 case clang::BuiltinType::Kind::OCLImage2dRO:
5036 case clang::BuiltinType::Kind::OCLImage2dWO:
5037 case clang::BuiltinType::Kind::OCLImage2dRW:
5038 case clang::BuiltinType::Kind::OCLImage2dArrayRO:
5039 case clang::BuiltinType::Kind::OCLImage2dArrayWO:
5040 case clang::BuiltinType::Kind::OCLImage2dArrayRW:
5041 case clang::BuiltinType::Kind::OCLImage2dArrayDepthRO:
5042 case clang::BuiltinType::Kind::OCLImage2dArrayDepthWO:
5043 case clang::BuiltinType::Kind::OCLImage2dArrayDepthRW:
5044 case clang::BuiltinType::Kind::OCLImage2dArrayMSAARO:
5045 case clang::BuiltinType::Kind::OCLImage2dArrayMSAAWO:
5046 case clang::BuiltinType::Kind::OCLImage2dArrayMSAARW:
5047 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRO:
5048 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthWO:
5049 case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRW:
5050 case clang::BuiltinType::Kind::OCLImage2dDepthRO:
5051 case clang::BuiltinType::Kind::OCLImage2dDepthWO:
5052 case clang::BuiltinType::Kind::OCLImage2dDepthRW:
5053 case clang::BuiltinType::Kind::OCLImage2dMSAARO:
5054 case clang::BuiltinType::Kind::OCLImage2dMSAAWO:
5055 case clang::BuiltinType::Kind::OCLImage2dMSAARW:
5056 case clang::BuiltinType::Kind::OCLImage2dMSAADepthRO:
5057 case clang::BuiltinType::Kind::OCLImage2dMSAADepthWO:
5058 case clang::BuiltinType::Kind::OCLImage2dMSAADepthRW:
5059 case clang::BuiltinType::Kind::OCLImage3dRO:
5060 case clang::BuiltinType::Kind::OCLImage3dWO:
5061 case clang::BuiltinType::Kind::OCLImage3dRW:
5062 case clang::BuiltinType::Kind::OCLQueue:
5063 case clang::BuiltinType::Kind::OCLReserveID:
5064 case clang::BuiltinType::Kind::OCLSampler:
5065 case clang::BuiltinType::Kind::OMPArraySection:
5066 case clang::BuiltinType::Kind::Overload:
5067 case clang::BuiltinType::Kind::PseudoObject:
5068 case clang::BuiltinType::Kind::UnknownAny:
5069 break;
5070 }
5071 break;
5072 // All pointer types are represented as unsigned integer encodings.
5073 // We may nee to add a eEncodingPointer if we ever need to know the
5074 // difference
5075 case clang::Type::ObjCObjectPointer:
5076 case clang::Type::BlockPointer:
5077 case clang::Type::Pointer:
5078 case clang::Type::LValueReference:
5079 case clang::Type::RValueReference:
5080 case clang::Type::MemberPointer:
5081 return lldb::eEncodingUint;
5082 case clang::Type::Complex: {
5083 lldb::Encoding encoding = lldb::eEncodingIEEE754;
5084 if (qual_type->isComplexType())
5085 encoding = lldb::eEncodingIEEE754;
5086 else {
5087 const clang::ComplexType *complex_type =
5088 qual_type->getAsComplexIntegerType();
5089 if (complex_type)
5090 encoding = CompilerType(getASTContext(), complex_type->getElementType())
5091 .GetEncoding(count);
5092 else
5093 encoding = lldb::eEncodingSint;
5094 }
5095 count = 2;
5096 return encoding;
5097 }
5098
5099 case clang::Type::ObjCInterface:
5100 break;
5101 case clang::Type::Record:
5102 break;
5103 case clang::Type::Enum:
5104 return lldb::eEncodingSint;
5105 case clang::Type::Typedef:
5106 return CompilerType(getASTContext(),
5107 llvm::cast<clang::TypedefType>(qual_type)
5108 ->getDecl()
5109 ->getUnderlyingType())
5110 .GetEncoding(count);
5111
5112 case clang::Type::Auto:
5113 return CompilerType(
5114 getASTContext(),
5115 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
5116 .GetEncoding(count);
5117
5118 case clang::Type::Elaborated:
5119 return CompilerType(
5120 getASTContext(),
5121 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
5122 .GetEncoding(count);
5123
5124 case clang::Type::Paren:
5125 return CompilerType(getASTContext(),
5126 llvm::cast<clang::ParenType>(qual_type)->desugar())
5127 .GetEncoding(count);
5128
5129 case clang::Type::DependentSizedArray:
5130 case clang::Type::DependentSizedExtVector:
5131 case clang::Type::UnresolvedUsing:
5132 case clang::Type::Attributed:
5133 case clang::Type::TemplateTypeParm:
5134 case clang::Type::SubstTemplateTypeParm:
5135 case clang::Type::SubstTemplateTypeParmPack:
5136 case clang::Type::InjectedClassName:
5137 case clang::Type::DependentName:
5138 case clang::Type::DependentTemplateSpecialization:
5139 case clang::Type::PackExpansion:
5140 case clang::Type::ObjCObject:
5141
5142 case clang::Type::TypeOfExpr:
5143 case clang::Type::TypeOf:
5144 case clang::Type::Decltype:
5145 case clang::Type::TemplateSpecialization:
5146 case clang::Type::DeducedTemplateSpecialization:
5147 case clang::Type::Atomic:
5148 case clang::Type::Adjusted:
5149 case clang::Type::Pipe:
5150 break;
5151
5152 // pointer type decayed from an array or function type.
5153 case clang::Type::Decayed:
5154 break;
5155 case clang::Type::ObjCTypeParam:
5156 break;
5157 }
5158 count = 0;
5159 return lldb::eEncodingInvalid;
5160}
5161
5162lldb::Format ClangASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
5163 if (!type)
5164 return lldb::eFormatDefault;
5165
5166 clang::QualType qual_type(GetCanonicalQualType(type));
5167
5168 switch (qual_type->getTypeClass()) {
5169 case clang::Type::UnaryTransform:
5170 break;
5171
5172 case clang::Type::FunctionNoProto:
5173 case clang::Type::FunctionProto:
5174 break;
5175
5176 case clang::Type::IncompleteArray:
5177 case clang::Type::VariableArray:
5178 break;
5179
5180 case clang::Type::ConstantArray:
5181 return lldb::eFormatVoid; // no value
5182
5183 case clang::Type::ExtVector:
5184 case clang::Type::Vector:
5185 break;
5186
5187 case clang::Type::Builtin:
5188 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5189 // default: assert(0 && "Unknown builtin type!");
5190 case clang::BuiltinType::UnknownAny:
5191 case clang::BuiltinType::Void:
5192 case clang::BuiltinType::BoundMember:
5193 break;
5194
5195 case clang::BuiltinType::Bool:
5196 return lldb::eFormatBoolean;
5197 case clang::BuiltinType::Char_S:
5198 case clang::BuiltinType::SChar:
5199 case clang::BuiltinType::WChar_S:
5200 case clang::BuiltinType::Char_U:
5201 case clang::BuiltinType::UChar:
5202 case clang::BuiltinType::WChar_U:
5203 return lldb::eFormatChar;
5204 case clang::BuiltinType::Char16:
5205 return lldb::eFormatUnicode16;
5206 case clang::BuiltinType::Char32:
5207 return lldb::eFormatUnicode32;
5208 case clang::BuiltinType::UShort:
5209 return lldb::eFormatUnsigned;
5210 case clang::BuiltinType::Short:
5211 return lldb::eFormatDecimal;
5212 case clang::BuiltinType::UInt:
5213 return lldb::eFormatUnsigned;
5214 case clang::BuiltinType::Int:
5215 return lldb::eFormatDecimal;
5216 case clang::BuiltinType::ULong:
5217 return lldb::eFormatUnsigned;
5218 case clang::BuiltinType::Long:
5219 return lldb::eFormatDecimal;
5220 case clang::BuiltinType::ULongLong:
5221 return lldb::eFormatUnsigned;
5222 case clang::BuiltinType::LongLong:
5223 return lldb::eFormatDecimal;
5224 case clang::BuiltinType::UInt128:
5225 return lldb::eFormatUnsigned;
5226 case clang::BuiltinType::Int128:
5227 return lldb::eFormatDecimal;
5228 case clang::BuiltinType::Half:
5229 case clang::BuiltinType::Float:
5230 case clang::BuiltinType::Double:
5231 case clang::BuiltinType::LongDouble:
5232 return lldb::eFormatFloat;
5233 default:
5234 return lldb::eFormatHex;
5235 }
5236 break;
5237 case clang::Type::ObjCObjectPointer:
5238 return lldb::eFormatHex;
5239 case clang::Type::BlockPointer:
5240 return lldb::eFormatHex;
5241 case clang::Type::Pointer:
5242 return lldb::eFormatHex;
5243 case clang::Type::LValueReference:
5244 case clang::Type::RValueReference:
5245 return lldb::eFormatHex;
5246 case clang::Type::MemberPointer:
5247 break;
5248 case clang::Type::Complex: {
5249 if (qual_type->isComplexType())
5250 return lldb::eFormatComplex;
5251 else
5252 return lldb::eFormatComplexInteger;
5253 }
5254 case clang::Type::ObjCInterface:
5255 break;
5256 case clang::Type::Record:
5257 break;
5258 case clang::Type::Enum:
5259 return lldb::eFormatEnum;
5260 case clang::Type::Typedef:
5261 return CompilerType(getASTContext(),
5262 llvm::cast<clang::TypedefType>(qual_type)
5263 ->getDecl()
5264 ->getUnderlyingType())
5265 .GetFormat();
5266 case clang::Type::Auto:
5267 return CompilerType(getASTContext(),
5268 llvm::cast<clang::AutoType>(qual_type)->desugar())
5269 .GetFormat();
5270 case clang::Type::Paren:
5271 return CompilerType(getASTContext(),
5272 llvm::cast<clang::ParenType>(qual_type)->desugar())
5273 .GetFormat();
5274 case clang::Type::Elaborated:
5275 return CompilerType(
5276 getASTContext(),
5277 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
5278 .GetFormat();
5279 case clang::Type::DependentSizedArray:
5280 case clang::Type::DependentSizedExtVector:
5281 case clang::Type::UnresolvedUsing:
5282 case clang::Type::Attributed:
5283 case clang::Type::TemplateTypeParm:
5284 case clang::Type::SubstTemplateTypeParm:
5285 case clang::Type::SubstTemplateTypeParmPack:
5286 case clang::Type::InjectedClassName:
5287 case clang::Type::DependentName:
5288 case clang::Type::DependentTemplateSpecialization:
5289 case clang::Type::PackExpansion:
5290 case clang::Type::ObjCObject:
5291
5292 case clang::Type::TypeOfExpr:
5293 case clang::Type::TypeOf:
5294 case clang::Type::Decltype:
5295 case clang::Type::TemplateSpecialization:
5296 case clang::Type::DeducedTemplateSpecialization:
5297 case clang::Type::Atomic:
5298 case clang::Type::Adjusted:
5299 case clang::Type::Pipe:
5300 break;
5301
5302 // pointer type decayed from an array or function type.
5303 case clang::Type::Decayed:
5304 break;
5305 case clang::Type::ObjCTypeParam:
5306 break;
5307 }
5308 // We don't know hot to display this type...
5309 return lldb::eFormatBytes;
5310}
5311
5312static bool ObjCDeclHasIVars(clang::ObjCInterfaceDecl *class_interface_decl,
5313 bool check_superclass) {
5314 while (class_interface_decl) {
5315 if (class_interface_decl->ivar_size() > 0)
5316 return true;
5317
5318 if (check_superclass)
5319 class_interface_decl = class_interface_decl->getSuperClass();
5320 else
5321 break;
5322 }
5323 return false;
5324}
5325
5326uint32_t ClangASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
5327 bool omit_empty_base_classes) {
5328 if (!type)
5329 return 0;
5330
5331 uint32_t num_children = 0;
5332 clang::QualType qual_type(GetQualType(type));
5333 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5334 switch (type_class) {
5335 case clang::Type::Builtin:
5336 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5337 case clang::BuiltinType::ObjCId: // child is Class
5338 case clang::BuiltinType::ObjCClass: // child is Class
5339 num_children = 1;
5340 break;
5341
5342 default:
5343 break;
5344 }
5345 break;
5346
5347 case clang::Type::Complex:
5348 return 0;
5349
5350 case clang::Type::Record:
5351 if (GetCompleteQualType(getASTContext(), qual_type)) {
5352 const clang::RecordType *record_type =
5353 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5354 const clang::RecordDecl *record_decl = record_type->getDecl();
5355 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 5355, __PRETTY_FUNCTION__))
;
5356 const clang::CXXRecordDecl *cxx_record_decl =
5357 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
5358 if (cxx_record_decl) {
5359 if (omit_empty_base_classes) {
5360 // Check each base classes to see if it or any of its
5361 // base classes contain any fields. This can help
5362 // limit the noise in variable views by not having to
5363 // show base classes that contain no members.
5364 clang::CXXRecordDecl::base_class_const_iterator base_class,
5365 base_class_end;
5366 for (base_class = cxx_record_decl->bases_begin(),
5367 base_class_end = cxx_record_decl->bases_end();
5368 base_class != base_class_end; ++base_class) {
5369 const clang::CXXRecordDecl *base_class_decl =
5370 llvm::cast<clang::CXXRecordDecl>(
5371 base_class->getType()
5372 ->getAs<clang::RecordType>()
5373 ->getDecl());
5374
5375 // Skip empty base classes
5376 if (ClangASTContext::RecordHasFields(base_class_decl) == false)
5377 continue;
5378
5379 num_children++;
5380 }
5381 } else {
5382 // Include all base classes
5383 num_children += cxx_record_decl->getNumBases();
5384 }
5385 }
5386 clang::RecordDecl::field_iterator field, field_end;
5387 for (field = record_decl->field_begin(),
5388 field_end = record_decl->field_end();
5389 field != field_end; ++field)
5390 ++num_children;
5391 }
5392 break;
5393
5394 case clang::Type::ObjCObject:
5395 case clang::Type::ObjCInterface:
5396 if (GetCompleteQualType(getASTContext(), qual_type)) {
5397 const clang::ObjCObjectType *objc_class_type =
5398 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5399 assert(objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 5399, __PRETTY_FUNCTION__))
;
5400 if (objc_class_type) {
5401 clang::ObjCInterfaceDecl *class_interface_decl =
5402 objc_class_type->getInterface();
5403
5404 if (class_interface_decl) {
5405
5406 clang::ObjCInterfaceDecl *superclass_interface_decl =
5407 class_interface_decl->getSuperClass();
5408 if (superclass_interface_decl) {
5409 if (omit_empty_base_classes) {
5410 if (ObjCDeclHasIVars(superclass_interface_decl, true))
5411 ++num_children;
5412 } else
5413 ++num_children;
5414 }
5415
5416 num_children += class_interface_decl->ivar_size();
5417 }
5418 }
5419 }
5420 break;
5421
5422 case clang::Type::ObjCObjectPointer: {
5423 const clang::ObjCObjectPointerType *pointer_type =
5424 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr());
5425 clang::QualType pointee_type = pointer_type->getPointeeType();
5426 uint32_t num_pointee_children =
5427 CompilerType(getASTContext(), pointee_type)
5428 .GetNumChildren(omit_empty_base_classes);
5429 // If this type points to a simple type, then it has 1 child
5430 if (num_pointee_children == 0)
5431 num_children = 1;
5432 else
5433 num_children = num_pointee_children;
5434 } break;
5435
5436 case clang::Type::Vector:
5437 case clang::Type::ExtVector:
5438 num_children =
5439 llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
5440 break;
5441
5442 case clang::Type::ConstantArray:
5443 num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())
5444 ->getSize()
5445 .getLimitedValue();
5446 break;
5447
5448 case clang::Type::Pointer: {
5449 const clang::PointerType *pointer_type =
5450 llvm::cast<clang::PointerType>(qual_type.getTypePtr());
5451 clang::QualType pointee_type(pointer_type->getPointeeType());
5452 uint32_t num_pointee_children =
5453 CompilerType(getASTContext(), pointee_type)
5454 .GetNumChildren(omit_empty_base_classes);
5455 if (num_pointee_children == 0) {
5456 // We have a pointer to a pointee type that claims it has no children.
5457 // We will want to look at
5458 num_children = GetNumPointeeChildren(pointee_type);
5459 } else
5460 num_children = num_pointee_children;
5461 } break;
5462
5463 case clang::Type::LValueReference:
5464 case clang::Type::RValueReference: {
5465 const clang::ReferenceType *reference_type =
5466 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
5467 clang::QualType pointee_type = reference_type->getPointeeType();
5468 uint32_t num_pointee_children =
5469 CompilerType(getASTContext(), pointee_type)
5470 .GetNumChildren(omit_empty_base_classes);
5471 // If this type points to a simple type, then it has 1 child
5472 if (num_pointee_children == 0)
5473 num_children = 1;
5474 else
5475 num_children = num_pointee_children;
5476 } break;
5477
5478 case clang::Type::Typedef:
5479 num_children =
5480 CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type)
5481 ->getDecl()
5482 ->getUnderlyingType())
5483 .GetNumChildren(omit_empty_base_classes);
5484 break;
5485
5486 case clang::Type::Auto:
5487 num_children =
5488 CompilerType(getASTContext(),
5489 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
5490 .GetNumChildren(omit_empty_base_classes);
5491 break;
5492
5493 case clang::Type::Elaborated:
5494 num_children =
5495 CompilerType(
5496 getASTContext(),
5497 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
5498 .GetNumChildren(omit_empty_base_classes);
5499 break;
5500
5501 case clang::Type::Paren:
5502 num_children =
5503 CompilerType(getASTContext(),
5504 llvm::cast<clang::ParenType>(qual_type)->desugar())
5505 .GetNumChildren(omit_empty_base_classes);
5506 break;
5507 default:
5508 break;
5509 }
5510 return num_children;
5511}
5512
5513CompilerType ClangASTContext::GetBuiltinTypeByName(const ConstString &name) {
5514 return GetBasicType(GetBasicTypeEnumeration(name));
5515}
5516
5517lldb::BasicType
5518ClangASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
5519 if (type) {
5520 clang::QualType qual_type(GetQualType(type));
5521 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5522 if (type_class == clang::Type::Builtin) {
5523 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
5524 case clang::BuiltinType::Void:
5525 return eBasicTypeVoid;
5526 case clang::BuiltinType::Bool:
5527 return eBasicTypeBool;
5528 case clang::BuiltinType::Char_S:
5529 return eBasicTypeSignedChar;
5530 case clang::BuiltinType::Char_U:
5531 return eBasicTypeUnsignedChar;
5532 case clang::BuiltinType::Char16:
5533 return eBasicTypeChar16;
5534 case clang::BuiltinType::Char32:
5535 return eBasicTypeChar32;
5536 case clang::BuiltinType::UChar:
5537 return eBasicTypeUnsignedChar;
5538 case clang::BuiltinType::SChar:
5539 return eBasicTypeSignedChar;
5540 case clang::BuiltinType::WChar_S:
5541 return eBasicTypeSignedWChar;
5542 case clang::BuiltinType::WChar_U:
5543 return eBasicTypeUnsignedWChar;
5544 case clang::BuiltinType::Short:
5545 return eBasicTypeShort;
5546 case clang::BuiltinType::UShort:
5547 return eBasicTypeUnsignedShort;
5548 case clang::BuiltinType::Int:
5549 return eBasicTypeInt;
5550 case clang::BuiltinType::UInt:
5551 return eBasicTypeUnsignedInt;
5552 case clang::BuiltinType::Long:
5553 return eBasicTypeLong;
5554 case clang::BuiltinType::ULong:
5555 return eBasicTypeUnsignedLong;
5556 case clang::BuiltinType::LongLong:
5557 return eBasicTypeLongLong;
5558 case clang::BuiltinType::ULongLong:
5559 return eBasicTypeUnsignedLongLong;
5560 case clang::BuiltinType::Int128:
5561 return eBasicTypeInt128;
5562 case clang::BuiltinType::UInt128:
5563 return eBasicTypeUnsignedInt128;
5564
5565 case clang::BuiltinType::Half:
5566 return eBasicTypeHalf;
5567 case clang::BuiltinType::Float:
5568 return eBasicTypeFloat;
5569 case clang::BuiltinType::Double:
5570 return eBasicTypeDouble;
5571 case clang::BuiltinType::LongDouble:
5572 return eBasicTypeLongDouble;
5573
5574 case clang::BuiltinType::NullPtr:
5575 return eBasicTypeNullPtr;
5576 case clang::BuiltinType::ObjCId:
5577 return eBasicTypeObjCID;
5578 case clang::BuiltinType::ObjCClass:
5579 return eBasicTypeObjCClass;
5580 case clang::BuiltinType::ObjCSel:
5581 return eBasicTypeObjCSel;
5582 default:
5583 return eBasicTypeOther;
5584 }
5585 }
5586 }
5587 return eBasicTypeInvalid;
5588}
5589
5590void ClangASTContext::ForEachEnumerator(
5591 lldb::opaque_compiler_type_t type,
5592 std::function<bool(const CompilerType &integer_type,
5593 const ConstString &name,
5594 const llvm::APSInt &value)> const &callback) {
5595 const clang::EnumType *enum_type =
5596 llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
5597 if (enum_type) {
5598 const clang::EnumDecl *enum_decl = enum_type->getDecl();
5599 if (enum_decl) {
5600 CompilerType integer_type(this,
5601 enum_decl->getIntegerType().getAsOpaquePtr());
5602
5603 clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
5604 for (enum_pos = enum_decl->enumerator_begin(),
5605 enum_end_pos = enum_decl->enumerator_end();
5606 enum_pos != enum_end_pos; ++enum_pos) {
5607 ConstString name(enum_pos->getNameAsString().c_str());
5608 if (!callback(integer_type, name, enum_pos->getInitVal()))
5609 break;
5610 }
5611 }
5612 }
5613}
5614
5615#pragma mark Aggregate Types
5616
5617uint32_t ClangASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
5618 if (!type)
5619 return 0;
5620
5621 uint32_t count = 0;
5622 clang::QualType qual_type(GetCanonicalQualType(type));
5623 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5624 switch (type_class) {
5625 case clang::Type::Record:
5626 if (GetCompleteType(type)) {
5627 const clang::RecordType *record_type =
5628 llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
5629 if (record_type) {
5630 clang::RecordDecl *record_decl = record_type->getDecl();
5631 if (record_decl) {
5632 uint32_t field_idx = 0;
5633 clang::RecordDecl::field_iterator field, field_end;
5634 for (field = record_decl->field_begin(),
5635 field_end = record_decl->field_end();
5636 field != field_end; ++field)
5637 ++field_idx;
5638 count = field_idx;
5639 }
5640 }
5641 }
5642 break;
5643
5644 case clang::Type::Typedef:
5645 count =
5646 CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type)
5647 ->getDecl()
5648 ->getUnderlyingType())
5649 .GetNumFields();
5650 break;
5651
5652 case clang::Type::Auto:
5653 count =
5654 CompilerType(getASTContext(),
5655 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
5656 .GetNumFields();
5657 break;
5658
5659 case clang::Type::Elaborated:
5660 count = CompilerType(
5661 getASTContext(),
5662 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
5663 .GetNumFields();
5664 break;
5665
5666 case clang::Type::Paren:
5667 count = CompilerType(getASTContext(),
5668 llvm::cast<clang::ParenType>(qual_type)->desugar())
5669 .GetNumFields();
5670 break;
5671
5672 case clang::Type::ObjCObjectPointer: {
5673 const clang::ObjCObjectPointerType *objc_class_type =
5674 qual_type->getAs<clang::ObjCObjectPointerType>();
5675 const clang::ObjCInterfaceType *objc_interface_type =
5676 objc_class_type->getInterfaceType();
5677 if (objc_interface_type &&
5678 GetCompleteType(static_cast<lldb::opaque_compiler_type_t>(
5679 const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
5680 clang::ObjCInterfaceDecl *class_interface_decl =
5681 objc_interface_type->getDecl();
5682 if (class_interface_decl) {
5683 count = class_interface_decl->ivar_size();
5684 }
5685 }
5686 break;
5687 }
5688
5689 case clang::Type::ObjCObject:
5690 case clang::Type::ObjCInterface:
5691 if (GetCompleteType(type)) {
5692 const clang::ObjCObjectType *objc_class_type =
5693 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5694 if (objc_class_type) {
5695 clang::ObjCInterfaceDecl *class_interface_decl =
5696 objc_class_type->getInterface();
5697
5698 if (class_interface_decl)
5699 count = class_interface_decl->ivar_size();
5700 }
5701 }
5702 break;
5703
5704 default:
5705 break;
5706 }
5707 return count;
5708}
5709
5710static lldb::opaque_compiler_type_t
5711GetObjCFieldAtIndex(clang::ASTContext *ast,
5712 clang::ObjCInterfaceDecl *class_interface_decl, size_t idx,
5713 std::string &name, uint64_t *bit_offset_ptr,
5714 uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) {
5715 if (class_interface_decl) {
5716 if (idx < (class_interface_decl->ivar_size())) {
5717 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
5718 ivar_end = class_interface_decl->ivar_end();
5719 uint32_t ivar_idx = 0;
5720
5721 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end;
5722 ++ivar_pos, ++ivar_idx) {
5723 if (ivar_idx == idx) {
5724 const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
5725
5726 clang::QualType ivar_qual_type(ivar_decl->getType());
5727
5728 name.assign(ivar_decl->getNameAsString());
5729
5730 if (bit_offset_ptr) {
5731 const clang::ASTRecordLayout &interface_layout =
5732 ast->getASTObjCInterfaceLayout(class_interface_decl);
5733 *bit_offset_ptr = interface_layout.getFieldOffset(ivar_idx);
5734 }
5735
5736 const bool is_bitfield = ivar_pos->isBitField();
5737
5738 if (bitfield_bit_size_ptr) {
5739 *bitfield_bit_size_ptr = 0;
5740
5741 if (is_bitfield && ast) {
5742 clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
5743 llvm::APSInt bitfield_apsint;
5744 if (bitfield_bit_size_expr &&
5745 bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint,
5746 *ast)) {
5747 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5748 }
5749 }
5750 }
5751 if (is_bitfield_ptr)
5752 *is_bitfield_ptr = is_bitfield;
5753
5754 return ivar_qual_type.getAsOpaquePtr();
5755 }
5756 }
5757 }
5758 }
5759 return nullptr;
5760}
5761
5762CompilerType ClangASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
5763 size_t idx, std::string &name,
5764 uint64_t *bit_offset_ptr,
5765 uint32_t *bitfield_bit_size_ptr,
5766 bool *is_bitfield_ptr) {
5767 if (!type)
5768 return CompilerType();
5769
5770 clang::QualType qual_type(GetCanonicalQualType(type));
5771 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5772 switch (type_class) {
5773 case clang::Type::Record:
5774 if (GetCompleteType(type)) {
5775 const clang::RecordType *record_type =
5776 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5777 const clang::RecordDecl *record_decl = record_type->getDecl();
5778 uint32_t field_idx = 0;
5779 clang::RecordDecl::field_iterator field, field_end;
5780 for (field = record_decl->field_begin(),
5781 field_end = record_decl->field_end();
5782 field != field_end; ++field, ++field_idx) {
5783 if (idx == field_idx) {
5784 // Print the member type if requested
5785 // Print the member name and equal sign
5786 name.assign(field->getNameAsString());
5787
5788 // Figure out the type byte size (field_type_info.first) and
5789 // alignment (field_type_info.second) from the AST context.
5790 if (bit_offset_ptr) {
5791 const clang::ASTRecordLayout &record_layout =
5792 getASTContext()->getASTRecordLayout(record_decl);
5793 *bit_offset_ptr = record_layout.getFieldOffset(field_idx);
5794 }
5795
5796 const bool is_bitfield = field->isBitField();
5797
5798 if (bitfield_bit_size_ptr) {
5799 *bitfield_bit_size_ptr = 0;
5800
5801 if (is_bitfield) {
5802 clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
5803 llvm::APSInt bitfield_apsint;
5804 if (bitfield_bit_size_expr &&
5805 bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint,
5806 *getASTContext())) {
5807 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5808 }
5809 }
5810 }
5811 if (is_bitfield_ptr)
5812 *is_bitfield_ptr = is_bitfield;
5813
5814 return CompilerType(getASTContext(), field->getType());
5815 }
5816 }
5817 }
5818 break;
5819
5820 case clang::Type::ObjCObjectPointer: {
5821 const clang::ObjCObjectPointerType *objc_class_type =
5822 qual_type->getAs<clang::ObjCObjectPointerType>();
5823 const clang::ObjCInterfaceType *objc_interface_type =
5824 objc_class_type->getInterfaceType();
5825 if (objc_interface_type &&
5826 GetCompleteType(static_cast<lldb::opaque_compiler_type_t>(
5827 const_cast<clang::ObjCInterfaceType *>(objc_interface_type)))) {
5828 clang::ObjCInterfaceDecl *class_interface_decl =
5829 objc_interface_type->getDecl();
5830 if (class_interface_decl) {
5831 return CompilerType(
5832 this, GetObjCFieldAtIndex(getASTContext(), class_interface_decl,
5833 idx, name, bit_offset_ptr,
5834 bitfield_bit_size_ptr, is_bitfield_ptr));
5835 }
5836 }
5837 break;
5838 }
5839
5840 case clang::Type::ObjCObject:
5841 case clang::Type::ObjCInterface:
5842 if (GetCompleteType(type)) {
5843 const clang::ObjCObjectType *objc_class_type =
5844 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5845 assert(objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 5845, __PRETTY_FUNCTION__))
;
5846 if (objc_class_type) {
5847 clang::ObjCInterfaceDecl *class_interface_decl =
5848 objc_class_type->getInterface();
5849 return CompilerType(
5850 this, GetObjCFieldAtIndex(getASTContext(), class_interface_decl,
5851 idx, name, bit_offset_ptr,
5852 bitfield_bit_size_ptr, is_bitfield_ptr));
5853 }
5854 }
5855 break;
5856
5857 case clang::Type::Typedef:
5858 return CompilerType(getASTContext(),
5859 llvm::cast<clang::TypedefType>(qual_type)
5860 ->getDecl()
5861 ->getUnderlyingType())
5862 .GetFieldAtIndex(idx, name, bit_offset_ptr, bitfield_bit_size_ptr,
5863 is_bitfield_ptr);
5864
5865 case clang::Type::Auto:
5866 return CompilerType(
5867 getASTContext(),
5868 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
5869 .GetFieldAtIndex(idx, name, bit_offset_ptr, bitfield_bit_size_ptr,
5870 is_bitfield_ptr);
5871
5872 case clang::Type::Elaborated:
5873 return CompilerType(
5874 getASTContext(),
5875 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
5876 .GetFieldAtIndex(idx, name, bit_offset_ptr, bitfield_bit_size_ptr,
5877 is_bitfield_ptr);
5878
5879 case clang::Type::Paren:
5880 return CompilerType(getASTContext(),
5881 llvm::cast<clang::ParenType>(qual_type)->desugar())
5882 .GetFieldAtIndex(idx, name, bit_offset_ptr, bitfield_bit_size_ptr,
5883 is_bitfield_ptr);
5884
5885 default:
5886 break;
5887 }
5888 return CompilerType();
5889}
5890
5891uint32_t
5892ClangASTContext::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) {
5893 uint32_t count = 0;
5894 clang::QualType qual_type(GetCanonicalQualType(type));
5895 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5896 switch (type_class) {
5897 case clang::Type::Record:
5898 if (GetCompleteType(type)) {
5899 const clang::CXXRecordDecl *cxx_record_decl =
5900 qual_type->getAsCXXRecordDecl();
5901 if (cxx_record_decl)
5902 count = cxx_record_decl->getNumBases();
5903 }
5904 break;
5905
5906 case clang::Type::ObjCObjectPointer:
5907 count = GetPointeeType(type).GetNumDirectBaseClasses();
5908 break;
5909
5910 case clang::Type::ObjCObject:
5911 if (GetCompleteType(type)) {
5912 const clang::ObjCObjectType *objc_class_type =
5913 qual_type->getAsObjCQualifiedInterfaceType();
5914 if (objc_class_type) {
5915 clang::ObjCInterfaceDecl *class_interface_decl =
5916 objc_class_type->getInterface();
5917
5918 if (class_interface_decl && class_interface_decl->getSuperClass())
5919 count = 1;
5920 }
5921 }
5922 break;
5923 case clang::Type::ObjCInterface:
5924 if (GetCompleteType(type)) {
5925 const clang::ObjCInterfaceType *objc_interface_type =
5926 qual_type->getAs<clang::ObjCInterfaceType>();
5927 if (objc_interface_type) {
5928 clang::ObjCInterfaceDecl *class_interface_decl =
5929 objc_interface_type->getInterface();
5930
5931 if (class_interface_decl && class_interface_decl->getSuperClass())
5932 count = 1;
5933 }
5934 }
5935 break;
5936
5937 case clang::Type::Typedef:
5938 count = GetNumDirectBaseClasses(llvm::cast<clang::TypedefType>(qual_type)
5939 ->getDecl()
5940 ->getUnderlyingType()
5941 .getAsOpaquePtr());
5942 break;
5943
5944 case clang::Type::Auto:
5945 count = GetNumDirectBaseClasses(llvm::cast<clang::AutoType>(qual_type)
5946 ->getDeducedType()
5947 .getAsOpaquePtr());
5948 break;
5949
5950 case clang::Type::Elaborated:
5951 count = GetNumDirectBaseClasses(llvm::cast<clang::ElaboratedType>(qual_type)
5952 ->getNamedType()
5953 .getAsOpaquePtr());
5954 break;
5955
5956 case clang::Type::Paren:
5957 return GetNumDirectBaseClasses(
5958 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
5959
5960 default:
5961 break;
5962 }
5963 return count;
5964}
5965
5966uint32_t
5967ClangASTContext::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) {
5968 uint32_t count = 0;
5969 clang::QualType qual_type(GetCanonicalQualType(type));
5970 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5971 switch (type_class) {
5972 case clang::Type::Record:
5973 if (GetCompleteType(type)) {
5974 const clang::CXXRecordDecl *cxx_record_decl =
5975 qual_type->getAsCXXRecordDecl();
5976 if (cxx_record_decl)
5977 count = cxx_record_decl->getNumVBases();
5978 }
5979 break;
5980
5981 case clang::Type::Typedef:
5982 count = GetNumVirtualBaseClasses(llvm::cast<clang::TypedefType>(qual_type)
5983 ->getDecl()
5984 ->getUnderlyingType()
5985 .getAsOpaquePtr());
5986 break;
5987
5988 case clang::Type::Auto:
5989 count = GetNumVirtualBaseClasses(llvm::cast<clang::AutoType>(qual_type)
5990 ->getDeducedType()
5991 .getAsOpaquePtr());
5992 break;
5993
5994 case clang::Type::Elaborated:
5995 count =
5996 GetNumVirtualBaseClasses(llvm::cast<clang::ElaboratedType>(qual_type)
5997 ->getNamedType()
5998 .getAsOpaquePtr());
5999 break;
6000
6001 case clang::Type::Paren:
6002 count = GetNumVirtualBaseClasses(
6003 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
6004 break;
6005
6006 default:
6007 break;
6008 }
6009 return count;
6010}
6011
6012CompilerType ClangASTContext::GetDirectBaseClassAtIndex(
6013 lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
6014 clang::QualType qual_type(GetCanonicalQualType(type));
6015 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6016 switch (type_class) {
6017 case clang::Type::Record:
6018 if (GetCompleteType(type)) {
6019 const clang::CXXRecordDecl *cxx_record_decl =
6020 qual_type->getAsCXXRecordDecl();
6021 if (cxx_record_decl) {
6022 uint32_t curr_idx = 0;
6023 clang::CXXRecordDecl::base_class_const_iterator base_class,
6024 base_class_end;
6025 for (base_class = cxx_record_decl->bases_begin(),
6026 base_class_end = cxx_record_decl->bases_end();
6027 base_class != base_class_end; ++base_class, ++curr_idx) {
6028 if (curr_idx == idx) {
6029 if (bit_offset_ptr) {
6030 const clang::ASTRecordLayout &record_layout =
6031 getASTContext()->getASTRecordLayout(cxx_record_decl);
6032 const clang::CXXRecordDecl *base_class_decl =
6033 llvm::cast<clang::CXXRecordDecl>(
6034 base_class->getType()
6035 ->getAs<clang::RecordType>()
6036 ->getDecl());
6037 if (base_class->isVirtual())
6038 *bit_offset_ptr =
6039 record_layout.getVBaseClassOffset(base_class_decl)
6040 .getQuantity() *
6041 8;
6042 else
6043 *bit_offset_ptr =
6044 record_layout.getBaseClassOffset(base_class_decl)
6045 .getQuantity() *
6046 8;
6047 }
6048 return CompilerType(this, base_class->getType().getAsOpaquePtr());
6049 }
6050 }
6051 }
6052 }
6053 break;
6054
6055 case clang::Type::ObjCObjectPointer:
6056 return GetPointeeType(type).GetDirectBaseClassAtIndex(idx, bit_offset_ptr);
6057
6058 case clang::Type::ObjCObject:
6059 if (idx == 0 && GetCompleteType(type)) {
6060 const clang::ObjCObjectType *objc_class_type =
6061 qual_type->getAsObjCQualifiedInterfaceType();
6062 if (objc_class_type) {
6063 clang::ObjCInterfaceDecl *class_interface_decl =
6064 objc_class_type->getInterface();
6065
6066 if (class_interface_decl) {
6067 clang::ObjCInterfaceDecl *superclass_interface_decl =
6068 class_interface_decl->getSuperClass();
6069 if (superclass_interface_decl) {
6070 if (bit_offset_ptr)
6071 *bit_offset_ptr = 0;
6072 return CompilerType(getASTContext(),
6073 getASTContext()->getObjCInterfaceType(
6074 superclass_interface_decl));
6075 }
6076 }
6077 }
6078 }
6079 break;
6080 case clang::Type::ObjCInterface:
6081 if (idx == 0 && GetCompleteType(type)) {
6082 const clang::ObjCObjectType *objc_interface_type =
6083 qual_type->getAs<clang::ObjCInterfaceType>();
6084 if (objc_interface_type) {
6085 clang::ObjCInterfaceDecl *class_interface_decl =
6086 objc_interface_type->getInterface();
6087
6088 if (class_interface_decl) {
6089 clang::ObjCInterfaceDecl *superclass_interface_decl =
6090 class_interface_decl->getSuperClass();
6091 if (superclass_interface_decl) {
6092 if (bit_offset_ptr)
6093 *bit_offset_ptr = 0;
6094 return CompilerType(getASTContext(),
6095 getASTContext()->getObjCInterfaceType(
6096 superclass_interface_decl));
6097 }
6098 }
6099 }
6100 }
6101 break;
6102
6103 case clang::Type::Typedef:
6104 return GetDirectBaseClassAtIndex(llvm::cast<clang::TypedefType>(qual_type)
6105 ->getDecl()
6106 ->getUnderlyingType()
6107 .getAsOpaquePtr(),
6108 idx, bit_offset_ptr);
6109
6110 case clang::Type::Auto:
6111 return GetDirectBaseClassAtIndex(llvm::cast<clang::AutoType>(qual_type)
6112 ->getDeducedType()
6113 .getAsOpaquePtr(),
6114 idx, bit_offset_ptr);
6115
6116 case clang::Type::Elaborated:
6117 return GetDirectBaseClassAtIndex(
6118 llvm::cast<clang::ElaboratedType>(qual_type)
6119 ->getNamedType()
6120 .getAsOpaquePtr(),
6121 idx, bit_offset_ptr);
6122
6123 case clang::Type::Paren:
6124 return GetDirectBaseClassAtIndex(
6125 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
6126 idx, bit_offset_ptr);
6127
6128 default:
6129 break;
6130 }
6131 return CompilerType();
6132}
6133
6134CompilerType ClangASTContext::GetVirtualBaseClassAtIndex(
6135 lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
6136 clang::QualType qual_type(GetCanonicalQualType(type));
6137 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6138 switch (type_class) {
6139 case clang::Type::Record:
6140 if (GetCompleteType(type)) {
6141 const clang::CXXRecordDecl *cxx_record_decl =
6142 qual_type->getAsCXXRecordDecl();
6143 if (cxx_record_decl) {
6144 uint32_t curr_idx = 0;
6145 clang::CXXRecordDecl::base_class_const_iterator base_class,
6146 base_class_end;
6147 for (base_class = cxx_record_decl->vbases_begin(),
6148 base_class_end = cxx_record_decl->vbases_end();
6149 base_class != base_class_end; ++base_class, ++curr_idx) {
6150 if (curr_idx == idx) {
6151 if (bit_offset_ptr) {
6152 const clang::ASTRecordLayout &record_layout =
6153 getASTContext()->getASTRecordLayout(cxx_record_decl);
6154 const clang::CXXRecordDecl *base_class_decl =
6155 llvm::cast<clang::CXXRecordDecl>(
6156 base_class->getType()
6157 ->getAs<clang::RecordType>()
6158 ->getDecl());
6159 *bit_offset_ptr =
6160 record_layout.getVBaseClassOffset(base_class_decl)
6161 .getQuantity() *
6162 8;
6163 }
6164 return CompilerType(this, base_class->getType().getAsOpaquePtr());
6165 }
6166 }
6167 }
6168 }
6169 break;
6170
6171 case clang::Type::Typedef:
6172 return GetVirtualBaseClassAtIndex(llvm::cast<clang::TypedefType>(qual_type)
6173 ->getDecl()
6174 ->getUnderlyingType()
6175 .getAsOpaquePtr(),
6176 idx, bit_offset_ptr);
6177
6178 case clang::Type::Auto:
6179 return GetVirtualBaseClassAtIndex(llvm::cast<clang::AutoType>(qual_type)
6180 ->getDeducedType()
6181 .getAsOpaquePtr(),
6182 idx, bit_offset_ptr);
6183
6184 case clang::Type::Elaborated:
6185 return GetVirtualBaseClassAtIndex(
6186 llvm::cast<clang::ElaboratedType>(qual_type)
6187 ->getNamedType()
6188 .getAsOpaquePtr(),
6189 idx, bit_offset_ptr);
6190
6191 case clang::Type::Paren:
6192 return GetVirtualBaseClassAtIndex(
6193 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
6194 idx, bit_offset_ptr);
6195
6196 default:
6197 break;
6198 }
6199 return CompilerType();
6200}
6201
6202// If a pointer to a pointee type (the clang_type arg) says that it has no
6203// children, then we either need to trust it, or override it and return a
6204// different result. For example, an "int *" has one child that is an integer,
6205// but a function pointer doesn't have any children. Likewise if a Record type
6206// claims it has no children, then there really is nothing to show.
6207uint32_t ClangASTContext::GetNumPointeeChildren(clang::QualType type) {
6208 if (type.isNull())
6209 return 0;
6210
6211 clang::QualType qual_type(type.getCanonicalType());
6212 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6213 switch (type_class) {
6214 case clang::Type::Builtin:
6215 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
6216 case clang::BuiltinType::UnknownAny:
6217 case clang::BuiltinType::Void:
6218 case clang::BuiltinType::NullPtr:
6219 case clang::BuiltinType::OCLEvent:
6220 case clang::BuiltinType::OCLImage1dRO:
6221 case clang::BuiltinType::OCLImage1dWO:
6222 case clang::BuiltinType::OCLImage1dRW:
6223 case clang::BuiltinType::OCLImage1dArrayRO:
6224 case clang::BuiltinType::OCLImage1dArrayWO:
6225 case clang::BuiltinType::OCLImage1dArrayRW:
6226 case clang::BuiltinType::OCLImage1dBufferRO:
6227 case clang::BuiltinType::OCLImage1dBufferWO:
6228 case clang::BuiltinType::OCLImage1dBufferRW:
6229 case clang::BuiltinType::OCLImage2dRO:
6230 case clang::BuiltinType::OCLImage2dWO:
6231 case clang::BuiltinType::OCLImage2dRW:
6232 case clang::BuiltinType::OCLImage2dArrayRO:
6233 case clang::BuiltinType::OCLImage2dArrayWO:
6234 case clang::BuiltinType::OCLImage2dArrayRW:
6235 case clang::BuiltinType::OCLImage3dRO:
6236 case clang::BuiltinType::OCLImage3dWO:
6237 case clang::BuiltinType::OCLImage3dRW:
6238 case clang::BuiltinType::OCLSampler:
6239 return 0;
6240 case clang::BuiltinType::Bool:
6241 case clang::BuiltinType::Char_U:
6242 case clang::BuiltinType::UChar:
6243 case clang::BuiltinType::WChar_U:
6244 case clang::BuiltinType::Char16:
6245 case clang::BuiltinType::Char32:
6246 case clang::BuiltinType::UShort:
6247 case clang::BuiltinType::UInt:
6248 case clang::BuiltinType::ULong:
6249 case clang::BuiltinType::ULongLong:
6250 case clang::BuiltinType::UInt128:
6251 case clang::BuiltinType::Char_S:
6252 case clang::BuiltinType::SChar:
6253 case clang::BuiltinType::WChar_S:
6254 case clang::BuiltinType::Short:
6255 case clang::BuiltinType::Int:
6256 case clang::BuiltinType::Long:
6257 case clang::BuiltinType::LongLong:
6258 case clang::BuiltinType::Int128:
6259 case clang::BuiltinType::Float:
6260 case clang::BuiltinType::Double:
6261 case clang::BuiltinType::LongDouble:
6262 case clang::BuiltinType::Dependent:
6263 case clang::BuiltinType::Overload:
6264 case clang::BuiltinType::ObjCId:
6265 case clang::BuiltinType::ObjCClass:
6266 case clang::BuiltinType::ObjCSel:
6267 case clang::BuiltinType::BoundMember:
6268 case clang::BuiltinType::Half:
6269 case clang::BuiltinType::ARCUnbridgedCast:
6270 case clang::BuiltinType::PseudoObject:
6271 case clang::BuiltinType::BuiltinFn:
6272 case clang::BuiltinType::OMPArraySection:
6273 return 1;
6274 default:
6275 return 0;
6276 }
6277 break;
6278
6279 case clang::Type::Complex:
6280 return 1;
6281 case clang::Type::Pointer:
6282 return 1;
6283 case clang::Type::BlockPointer:
6284 return 0; // If block pointers don't have debug info, then no children for
6285 // them
6286 case clang::Type::LValueReference:
6287 return 1;
6288 case clang::Type::RValueReference:
6289 return 1;
6290 case clang::Type::MemberPointer:
6291 return 0;
6292 case clang::Type::ConstantArray:
6293 return 0;
6294 case clang::Type::IncompleteArray:
6295 return 0;
6296 case clang::Type::VariableArray:
6297 return 0;
6298 case clang::Type::DependentSizedArray:
6299 return 0;
6300 case clang::Type::DependentSizedExtVector:
6301 return 0;
6302 case clang::Type::Vector:
6303 return 0;
6304 case clang::Type::ExtVector:
6305 return 0;
6306 case clang::Type::FunctionProto:
6307 return 0; // When we function pointers, they have no children...
6308 case clang::Type::FunctionNoProto:
6309 return 0; // When we function pointers, they have no children...
6310 case clang::Type::UnresolvedUsing:
6311 return 0;
6312 case clang::Type::Paren:
6313 return GetNumPointeeChildren(
6314 llvm::cast<clang::ParenType>(qual_type)->desugar());
6315 case clang::Type::Typedef:
6316 return GetNumPointeeChildren(llvm::cast<clang::TypedefType>(qual_type)
6317 ->getDecl()
6318 ->getUnderlyingType());
6319 case clang::Type::Auto:
6320 return GetNumPointeeChildren(
6321 llvm::cast<clang::AutoType>(qual_type)->getDeducedType());
6322 case clang::Type::Elaborated:
6323 return GetNumPointeeChildren(
6324 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType());
6325 case clang::Type::TypeOfExpr:
6326 return 0;
6327 case clang::Type::TypeOf:
6328 return 0;
6329 case clang::Type::Decltype:
6330 return 0;
6331 case clang::Type::Record:
6332 return 0;
6333 case clang::Type::Enum:
6334 return 1;
6335 case clang::Type::TemplateTypeParm:
6336 return 1;
6337 case clang::Type::SubstTemplateTypeParm:
6338 return 1;
6339 case clang::Type::TemplateSpecialization:
6340 return 1;
6341 case clang::Type::InjectedClassName:
6342 return 0;
6343 case clang::Type::DependentName:
6344 return 1;
6345 case clang::Type::DependentTemplateSpecialization:
6346 return 1;
6347 case clang::Type::ObjCObject:
6348 return 0;
6349 case clang::Type::ObjCInterface:
6350 return 0;
6351 case clang::Type::ObjCObjectPointer:
6352 return 1;
6353 default:
6354 break;
6355 }
6356 return 0;
6357}
6358
6359CompilerType ClangASTContext::GetChildCompilerTypeAtIndex(
6360 lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
6361 bool transparent_pointers, bool omit_empty_base_classes,
6362 bool ignore_array_bounds, std::string &child_name,
6363 uint32_t &child_byte_size, int32_t &child_byte_offset,
6364 uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
6365 bool &child_is_base_class, bool &child_is_deref_of_parent,
6366 ValueObject *valobj, uint64_t &language_flags) {
6367 if (!type)
6368 return CompilerType();
6369
6370 clang::QualType parent_qual_type(GetCanonicalQualType(type));
6371 const clang::Type::TypeClass parent_type_class =
6372 parent_qual_type->getTypeClass();
6373 child_bitfield_bit_size = 0;
6374 child_bitfield_bit_offset = 0;
6375 child_is_base_class = false;
6376 language_flags = 0;
6377
6378 const bool idx_is_valid = idx < GetNumChildren(type, omit_empty_base_classes);
6379 uint32_t bit_offset;
6380 switch (parent_type_class) {
6381 case clang::Type::Builtin:
6382 if (idx_is_valid) {
6383 switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind()) {
6384 case clang::BuiltinType::ObjCId:
6385 case clang::BuiltinType::ObjCClass:
6386 child_name = "isa";
6387 child_byte_size =
6388 getASTContext()->getTypeSize(getASTContext()->ObjCBuiltinClassTy) /
6389 CHAR_BIT8;
6390 return CompilerType(getASTContext(),
6391 getASTContext()->ObjCBuiltinClassTy);
6392
6393 default:
6394 break;
6395 }
6396 }
6397 break;
6398
6399 case clang::Type::Record:
6400 if (idx_is_valid && GetCompleteType(type)) {
6401 const clang::RecordType *record_type =
6402 llvm::cast<clang::RecordType>(parent_qual_type.getTypePtr());
6403 const clang::RecordDecl *record_decl = record_type->getDecl();
6404 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 6404, __PRETTY_FUNCTION__))
;
6405 const clang::ASTRecordLayout &record_layout =
6406 getASTContext()->getASTRecordLayout(record_decl);
6407 uint32_t child_idx = 0;
6408
6409 const clang::CXXRecordDecl *cxx_record_decl =
6410 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6411 if (cxx_record_decl) {
6412 // We might have base classes to print out first
6413 clang::CXXRecordDecl::base_class_const_iterator base_class,
6414 base_class_end;
6415 for (base_class = cxx_record_decl->bases_begin(),
6416 base_class_end = cxx_record_decl->bases_end();
6417 base_class != base_class_end; ++base_class) {
6418 const clang::CXXRecordDecl *base_class_decl = nullptr;
6419
6420 // Skip empty base classes
6421 if (omit_empty_base_classes) {
6422 base_class_decl = llvm::cast<clang::CXXRecordDecl>(
6423 base_class->getType()->getAs<clang::RecordType>()->getDecl());
6424 if (ClangASTContext::RecordHasFields(base_class_decl) == false)
6425 continue;
6426 }
6427
6428 if (idx == child_idx) {
6429 if (base_class_decl == nullptr)
6430 base_class_decl = llvm::cast<clang::CXXRecordDecl>(
6431 base_class->getType()->getAs<clang::RecordType>()->getDecl());
6432
6433 if (base_class->isVirtual()) {
6434 bool handled = false;
6435 if (valobj) {
6436 Status err;
6437 AddressType addr_type = eAddressTypeInvalid;
6438 lldb::addr_t vtable_ptr_addr =
6439 valobj->GetCPPVTableAddress(addr_type);
6440
6441 if (vtable_ptr_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL) &&
6442 addr_type == eAddressTypeLoad) {
6443
6444 ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
6445 Process *process = exe_ctx.GetProcessPtr();
6446 if (process) {
6447 clang::VTableContextBase *vtable_ctx =
6448 getASTContext()->getVTableContext();
6449 if (vtable_ctx) {
6450 if (vtable_ctx->isMicrosoft()) {
6451 clang::MicrosoftVTableContext *msoft_vtable_ctx =
6452 static_cast<clang::MicrosoftVTableContext *>(
6453 vtable_ctx);
6454
6455 if (vtable_ptr_addr) {
6456 const lldb::addr_t vbtable_ptr_addr =
6457 vtable_ptr_addr +
6458 record_layout.getVBPtrOffset().getQuantity();
6459
6460 const lldb::addr_t vbtable_ptr =
6461 process->ReadPointerFromMemory(vbtable_ptr_addr,
6462 err);
6463 if (vbtable_ptr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
6464 // Get the index into the virtual base table. The
6465 // index is the index in uint32_t from vbtable_ptr
6466 const unsigned vbtable_index =
6467 msoft_vtable_ctx->getVBTableIndex(
6468 cxx_record_decl, base_class_decl);
6469 const lldb::addr_t base_offset_addr =
6470 vbtable_ptr + vbtable_index * 4;
6471 const uint32_t base_offset =
6472 process->ReadUnsignedIntegerFromMemory(
6473 base_offset_addr, 4, UINT32_MAX(4294967295U), err);
6474 if (base_offset != UINT32_MAX(4294967295U)) {
6475 handled = true;
6476 bit_offset = base_offset * 8;
6477 }
6478 }
6479 }
6480 } else {
6481 clang::ItaniumVTableContext *itanium_vtable_ctx =
6482 static_cast<clang::ItaniumVTableContext *>(
6483 vtable_ctx);
6484 if (vtable_ptr_addr) {
6485 const lldb::addr_t vtable_ptr =
6486 process->ReadPointerFromMemory(vtable_ptr_addr,
6487 err);
6488 if (vtable_ptr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
6489 clang::CharUnits base_offset_offset =
6490 itanium_vtable_ctx->getVirtualBaseOffsetOffset(
6491 cxx_record_decl, base_class_decl);
6492 const lldb::addr_t base_offset_addr =
6493 vtable_ptr + base_offset_offset.getQuantity();
6494 const uint32_t base_offset_size =
6495 process->GetAddressByteSize();
6496 const uint64_t base_offset =
6497 process->ReadUnsignedIntegerFromMemory(
6498 base_offset_addr, base_offset_size,
6499 UINT32_MAX(4294967295U), err);
6500 if (base_offset < UINT32_MAX(4294967295U)) {
6501 handled = true;
6502 bit_offset = base_offset * 8;
6503 }
6504 }
6505 }
6506 }
6507 }
6508 }
6509 }
6510 }
6511 if (!handled)
6512 bit_offset = record_layout.getVBaseClassOffset(base_class_decl)
6513 .getQuantity() *
6514 8;
6515 } else
6516 bit_offset = record_layout.getBaseClassOffset(base_class_decl)
6517 .getQuantity() *
6518 8;
6519
6520 // Base classes should be a multiple of 8 bits in size
6521 child_byte_offset = bit_offset / 8;
6522 CompilerType base_class_clang_type(getASTContext(),
6523 base_class->getType());
6524 child_name = base_class_clang_type.GetTypeName().AsCString("");
6525 uint64_t base_class_clang_type_bit_size =
6526 base_class_clang_type.GetBitSize(
6527 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL__null);
6528
6529 // Base classes bit sizes should be a multiple of 8 bits in size
6530 assert(base_class_clang_type_bit_size % 8 == 0)((base_class_clang_type_bit_size % 8 == 0) ? static_cast<void
> (0) : __assert_fail ("base_class_clang_type_bit_size % 8 == 0"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 6530, __PRETTY_FUNCTION__))
;
6531 child_byte_size = base_class_clang_type_bit_size / 8;
6532 child_is_base_class = true;
6533 return base_class_clang_type;
6534 }
6535 // We don't increment the child index in the for loop since we might
6536 // be skipping empty base classes
6537 ++child_idx;
6538 }
6539 }
6540 // Make sure index is in range...
6541 uint32_t field_idx = 0;
6542 clang::RecordDecl::field_iterator field, field_end;
6543 for (field = record_decl->field_begin(),
6544 field_end = record_decl->field_end();
6545 field != field_end; ++field, ++field_idx, ++child_idx) {
6546 if (idx == child_idx) {
6547 // Print the member type if requested
6548 // Print the member name and equal sign
6549 child_name.assign(field->getNameAsString());
6550
6551 // Figure out the type byte size (field_type_info.first) and
6552 // alignment (field_type_info.second) from the AST context.
6553 CompilerType field_clang_type(getASTContext(), field->getType());
6554 assert(field_idx < record_layout.getFieldCount())((field_idx < record_layout.getFieldCount()) ? static_cast
<void> (0) : __assert_fail ("field_idx < record_layout.getFieldCount()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 6554, __PRETTY_FUNCTION__))
;
6555 child_byte_size = field_clang_type.GetByteSize(
6556 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL__null);
6557 const uint32_t child_bit_size = child_byte_size * 8;
6558
6559 // Figure out the field offset within the current struct/union/class
6560 // type
6561 bit_offset = record_layout.getFieldOffset(field_idx);
6562 if (ClangASTContext::FieldIsBitfield(getASTContext(), *field,
6563 child_bitfield_bit_size)) {
6564 child_bitfield_bit_offset = bit_offset % child_bit_size;
6565 const uint32_t child_bit_offset =
6566 bit_offset - child_bitfield_bit_offset;
6567 child_byte_offset = child_bit_offset / 8;
6568 } else {
6569 child_byte_offset = bit_offset / 8;
6570 }
6571
6572 return field_clang_type;
6573 }
6574 }
6575 }
6576 break;
6577
6578 case clang::Type::ObjCObject:
6579 case clang::Type::ObjCInterface:
6580 if (idx_is_valid && GetCompleteType(type)) {
6581 const clang::ObjCObjectType *objc_class_type =
6582 llvm::dyn_cast<clang::ObjCObjectType>(parent_qual_type.getTypePtr());
6583 assert(objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 6583, __PRETTY_FUNCTION__))
;
6584 if (objc_class_type) {
6585 uint32_t child_idx = 0;
6586 clang::ObjCInterfaceDecl *class_interface_decl =
6587 objc_class_type->getInterface();
6588
6589 if (class_interface_decl) {
6590
6591 const clang::ASTRecordLayout &interface_layout =
6592 getASTContext()->getASTObjCInterfaceLayout(class_interface_decl);
6593 clang::ObjCInterfaceDecl *superclass_interface_decl =
6594 class_interface_decl->getSuperClass();
6595 if (superclass_interface_decl) {
6596 if (omit_empty_base_classes) {
6597 CompilerType base_class_clang_type(
6598 getASTContext(), getASTContext()->getObjCInterfaceType(
6599 superclass_interface_decl));
6600 if (base_class_clang_type.GetNumChildren(
6601 omit_empty_base_classes) > 0) {
6602 if (idx == 0) {
6603 clang::QualType ivar_qual_type(
6604 getASTContext()->getObjCInterfaceType(
6605 superclass_interface_decl));
6606
6607 child_name.assign(
6608 superclass_interface_decl->getNameAsString());
6609
6610 clang::TypeInfo ivar_type_info =
6611 getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr());
6612
6613 child_byte_size = ivar_type_info.Width / 8;
6614 child_byte_offset = 0;
6615 child_is_base_class = true;
6616
6617 return CompilerType(getASTContext(), ivar_qual_type);
6618 }
6619
6620 ++child_idx;
6621 }
6622 } else
6623 ++child_idx;
6624 }
6625
6626 const uint32_t superclass_idx = child_idx;
6627
6628 if (idx < (child_idx + class_interface_decl->ivar_size())) {
6629 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
6630 ivar_end = class_interface_decl->ivar_end();
6631
6632 for (ivar_pos = class_interface_decl->ivar_begin();
6633 ivar_pos != ivar_end; ++ivar_pos) {
6634 if (child_idx == idx) {
6635 clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
6636
6637 clang::QualType ivar_qual_type(ivar_decl->getType());
6638
6639 child_name.assign(ivar_decl->getNameAsString());
6640
6641 clang::TypeInfo ivar_type_info =
6642 getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr());
6643
6644 child_byte_size = ivar_type_info.Width / 8;
6645
6646 // Figure out the field offset within the current
6647 // struct/union/class type
6648 // For ObjC objects, we can't trust the bit offset we get from
6649 // the Clang AST, since
6650 // that doesn't account for the space taken up by unbacked
6651 // properties, or from
6652 // the changing size of base classes that are newer than this
6653 // class.
6654 // So if we have a process around that we can ask about this
6655 // object, do so.
6656 child_byte_offset = LLDB_INVALID_IVAR_OFFSET(4294967295U);
6657 Process *process = nullptr;
6658 if (exe_ctx)
6659 process = exe_ctx->GetProcessPtr();
6660 if (process) {
6661 ObjCLanguageRuntime *objc_runtime =
6662 process->GetObjCLanguageRuntime();
6663 if (objc_runtime != nullptr) {
6664 CompilerType parent_ast_type(getASTContext(),
6665 parent_qual_type);
6666 child_byte_offset = objc_runtime->GetByteOffsetForIvar(
6667 parent_ast_type, ivar_decl->getNameAsString().c_str());
6668 }
6669 }
6670
6671 // Setting this to UINT32_MAX to make sure we don't compute it
6672 // twice...
6673 bit_offset = UINT32_MAX(4294967295U);
6674
6675 if (child_byte_offset ==
6676 static_cast<int32_t>(LLDB_INVALID_IVAR_OFFSET(4294967295U))) {
6677 bit_offset = interface_layout.getFieldOffset(child_idx -
6678 superclass_idx);
6679 child_byte_offset = bit_offset / 8;
6680 }
6681
6682 // Note, the ObjC Ivar Byte offset is just that, it doesn't
6683 // account for the bit offset
6684 // of a bitfield within its containing object. So regardless of
6685 // where we get the byte
6686 // offset from, we still need to get the bit offset for
6687 // bitfields from the layout.
6688
6689 if (ClangASTContext::FieldIsBitfield(getASTContext(), ivar_decl,
6690 child_bitfield_bit_size)) {
6691 if (bit_offset == UINT32_MAX(4294967295U))
6692 bit_offset = interface_layout.getFieldOffset(
6693 child_idx - superclass_idx);
6694
6695 child_bitfield_bit_offset = bit_offset % 8;
6696 }
6697 return CompilerType(getASTContext(), ivar_qual_type);
6698 }
6699 ++child_idx;
6700 }
6701 }
6702 }
6703 }
6704 }
6705 break;
6706
6707 case clang::Type::ObjCObjectPointer:
6708 if (idx_is_valid) {
6709 CompilerType pointee_clang_type(GetPointeeType(type));
6710
6711 if (transparent_pointers && pointee_clang_type.IsAggregateType()) {
6712 child_is_deref_of_parent = false;
6713 bool tmp_child_is_deref_of_parent = false;
6714 return pointee_clang_type.GetChildCompilerTypeAtIndex(
6715 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6716 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6717 child_bitfield_bit_size, child_bitfield_bit_offset,
6718 child_is_base_class, tmp_child_is_deref_of_parent, valobj,
6719 language_flags);
6720 } else {
6721 child_is_deref_of_parent = true;
6722 const char *parent_name =
6723 valobj ? valobj->GetName().GetCString() : NULL__null;
6724 if (parent_name) {
6725 child_name.assign(1, '*');
6726 child_name += parent_name;
6727 }
6728
6729 // We have a pointer to an simple type
6730 if (idx == 0 && pointee_clang_type.GetCompleteType()) {
6731 child_byte_size = pointee_clang_type.GetByteSize(
6732 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL__null);
6733 child_byte_offset = 0;
6734 return pointee_clang_type;
6735 }
6736 }
6737 }
6738 break;
6739
6740 case clang::Type::Vector:
6741 case clang::Type::ExtVector:
6742 if (idx_is_valid) {
6743 const clang::VectorType *array =
6744 llvm::cast<clang::VectorType>(parent_qual_type.getTypePtr());
6745 if (array) {
6746 CompilerType element_type(getASTContext(), array->getElementType());
6747 if (element_type.GetCompleteType()) {
6748 char element_name[64];
6749 ::snprintf(element_name, sizeof(element_name), "[%" PRIu64"l" "u" "]",
6750 static_cast<uint64_t>(idx));
6751 child_name.assign(element_name);
6752 child_byte_size = element_type.GetByteSize(
6753 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL__null);
6754 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
6755 return element_type;
6756 }
6757 }
6758 }
6759 break;
6760
6761 case clang::Type::ConstantArray:
6762 case clang::Type::IncompleteArray:
6763 if (ignore_array_bounds || idx_is_valid) {
6764 const clang::ArrayType *array = GetQualType(type)->getAsArrayTypeUnsafe();
6765 if (array) {
6766 CompilerType element_type(getASTContext(), array->getElementType());
6767 if (element_type.GetCompleteType()) {
6768 child_name = llvm::formatv("[{0}]", idx);
6769 child_byte_size = element_type.GetByteSize(
6770 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL__null);
6771 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
6772 return element_type;
6773 }
6774 }
6775 }
6776 break;
6777
6778 case clang::Type::Pointer: {
6779 CompilerType pointee_clang_type(GetPointeeType(type));
6780
6781 // Don't dereference "void *" pointers
6782 if (pointee_clang_type.IsVoidType())
6783 return CompilerType();
6784
6785 if (transparent_pointers && pointee_clang_type.IsAggregateType()) {
6786 child_is_deref_of_parent = false;
6787 bool tmp_child_is_deref_of_parent = false;
6788 return pointee_clang_type.GetChildCompilerTypeAtIndex(
6789 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6790 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6791 child_bitfield_bit_size, child_bitfield_bit_offset,
6792 child_is_base_class, tmp_child_is_deref_of_parent, valobj,
6793 language_flags);
6794 } else {
6795 child_is_deref_of_parent = true;
6796
6797 const char *parent_name =
6798 valobj ? valobj->GetName().GetCString() : NULL__null;
6799 if (parent_name) {
6800 child_name.assign(1, '*');
6801 child_name += parent_name;
6802 }
6803
6804 // We have a pointer to an simple type
6805 if (idx == 0) {
6806 child_byte_size = pointee_clang_type.GetByteSize(
6807 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL__null);
6808 child_byte_offset = 0;
6809 return pointee_clang_type;
6810 }
6811 }
6812 break;
6813 }
6814
6815 case clang::Type::LValueReference:
6816 case clang::Type::RValueReference:
6817 if (idx_is_valid) {
6818 const clang::ReferenceType *reference_type =
6819 llvm::cast<clang::ReferenceType>(parent_qual_type.getTypePtr());
6820 CompilerType pointee_clang_type(getASTContext(),
6821 reference_type->getPointeeType());
6822 if (transparent_pointers && pointee_clang_type.IsAggregateType()) {
6823 child_is_deref_of_parent = false;
6824 bool tmp_child_is_deref_of_parent = false;
6825 return pointee_clang_type.GetChildCompilerTypeAtIndex(
6826 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6827 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6828 child_bitfield_bit_size, child_bitfield_bit_offset,
6829 child_is_base_class, tmp_child_is_deref_of_parent, valobj,
6830 language_flags);
6831 } else {
6832 const char *parent_name =
6833 valobj ? valobj->GetName().GetCString() : NULL__null;
6834 if (parent_name) {
6835 child_name.assign(1, '&');
6836 child_name += parent_name;
6837 }
6838
6839 // We have a pointer to an simple type
6840 if (idx == 0) {
6841 child_byte_size = pointee_clang_type.GetByteSize(
6842 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL__null);
6843 child_byte_offset = 0;
6844 return pointee_clang_type;
6845 }
6846 }
6847 }
6848 break;
6849
6850 case clang::Type::Typedef: {
6851 CompilerType typedefed_clang_type(
6852 getASTContext(), llvm::cast<clang::TypedefType>(parent_qual_type)
6853 ->getDecl()
6854 ->getUnderlyingType());
6855 return typedefed_clang_type.GetChildCompilerTypeAtIndex(
6856 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6857 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6858 child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
6859 child_is_deref_of_parent, valobj, language_flags);
6860 } break;
6861
6862 case clang::Type::Auto: {
6863 CompilerType elaborated_clang_type(
6864 getASTContext(),
6865 llvm::cast<clang::AutoType>(parent_qual_type)->getDeducedType());
6866 return elaborated_clang_type.GetChildCompilerTypeAtIndex(
6867 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6868 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6869 child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
6870 child_is_deref_of_parent, valobj, language_flags);
6871 }
6872
6873 case clang::Type::Elaborated: {
6874 CompilerType elaborated_clang_type(
6875 getASTContext(),
6876 llvm::cast<clang::ElaboratedType>(parent_qual_type)->getNamedType());
6877 return elaborated_clang_type.GetChildCompilerTypeAtIndex(
6878 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6879 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6880 child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
6881 child_is_deref_of_parent, valobj, language_flags);
6882 }
6883
6884 case clang::Type::Paren: {
6885 CompilerType paren_clang_type(
6886 getASTContext(),
6887 llvm::cast<clang::ParenType>(parent_qual_type)->desugar());
6888 return paren_clang_type.GetChildCompilerTypeAtIndex(
6889 exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
6890 ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
6891 child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
6892 child_is_deref_of_parent, valobj, language_flags);
6893 }
6894
6895 default:
6896 break;
6897 }
6898 return CompilerType();
6899}
6900
6901static uint32_t GetIndexForRecordBase(const clang::RecordDecl *record_decl,
6902 const clang::CXXBaseSpecifier *base_spec,
6903 bool omit_empty_base_classes) {
6904 uint32_t child_idx = 0;
6905
6906 const clang::CXXRecordDecl *cxx_record_decl =
6907 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6908
6909 // const char *super_name = record_decl->getNameAsCString();
6910 // const char *base_name =
6911 // base_spec->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString();
6912 // printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
6913 //
6914 if (cxx_record_decl) {
6915 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
6916 for (base_class = cxx_record_decl->bases_begin(),
6917 base_class_end = cxx_record_decl->bases_end();
6918 base_class != base_class_end; ++base_class) {
6919 if (omit_empty_base_classes) {
6920 if (BaseSpecifierIsEmpty(base_class))
6921 continue;
6922 }
6923
6924 // printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n",
6925 // super_name, base_name,
6926 // child_idx,
6927 // base_class->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString());
6928 //
6929 //
6930 if (base_class == base_spec)
6931 return child_idx;
6932 ++child_idx;
6933 }
6934 }
6935
6936 return UINT32_MAX(4294967295U);
6937}
6938
6939static uint32_t GetIndexForRecordChild(const clang::RecordDecl *record_decl,
6940 clang::NamedDecl *canonical_decl,
6941 bool omit_empty_base_classes) {
6942 uint32_t child_idx = ClangASTContext::GetNumBaseClasses(
6943 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl),
6944 omit_empty_base_classes);
6945
6946 clang::RecordDecl::field_iterator field, field_end;
6947 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
6948 field != field_end; ++field, ++child_idx) {
6949 if (field->getCanonicalDecl() == canonical_decl)
6950 return child_idx;
6951 }
6952
6953 return UINT32_MAX(4294967295U);
6954}
6955
6956// Look for a child member (doesn't include base classes, but it does include
6957// their members) in the type hierarchy. Returns an index path into "clang_type"
6958// on how to reach the appropriate member.
6959//
6960// class A
6961// {
6962// public:
6963// int m_a;
6964// int m_b;
6965// };
6966//
6967// class B
6968// {
6969// };
6970//
6971// class C :
6972// public B,
6973// public A
6974// {
6975// };
6976//
6977// If we have a clang type that describes "class C", and we wanted to looked
6978// "m_b" in it:
6979//
6980// With omit_empty_base_classes == false we would get an integer array back
6981// with:
6982// { 1, 1 }
6983// The first index 1 is the child index for "class A" within class C
6984// The second index 1 is the child index for "m_b" within class A
6985//
6986// With omit_empty_base_classes == true we would get an integer array back with:
6987// { 0, 1 }
6988// The first index 0 is the child index for "class A" within class C (since
6989// class B doesn't have any members it doesn't count)
6990// The second index 1 is the child index for "m_b" within class A
6991
6992size_t ClangASTContext::GetIndexOfChildMemberWithName(
6993 lldb::opaque_compiler_type_t type, const char *name,
6994 bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) {
6995 if (type && name && name[0]) {
6996 clang::QualType qual_type(GetCanonicalQualType(type));
6997 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6998 switch (type_class) {
6999 case clang::Type::Record:
7000 if (GetCompleteType(type)) {
7001 const clang::RecordType *record_type =
7002 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
7003 const clang::RecordDecl *record_decl = record_type->getDecl();
7004
7005 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 7005, __PRETTY_FUNCTION__))
;
7006 uint32_t child_idx = 0;
7007
7008 const clang::CXXRecordDecl *cxx_record_decl =
7009 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
7010
7011 // Try and find a field that matches NAME
7012 clang::RecordDecl::field_iterator field, field_end;
7013 llvm::StringRef name_sref(name);
7014 for (field = record_decl->field_begin(),
7015 field_end = record_decl->field_end();
7016 field != field_end; ++field, ++child_idx) {
7017 llvm::StringRef field_name = field->getName();
7018 if (field_name.empty()) {
7019 CompilerType field_type(getASTContext(), field->getType());
7020 child_indexes.push_back(child_idx);
7021 if (field_type.GetIndexOfChildMemberWithName(
7022 name, omit_empty_base_classes, child_indexes))
7023 return child_indexes.size();
7024 child_indexes.pop_back();
7025
7026 } else if (field_name.equals(name_sref)) {
7027 // We have to add on the number of base classes to this index!
7028 child_indexes.push_back(
7029 child_idx + ClangASTContext::GetNumBaseClasses(
7030 cxx_record_decl, omit_empty_base_classes));
7031 return child_indexes.size();
7032 }
7033 }
7034
7035 if (cxx_record_decl) {
7036 const clang::RecordDecl *parent_record_decl = cxx_record_decl;
7037
7038 // printf ("parent = %s\n", parent_record_decl->getNameAsCString());
7039
7040 // const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
7041 // Didn't find things easily, lets let clang do its thang...
7042 clang::IdentifierInfo &ident_ref =
7043 getASTContext()->Idents.get(name_sref);
7044 clang::DeclarationName decl_name(&ident_ref);
7045
7046 clang::CXXBasePaths paths;
7047 if (cxx_record_decl->lookupInBases(
7048 [decl_name](const clang::CXXBaseSpecifier *specifier,
7049 clang::CXXBasePath &path) {
7050 return clang::CXXRecordDecl::FindOrdinaryMember(
7051 specifier, path, decl_name);
7052 },
7053 paths)) {
7054 clang::CXXBasePaths::const_paths_iterator path,
7055 path_end = paths.end();
7056 for (path = paths.begin(); path != path_end; ++path) {
7057 const size_t num_path_elements = path->size();
7058 for (size_t e = 0; e < num_path_elements; ++e) {
7059 clang::CXXBasePathElement elem = (*path)[e];
7060
7061 child_idx = GetIndexForRecordBase(parent_record_decl, elem.Base,
7062 omit_empty_base_classes);
7063 if (child_idx == UINT32_MAX(4294967295U)) {
7064 child_indexes.clear();
7065 return 0;
7066 } else {
7067 child_indexes.push_back(child_idx);
7068 parent_record_decl = llvm::cast<clang::RecordDecl>(
7069 elem.Base->getType()
7070 ->getAs<clang::RecordType>()
7071 ->getDecl());
7072 }
7073 }
7074 for (clang::NamedDecl *path_decl : path->Decls) {
7075 child_idx = GetIndexForRecordChild(
7076 parent_record_decl, path_decl, omit_empty_base_classes);
7077 if (child_idx == UINT32_MAX(4294967295U)) {
7078 child_indexes.clear();
7079 return 0;
7080 } else {
7081 child_indexes.push_back(child_idx);
7082 }
7083 }
7084 }
7085 return child_indexes.size();
7086 }
7087 }
7088 }
7089 break;
7090
7091 case clang::Type::ObjCObject:
7092 case clang::Type::ObjCInterface:
7093 if (GetCompleteType(type)) {
7094 llvm::StringRef name_sref(name);
7095 const clang::ObjCObjectType *objc_class_type =
7096 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
7097 assert(objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 7097, __PRETTY_FUNCTION__))
;
7098 if (objc_class_type) {
7099 uint32_t child_idx = 0;
7100 clang::ObjCInterfaceDecl *class_interface_decl =
7101 objc_class_type->getInterface();
7102
7103 if (class_interface_decl) {
7104 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
7105 ivar_end = class_interface_decl->ivar_end();
7106 clang::ObjCInterfaceDecl *superclass_interface_decl =
7107 class_interface_decl->getSuperClass();
7108
7109 for (ivar_pos = class_interface_decl->ivar_begin();
7110 ivar_pos != ivar_end; ++ivar_pos, ++child_idx) {
7111 const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
7112
7113 if (ivar_decl->getName().equals(name_sref)) {
7114 if ((!omit_empty_base_classes && superclass_interface_decl) ||
7115 (omit_empty_base_classes &&
7116 ObjCDeclHasIVars(superclass_interface_decl, true)))
7117 ++child_idx;
7118
7119 child_indexes.push_back(child_idx);
7120 return child_indexes.size();
7121 }
7122 }
7123
7124 if (superclass_interface_decl) {
7125 // The super class index is always zero for ObjC classes,
7126 // so we push it onto the child indexes in case we find
7127 // an ivar in our superclass...
7128 child_indexes.push_back(0);
7129
7130 CompilerType superclass_clang_type(
7131 getASTContext(), getASTContext()->getObjCInterfaceType(
7132 superclass_interface_decl));
7133 if (superclass_clang_type.GetIndexOfChildMemberWithName(
7134 name, omit_empty_base_classes, child_indexes)) {
7135 // We did find an ivar in a superclass so just
7136 // return the results!
7137 return child_indexes.size();
7138 }
7139
7140 // We didn't find an ivar matching "name" in our
7141 // superclass, pop the superclass zero index that
7142 // we pushed on above.
7143 child_indexes.pop_back();
7144 }
7145 }
7146 }
7147 }
7148 break;
7149
7150 case clang::Type::ObjCObjectPointer: {
7151 CompilerType objc_object_clang_type(
7152 getASTContext(),
7153 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
7154 ->getPointeeType());
7155 return objc_object_clang_type.GetIndexOfChildMemberWithName(
7156 name, omit_empty_base_classes, child_indexes);
7157 } break;
7158
7159 case clang::Type::ConstantArray: {
7160 // const clang::ConstantArrayType *array =
7161 // llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
7162 // const uint64_t element_count =
7163 // array->getSize().getLimitedValue();
7164 //
7165 // if (idx < element_count)
7166 // {
7167 // std::pair<uint64_t, unsigned> field_type_info =
7168 // ast->getTypeInfo(array->getElementType());
7169 //
7170 // char element_name[32];
7171 // ::snprintf (element_name, sizeof (element_name),
7172 // "%s[%u]", parent_name ? parent_name : "", idx);
7173 //
7174 // child_name.assign(element_name);
7175 // assert(field_type_info.first % 8 == 0);
7176 // child_byte_size = field_type_info.first / 8;
7177 // child_byte_offset = idx * child_byte_size;
7178 // return array->getElementType().getAsOpaquePtr();
7179 // }
7180 } break;
7181
7182 // case clang::Type::MemberPointerType:
7183 // {
7184 // MemberPointerType *mem_ptr_type =
7185 // llvm::cast<MemberPointerType>(qual_type.getTypePtr());
7186 // clang::QualType pointee_type =
7187 // mem_ptr_type->getPointeeType();
7188 //
7189 // if (ClangASTContext::IsAggregateType
7190 // (pointee_type.getAsOpaquePtr()))
7191 // {
7192 // return GetIndexOfChildWithName (ast,
7193 // mem_ptr_type->getPointeeType().getAsOpaquePtr(),
7194 // name);
7195 // }
7196 // }
7197 // break;
7198 //
7199 case clang::Type::LValueReference:
7200 case clang::Type::RValueReference: {
7201 const clang::ReferenceType *reference_type =
7202 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
7203 clang::QualType pointee_type(reference_type->getPointeeType());
7204 CompilerType pointee_clang_type(getASTContext(), pointee_type);
7205
7206 if (pointee_clang_type.IsAggregateType()) {
7207 return pointee_clang_type.GetIndexOfChildMemberWithName(
7208 name, omit_empty_base_classes, child_indexes);
7209 }
7210 } break;
7211
7212 case clang::Type::Pointer: {
7213 CompilerType pointee_clang_type(GetPointeeType(type));
7214
7215 if (pointee_clang_type.IsAggregateType()) {
7216 return pointee_clang_type.GetIndexOfChildMemberWithName(
7217 name, omit_empty_base_classes, child_indexes);
7218 }
7219 } break;
7220
7221 case clang::Type::Typedef:
7222 return CompilerType(getASTContext(),
7223 llvm::cast<clang::TypedefType>(qual_type)
7224 ->getDecl()
7225 ->getUnderlyingType())
7226 .GetIndexOfChildMemberWithName(name, omit_empty_base_classes,
7227 child_indexes);
7228
7229 case clang::Type::Auto:
7230 return CompilerType(
7231 getASTContext(),
7232 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
7233 .GetIndexOfChildMemberWithName(name, omit_empty_base_classes,
7234 child_indexes);
7235
7236 case clang::Type::Elaborated:
7237 return CompilerType(
7238 getASTContext(),
7239 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
7240 .GetIndexOfChildMemberWithName(name, omit_empty_base_classes,
7241 child_indexes);
7242
7243 case clang::Type::Paren:
7244 return CompilerType(getASTContext(),
7245 llvm::cast<clang::ParenType>(qual_type)->desugar())
7246 .GetIndexOfChildMemberWithName(name, omit_empty_base_classes,
7247 child_indexes);
7248
7249 default:
7250 break;
7251 }
7252 }
7253 return 0;
7254}
7255
7256// Get the index of the child of "clang_type" whose name matches. This function
7257// doesn't descend into the children, but only looks one level deep and name
7258// matches can include base class names.
7259
7260uint32_t
7261ClangASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
7262 const char *name,
7263 bool omit_empty_base_classes) {
7264 if (type && name && name[0]) {
7265 clang::QualType qual_type(GetCanonicalQualType(type));
7266
7267 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7268
7269 switch (type_class) {
7270 case clang::Type::Record:
7271 if (GetCompleteType(type)) {
7272 const clang::RecordType *record_type =
7273 llvm::cast<clang::RecordType>(qual_type.getTypePtr());
7274 const clang::RecordDecl *record_decl = record_type->getDecl();
7275
7276 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 7276, __PRETTY_FUNCTION__))
;
7277 uint32_t child_idx = 0;
7278
7279 const clang::CXXRecordDecl *cxx_record_decl =
7280 llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
7281
7282 if (cxx_record_decl) {
7283 clang::CXXRecordDecl::base_class_const_iterator base_class,
7284 base_class_end;
7285 for (base_class = cxx_record_decl->bases_begin(),
7286 base_class_end = cxx_record_decl->bases_end();
7287 base_class != base_class_end; ++base_class) {
7288 // Skip empty base classes
7289 clang::CXXRecordDecl *base_class_decl =
7290 llvm::cast<clang::CXXRecordDecl>(
7291 base_class->getType()
7292 ->getAs<clang::RecordType>()
7293 ->getDecl());
7294 if (omit_empty_base_classes &&
7295 ClangASTContext::RecordHasFields(base_class_decl) == false)
7296 continue;
7297
7298 CompilerType base_class_clang_type(getASTContext(),
7299 base_class->getType());
7300 std::string base_class_type_name(
7301 base_class_clang_type.GetTypeName().AsCString(""));
7302 if (base_class_type_name.compare(name) == 0)
7303 return child_idx;
7304 ++child_idx;
7305 }
7306 }
7307
7308 // Try and find a field that matches NAME
7309 clang::RecordDecl::field_iterator field, field_end;
7310 llvm::StringRef name_sref(name);
7311 for (field = record_decl->field_begin(),
7312 field_end = record_decl->field_end();
7313 field != field_end; ++field, ++child_idx) {
7314 if (field->getName().equals(name_sref))
7315 return child_idx;
7316 }
7317 }
7318 break;
7319
7320 case clang::Type::ObjCObject:
7321 case clang::Type::ObjCInterface:
7322 if (GetCompleteType(type)) {
7323 llvm::StringRef name_sref(name);
7324 const clang::ObjCObjectType *objc_class_type =
7325 llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
7326 assert(objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 7326, __PRETTY_FUNCTION__))
;
7327 if (objc_class_type) {
7328 uint32_t child_idx = 0;
7329 clang::ObjCInterfaceDecl *class_interface_decl =
7330 objc_class_type->getInterface();
7331
7332 if (class_interface_decl) {
7333 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
7334 ivar_end = class_interface_decl->ivar_end();
7335 clang::ObjCInterfaceDecl *superclass_interface_decl =
7336 class_interface_decl->getSuperClass();
7337
7338 for (ivar_pos = class_interface_decl->ivar_begin();
7339 ivar_pos != ivar_end; ++ivar_pos, ++child_idx) {
7340 const clang::ObjCIvarDecl *ivar_decl = *ivar_pos;
7341
7342 if (ivar_decl->getName().equals(name_sref)) {
7343 if ((!omit_empty_base_classes && superclass_interface_decl) ||
7344 (omit_empty_base_classes &&
7345 ObjCDeclHasIVars(superclass_interface_decl, true)))
7346 ++child_idx;
7347
7348 return child_idx;
7349 }
7350 }
7351
7352 if (superclass_interface_decl) {
7353 if (superclass_interface_decl->getName().equals(name_sref))
7354 return 0;
7355 }
7356 }
7357 }
7358 }
7359 break;
7360
7361 case clang::Type::ObjCObjectPointer: {
7362 CompilerType pointee_clang_type(
7363 getASTContext(),
7364 llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())
7365 ->getPointeeType());
7366 return pointee_clang_type.GetIndexOfChildWithName(
7367 name, omit_empty_base_classes);
7368 } break;
7369
7370 case clang::Type::ConstantArray: {
7371 // const clang::ConstantArrayType *array =
7372 // llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
7373 // const uint64_t element_count =
7374 // array->getSize().getLimitedValue();
7375 //
7376 // if (idx < element_count)
7377 // {
7378 // std::pair<uint64_t, unsigned> field_type_info =
7379 // ast->getTypeInfo(array->getElementType());
7380 //
7381 // char element_name[32];
7382 // ::snprintf (element_name, sizeof (element_name),
7383 // "%s[%u]", parent_name ? parent_name : "", idx);
7384 //
7385 // child_name.assign(element_name);
7386 // assert(field_type_info.first % 8 == 0);
7387 // child_byte_size = field_type_info.first / 8;
7388 // child_byte_offset = idx * child_byte_size;
7389 // return array->getElementType().getAsOpaquePtr();
7390 // }
7391 } break;
7392
7393 // case clang::Type::MemberPointerType:
7394 // {
7395 // MemberPointerType *mem_ptr_type =
7396 // llvm::cast<MemberPointerType>(qual_type.getTypePtr());
7397 // clang::QualType pointee_type =
7398 // mem_ptr_type->getPointeeType();
7399 //
7400 // if (ClangASTContext::IsAggregateType
7401 // (pointee_type.getAsOpaquePtr()))
7402 // {
7403 // return GetIndexOfChildWithName (ast,
7404 // mem_ptr_type->getPointeeType().getAsOpaquePtr(),
7405 // name);
7406 // }
7407 // }
7408 // break;
7409 //
7410 case clang::Type::LValueReference:
7411 case clang::Type::RValueReference: {
7412 const clang::ReferenceType *reference_type =
7413 llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
7414 CompilerType pointee_type(getASTContext(),
7415 reference_type->getPointeeType());
7416
7417 if (pointee_type.IsAggregateType()) {
7418 return pointee_type.GetIndexOfChildWithName(name,
7419 omit_empty_base_classes);
7420 }
7421 } break;
7422
7423 case clang::Type::Pointer: {
7424 const clang::PointerType *pointer_type =
7425 llvm::cast<clang::PointerType>(qual_type.getTypePtr());
7426 CompilerType pointee_type(getASTContext(),
7427 pointer_type->getPointeeType());
7428
7429 if (pointee_type.IsAggregateType()) {
7430 return pointee_type.GetIndexOfChildWithName(name,
7431 omit_empty_base_classes);
7432 } else {
7433 // if (parent_name)
7434 // {
7435 // child_name.assign(1, '*');
7436 // child_name += parent_name;
7437 // }
7438 //
7439 // // We have a pointer to an simple type
7440 // if (idx == 0)
7441 // {
7442 // std::pair<uint64_t, unsigned> clang_type_info
7443 // = ast->getTypeInfo(pointee_type);
7444 // assert(clang_type_info.first % 8 == 0);
7445 // child_byte_size = clang_type_info.first / 8;
7446 // child_byte_offset = 0;
7447 // return pointee_type.getAsOpaquePtr();
7448 // }
7449 }
7450 } break;
7451
7452 case clang::Type::Auto:
7453 return CompilerType(
7454 getASTContext(),
7455 llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
7456 .GetIndexOfChildWithName(name, omit_empty_base_classes);
7457
7458 case clang::Type::Elaborated:
7459 return CompilerType(
7460 getASTContext(),
7461 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
7462 .GetIndexOfChildWithName(name, omit_empty_base_classes);
7463
7464 case clang::Type::Paren:
7465 return CompilerType(getASTContext(),
7466 llvm::cast<clang::ParenType>(qual_type)->desugar())
7467 .GetIndexOfChildWithName(name, omit_empty_base_classes);
7468
7469 case clang::Type::Typedef:
7470 return CompilerType(getASTContext(),
7471 llvm::cast<clang::TypedefType>(qual_type)
7472 ->getDecl()
7473 ->getUnderlyingType())
7474 .GetIndexOfChildWithName(name, omit_empty_base_classes);
7475
7476 default:
7477 break;
7478 }
7479 }
7480 return UINT32_MAX(4294967295U);
7481}
7482
7483size_t
7484ClangASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
7485 if (!type)
7486 return 0;
7487
7488 clang::QualType qual_type(GetCanonicalQualType(type));
7489 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7490 switch (type_class) {
7491 case clang::Type::Record:
7492 if (GetCompleteType(type)) {
7493 const clang::CXXRecordDecl *cxx_record_decl =
7494 qual_type->getAsCXXRecordDecl();
7495 if (cxx_record_decl) {
7496 const clang::ClassTemplateSpecializationDecl *template_decl =
7497 llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
7498 cxx_record_decl);
7499 if (template_decl)
7500 return template_decl->getTemplateArgs().size();
7501 }
7502 }
7503 break;
7504
7505 case clang::Type::Typedef:
7506 return (CompilerType(getASTContext(),
7507 llvm::cast<clang::TypedefType>(qual_type)
7508 ->getDecl()
7509 ->getUnderlyingType()))
7510 .GetNumTemplateArguments();
7511
7512 case clang::Type::Auto:
7513 return (CompilerType(
7514 getASTContext(),
7515 llvm::cast<clang::AutoType>(qual_type)->getDeducedType()))
7516 .GetNumTemplateArguments();
7517
7518 case clang::Type::Elaborated:
7519 return (CompilerType(
7520 getASTContext(),
7521 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()))
7522 .GetNumTemplateArguments();
7523
7524 case clang::Type::Paren:
7525 return (CompilerType(getASTContext(),
7526 llvm::cast<clang::ParenType>(qual_type)->desugar()))
7527 .GetNumTemplateArguments();
7528
7529 default:
7530 break;
7531 }
7532
7533 return 0;
7534}
7535
7536CompilerType
7537ClangASTContext::GetTemplateArgument(lldb::opaque_compiler_type_t type,
7538 size_t arg_idx,
7539 lldb::TemplateArgumentKind &kind) {
7540 if (!type)
7541 return CompilerType();
7542
7543 clang::QualType qual_type(GetCanonicalQualType(type));
7544 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7545 switch (type_class) {
7546 case clang::Type::Record:
7547 if (GetCompleteType(type)) {
7548 const clang::CXXRecordDecl *cxx_record_decl =
7549 qual_type->getAsCXXRecordDecl();
7550 if (cxx_record_decl) {
7551 const clang::ClassTemplateSpecializationDecl *template_decl =
7552 llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
7553 cxx_record_decl);
7554 if (template_decl &&
7555 arg_idx < template_decl->getTemplateArgs().size()) {
7556 const clang::TemplateArgument &template_arg =
7557 template_decl->getTemplateArgs()[arg_idx];
7558 switch (template_arg.getKind()) {
7559 case clang::TemplateArgument::Null:
7560 kind = eTemplateArgumentKindNull;
7561 return CompilerType();
7562
7563 case clang::TemplateArgument::Type:
7564 kind = eTemplateArgumentKindType;
7565 return CompilerType(getASTContext(), template_arg.getAsType());
7566
7567 case clang::TemplateArgument::Declaration:
7568 kind = eTemplateArgumentKindDeclaration;
7569 return CompilerType();
7570
7571 case clang::TemplateArgument::Integral:
7572 kind = eTemplateArgumentKindIntegral;
7573 return CompilerType(getASTContext(),
7574 template_arg.getIntegralType());
7575
7576 case clang::TemplateArgument::Template:
7577 kind = eTemplateArgumentKindTemplate;
7578 return CompilerType();
7579
7580 case clang::TemplateArgument::TemplateExpansion:
7581 kind = eTemplateArgumentKindTemplateExpansion;
7582 return CompilerType();
7583
7584 case clang::TemplateArgument::Expression:
7585 kind = eTemplateArgumentKindExpression;
7586 return CompilerType();
7587
7588 case clang::TemplateArgument::Pack:
7589 kind = eTemplateArgumentKindPack;
7590 return CompilerType();
7591
7592 default:
7593 llvm_unreachable("Unhandled clang::TemplateArgument::ArgKind")::llvm::llvm_unreachable_internal("Unhandled clang::TemplateArgument::ArgKind"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/lldb/source/Symbol/ClangASTContext.cpp"
, 7593)
;
7594 }
7595 }
7596 }
7597 }
7598 break;
7599
7600 case clang::Type::Typedef:
7601 return (CompilerType(getASTContext(),
7602 llvm::cast<clang::TypedefType>(qual_type)
7603 ->getDecl()
7604 ->getUnderlyingType()))
7605 .GetTemplateArgument(arg_idx, kind);
7606
7607 case clang::Type::Auto:
7608 return (CompilerType(
7609 getASTContext(),
7610 llvm::cast<clang::AutoType>(qual_type)->getDeducedType()))
7611 .GetTemplateArgument(arg_idx, kind);
7612
7613 case clang::Type::Elaborated:
7614 return (CompilerType(
7615 getASTContext(),
7616 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()))
7617 .GetTemplateArgument(arg_idx, kind);
7618
7619 case clang::Type::Paren:
7620 return (CompilerType(getASTContext(),
7621 llvm::cast<clang::ParenType>(qual_type)->desugar()))
7622 .GetTemplateArgument(arg_idx, kind);
7623
7624 default:
7625 break;
7626 }
7627 kind = eTemplateArgumentKindNull;
7628 return CompilerType();
7629}
7630
7631CompilerType ClangASTContext::GetTypeForFormatters(void *type) {
7632 if (type)
7633 return ClangUtil::RemoveFastQualifiers(CompilerType(this, type));
7634 return CompilerType();
7635}
7636
7637clang::EnumDecl *ClangASTContext::GetAsEnumDecl(const CompilerType &type) {
7638 const clang::EnumType *enutype =
7639 llvm::dyn_cast<clang::EnumType>(ClangUtil::GetCanonicalQualType(type));
7640 if (enutype)
7641 return enutype->getDecl();
7642 return NULL__null;
7643}
7644
7645clang::RecordDecl *ClangASTContext::GetAsRecordDecl(const CompilerType &type) {
7646 const clang::RecordType *record_type =
7647 llvm::dyn_cast<clang::RecordType>(ClangUtil::GetCanonicalQualType(type));
7648 if (record_type)
7649 return record_type->getDecl();
7650 return nullptr;
7651}
7652
7653clang::TagDecl *ClangASTContext::GetAsTagDecl(const CompilerType &type) {
7654 clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type);
7655 if (qual_type.isNull())
7656 return nullptr;
7657 else
7658 return qual_type->getAsTagDecl();
7659}
7660
7661clang::CXXRecordDecl *
7662ClangASTContext::GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type) {
7663 return GetCanonicalQualType(type)->getAsCXXRecordDecl();
7664}
7665
7666clang::ObjCInterfaceDecl *
7667ClangASTContext::GetAsObjCInterfaceDecl(const CompilerType &type) {
7668 const clang::ObjCObjectType *objc_class_type =
7669 llvm::dyn_cast<clang::ObjCObjectType>(
7670 ClangUtil::GetCanonicalQualType(type));
7671 if (objc_class_type)
7672 return objc_class_type->getInterface();
7673 return nullptr;
7674}
7675
7676clang::FieldDecl *ClangASTContext::AddFieldToRecordType(
7677 const CompilerType &type, const char *name,
7678 const CompilerType &field_clang_type, AccessType access,
7679 uint32_t bitfield_bit_size) {
7680 if (!type.IsValid() || !field_clang_type.IsValid())
7681 return nullptr;
7682 ClangASTContext *ast =
7683 llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem());
7684 if (!ast)
7685 return nullptr;
7686 clang::ASTContext *clang_ast = ast->getASTContext();
7687
7688 clang::FieldDecl *field = nullptr;
7689
7690 clang::Expr *bit_width = nullptr;
7691 if (bitfield_bit_size != 0) {
7692 llvm::APInt bitfield_bit_size_apint(
7693 clang_ast->getTypeSize(clang_ast->IntTy), bitfield_bit_size);
7694 bit_width = new (*clang_ast)
7695 clang::IntegerLiteral(*clang_ast, bitfield_bit_size_apint,
7696 clang_ast->IntTy, clang::SourceLocation());
7697 }
7698
7699 clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
7700 if (record_decl) {
7701 field = clang::FieldDecl::Create(
7702 *clang_ast, record_decl, clang::SourceLocation(),
7703 clang::SourceLocation(),
7704 name ? &clang_ast->Idents.get(name) : nullptr, // Identifier
7705 ClangUtil::GetQualType(field_clang_type), // Field type
7706 nullptr, // TInfo *
7707 bit_width, // BitWidth
7708 false, // Mutable
7709 clang::ICIS_NoInit); // HasInit
7710
7711 if (!name) {
7712 // Determine whether this field corresponds to an anonymous
7713 // struct or union.
7714 if (const clang::TagType *TagT =
7715 field->getType()->getAs<clang::TagType>()) {
7716 if (clang::RecordDecl *Rec =
7717 llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl()))
7718 if (!Rec->getDeclName()) {
7719 Rec->setAnonymousStructOrUnion(true);
7720 field->setImplicit();
7721 }
7722 }
7723 }
7724
7725 if (field) {
7726 field->setAccess(
7727 ClangASTContext::ConvertAccessTypeToAccessSpecifier(access));
7728
7729 record_decl->addDecl(field);
7730
7731#ifdef LLDB_CONFIGURATION_DEBUG
7732 VerifyDecl(field);
7733#endif
7734 }
7735 } else {
7736 clang::ObjCInterfaceDecl *class_interface_decl =
7737 ast->GetAsObjCInterfaceDecl(type);
7738
7739 if (class_interface_decl) {
7740 const bool is_synthesized = false;
7741
7742 field_clang_type.GetCompleteType();
7743
7744 field = clang::ObjCIvarDecl::Create(
7745 *clang_ast, class_interface_decl, clang::SourceLocation(),
7746 clang::SourceLocation(),
7747 name ? &clang_ast->Idents.get(name) : nullptr, // Identifier
7748 ClangUtil::GetQualType(field_clang_type), // Field type
7749 nullptr, // TypeSourceInfo *
7750 ConvertAccessTypeToObjCIvarAccessControl(access), bit_width,
7751 is_synthesized);
7752
7753 if (field) {
7754 class_interface_decl->addDecl(field);
7755
7756#ifdef LLDB_CONFIGURATION_DEBUG
7757 VerifyDecl(field);
7758#endif
7759 }
7760 }
7761 }
7762 return field;
7763}
7764
7765void ClangASTContext::BuildIndirectFields(const CompilerType &type) {
7766 if (!type)
7767 return;
7768
7769 ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
7770 if (!ast)
7771 return;
7772
7773 clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
7774
7775 if (!record_decl)
7776 return;
7777
7778 typedef llvm::SmallVector<clang::IndirectFieldDecl *, 1> IndirectFieldVector;
7779
7780 IndirectFieldVector indirect_fields;
7781 clang::RecordDecl::field_iterator field_pos;
7782 clang::RecordDecl::field_iterator field_end_pos = record_decl->field_end();
7783 clang::RecordDecl::field_iterator last_field_pos = field_end_pos;
7784 for (field_pos = record_decl->field_begin(); field_pos != field_end_pos;
7785 last_field_pos = field_pos++) {
7786 if (field_pos->isAnonymousStructOrUnion()) {
7787 clang::QualType field_qual_type = field_pos->getType();
7788
7789 const clang::RecordType *field_record_type =
7790 field_qual_type->getAs<clang::RecordType>();
7791
7792 if (!field_record_type)
7793 continue;
7794
7795 clang::RecordDecl *field_record_decl = field_record_type->getDecl();
7796
7797 if (!field_record_decl)
7798 continue;
7799
7800 for (clang::RecordDecl::decl_iterator
7801 di = field_record_decl->decls_begin(),
7802 de = field_record_decl->decls_end();
7803 di != de; ++di) {
7804 if (clang::FieldDecl *nested_field_decl =
7805 llvm::dyn_cast<clang::FieldDecl>(*di)) {
7806 clang::NamedDecl **chain =
7807 new (*ast->getASTContext()) clang::NamedDecl *[2];
7808 chain[0] = *field_pos;
7809 chain[1] = nested_field_decl;
7810 clang::IndirectFieldDecl *indirect_field =
7811 clang::IndirectFieldDecl::Create(
7812 *ast->getASTContext(), record_decl, clang::SourceLocation(),
7813 nested_field_decl->getIdentifier(),
7814 nested_field_decl->getType(), {chain, 2});
7815
7816 indirect_field->setImplicit();
7817
7818 indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(
7819 field_pos->getAccess(), nested_field_decl->getAccess()));
7820
7821 indirect_fields.push_back(indirect_field);
7822 } else if (clang::IndirectFieldDecl *nested_indirect_field_decl =
7823 llvm::dyn_cast<clang::IndirectFieldDecl>(*di)) {
7824 size_t nested_chain_size =
7825 nested_indirect_field_decl->getChainingSize();
7826 clang::NamedDecl **chain = new (*ast->getASTContext())
7827 clang::NamedDecl *[nested_chain_size + 1];
7828 chain[0] = *field_pos;
7829
7830 int chain_index = 1;
7831 for (clang::IndirectFieldDecl::chain_iterator
7832 nci = nested_indirect_field_decl->chain_begin(),
7833 nce = nested_indirect_field_decl->chain_end();
7834 nci < nce; ++nci) {
7835 chain[chain_index] = *nci;
7836 chain_index++;
7837 }
7838
7839 clang::IndirectFieldDecl *indirect_field =
7840 clang::IndirectFieldDecl::Create(
7841 *ast->getASTContext(), record_decl, clang::SourceLocation(),
7842 nested_indirect_field_decl->getIdentifier(),
7843 nested_indirect_field_decl->getType(),
7844 {chain, nested_chain_size + 1});
7845
7846 indirect_field->setImplicit();
7847
7848 indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(
7849 field_pos->getAccess(), nested_indirect_field_decl->getAccess()));
7850
7851 indirect_fields.push_back(indirect_field);
7852 }
7853 }
7854 }
7855 }
7856
7857 // Check the last field to see if it has an incomplete array type as its
7858 // last member and if it does, the tell the record decl about it
7859 if (last_field_pos != field_end_pos) {
7860 if (last_field_pos->getType()->isIncompleteArrayType())
7861 record_decl->hasFlexibleArrayMember();
7862 }
7863
7864 for (IndirectFieldVector::iterator ifi = indirect_fields.begin(),
7865 ife = indirect_fields.end();
7866 ifi < ife; ++ifi) {
7867 record_decl->addDecl(*ifi);
7868 }
7869}
7870
7871void ClangASTContext::SetIsPacked(const CompilerType &type) {
7872 if (type) {
7873 ClangASTContext *ast =
7874 llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
7875 if (ast) {
7876 clang::RecordDecl *record_decl = GetAsRecordDecl(type);
7877
7878 if (!record_decl)
7879 return;
7880
7881 record_decl->addAttr(
7882 clang::PackedAttr::CreateImplicit(*ast->getASTContext()));
7883 }
7884 }
7885}
7886
7887clang::VarDecl *ClangASTContext::AddVariableToRecordType(
7888 const CompilerType &type, const char *name, const CompilerType &var_type,
7889 AccessType access) {
7890 clang::VarDecl *var_decl = nullptr;
7891
7892 if (!type.IsValid() || !var_type.IsValid())
7893 return nullptr;
7894 ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
7895 if (!ast)
7896 return nullptr;
7897
7898 clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
7899 if (record_decl) {
7900 var_decl = clang::VarDecl::Create(
7901 *ast->getASTContext(), // ASTContext &
7902 record_decl, // DeclContext *
7903 clang::SourceLocation(), // clang::SourceLocation StartLoc
7904 clang::SourceLocation(), // clang::SourceLocation IdLoc
7905 name ? &ast->getASTContext()->Idents.get(name)
7906 : nullptr, // clang::IdentifierInfo *
7907 ClangUtil::GetQualType(var_type), // Variable clang::QualType
7908 nullptr, // TypeSourceInfo *
7909 clang::SC_Static); // StorageClass
7910 if (var_decl) {
7911 var_decl->setAccess(
7912 ClangASTContext::ConvertAccessTypeToAccessSpecifier(access));
7913 record_decl->addDecl(var_decl);
7914
7915#ifdef LLDB_CONFIGURATION_DEBUG
7916 VerifyDecl(var_decl);
7917#endif
7918 }
7919 }
7920 return var_decl;
7921}
7922
7923clang::CXXMethodDecl *ClangASTContext::AddMethodToCXXRecordType(
7924 lldb::opaque_compiler_type_t type, const char *name,
7925 const CompilerType &method_clang_type, lldb::AccessType access,
7926 bool is_virtual, bool is_static, bool is_inline, bool is_explicit,
7927 bool is_attr_used, bool is_artificial) {
7928 if (!type || !method_clang_type.IsValid() || name == nullptr ||
7929 name[0] == '\0')
7930 return nullptr;
7931
7932 clang::QualType record_qual_type(GetCanonicalQualType(type));
7933
7934 clang::CXXRecordDecl *cxx_record_decl =
7935 record_qual_type->getAsCXXRecordDecl();
7936
7937 if (cxx_record_decl == nullptr)
7938 return nullptr;
7939
7940 clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type));
7941
7942 clang::CXXMethodDecl *cxx_method_decl = nullptr;
7943
7944 clang::DeclarationName decl_name(&getASTContext()->Idents.get(name));
7945
7946 const clang::FunctionType *function_type =
7947 llvm::dyn_cast<clang::FunctionType>(method_qual_type.getTypePtr());
7948
7949 if (function_type == nullptr)
7950 return nullptr;
7951
7952 const clang::FunctionProtoType *method_function_prototype(
7953 llvm::dyn_cast<clang::FunctionProtoType>(function_type));
7954
7955 if (!method_function_prototype)
7956 return nullptr;
7957
7958 unsigned int num_params = method_function_prototype->getNumParams();
7959
7960 clang::CXXDestructorDecl *cxx_dtor_decl(nullptr);
7961 clang::CXXConstructorDecl *cxx_ctor_decl(nullptr);
7962
7963 if (is_artificial)
7964 return nullptr; // skip everything artificial
7965
7966 if (name[0] == '~') {
7967 cxx_dtor_decl = clang::CXXDestructorDecl::Create(
7968 *getASTContext(), cxx_record_decl, clang::SourceLocation(),
7969 clang::DeclarationNameInfo(
7970 getASTContext()->DeclarationNames.getCXXDestructorName(
7971 getASTContext()->getCanonicalType(record_qual_type)),
7972 clang::SourceLocation()),
7973 method_qual_type, nullptr, is_inline, is_artificial);
7974 cxx_method_decl = cxx_dtor_decl;
7975 } else if (decl_name == cxx_record_decl->getDeclName()) {
7976 cxx_ctor_decl = clang::CXXConstructorDecl::Create(
7977 *getASTContext(), cxx_record_decl, clang::SourceLocation(),
7978 clang::DeclarationNameInfo(
7979 getASTContext()->DeclarationNames.getCXXConstructorName(
7980 getASTContext()->getCanonicalType(record_qual_type)),
7981 clang::SourceLocation()),
7982 method_qual_type,
7983 nullptr, // TypeSourceInfo *
7984 is_explicit, is_inline, is_artificial, false /*is_constexpr*/);
7985 cxx_method_decl = cxx_ctor_decl;
7986 } else {
7987 clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None;
7988 clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
7989
7990 if (IsOperator(name, op_kind)) {
7991 if (op_kind != clang::NUM_OVERLOADED_OPERATORS) {
7992 // Check the number of operator parameters. Sometimes we have
7993 // seen bad DWARF that doesn't correctly describe operators and
7994 // if we try to create a method and add it to the class, clang
7995 // will assert and crash, so we need to make sure things are
7996 // acceptable.
7997 const bool is_method = true;
7998 if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount(
7999 is_method, op_kind, num_params))
8000 return nullptr;
8001 cxx_method_decl = clang::CXXMethodDecl::Create(
8002 *getASTContext(), cxx_record_decl, clang::SourceLocation(),
8003 clang::DeclarationNameInfo(
8004 getASTContext()->DeclarationNames.getCXXOperatorName(op_kind),
8005 clang::SourceLocation()),
8006 method_qual_type,
8007 nullptr, // TypeSourceInfo *
8008 SC, is_inline, false /*is_constexpr*/, clang::SourceLocation());
8009 } else if (num_params == 0) {
8010 // Conversion operators don't take params...
8011 cxx_method_decl = clang::CXXConversionDecl::Create(
8012 *getASTContext(), cxx_record_decl, clang::SourceLocation(),
8013 clang::DeclarationNameInfo(
8014 getASTContext()->DeclarationNames.getCXXConversionFunctionName(
8015 getASTContext()->getCanonicalType(
8016 function_type->getReturnType())),
8017 clang::SourceLocation()),
8018 method_qual_type,
8019 nullptr, // TypeSourceInfo *
8020 is_inline, is_explicit, false /*is_constexpr*/,
8021 clang::SourceLocation());
8022 }
8023 }
8024
8025 if (cxx_method_decl == nullptr) {
8026 cxx_method_decl = clang::CXXMethodDecl::Create(
8027 *getASTContext(), cxx_record_decl, clang::SourceLocation(),
8028 clang::DeclarationNameInfo(decl_name, clang::SourceLocation()),
8029 method_qual_type,
8030 nullptr, // TypeSourceInfo *
8031 SC, is_inline, false /*is_constexpr*/, clang::SourceLocation());
8032 }
8033 }
8034
8035 clang::AccessSpecifier access_specifier =
8036 ClangASTContext::ConvertAccessTypeToAccessSpecifier(access);
8037
8038 cxx_method_decl->setAccess(access_specifier);
8039 cxx_method_decl->setVirtualAsWritten(is_virtual);
8040
8041 if (is_attr_used)
8042 cxx_method_decl->addAttr(clang::UsedAttr::CreateImplicit(*getASTContext()));
8043
8044 // Populate the method decl with parameter decls
8045
8046 llvm::SmallVector<clang::ParmVarDecl *, 12> params;
8047
8048 for (unsigned param_index = 0; param_index < num_params; ++param_index) {
8049 params.push_back(clang::ParmVarDecl::Create(
8050 *getASTContext(), cxx_method_decl, clang::SourceLocation(),
8051 clang::SourceLocation(),
8052 nullptr, // anonymous
8053 method_function_prototype->getParamType(param_index), nullptr,
8054 clang::SC_None, nullptr));
8055 }
8056
8057 cxx_method_decl->setParams(llvm::ArrayRef<clang::ParmVarDecl *>(params));
8058
8059 cxx_record_decl->addDecl(cxx_method_decl);
8060
8061 // Sometimes the debug info will mention a constructor (default/copy/move),
8062 // destructor, or assignment operator (copy/move) but there won't be any
8063 // version of this in the code. So we check if the function was artificially
8064 // generated and if it is trivial and this lets the compiler/backend know
8065 // that it can inline the IR for these when it needs to and we can avoid a
8066 // "missing function" error when running expressions.
8067
8068 if (is_artificial) {
8069 if (cxx_ctor_decl && ((cxx_ctor_decl->isDefaultConstructor() &&
8070 cxx_record_decl->hasTrivialDefaultConstructor()) ||
8071 (cxx_ctor_decl->isCopyConstructor() &&
8072 cxx_record_decl->hasTrivialCopyConstructor()) ||
8073 (cxx_ctor_decl->isMoveConstructor() &&
8074 cxx_record_decl->hasTrivialMoveConstructor()))) {
8075 cxx_ctor_decl->setDefaulted();
8076 cxx_ctor_decl->setTrivial(true);
8077 } else if (cxx_dtor_decl) {
8078 if (cxx_record_decl->hasTrivialDestructor()) {
8079 cxx_dtor_decl->setDefaulted();
8080 cxx_dtor_decl->setTrivial(true);
8081 }
8082 } else if ((cxx_method_decl->isCopyAssignmentOperator() &&
8083 cxx_record_decl->hasTrivialCopyAssignment()) ||
8084 (cxx_method_decl->isMoveAssignmentOperator() &&
8085 cxx_record_decl->hasTrivialMoveAssignment())) {
8086 cxx_method_decl->setDefaulted();
8087 cxx_method_decl->setTrivial(true);
8088 }
8089 }
8090
8091#ifdef LLDB_CONFIGURATION_DEBUG
8092 VerifyDecl(cxx_method_decl);
8093#endif
8094
8095 // printf ("decl->isPolymorphic() = %i\n",
8096 // cxx_record_decl->isPolymorphic());
8097 // printf ("decl->isAggregate() = %i\n",
8098 // cxx_record_decl->isAggregate());
8099 // printf ("decl->isPOD() = %i\n",
8100 // cxx_record_decl->isPOD());
8101 // printf ("decl->isEmpty() = %i\n",
8102 // cxx_record_decl->isEmpty());
8103 // printf ("decl->isAbstract() = %i\n",
8104 // cxx_record_decl->isAbstract());
8105 // printf ("decl->hasTrivialConstructor() = %i\n",
8106 // cxx_record_decl->hasTrivialConstructor());
8107 // printf ("decl->hasTrivialCopyConstructor() = %i\n",
8108 // cxx_record_decl->hasTrivialCopyConstructor());
8109 // printf ("decl->hasTrivialCopyAssignment() = %i\n",
8110 // cxx_record_decl->hasTrivialCopyAssignment());
8111 // printf ("decl->hasTrivialDestructor() = %i\n",
8112 // cxx_record_decl->hasTrivialDestructor());
8113 return cxx_method_decl;
8114}
8115
8116#pragma mark C++ Base Classes
8117
8118clang::CXXBaseSpecifier *
8119ClangASTContext::CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type,
8120 AccessType access, bool is_virtual,
8121 bool base_of_class) {
8122 if (type)
8123 return new clang::CXXBaseSpecifier(
8124 clang::SourceRange(), is_virtual, base_of_class,
8125 ClangASTContext::ConvertAccessTypeToAccessSpecifier(access),
8126 getASTContext()->getTrivialTypeSourceInfo(GetQualType(type)),
8127 clang::SourceLocation());
8128 return nullptr;
8129}
8130
8131void ClangASTContext::DeleteBaseClassSpecifiers(
8132 clang::CXXBaseSpecifier **base_classes, unsigned num_base_classes) {
8133 for (unsigned i = 0; i < num_base_classes; ++i) {
8134 delete base_classes[i];
8135 base_classes[i] = nullptr;
8136 }
8137}
8138
8139bool ClangASTContext::SetBaseClassesForClassType(
8140 lldb::opaque_compiler_type_t type,
8141 clang::CXXBaseSpecifier const *const *base_classes,
8142 unsigned num_base_classes) {
8143 if (type) {
8144 clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(type);
8145 if (cxx_record_decl) {
8146 cxx_record_decl->setBases(base_classes, num_base_classes);
8147 return true;
8148 }
8149 }
8150 return false;
8151}
8152
8153bool ClangASTContext::SetObjCSuperClass(
8154 const CompilerType &type, const CompilerType &superclass_clang_type) {
8155 ClangASTContext *ast =
8156 llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem());
8157 if (!ast)
8158 return false;
8159 clang::ASTContext *clang_ast = ast->getASTContext();
8160
8161 if (type && superclass_clang_type.IsValid() &&
8162 superclass_clang_type.GetTypeSystem() == type.GetTypeSystem()) {
8163 clang::ObjCInterfaceDecl *class_interface_decl =
8164 GetAsObjCInterfaceDecl(type);
8165 clang::ObjCInterfaceDecl *super_interface_decl =
8166 GetAsObjCInterfaceDecl(superclass_clang_type);
8167 if (class_interface_decl && super_interface_decl) {
8168 class_interface_decl->setSuperClass(clang_ast->getTrivialTypeSourceInfo(
8169 clang_ast->getObjCInterfaceType(super_interface_decl)));
8170 return true;
8171 }
8172 }
8173 return false;
8174}
8175
8176bool ClangASTContext::AddObjCClassProperty(
8177 const CompilerType &type, const char *property_name,
8178 const CompilerType &property_clang_type, clang::ObjCIvarDecl *ivar_decl,
8179 const char *property_setter_name, const char *property_getter_name,
8180 uint32_t property_attributes, ClangASTMetadata *metadata) {
8181 if (!type || !property_clang_type.IsValid() || property_name == nullptr ||
8182 property_name[0] == '\0')
8183 return false;
8184 ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
8185 if (!ast)
8186 return false;
8187 clang::ASTContext *clang_ast = ast->getASTContext();
8188
8189 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
8190
8191 if (class_interface_decl) {
8192 CompilerType property_clang_type_to_access;
8193
8194 if (property_clang_type.IsValid())
8195 property_clang_type_to_access = property_clang_type;
8196 else if (ivar_decl)
8197 property_clang_type_to_access =
8198 CompilerType(clang_ast, ivar_decl->getType());
8199
8200 if (class_interface_decl && property_clang_type_to_access.IsValid()) {
8201 clang::TypeSourceInfo *prop_type_source;
8202 if (ivar_decl)
8203 prop_type_source =
8204 clang_ast->getTrivialTypeSourceInfo(ivar_decl->getType());
8205 else
8206 prop_type_source = clang_ast->getTrivialTypeSourceInfo(
8207 ClangUtil::GetQualType(property_clang_type));
8208
8209 clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create(
8210 *clang_ast, class_interface_decl,
8211 clang::SourceLocation(), // Source Location
8212 &clang_ast->Idents.get(property_name),
8213 clang::SourceLocation(), // Source Location for AT
8214 clang::SourceLocation(), // Source location for (
8215 ivar_decl ? ivar_decl->getType()
8216 : ClangUtil::GetQualType(property_clang_type),
8217 prop_type_source);
8218
8219 if (property_decl) {
8220 if (metadata)
8221 ClangASTContext::SetMetadata(clang_ast, property_decl, *metadata);
8222
8223 class_interface_decl->addDecl(property_decl);
8224
8225 clang::Selector setter_sel, getter_sel;
8226
8227 if (property_setter_name != nullptr) {
8228 std::string property_setter_no_colon(
8229 property_setter_name, strlen(property_setter_name) - 1);
8230 clang::IdentifierInfo *setter_ident =
8231 &clang_ast->Idents.get(property_setter_no_colon);
8232 setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident);
8233 } else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) {
8234 std::string setter_sel_string("set");
8235 setter_sel_string.push_back(::toupper(property_name[0]));
8236 setter_sel_string.append(&property_name[1]);
8237 clang::IdentifierInfo *setter_ident =
8238 &clang_ast->Idents.get(setter_sel_string);
8239 setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident);
8240 }
8241 property_decl->setSetterName(setter_sel);
8242 property_decl->setPropertyAttributes(
8243 clang::ObjCPropertyDecl::OBJC_PR_setter);
8244
8245 if (property_getter_name != nullptr) {
8246 clang::IdentifierInfo *getter_ident =
8247 &clang_ast->Idents.get(property_getter_name);
8248 getter_sel = clang_ast->Selectors.getSelector(0, &getter_ident);
8249 } else {
8250 clang::IdentifierInfo *getter_ident =
8251 &clang_ast->Idents.get(property_name);
8252 getter_sel = clang_ast->Selectors.getSelector(0, &getter_ident);
8253 }
8254 property_decl->setGetterName(getter_sel);
8255 property_decl->setPropertyAttributes(
8256 clang::ObjCPropertyDecl::OBJC_PR_getter);
8257
8258 if (ivar_decl)
8259 property_decl->setPropertyIvarDecl(ivar_decl);
8260
8261 if (property_attributes & DW_APPLE_PROPERTY_readonly)
8262 property_decl->setPropertyAttributes(
8263 clang::ObjCPropertyDecl::OBJC_PR_readonly);
8264 if (property_attributes & DW_APPLE_PROPERTY_readwrite)
8265 property_decl->setPropertyAttributes(
8266 clang::ObjCPropertyDecl::OBJC_PR_readwrite);
8267 if (property_attributes & DW_APPLE_PROPERTY_assign)
8268 property_decl->setPropertyAttributes(
8269 clang::ObjCPropertyDecl::OBJC_PR_assign);
8270 if (property_attributes & DW_APPLE_PROPERTY_retain)
8271 property_decl->setPropertyAttributes(
8272 clang::ObjCPropertyDecl::OBJC_PR_retain);
8273 if (property_attributes & DW_APPLE_PROPERTY_copy)
8274 property_decl->setPropertyAttributes(
8275 clang::ObjCPropertyDecl::OBJC_PR_copy);
8276 if (property_attributes & DW_APPLE_PROPERTY_nonatomic)
8277 property_decl->setPropertyAttributes(
8278 clang::ObjCPropertyDecl::OBJC_PR_nonatomic);
8279 if (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_nullability)
8280 property_decl->setPropertyAttributes(
8281 clang::ObjCPropertyDecl::OBJC_PR_nullability);
8282 if (property_attributes &
8283 clang::ObjCPropertyDecl::OBJC_PR_null_resettable)
8284 property_decl->setPropertyAttributes(
8285 clang::ObjCPropertyDecl::OBJC_PR_null_resettable);
8286 if (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_class)
8287 property_decl->setPropertyAttributes(
8288 clang::ObjCPropertyDecl::OBJC_PR_class);
8289
8290 const bool isInstance =
8291 (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_class) == 0;
8292
8293 if (!getter_sel.isNull() &&
8294 !(isInstance
8295 ? class_interface_decl->lookupInstanceMethod(getter_sel)
8296 : class_interface_decl->lookupClassMethod(getter_sel))) {
8297 const bool isVariadic = false;
8298 const bool isSynthesized = false;
8299 const bool isImplicitlyDeclared = true;
8300 const bool isDefined = false;
8301 const clang::ObjCMethodDecl::ImplementationControl impControl =
8302 clang::ObjCMethodDecl::None;
8303 const bool HasRelatedResultType = false;
8304
8305 clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create(
8306 *clang_ast, clang::SourceLocation(), clang::SourceLocation(),
8307 getter_sel, ClangUtil::GetQualType(property_clang_type_to_access),
8308 nullptr, class_interface_decl, isInstance, isVariadic,
8309 isSynthesized, isImplicitlyDeclared, isDefined, impControl,
8310 HasRelatedResultType);
8311
8312 if (getter && metadata)
8313 ClangASTContext::SetMetadata(clang_ast, getter, *metadata);
8314
8315 if (getter) {
8316 getter->setMethodParams(*clang_ast,
8317 llvm::ArrayRef<clang::ParmVarDecl *>(),
8318 llvm::ArrayRef<clang::SourceLocation>());
8319
8320 class_interface_decl->addDecl(getter);
8321 }
8322 }
8323
8324 if (!setter_sel.isNull() &&
8325 !(isInstance
8326 ? class_interface_decl->lookupInstanceMethod(setter_sel)
8327 : class_interface_decl->lookupClassMethod(setter_sel))) {
8328 clang::QualType result_type = clang_ast->VoidTy;
8329 const bool isVariadic = false;
8330 const bool isSynthesized = false;
8331 const bool isImplicitlyDeclared = true;
8332 const bool isDefined = false;
8333 const clang::ObjCMethodDecl::ImplementationControl impControl =
8334 clang::ObjCMethodDecl::None;
8335 const bool HasRelatedResultType = false;
8336
8337 clang::ObjCMethodDecl *setter = clang::ObjCMethodDecl::Create(
8338 *clang_ast, clang::SourceLocation(), clang::SourceLocation(),
8339 setter_sel, result_type, nullptr, class_interface_decl,
8340 isInstance, isVariadic, isSynthesized, isImplicitlyDeclared,
8341 isDefined, impControl, HasRelatedResultType);
8342
8343 if (setter && metadata)
8344 ClangASTContext::SetMetadata(clang_ast, setter, *metadata);
8345
8346 llvm::SmallVector<clang::ParmVarDecl *, 1> params;
8347
8348 params.push_back(clang::ParmVarDecl::Create(
8349 *clang_ast, setter, clang::SourceLocation(),
8350 clang::SourceLocation(),
8351 nullptr, // anonymous
8352 ClangUtil::GetQualType(property_clang_type_to_access), nullptr,
8353 clang::SC_Auto, nullptr));
8354
8355 if (setter) {
8356 setter->setMethodParams(
8357 *clang_ast, llvm::ArrayRef<clang::ParmVarDecl *>(params),
8358 llvm::ArrayRef<clang::SourceLocation>());
8359
8360 class_interface_decl->addDecl(setter);
8361 }
8362 }
8363
8364 return true;
8365 }
8366 }
8367 }
8368 return false;
8369}
8370
8371bool ClangASTContext::IsObjCClassTypeAndHasIVars(const CompilerType &type,
8372 bool check_superclass) {
8373 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
8374 if (class_interface_decl)
8375 return ObjCDeclHasIVars(class_interface_decl, check_superclass);
8376 return false;
8377}
8378
8379clang::ObjCMethodDecl *ClangASTContext::AddMethodToObjCObjectType(
8380 const CompilerType &type,
8381 const char *name, // the full symbol name as seen in the symbol table
8382 // (lldb::opaque_compiler_type_t type, "-[NString
8383 // stringWithCString:]")
8384 const CompilerType &method_clang_type, lldb::AccessType access,
8385 bool is_artificial, bool is_variadic) {
8386 if (!type || !method_clang_type.IsValid())
8387 return nullptr;
8388
8389 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
8390
8391 if (class_interface_decl == nullptr)
8392 return nullptr;
8393 ClangASTContext *lldb_ast =
8394 llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
8395 if (lldb_ast == nullptr)
8396 return nullptr;
8397 clang::ASTContext *ast = lldb_ast->getASTContext();
8398
8399 const char *selector_start = ::strchr(name, ' ');
8400 if (selector_start == nullptr)
8401 return nullptr;
8402
8403 selector_start++;
8404 llvm::SmallVector<clang::IdentifierInfo *, 12> selector_idents;
8405
8406 size_t len = 0;
8407 const char *start;
8408 // printf ("name = '%s'\n", name);
8409
8410 unsigned num_selectors_with_args = 0;
8411 for (start = selector_start; start && *start != '\0' && *start != ']';
8412 start += len) {
8413 len = ::strcspn(start, ":]");
8414 bool has_arg = (start[len] == ':');
8415 if (has_arg)
8416 ++num_selectors_with_args;
8417 selector_idents.push_back(&ast->Idents.get(llvm::StringRef(sta