blob: 41cddb0ca876640f4ffee90a3eebe3f032e80a56 [file] [log] [blame]
Chris Lattner24943d22010-06-08 16:52:24 +00001//===-- 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
Eli Friedmanf05633b2010-06-13 19:06:42 +000010#include "lldb/Symbol/ClangASTContext.h"
Chris Lattner24943d22010-06-08 16:52:24 +000011
12// C Includes
13// C++ Includes
14#include <string>
15
16// Other libraries and framework includes
Greg Claytonb01000f2011-01-17 03:46:26 +000017
18// Clang headers like to use NDEBUG inside of them to enable/disable debug
19// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing
20// or another. This is bad because it means that if clang was built in release
21// mode, it assumes that you are building in release mode which is not always
22// the case. You can end up with functions that are defined as empty in header
23// files when NDEBUG is not defined, and this can cause link errors with the
24// clang .a files that you have since you might be missing functions in the .a
25// file. So we have to define NDEBUG when including clang headers to avoid any
26// mismatches. This is covered by rdar://problem/8691220
27
28#ifndef NDEBUG
29#define LLDB_DEFINED_NDEBUG_FOR_CLANG
Sean Callananbc4f0f52010-07-08 18:16:16 +000030#define NDEBUG
Greg Claytonb01000f2011-01-17 03:46:26 +000031// Need to include assert.h so it is as clang would expect it to be (disabled)
32#include <assert.h>
33#endif
34
Chris Lattner24943d22010-06-08 16:52:24 +000035#include "clang/AST/ASTContext.h"
36#include "clang/AST/ASTImporter.h"
37#include "clang/AST/CXXInheritance.h"
Greg Clayton84f80752010-07-22 18:30:50 +000038#include "clang/AST/DeclObjC.h"
Chris Lattner24943d22010-06-08 16:52:24 +000039#include "clang/AST/RecordLayout.h"
40#include "clang/AST/Type.h"
41#include "clang/Basic/Builtins.h"
42#include "clang/Basic/FileManager.h"
Sean Callanan8a3b0a82010-11-18 02:56:27 +000043#include "clang/Basic/FileSystemOptions.h"
Chris Lattner24943d22010-06-08 16:52:24 +000044#include "clang/Basic/SourceManager.h"
45#include "clang/Basic/TargetInfo.h"
46#include "clang/Basic/TargetOptions.h"
47#include "clang/Frontend/FrontendOptions.h"
48#include "clang/Frontend/LangStandard.h"
Greg Claytonb01000f2011-01-17 03:46:26 +000049
50#ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
Sean Callananbc4f0f52010-07-08 18:16:16 +000051#undef NDEBUG
Greg Claytonb01000f2011-01-17 03:46:26 +000052#undef LLDB_DEFINED_NDEBUG_FOR_CLANG
53// Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
54#include <assert.h>
55#endif
Chris Lattner24943d22010-06-08 16:52:24 +000056
Chris Lattner24943d22010-06-08 16:52:24 +000057#include "lldb/Core/dwarf.h"
Greg Claytonf3d0b0c2010-10-27 03:32:59 +000058#include "lldb/Core/Flags.h"
Sean Callanan839fde42010-10-28 18:19:36 +000059#include "lldb/Core/Log.h"
Chris Lattner24943d22010-06-08 16:52:24 +000060
Eli Friedmanf05633b2010-06-13 19:06:42 +000061#include <stdio.h>
62
Greg Clayton585660c2010-08-05 01:57:25 +000063using namespace lldb;
Chris Lattner24943d22010-06-08 16:52:24 +000064using namespace lldb_private;
65using namespace llvm;
66using namespace clang;
67
Greg Claytonb01000f2011-01-17 03:46:26 +000068
69static bool
70GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type)
71{
72 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
73 switch (type_class)
74 {
75 case clang::Type::Record:
76 case clang::Type::Enum:
77 {
78 clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
79 if (tag_type)
80 {
81 clang::TagDecl *tag_decl = tag_type->getDecl();
82 if (tag_decl)
83 {
84 if (tag_decl->getDefinition())
85 return true;
86
87 if (tag_decl->hasExternalLexicalStorage())
88 {
89 ExternalASTSource *external_ast_source = ast->getExternalSource();
90 if (external_ast_source)
91 {
92 external_ast_source->CompleteType(tag_decl);
93 return !tag_type->isIncompleteType();
94 }
95 }
96 return false;
97 }
98 }
99
100 }
101 break;
102
103 case clang::Type::ObjCObject:
104 case clang::Type::ObjCInterface:
105 {
106 clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type);
107 if (objc_class_type)
108 {
109 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
110 // We currently can't complete objective C types through the newly added ASTContext
111 // because it only supports TagDecl objects right now...
112 bool is_forward_decl = class_interface_decl->isForwardDecl();
113 if (is_forward_decl && class_interface_decl->hasExternalLexicalStorage())
114 {
115 ExternalASTSource *external_ast_source = ast->getExternalSource();
116 if (external_ast_source)
117 {
118 external_ast_source->CompleteType (class_interface_decl);
119 is_forward_decl = class_interface_decl->isForwardDecl();
120 }
121 }
122 return is_forward_decl;
123 }
124 }
125 break;
126
127 case clang::Type::Typedef:
128 return GetCompleteQualType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType());
129
130 default:
131 break;
132 }
133
134 return true;
135}
136
137
Greg Clayton84f80752010-07-22 18:30:50 +0000138static AccessSpecifier
Greg Clayton585660c2010-08-05 01:57:25 +0000139ConvertAccessTypeToAccessSpecifier (AccessType access)
Greg Clayton84f80752010-07-22 18:30:50 +0000140{
141 switch (access)
142 {
Greg Clayton585660c2010-08-05 01:57:25 +0000143 default: break;
144 case eAccessNone: return AS_none;
145 case eAccessPublic: return AS_public;
146 case eAccessPrivate: return AS_private;
147 case eAccessProtected: return AS_protected;
Greg Clayton84f80752010-07-22 18:30:50 +0000148 }
149 return AS_none;
150}
151
152static ObjCIvarDecl::AccessControl
Greg Clayton585660c2010-08-05 01:57:25 +0000153ConvertAccessTypeToObjCIvarAccessControl (AccessType access)
Greg Clayton84f80752010-07-22 18:30:50 +0000154{
155 switch (access)
156 {
Greg Clayton585660c2010-08-05 01:57:25 +0000157 default: break;
158 case eAccessNone: return ObjCIvarDecl::None;
159 case eAccessPublic: return ObjCIvarDecl::Public;
160 case eAccessPrivate: return ObjCIvarDecl::Private;
161 case eAccessProtected: return ObjCIvarDecl::Protected;
162 case eAccessPackage: return ObjCIvarDecl::Package;
Greg Clayton84f80752010-07-22 18:30:50 +0000163 }
164 return ObjCIvarDecl::None;
165}
166
167
Chris Lattner24943d22010-06-08 16:52:24 +0000168static void
169ParseLangArgs
170(
171 LangOptions &Opts,
Greg Claytone41c4b22010-06-13 17:34:29 +0000172 InputKind IK
Chris Lattner24943d22010-06-08 16:52:24 +0000173)
174{
175 // FIXME: Cleanup per-file based stuff.
176
177 // Set some properties which depend soley on the input kind; it would be nice
178 // to move these to the language standard, and have the driver resolve the
179 // input kind + language standard.
Greg Claytone41c4b22010-06-13 17:34:29 +0000180 if (IK == IK_Asm) {
Chris Lattner24943d22010-06-08 16:52:24 +0000181 Opts.AsmPreprocessor = 1;
Greg Claytone41c4b22010-06-13 17:34:29 +0000182 } else if (IK == IK_ObjC ||
183 IK == IK_ObjCXX ||
184 IK == IK_PreprocessedObjC ||
185 IK == IK_PreprocessedObjCXX) {
Chris Lattner24943d22010-06-08 16:52:24 +0000186 Opts.ObjC1 = Opts.ObjC2 = 1;
187 }
188
189 LangStandard::Kind LangStd = LangStandard::lang_unspecified;
190
191 if (LangStd == LangStandard::lang_unspecified) {
192 // Based on the base language, pick one.
193 switch (IK) {
Greg Claytone41c4b22010-06-13 17:34:29 +0000194 case IK_None:
195 case IK_AST:
Greg Claytonb01000f2011-01-17 03:46:26 +0000196 assert (!"Invalid input kind!");
Greg Claytone41c4b22010-06-13 17:34:29 +0000197 case IK_OpenCL:
Chris Lattner24943d22010-06-08 16:52:24 +0000198 LangStd = LangStandard::lang_opencl;
199 break;
Greg Claytone41c4b22010-06-13 17:34:29 +0000200 case IK_Asm:
201 case IK_C:
202 case IK_PreprocessedC:
203 case IK_ObjC:
204 case IK_PreprocessedObjC:
Chris Lattner24943d22010-06-08 16:52:24 +0000205 LangStd = LangStandard::lang_gnu99;
206 break;
Greg Claytone41c4b22010-06-13 17:34:29 +0000207 case IK_CXX:
208 case IK_PreprocessedCXX:
209 case IK_ObjCXX:
210 case IK_PreprocessedObjCXX:
Chris Lattner24943d22010-06-08 16:52:24 +0000211 LangStd = LangStandard::lang_gnucxx98;
212 break;
213 }
214 }
215
216 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
217 Opts.BCPLComment = Std.hasBCPLComments();
218 Opts.C99 = Std.isC99();
219 Opts.CPlusPlus = Std.isCPlusPlus();
220 Opts.CPlusPlus0x = Std.isCPlusPlus0x();
221 Opts.Digraphs = Std.hasDigraphs();
222 Opts.GNUMode = Std.isGNUMode();
223 Opts.GNUInline = !Std.isC99();
224 Opts.HexFloats = Std.hasHexFloats();
225 Opts.ImplicitInt = Std.hasImplicitInt();
226
227 // OpenCL has some additional defaults.
228 if (LangStd == LangStandard::lang_opencl) {
229 Opts.OpenCL = 1;
230 Opts.AltiVec = 1;
231 Opts.CXXOperatorNames = 1;
232 Opts.LaxVectorConversions = 1;
233 }
234
235 // OpenCL and C++ both have bool, true, false keywords.
236 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
237
238// if (Opts.CPlusPlus)
239// Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
240//
241// if (Args.hasArg(OPT_fobjc_gc_only))
242// Opts.setGCMode(LangOptions::GCOnly);
243// else if (Args.hasArg(OPT_fobjc_gc))
244// Opts.setGCMode(LangOptions::HybridGC);
245//
246// if (Args.hasArg(OPT_print_ivar_layout))
247// Opts.ObjCGCBitmapPrint = 1;
248//
249// if (Args.hasArg(OPT_faltivec))
250// Opts.AltiVec = 1;
251//
252// if (Args.hasArg(OPT_pthread))
253// Opts.POSIXThreads = 1;
254//
255// llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
256// "default");
257// if (Vis == "default")
Sean Callanan8950c9a2010-10-29 18:38:40 +0000258 Opts.setVisibilityMode(DefaultVisibility);
Chris Lattner24943d22010-06-08 16:52:24 +0000259// else if (Vis == "hidden")
260// Opts.setVisibilityMode(LangOptions::Hidden);
261// else if (Vis == "protected")
262// Opts.setVisibilityMode(LangOptions::Protected);
263// else
264// Diags.Report(diag::err_drv_invalid_value)
265// << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
266
267// Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
268
269 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
270 // is specified, or -std is set to a conforming mode.
271 Opts.Trigraphs = !Opts.GNUMode;
272// if (Args.hasArg(OPT_trigraphs))
273// Opts.Trigraphs = 1;
274//
275// Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
276// OPT_fno_dollars_in_identifiers,
277// !Opts.AsmPreprocessor);
278// Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
279// Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
280// Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
281// if (Args.hasArg(OPT_fno_lax_vector_conversions))
282// Opts.LaxVectorConversions = 0;
283// Opts.Exceptions = Args.hasArg(OPT_fexceptions);
284// Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
285// Opts.Blocks = Args.hasArg(OPT_fblocks);
286// Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
287// Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
288// Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
289// Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
290// Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
291// Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
292// Opts.AccessControl = Args.hasArg(OPT_faccess_control);
293// Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
294// Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno);
295// Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99,
296// Diags);
297// Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
298// Opts.ObjCConstantStringClass = getLastArgValue(Args,
299// OPT_fconstant_string_class);
300// Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
301// Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
302// Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
303// Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
304// Opts.Static = Args.hasArg(OPT_static_define);
305 Opts.OptimizeSize = 0;
306
307 // FIXME: Eliminate this dependency.
308// unsigned Opt =
309// Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
310// Opts.Optimize = Opt != 0;
311 unsigned Opt = 0;
312
313 // This is the __NO_INLINE__ define, which just depends on things like the
314 // optimization level and -fno-inline, not actually whether the backend has
315 // inlining enabled.
316 //
317 // FIXME: This is affected by other options (-fno-inline).
318 Opts.NoInline = !Opt;
319
320// unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
321// switch (SSP) {
322// default:
323// Diags.Report(diag::err_drv_invalid_value)
324// << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
325// break;
326// case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
327// case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break;
328// case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
329// }
330}
331
Chris Lattner24943d22010-06-08 16:52:24 +0000332
Greg Claytonb01000f2011-01-17 03:46:26 +0000333ClangASTContext::ClangASTContext (const char *target_triple) :
Chris Lattner24943d22010-06-08 16:52:24 +0000334 m_target_triple(),
Greg Claytonb01000f2011-01-17 03:46:26 +0000335 m_ast_ap(),
Chris Lattner24943d22010-06-08 16:52:24 +0000336 m_language_options_ap(),
337 m_source_manager_ap(),
338 m_diagnostic_ap(),
339 m_target_options_ap(),
340 m_target_info_ap(),
341 m_identifier_table_ap(),
342 m_selector_table_ap(),
Greg Claytonb01000f2011-01-17 03:46:26 +0000343 m_builtins_ap(),
344 m_callback_tag_decl (NULL),
345 m_callback_objc_decl (NULL),
346 m_callback_baton (NULL)
347
Chris Lattner24943d22010-06-08 16:52:24 +0000348{
349 if (target_triple && target_triple[0])
350 m_target_triple.assign (target_triple);
351}
352
353//----------------------------------------------------------------------
354// Destructor
355//----------------------------------------------------------------------
356ClangASTContext::~ClangASTContext()
357{
358 m_builtins_ap.reset();
359 m_selector_table_ap.reset();
360 m_identifier_table_ap.reset();
361 m_target_info_ap.reset();
362 m_target_options_ap.reset();
363 m_diagnostic_ap.reset();
364 m_source_manager_ap.reset();
365 m_language_options_ap.reset();
Greg Claytonb01000f2011-01-17 03:46:26 +0000366 m_ast_ap.reset();
Chris Lattner24943d22010-06-08 16:52:24 +0000367}
368
369
370void
371ClangASTContext::Clear()
372{
Greg Claytonb01000f2011-01-17 03:46:26 +0000373 m_ast_ap.reset();
Chris Lattner24943d22010-06-08 16:52:24 +0000374 m_language_options_ap.reset();
375 m_source_manager_ap.reset();
376 m_diagnostic_ap.reset();
377 m_target_options_ap.reset();
378 m_target_info_ap.reset();
379 m_identifier_table_ap.reset();
380 m_selector_table_ap.reset();
381 m_builtins_ap.reset();
382}
383
384const char *
385ClangASTContext::GetTargetTriple ()
386{
387 return m_target_triple.c_str();
388}
389
390void
391ClangASTContext::SetTargetTriple (const char *target_triple)
392{
393 Clear();
394 m_target_triple.assign(target_triple);
395}
396
Greg Claytonb01000f2011-01-17 03:46:26 +0000397bool
398ClangASTContext::HasExternalSource ()
399{
400 ASTContext *ast = getASTContext();
401 if (ast)
402 return ast->getExternalSource () != NULL;
403 return false;
404}
405
406void
407ClangASTContext::SetExternalSource (llvm::OwningPtr<ExternalASTSource> &ast_source_ap)
408{
409 ASTContext *ast = getASTContext();
410 if (ast)
411 {
412 ast->setExternalSource (ast_source_ap);
413 ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
414 //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true);
415 }
416}
417
418void
419ClangASTContext::RemoveExternalSource ()
420{
421 ASTContext *ast = getASTContext();
422
423 if (ast)
424 {
425 llvm::OwningPtr<ExternalASTSource> empty_ast_source_ap;
426 ast->setExternalSource (empty_ast_source_ap);
427 ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false);
428 //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false);
429 }
430}
431
432
Chris Lattner24943d22010-06-08 16:52:24 +0000433
434ASTContext *
435ClangASTContext::getASTContext()
436{
Greg Claytonb01000f2011-01-17 03:46:26 +0000437 if (m_ast_ap.get() == NULL)
Chris Lattner24943d22010-06-08 16:52:24 +0000438 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000439 m_ast_ap.reset(new ASTContext (*getLanguageOptions(),
440 *getSourceManager(),
441 *getTargetInfo(),
442 *getIdentifierTable(),
443 *getSelectorTable(),
444 *getBuiltinContext(),
445 0));
Sean Callanan887d2512010-12-11 00:08:56 +0000446
Greg Claytonb01000f2011-01-17 03:46:26 +0000447 if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton)
448 {
449 m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage();
450 //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage();
451 }
452
453 m_ast_ap->getDiagnostics().setClient(getDiagnosticClient(), false);
Chris Lattner24943d22010-06-08 16:52:24 +0000454 }
Greg Claytonb01000f2011-01-17 03:46:26 +0000455 return m_ast_ap.get();
Chris Lattner24943d22010-06-08 16:52:24 +0000456}
457
458Builtin::Context *
459ClangASTContext::getBuiltinContext()
460{
461 if (m_builtins_ap.get() == NULL)
462 m_builtins_ap.reset (new Builtin::Context(*getTargetInfo()));
463 return m_builtins_ap.get();
464}
465
466IdentifierTable *
467ClangASTContext::getIdentifierTable()
468{
469 if (m_identifier_table_ap.get() == NULL)
470 m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), NULL));
471 return m_identifier_table_ap.get();
472}
473
474LangOptions *
475ClangASTContext::getLanguageOptions()
476{
477 if (m_language_options_ap.get() == NULL)
478 {
479 m_language_options_ap.reset(new LangOptions());
Greg Claytone41c4b22010-06-13 17:34:29 +0000480 ParseLangArgs(*m_language_options_ap, IK_ObjCXX);
481// InitializeLangOptions(*m_language_options_ap, IK_ObjCXX);
Chris Lattner24943d22010-06-08 16:52:24 +0000482 }
483 return m_language_options_ap.get();
484}
485
486SelectorTable *
487ClangASTContext::getSelectorTable()
488{
489 if (m_selector_table_ap.get() == NULL)
490 m_selector_table_ap.reset (new SelectorTable());
491 return m_selector_table_ap.get();
492}
493
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000494clang::FileManager *
495ClangASTContext::getFileManager()
496{
497 if (m_file_manager_ap.get() == NULL)
Greg Clayton22defe82010-12-02 23:20:03 +0000498 {
499 clang::FileSystemOptions file_system_options;
500 m_file_manager_ap.reset(new clang::FileManager(file_system_options));
501 }
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000502 return m_file_manager_ap.get();
503}
504
Greg Clayton1674b122010-07-21 22:12:05 +0000505clang::SourceManager *
Chris Lattner24943d22010-06-08 16:52:24 +0000506ClangASTContext::getSourceManager()
507{
508 if (m_source_manager_ap.get() == NULL)
Greg Clayton22defe82010-12-02 23:20:03 +0000509 m_source_manager_ap.reset(new clang::SourceManager(*getDiagnostic(), *getFileManager()));
Chris Lattner24943d22010-06-08 16:52:24 +0000510 return m_source_manager_ap.get();
511}
512
513Diagnostic *
514ClangASTContext::getDiagnostic()
515{
516 if (m_diagnostic_ap.get() == NULL)
Greg Claytoneae91242010-11-19 21:46:54 +0000517 {
518 llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
519 m_diagnostic_ap.reset(new Diagnostic(diag_id_sp));
520 }
Chris Lattner24943d22010-06-08 16:52:24 +0000521 return m_diagnostic_ap.get();
522}
523
Sean Callanan887d2512010-12-11 00:08:56 +0000524class NullDiagnosticClient : public DiagnosticClient
525{
526public:
527 NullDiagnosticClient ()
528 {
529 m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
530 }
531
532 void HandleDiagnostic (Diagnostic::Level DiagLevel, const DiagnosticInfo &info)
533 {
534 if (m_log)
535 {
536 llvm::SmallVectorImpl<char> diag_str(10);
537 info.FormatDiagnostic(diag_str);
538 diag_str.push_back('\0');
539 m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
540 }
541 }
542private:
543 LogSP m_log;
544};
545
546DiagnosticClient *
547ClangASTContext::getDiagnosticClient()
548{
549 if (m_diagnostic_client_ap.get() == NULL)
550 m_diagnostic_client_ap.reset(new NullDiagnosticClient);
551
552 return m_diagnostic_client_ap.get();
553}
554
Chris Lattner24943d22010-06-08 16:52:24 +0000555TargetOptions *
556ClangASTContext::getTargetOptions()
557{
558 if (m_target_options_ap.get() == NULL && !m_target_triple.empty())
559 {
560 m_target_options_ap.reset (new TargetOptions());
561 if (m_target_options_ap.get())
562 m_target_options_ap->Triple = m_target_triple;
563 }
564 return m_target_options_ap.get();
565}
566
567
568TargetInfo *
569ClangASTContext::getTargetInfo()
570{
571 // target_triple should be something like "x86_64-apple-darwin10"
572 if (m_target_info_ap.get() == NULL && !m_target_triple.empty())
573 m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnostic(), *getTargetOptions()));
574 return m_target_info_ap.get();
575}
576
577#pragma mark Basic Types
578
579static inline bool
Greg Claytonb01000f2011-01-17 03:46:26 +0000580QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000581{
Greg Claytonb01000f2011-01-17 03:46:26 +0000582 uint64_t qual_type_bit_size = ast->getTypeSize(qual_type);
Chris Lattner24943d22010-06-08 16:52:24 +0000583 if (qual_type_bit_size == bit_size)
584 return true;
585 return false;
586}
587
Greg Clayton462d4142010-09-29 01:12:09 +0000588clang_type_t
Greg Clayton585660c2010-08-05 01:57:25 +0000589ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size)
Chris Lattner24943d22010-06-08 16:52:24 +0000590{
Greg Claytonb01000f2011-01-17 03:46:26 +0000591 ASTContext *ast = getASTContext();
Chris Lattner24943d22010-06-08 16:52:24 +0000592
Greg Claytonb01000f2011-01-17 03:46:26 +0000593 assert (ast != NULL);
Chris Lattner24943d22010-06-08 16:52:24 +0000594
Greg Claytonb01000f2011-01-17 03:46:26 +0000595 return GetBuiltinTypeForEncodingAndBitSize (ast, encoding, bit_size);
Chris Lattner24943d22010-06-08 16:52:24 +0000596}
597
Greg Clayton462d4142010-09-29 01:12:09 +0000598clang_type_t
Greg Claytonb01000f2011-01-17 03:46:26 +0000599ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size)
Chris Lattner24943d22010-06-08 16:52:24 +0000600{
Greg Claytonb01000f2011-01-17 03:46:26 +0000601 if (!ast)
Chris Lattner24943d22010-06-08 16:52:24 +0000602 return NULL;
603
604 switch (encoding)
605 {
Greg Clayton585660c2010-08-05 01:57:25 +0000606 case eEncodingInvalid:
Greg Claytonb01000f2011-01-17 03:46:26 +0000607 if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
608 return ast->VoidPtrTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000609 break;
610
Greg Clayton585660c2010-08-05 01:57:25 +0000611 case eEncodingUint:
Greg Claytonb01000f2011-01-17 03:46:26 +0000612 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
613 return ast->UnsignedCharTy.getAsOpaquePtr();
614 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
615 return ast->UnsignedShortTy.getAsOpaquePtr();
616 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
617 return ast->UnsignedIntTy.getAsOpaquePtr();
618 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
619 return ast->UnsignedLongTy.getAsOpaquePtr();
620 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
621 return ast->UnsignedLongLongTy.getAsOpaquePtr();
622 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
623 return ast->UnsignedInt128Ty.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000624 break;
625
Greg Clayton585660c2010-08-05 01:57:25 +0000626 case eEncodingSint:
Greg Claytonb01000f2011-01-17 03:46:26 +0000627 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
628 return ast->CharTy.getAsOpaquePtr();
629 if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
630 return ast->ShortTy.getAsOpaquePtr();
631 if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
632 return ast->IntTy.getAsOpaquePtr();
633 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
634 return ast->LongTy.getAsOpaquePtr();
635 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
636 return ast->LongLongTy.getAsOpaquePtr();
637 if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
638 return ast->Int128Ty.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000639 break;
640
Greg Clayton585660c2010-08-05 01:57:25 +0000641 case eEncodingIEEE754:
Greg Claytonb01000f2011-01-17 03:46:26 +0000642 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
643 return ast->FloatTy.getAsOpaquePtr();
644 if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
645 return ast->DoubleTy.getAsOpaquePtr();
646 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
647 return ast->LongDoubleTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000648 break;
649
Greg Clayton585660c2010-08-05 01:57:25 +0000650 case eEncodingVector:
Chris Lattner24943d22010-06-08 16:52:24 +0000651 default:
652 break;
653 }
654
655 return NULL;
656}
657
Greg Clayton462d4142010-09-29 01:12:09 +0000658clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +0000659ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size)
660{
Greg Claytonb01000f2011-01-17 03:46:26 +0000661 ASTContext *ast = getASTContext();
Chris Lattner24943d22010-06-08 16:52:24 +0000662
663 #define streq(a,b) strcmp(a,b) == 0
Greg Claytonb01000f2011-01-17 03:46:26 +0000664 assert (ast != NULL);
665 if (ast)
Chris Lattner24943d22010-06-08 16:52:24 +0000666 {
667 switch (dw_ate)
668 {
669 default:
670 break;
671
672 case DW_ATE_address:
Greg Claytonb01000f2011-01-17 03:46:26 +0000673 if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
674 return ast->VoidPtrTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000675 break;
676
677 case DW_ATE_boolean:
Greg Claytonb01000f2011-01-17 03:46:26 +0000678 if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy))
679 return ast->BoolTy.getAsOpaquePtr();
680 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
681 return ast->UnsignedCharTy.getAsOpaquePtr();
682 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
683 return ast->UnsignedShortTy.getAsOpaquePtr();
684 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
685 return ast->UnsignedIntTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000686 break;
687
Greg Claytone52f37b2011-01-15 02:52:14 +0000688 case DW_ATE_lo_user:
689 // This has been seen to mean DW_AT_complex_integer
690 if (strcmp(type_name, "complex") == 0)
691 {
692 clang_type_t complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2);
Greg Claytonb01000f2011-01-17 03:46:26 +0000693 return ast->getComplexType (QualType::getFromOpaquePtr(complex_int_clang_type)).getAsOpaquePtr();
Greg Claytone52f37b2011-01-15 02:52:14 +0000694 }
695 break;
696
Chris Lattner24943d22010-06-08 16:52:24 +0000697 case DW_ATE_complex_float:
Greg Claytonb01000f2011-01-17 03:46:26 +0000698 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy))
699 return ast->FloatComplexTy.getAsOpaquePtr();
700 else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy))
701 return ast->DoubleComplexTy.getAsOpaquePtr();
702 else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy))
703 return ast->LongDoubleComplexTy.getAsOpaquePtr();
Greg Claytone52f37b2011-01-15 02:52:14 +0000704 else
705 {
706 clang_type_t complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2);
Greg Claytonb01000f2011-01-17 03:46:26 +0000707 return ast->getComplexType (QualType::getFromOpaquePtr(complex_float_clang_type)).getAsOpaquePtr();
Greg Claytone52f37b2011-01-15 02:52:14 +0000708 }
Chris Lattner24943d22010-06-08 16:52:24 +0000709 break;
710
711 case DW_ATE_float:
Greg Claytonb01000f2011-01-17 03:46:26 +0000712 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
713 return ast->FloatTy.getAsOpaquePtr();
714 if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
715 return ast->DoubleTy.getAsOpaquePtr();
716 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
717 return ast->LongDoubleTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000718 break;
719
720 case DW_ATE_signed:
721 if (type_name)
722 {
Greg Clayton8ff5d552010-11-02 03:48:39 +0000723 if (strstr(type_name, "long long"))
Chris Lattner24943d22010-06-08 16:52:24 +0000724 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000725 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
726 return ast->LongLongTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000727 }
Greg Clayton8ff5d552010-11-02 03:48:39 +0000728 else if (strstr(type_name, "long"))
729 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000730 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
731 return ast->LongTy.getAsOpaquePtr();
Greg Clayton8ff5d552010-11-02 03:48:39 +0000732 }
733 else if (strstr(type_name, "short"))
Chris Lattner24943d22010-06-08 16:52:24 +0000734 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000735 if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
736 return ast->ShortTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000737 }
Greg Clayton8ff5d552010-11-02 03:48:39 +0000738 else if (strstr(type_name, "char"))
Chris Lattner24943d22010-06-08 16:52:24 +0000739 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000740 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
741 return ast->CharTy.getAsOpaquePtr();
742 if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
743 return ast->SignedCharTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000744 }
Greg Clayton8ff5d552010-11-02 03:48:39 +0000745 else if (strstr(type_name, "int"))
746 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000747 if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
748 return ast->IntTy.getAsOpaquePtr();
749 if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
750 return ast->Int128Ty.getAsOpaquePtr();
Greg Clayton8ff5d552010-11-02 03:48:39 +0000751 }
752 else if (streq(type_name, "wchar_t"))
Chris Lattner24943d22010-06-08 16:52:24 +0000753 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000754 if (QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy))
755 return ast->WCharTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000756 }
Chris Lattner24943d22010-06-08 16:52:24 +0000757 }
758 // We weren't able to match up a type name, just search by size
Greg Claytonb01000f2011-01-17 03:46:26 +0000759 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
760 return ast->CharTy.getAsOpaquePtr();
761 if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
762 return ast->ShortTy.getAsOpaquePtr();
763 if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
764 return ast->IntTy.getAsOpaquePtr();
765 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
766 return ast->LongTy.getAsOpaquePtr();
767 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
768 return ast->LongLongTy.getAsOpaquePtr();
769 if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
770 return ast->Int128Ty.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000771 break;
772
773 case DW_ATE_signed_char:
774 if (type_name)
775 {
776 if (streq(type_name, "signed char"))
777 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000778 if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
779 return ast->SignedCharTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000780 }
781 }
Greg Claytonb01000f2011-01-17 03:46:26 +0000782 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
783 return ast->CharTy.getAsOpaquePtr();
784 if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
785 return ast->SignedCharTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000786 break;
787
788 case DW_ATE_unsigned:
789 if (type_name)
790 {
Greg Clayton8ff5d552010-11-02 03:48:39 +0000791 if (strstr(type_name, "long long"))
792 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000793 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
794 return ast->UnsignedLongLongTy.getAsOpaquePtr();
Greg Clayton8ff5d552010-11-02 03:48:39 +0000795 }
796 else if (strstr(type_name, "long"))
797 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000798 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
799 return ast->UnsignedLongTy.getAsOpaquePtr();
Greg Clayton8ff5d552010-11-02 03:48:39 +0000800 }
801 else if (strstr(type_name, "short"))
802 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000803 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
804 return ast->UnsignedShortTy.getAsOpaquePtr();
Greg Clayton8ff5d552010-11-02 03:48:39 +0000805 }
806 else if (strstr(type_name, "char"))
807 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000808 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
809 return ast->UnsignedCharTy.getAsOpaquePtr();
Greg Clayton8ff5d552010-11-02 03:48:39 +0000810 }
811 else if (strstr(type_name, "int"))
Chris Lattner24943d22010-06-08 16:52:24 +0000812 {
Greg Claytonb01000f2011-01-17 03:46:26 +0000813 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
814 return ast->UnsignedIntTy.getAsOpaquePtr();
815 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
816 return ast->UnsignedInt128Ty.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000817 }
Chris Lattner24943d22010-06-08 16:52:24 +0000818 }
819 // We weren't able to match up a type name, just search by size
Greg Claytonb01000f2011-01-17 03:46:26 +0000820 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
821 return ast->UnsignedCharTy.getAsOpaquePtr();
822 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
823 return ast->UnsignedShortTy.getAsOpaquePtr();
824 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
825 return ast->UnsignedIntTy.getAsOpaquePtr();
826 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
827 return ast->UnsignedLongTy.getAsOpaquePtr();
828 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
829 return ast->UnsignedLongLongTy.getAsOpaquePtr();
830 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
831 return ast->UnsignedInt128Ty.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000832 break;
833
834 case DW_ATE_unsigned_char:
Greg Claytonb01000f2011-01-17 03:46:26 +0000835 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
836 return ast->UnsignedCharTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000837 break;
838
839 case DW_ATE_imaginary_float:
840 break;
841 }
842 }
843 // This assert should fire for anything that we don't catch above so we know
844 // to fix any issues we run into.
845 assert (!"error: ClangASTContext::GetClangTypeForDWARFEncodingAndSize() contains an unhandled encoding. Fix this ASAP!");
846 return NULL;
847}
848
Greg Clayton462d4142010-09-29 01:12:09 +0000849clang_type_t
Greg Claytonb01000f2011-01-17 03:46:26 +0000850ClangASTContext::GetBuiltInType_void(ASTContext *ast)
Chris Lattner24943d22010-06-08 16:52:24 +0000851{
Greg Claytonb01000f2011-01-17 03:46:26 +0000852 return ast->VoidTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000853}
854
Greg Clayton462d4142010-09-29 01:12:09 +0000855clang_type_t
Sean Callanana91dd992010-11-19 02:52:21 +0000856ClangASTContext::GetBuiltInType_bool()
857{
858 return getASTContext()->BoolTy.getAsOpaquePtr();
859}
860
861clang_type_t
Greg Clayton960d6a42010-08-03 00:35:52 +0000862ClangASTContext::GetBuiltInType_objc_id()
863{
Sean Callananc4217a62010-12-06 23:53:20 +0000864 return getASTContext()->getPointerType(getASTContext()->ObjCBuiltinIdTy).getAsOpaquePtr();
Greg Clayton960d6a42010-08-03 00:35:52 +0000865}
866
Greg Clayton462d4142010-09-29 01:12:09 +0000867clang_type_t
Greg Clayton960d6a42010-08-03 00:35:52 +0000868ClangASTContext::GetBuiltInType_objc_Class()
869{
Sean Callanan04325062010-10-25 00:29:48 +0000870 return getASTContext()->ObjCBuiltinClassTy.getAsOpaquePtr();
Greg Clayton960d6a42010-08-03 00:35:52 +0000871}
872
Greg Clayton462d4142010-09-29 01:12:09 +0000873clang_type_t
Greg Clayton960d6a42010-08-03 00:35:52 +0000874ClangASTContext::GetBuiltInType_objc_selector()
875{
Sean Callananc4217a62010-12-06 23:53:20 +0000876 return getASTContext()->getPointerType(getASTContext()->ObjCBuiltinSelTy).getAsOpaquePtr();
Greg Clayton960d6a42010-08-03 00:35:52 +0000877}
878
Greg Clayton462d4142010-09-29 01:12:09 +0000879clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +0000880ClangASTContext::GetCStringType (bool is_const)
881{
882 QualType char_type(getASTContext()->CharTy);
883
884 if (is_const)
885 char_type.addConst();
886
887 return getASTContext()->getPointerType(char_type).getAsOpaquePtr();
888}
889
Greg Clayton462d4142010-09-29 01:12:09 +0000890clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +0000891ClangASTContext::GetVoidPtrType (bool is_const)
892{
893 return GetVoidPtrType(getASTContext(), is_const);
894}
895
Greg Clayton462d4142010-09-29 01:12:09 +0000896clang_type_t
Greg Claytonb01000f2011-01-17 03:46:26 +0000897ClangASTContext::GetVoidPtrType (ASTContext *ast, bool is_const)
Chris Lattner24943d22010-06-08 16:52:24 +0000898{
Greg Claytonb01000f2011-01-17 03:46:26 +0000899 QualType void_ptr_type(ast->VoidPtrTy);
Chris Lattner24943d22010-06-08 16:52:24 +0000900
901 if (is_const)
902 void_ptr_type.addConst();
903
904 return void_ptr_type.getAsOpaquePtr();
905}
906
Greg Clayton462d4142010-09-29 01:12:09 +0000907clang_type_t
Greg Clayton22defe82010-12-02 23:20:03 +0000908ClangASTContext::CopyType (ASTContext *dst_ast,
909 ASTContext *src_ast,
Greg Clayton462d4142010-09-29 01:12:09 +0000910 clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000911{
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000912 FileSystemOptions file_system_options;
Greg Clayton22defe82010-12-02 23:20:03 +0000913 FileManager file_manager (file_system_options);
914 ASTImporter importer(*dst_ast, file_manager,
915 *src_ast, file_manager);
Sean Callanancf18faa2010-11-09 22:37:10 +0000916
Greg Clayton22defe82010-12-02 23:20:03 +0000917 QualType src (QualType::getFromOpaquePtr(clang_type));
918 QualType dst (importer.Import(src));
Sean Callanancf18faa2010-11-09 22:37:10 +0000919
920 return dst.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000921}
922
Greg Clayton6916e352010-11-13 03:52:47 +0000923
924clang::Decl *
Greg Clayton22defe82010-12-02 23:20:03 +0000925ClangASTContext::CopyDecl (ASTContext *dst_ast,
926 ASTContext *src_ast,
Greg Clayton6916e352010-11-13 03:52:47 +0000927 clang::Decl *source_decl)
Sean Callanan887d2512010-12-11 00:08:56 +0000928{
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000929 FileSystemOptions file_system_options;
Greg Clayton22defe82010-12-02 23:20:03 +0000930 FileManager file_manager (file_system_options);
931 ASTImporter importer(*dst_ast, file_manager,
932 *src_ast, file_manager);
Greg Clayton6916e352010-11-13 03:52:47 +0000933
934 return importer.Import(source_decl);
935}
936
Sean Callanan8d825062010-07-16 00:00:27 +0000937bool
Greg Claytonb01000f2011-01-17 03:46:26 +0000938ClangASTContext::AreTypesSame(ASTContext *ast,
Greg Clayton462d4142010-09-29 01:12:09 +0000939 clang_type_t type1,
940 clang_type_t type2)
Sean Callanan5510ddd2010-07-15 22:30:52 +0000941{
Greg Claytonb01000f2011-01-17 03:46:26 +0000942 return ast->hasSameType(QualType::getFromOpaquePtr(type1),
Sean Callanan5510ddd2010-07-15 22:30:52 +0000943 QualType::getFromOpaquePtr(type2));
944}
945
Chris Lattner24943d22010-06-08 16:52:24 +0000946#pragma mark CVR modifiers
947
Greg Clayton462d4142010-09-29 01:12:09 +0000948clang_type_t
949ClangASTContext::AddConstModifier (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000950{
951 if (clang_type)
952 {
953 QualType result(QualType::getFromOpaquePtr(clang_type));
954 result.addConst();
955 return result.getAsOpaquePtr();
956 }
957 return NULL;
958}
959
Greg Clayton462d4142010-09-29 01:12:09 +0000960clang_type_t
961ClangASTContext::AddRestrictModifier (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000962{
963 if (clang_type)
964 {
965 QualType result(QualType::getFromOpaquePtr(clang_type));
966 result.getQualifiers().setRestrict (true);
967 return result.getAsOpaquePtr();
968 }
969 return NULL;
970}
971
Greg Clayton462d4142010-09-29 01:12:09 +0000972clang_type_t
973ClangASTContext::AddVolatileModifier (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000974{
975 if (clang_type)
976 {
977 QualType result(QualType::getFromOpaquePtr(clang_type));
978 result.getQualifiers().setVolatile (true);
979 return result.getAsOpaquePtr();
980 }
981 return NULL;
982}
983
Greg Claytonb01000f2011-01-17 03:46:26 +0000984
985clang_type_t
986ClangASTContext::GetTypeForDecl (TagDecl *decl)
987{
988 // No need to call the getASTContext() accessor (which can create the AST
989 // if it isn't created yet, because we can't have created a decl in this
990 // AST if our AST didn't already exist...
991 if (m_ast_ap.get())
992 return m_ast_ap->getTagDeclType(decl).getAsOpaquePtr();
993 return NULL;
994}
995
996clang_type_t
997ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl)
998{
999 // No need to call the getASTContext() accessor (which can create the AST
1000 // if it isn't created yet, because we can't have created a decl in this
1001 // AST if our AST didn't already exist...
1002 if (m_ast_ap.get())
1003 return m_ast_ap->getObjCInterfaceType(decl).getAsOpaquePtr();
1004 return NULL;
1005}
1006
Chris Lattner24943d22010-06-08 16:52:24 +00001007#pragma mark Structure, Unions, Classes
1008
Greg Clayton462d4142010-09-29 01:12:09 +00001009clang_type_t
Greg Clayton585660c2010-08-05 01:57:25 +00001010ClangASTContext::CreateRecordType (const char *name, int kind, DeclContext *decl_ctx, LanguageType language)
Chris Lattner24943d22010-06-08 16:52:24 +00001011{
Greg Claytonb01000f2011-01-17 03:46:26 +00001012 ASTContext *ast = getASTContext();
1013 assert (ast != NULL);
Sean Callanan04325062010-10-25 00:29:48 +00001014
Chris Lattner24943d22010-06-08 16:52:24 +00001015 if (decl_ctx == NULL)
Greg Claytonb01000f2011-01-17 03:46:26 +00001016 decl_ctx = ast->getTranslationUnitDecl();
Chris Lattner24943d22010-06-08 16:52:24 +00001017
Greg Clayton9488b742010-07-28 02:04:09 +00001018
Greg Clayton585660c2010-08-05 01:57:25 +00001019 if (language == eLanguageTypeObjC)
Greg Clayton9488b742010-07-28 02:04:09 +00001020 {
Greg Clayton306edca2010-10-11 02:25:34 +00001021 bool isForwardDecl = true;
Greg Clayton9488b742010-07-28 02:04:09 +00001022 bool isInternal = false;
1023 return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal);
1024 }
1025
Chris Lattner24943d22010-06-08 16:52:24 +00001026 // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1027 // we will need to update this code. I was told to currently always use
1028 // the CXXRecordDecl class since we often don't know from debug information
1029 // if something is struct or a class, so we default to always use the more
1030 // complete definition just in case.
Greg Claytonb01000f2011-01-17 03:46:26 +00001031 CXXRecordDecl *decl = CXXRecordDecl::Create(*ast,
Chris Lattner24943d22010-06-08 16:52:24 +00001032 (TagDecl::TagKind)kind,
1033 decl_ctx,
1034 SourceLocation(),
Greg Claytonb01000f2011-01-17 03:46:26 +00001035 name && name[0] ? &ast->Idents.get(name) : NULL);
Chris Lattner24943d22010-06-08 16:52:24 +00001036
Greg Claytonb01000f2011-01-17 03:46:26 +00001037 return ast->getTagDeclType(decl).getAsOpaquePtr();
1038}
1039
1040bool
1041ClangASTContext::SetHasExternalStorage (clang_type_t clang_type, bool has_extern)
1042{
1043 if (clang_type == NULL)
1044 return false;
1045
1046 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
1047
1048 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1049 switch (type_class)
1050 {
1051 case clang::Type::Record:
1052 {
1053 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
1054 if (cxx_record_decl)
1055 {
1056 cxx_record_decl->setHasExternalLexicalStorage (has_extern);
1057 //cxx_record_decl->setHasExternalVisibleStorage (has_extern);
1058 return true;
1059 }
1060 }
1061 break;
1062
1063 case clang::Type::Enum:
1064 {
1065 EnumDecl *enum_decl = cast<EnumType>(qual_type)->getDecl();
1066 if (enum_decl)
1067 {
1068 enum_decl->setHasExternalLexicalStorage (has_extern);
1069 //enum_decl->setHasExternalVisibleStorage (has_extern);
1070 return true;
1071 }
1072 }
1073 break;
1074
1075 case clang::Type::ObjCObject:
1076 case clang::Type::ObjCInterface:
1077 {
1078 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
1079 assert (objc_class_type);
1080 if (objc_class_type)
1081 {
1082 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1083
1084 if (class_interface_decl)
1085 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001086 class_interface_decl->setHasExternalLexicalStorage (has_extern);
1087 //class_interface_decl->setHasExternalVisibleStorage (has_extern);
1088 return true;
1089 }
1090 }
1091 }
1092 break;
1093
1094 case clang::Type::Typedef:
1095 return ClangASTContext::SetHasExternalStorage (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), has_extern);
1096
1097 default:
1098 break;
1099 }
1100 return false;
Chris Lattner24943d22010-06-08 16:52:24 +00001101}
1102
Greg Claytondbf26152010-10-01 23:13:49 +00001103static bool
1104IsOperator (const char *name, OverloadedOperatorKind &op_kind)
1105{
1106 if (name == NULL || name[0] == '\0')
1107 return false;
1108
Sean Callanan494735d2010-12-10 19:51:54 +00001109#define OPERATOR_PREFIX "operator"
Greg Clayton427f2902010-12-14 02:59:59 +00001110#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
Sean Callananc2c9a142010-12-10 02:15:55 +00001111
1112 const char *post_op_name = NULL;
1113
Sean Callanan494735d2010-12-10 19:51:54 +00001114 bool no_space = true;
Sean Callananc2c9a142010-12-10 02:15:55 +00001115
Greg Clayton427f2902010-12-14 02:59:59 +00001116 if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
Greg Claytondbf26152010-10-01 23:13:49 +00001117 return false;
1118
Greg Clayton427f2902010-12-14 02:59:59 +00001119 post_op_name = name + OPERATOR_PREFIX_LENGTH;
1120
Sean Callanan494735d2010-12-10 19:51:54 +00001121 if (post_op_name[0] == ' ')
1122 {
1123 post_op_name++;
1124 no_space = false;
1125 }
1126
1127#undef OPERATOR_PREFIX
Greg Clayton427f2902010-12-14 02:59:59 +00001128#undef OPERATOR_PREFIX_LENGTH
Sean Callanan494735d2010-12-10 19:51:54 +00001129
Greg Claytondbf26152010-10-01 23:13:49 +00001130 // This is an operator, set the overloaded operator kind to invalid
1131 // in case this is a conversion operator...
1132 op_kind = NUM_OVERLOADED_OPERATORS;
1133
1134 switch (post_op_name[0])
1135 {
Sean Callananc2c9a142010-12-10 02:15:55 +00001136 default:
1137 if (no_space)
1138 return false;
1139 break;
Greg Claytondbf26152010-10-01 23:13:49 +00001140 case 'n':
Sean Callananc2c9a142010-12-10 02:15:55 +00001141 if (no_space)
1142 return false;
Greg Claytondbf26152010-10-01 23:13:49 +00001143 if (strcmp (post_op_name, "new") == 0)
1144 op_kind = OO_New;
1145 else if (strcmp (post_op_name, "new[]") == 0)
1146 op_kind = OO_Array_New;
1147 break;
1148
1149 case 'd':
Sean Callananc2c9a142010-12-10 02:15:55 +00001150 if (no_space)
1151 return false;
Greg Claytondbf26152010-10-01 23:13:49 +00001152 if (strcmp (post_op_name, "delete") == 0)
1153 op_kind = OO_Delete;
1154 else if (strcmp (post_op_name, "delete[]") == 0)
1155 op_kind = OO_Array_Delete;
1156 break;
1157
1158 case '+':
1159 if (post_op_name[1] == '\0')
1160 op_kind = OO_Plus;
1161 else if (post_op_name[2] == '\0')
1162 {
1163 if (post_op_name[1] == '=')
1164 op_kind = OO_PlusEqual;
1165 else if (post_op_name[1] == '+')
1166 op_kind = OO_PlusPlus;
1167 }
1168 break;
1169
1170 case '-':
1171 if (post_op_name[1] == '\0')
1172 op_kind = OO_Minus;
1173 else if (post_op_name[2] == '\0')
1174 {
1175 switch (post_op_name[1])
1176 {
1177 case '=': op_kind = OO_MinusEqual; break;
1178 case '-': op_kind = OO_MinusMinus; break;
1179 case '>': op_kind = OO_Arrow; break;
1180 }
1181 }
1182 else if (post_op_name[3] == '\0')
1183 {
1184 if (post_op_name[2] == '*')
1185 op_kind = OO_ArrowStar; break;
1186 }
1187 break;
1188
1189 case '*':
1190 if (post_op_name[1] == '\0')
1191 op_kind = OO_Star;
1192 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1193 op_kind = OO_StarEqual;
1194 break;
1195
1196 case '/':
1197 if (post_op_name[1] == '\0')
1198 op_kind = OO_Slash;
1199 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1200 op_kind = OO_SlashEqual;
1201 break;
1202
1203 case '%':
1204 if (post_op_name[1] == '\0')
1205 op_kind = OO_Percent;
1206 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1207 op_kind = OO_PercentEqual;
1208 break;
1209
1210
1211 case '^':
1212 if (post_op_name[1] == '\0')
1213 op_kind = OO_Caret;
1214 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1215 op_kind = OO_CaretEqual;
1216 break;
1217
1218 case '&':
1219 if (post_op_name[1] == '\0')
1220 op_kind = OO_Amp;
1221 else if (post_op_name[2] == '\0')
1222 {
1223 switch (post_op_name[1])
1224 {
1225 case '=': op_kind = OO_AmpEqual; break;
1226 case '&': op_kind = OO_AmpAmp; break;
1227 }
1228 }
1229 break;
1230
1231 case '|':
1232 if (post_op_name[1] == '\0')
1233 op_kind = OO_Pipe;
1234 else if (post_op_name[2] == '\0')
1235 {
1236 switch (post_op_name[1])
1237 {
1238 case '=': op_kind = OO_PipeEqual; break;
1239 case '|': op_kind = OO_PipePipe; break;
1240 }
1241 }
1242 break;
1243
1244 case '~':
1245 if (post_op_name[1] == '\0')
1246 op_kind = OO_Tilde;
1247 break;
1248
1249 case '!':
1250 if (post_op_name[1] == '\0')
1251 op_kind = OO_Exclaim;
1252 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1253 op_kind = OO_ExclaimEqual;
1254 break;
1255
1256 case '=':
1257 if (post_op_name[1] == '\0')
1258 op_kind = OO_Equal;
1259 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1260 op_kind = OO_EqualEqual;
1261 break;
1262
1263 case '<':
1264 if (post_op_name[1] == '\0')
1265 op_kind = OO_Less;
1266 else if (post_op_name[2] == '\0')
1267 {
1268 switch (post_op_name[1])
1269 {
1270 case '<': op_kind = OO_LessLess; break;
1271 case '=': op_kind = OO_LessEqual; break;
1272 }
1273 }
1274 else if (post_op_name[3] == '\0')
1275 {
1276 if (post_op_name[2] == '=')
1277 op_kind = OO_LessLessEqual;
1278 }
1279 break;
1280
1281 case '>':
1282 if (post_op_name[1] == '\0')
1283 op_kind = OO_Greater;
1284 else if (post_op_name[2] == '\0')
1285 {
1286 switch (post_op_name[1])
1287 {
1288 case '>': op_kind = OO_GreaterGreater; break;
1289 case '=': op_kind = OO_GreaterEqual; break;
1290 }
1291 }
1292 else if (post_op_name[1] == '>' &&
1293 post_op_name[2] == '=' &&
1294 post_op_name[3] == '\0')
1295 {
1296 op_kind = OO_GreaterGreaterEqual;
1297 }
1298 break;
1299
1300 case ',':
1301 if (post_op_name[1] == '\0')
1302 op_kind = OO_Comma;
1303 break;
1304
1305 case '(':
1306 if (post_op_name[1] == ')' && post_op_name[2] == '\0')
1307 op_kind = OO_Call;
1308 break;
1309
1310 case '[':
1311 if (post_op_name[1] == ']' && post_op_name[2] == '\0')
1312 op_kind = OO_Subscript;
1313 break;
1314 }
1315
1316 return true;
1317}
Greg Claytonb01000f2011-01-17 03:46:26 +00001318
Greg Clayton412440a2010-09-23 01:09:21 +00001319CXXMethodDecl *
Sean Callanan79523002010-09-17 02:58:26 +00001320ClangASTContext::AddMethodToCXXRecordType
1321(
Greg Claytonb01000f2011-01-17 03:46:26 +00001322 ASTContext *ast,
Greg Clayton462d4142010-09-29 01:12:09 +00001323 clang_type_t record_opaque_type,
Greg Clayton412440a2010-09-23 01:09:21 +00001324 const char *name,
Greg Clayton462d4142010-09-29 01:12:09 +00001325 clang_type_t method_opaque_type,
Greg Clayton412440a2010-09-23 01:09:21 +00001326 lldb::AccessType access,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001327 bool is_virtual,
1328 bool is_static,
Greg Clayton30449d52010-10-01 02:31:07 +00001329 bool is_inline,
1330 bool is_explicit
Greg Clayton412440a2010-09-23 01:09:21 +00001331)
Sean Callanan79523002010-09-17 02:58:26 +00001332{
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001333 if (!record_opaque_type || !method_opaque_type || !name)
Johnny Chen974fddb2010-09-28 16:10:54 +00001334 return NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001335
Greg Claytonb01000f2011-01-17 03:46:26 +00001336 assert(ast);
Sean Callanan79523002010-09-17 02:58:26 +00001337
Greg Claytonb01000f2011-01-17 03:46:26 +00001338 IdentifierTable *identifier_table = &ast->Idents;
Sean Callanan79523002010-09-17 02:58:26 +00001339
1340 assert(identifier_table);
1341
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001342 QualType record_qual_type(QualType::getFromOpaquePtr(record_opaque_type));
Greg Clayton1d8173f2010-09-24 05:15:53 +00001343
Greg Claytonb01000f2011-01-17 03:46:26 +00001344 CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
Sean Callanan79523002010-09-17 02:58:26 +00001345
Greg Clayton1d8173f2010-09-24 05:15:53 +00001346 if (cxx_record_decl == NULL)
Greg Clayton412440a2010-09-23 01:09:21 +00001347 return NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001348
Greg Clayton1d8173f2010-09-24 05:15:53 +00001349 QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001350
Greg Clayton30449d52010-10-01 02:31:07 +00001351 CXXMethodDecl *cxx_method_decl = NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001352
Greg Clayton30449d52010-10-01 02:31:07 +00001353 DeclarationName decl_name (&identifier_table->get(name));
Greg Clayton90e325d2010-10-01 03:45:20 +00001354
Greg Clayton90e325d2010-10-01 03:45:20 +00001355 const bool is_implicitly_declared = false;
Greg Clayton30449d52010-10-01 02:31:07 +00001356
Greg Clayton5325a362010-10-02 01:40:05 +00001357 clang::FunctionType *function_Type = dyn_cast<FunctionType>(method_qual_type.getTypePtr());
Greg Clayton90e325d2010-10-01 03:45:20 +00001358
Greg Clayton5325a362010-10-02 01:40:05 +00001359 if (function_Type == NULL)
Greg Clayton90e325d2010-10-01 03:45:20 +00001360 return NULL;
1361
Greg Clayton5325a362010-10-02 01:40:05 +00001362 FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_Type));
Greg Clayton90e325d2010-10-01 03:45:20 +00001363
1364 if (!method_function_prototype)
1365 return NULL;
1366
1367 unsigned int num_params = method_function_prototype->getNumArgs();
1368
1369 if (name[0] == '~')
Greg Clayton30449d52010-10-01 02:31:07 +00001370 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001371 cxx_method_decl = CXXDestructorDecl::Create (*ast,
Greg Clayton90e325d2010-10-01 03:45:20 +00001372 cxx_record_decl,
Greg Claytonb01000f2011-01-17 03:46:26 +00001373 DeclarationNameInfo (ast->DeclarationNames.getCXXDestructorName (ast->getCanonicalType (record_qual_type)), SourceLocation()),
Greg Clayton90e325d2010-10-01 03:45:20 +00001374 method_qual_type,
Sean Callanan8950c9a2010-10-29 18:38:40 +00001375 NULL,
Greg Clayton90e325d2010-10-01 03:45:20 +00001376 is_inline,
1377 is_implicitly_declared);
1378 }
Greg Claytonb01000f2011-01-17 03:46:26 +00001379 else if (decl_name == cxx_record_decl->getDeclName())
Greg Clayton90e325d2010-10-01 03:45:20 +00001380 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001381 cxx_method_decl = CXXConstructorDecl::Create (*ast,
Greg Clayton30449d52010-10-01 02:31:07 +00001382 cxx_record_decl,
Greg Claytonb01000f2011-01-17 03:46:26 +00001383 DeclarationNameInfo (ast->DeclarationNames.getCXXConstructorName (ast->getCanonicalType (record_qual_type)), SourceLocation()),
Greg Clayton30449d52010-10-01 02:31:07 +00001384 method_qual_type,
1385 NULL, // TypeSourceInfo *
1386 is_explicit,
1387 is_inline,
1388 is_implicitly_declared);
1389 }
1390 else
Greg Clayton90e325d2010-10-01 03:45:20 +00001391 {
Greg Claytondbf26152010-10-01 23:13:49 +00001392
1393 OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS;
1394 if (IsOperator (name, op_kind))
Greg Clayton90e325d2010-10-01 03:45:20 +00001395 {
Greg Claytondbf26152010-10-01 23:13:49 +00001396 if (op_kind != NUM_OVERLOADED_OPERATORS)
1397 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001398 cxx_method_decl = CXXMethodDecl::Create (*ast,
Greg Clayton90e325d2010-10-01 03:45:20 +00001399 cxx_record_decl,
Greg Claytonb01000f2011-01-17 03:46:26 +00001400 DeclarationNameInfo (ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()),
Greg Clayton90e325d2010-10-01 03:45:20 +00001401 method_qual_type,
1402 NULL, // TypeSourceInfo *
Greg Claytondbf26152010-10-01 23:13:49 +00001403 is_static,
1404 SC_None,
1405 is_inline);
1406 }
1407 else if (num_params == 0)
1408 {
1409 // Conversion operators don't take params...
Greg Claytonb01000f2011-01-17 03:46:26 +00001410 cxx_method_decl = CXXConversionDecl::Create (*ast,
Greg Claytondbf26152010-10-01 23:13:49 +00001411 cxx_record_decl,
Greg Claytonb01000f2011-01-17 03:46:26 +00001412 DeclarationNameInfo (ast->DeclarationNames.getCXXConversionFunctionName (ast->getCanonicalType (function_Type->getResultType())), SourceLocation()),
Greg Claytondbf26152010-10-01 23:13:49 +00001413 method_qual_type,
1414 NULL, // TypeSourceInfo *
1415 is_inline,
1416 is_explicit);
1417 }
Greg Clayton90e325d2010-10-01 03:45:20 +00001418 }
Greg Claytondbf26152010-10-01 23:13:49 +00001419
1420 if (cxx_method_decl == NULL)
Greg Clayton90e325d2010-10-01 03:45:20 +00001421 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001422 cxx_method_decl = CXXMethodDecl::Create (*ast,
Greg Clayton90e325d2010-10-01 03:45:20 +00001423 cxx_record_decl,
Greg Claytondbf26152010-10-01 23:13:49 +00001424 DeclarationNameInfo (decl_name, SourceLocation()),
Greg Clayton90e325d2010-10-01 03:45:20 +00001425 method_qual_type,
1426 NULL, // TypeSourceInfo *
1427 is_static,
1428 SC_None,
1429 is_inline);
1430 }
Greg Clayton30449d52010-10-01 02:31:07 +00001431 }
Greg Claytondbf26152010-10-01 23:13:49 +00001432
Greg Clayton462d4142010-09-29 01:12:09 +00001433 AccessSpecifier access_specifier = ConvertAccessTypeToAccessSpecifier (access);
Greg Clayton1d8173f2010-09-24 05:15:53 +00001434
1435 cxx_method_decl->setAccess (access_specifier);
1436 cxx_method_decl->setVirtualAsWritten (is_virtual);
Sean Callanan47a5c4c2010-09-23 03:01:22 +00001437
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001438 // Populate the method decl with parameter decls
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001439
1440 ParmVarDecl *params[num_params];
1441
1442 for (int param_index = 0;
1443 param_index < num_params;
1444 ++param_index)
1445 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001446 params[param_index] = ParmVarDecl::Create (*ast,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001447 cxx_method_decl,
1448 SourceLocation(),
1449 NULL, // anonymous
1450 method_function_prototype->getArgType(param_index),
1451 NULL,
1452 SC_None,
1453 SC_None,
1454 NULL);
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001455 }
1456
Greg Clayton1d8173f2010-09-24 05:15:53 +00001457 cxx_method_decl->setParams (params, num_params);
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001458
Greg Clayton1d8173f2010-09-24 05:15:53 +00001459 cxx_record_decl->addDecl (cxx_method_decl);
Sean Callanan79523002010-09-17 02:58:26 +00001460
Greg Clayton412440a2010-09-23 01:09:21 +00001461 return cxx_method_decl;
Sean Callanan79523002010-09-17 02:58:26 +00001462}
1463
1464bool
Greg Clayton84f80752010-07-22 18:30:50 +00001465ClangASTContext::AddFieldToRecordType
1466(
Greg Claytonb01000f2011-01-17 03:46:26 +00001467 ASTContext *ast,
Greg Clayton462d4142010-09-29 01:12:09 +00001468 clang_type_t record_clang_type,
Greg Clayton84f80752010-07-22 18:30:50 +00001469 const char *name,
Greg Clayton462d4142010-09-29 01:12:09 +00001470 clang_type_t field_type,
Greg Clayton84f80752010-07-22 18:30:50 +00001471 AccessType access,
1472 uint32_t bitfield_bit_size
1473)
Chris Lattner24943d22010-06-08 16:52:24 +00001474{
1475 if (record_clang_type == NULL || field_type == NULL)
1476 return false;
1477
Greg Claytonb01000f2011-01-17 03:46:26 +00001478 IdentifierTable *identifier_table = &ast->Idents;
Chris Lattner24943d22010-06-08 16:52:24 +00001479
Greg Claytonb01000f2011-01-17 03:46:26 +00001480 assert (ast != NULL);
Chris Lattner24943d22010-06-08 16:52:24 +00001481 assert (identifier_table != NULL);
1482
1483 QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type));
1484
Greg Clayton1674b122010-07-21 22:12:05 +00001485 clang::Type *clang_type = record_qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00001486 if (clang_type)
1487 {
1488 const RecordType *record_type = dyn_cast<RecordType>(clang_type);
1489
1490 if (record_type)
1491 {
1492 RecordDecl *record_decl = record_type->getDecl();
1493
Chris Lattner24943d22010-06-08 16:52:24 +00001494 clang::Expr *bit_width = NULL;
1495 if (bitfield_bit_size != 0)
1496 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001497 APInt bitfield_bit_size_apint(ast->getTypeSize(ast->IntTy), bitfield_bit_size);
1498 bit_width = new (*ast)IntegerLiteral (*ast, bitfield_bit_size_apint, ast->IntTy, SourceLocation());
Chris Lattner24943d22010-06-08 16:52:24 +00001499 }
Greg Claytonb01000f2011-01-17 03:46:26 +00001500 FieldDecl *field = FieldDecl::Create (*ast,
Greg Clayton84f80752010-07-22 18:30:50 +00001501 record_decl,
1502 SourceLocation(),
1503 name ? &identifier_table->get(name) : NULL, // Identifier
1504 QualType::getFromOpaquePtr(field_type), // Field type
1505 NULL, // DeclaratorInfo *
1506 bit_width, // BitWidth
1507 false); // Mutable
Chris Lattner24943d22010-06-08 16:52:24 +00001508
Greg Clayton84f80752010-07-22 18:30:50 +00001509 field->setAccess (ConvertAccessTypeToAccessSpecifier (access));
Chris Lattner24943d22010-06-08 16:52:24 +00001510
1511 if (field)
1512 {
1513 record_decl->addDecl(field);
Chris Lattner24943d22010-06-08 16:52:24 +00001514 }
1515 }
Greg Clayton9488b742010-07-28 02:04:09 +00001516 else
1517 {
1518 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(clang_type);
1519 if (objc_class_type)
1520 {
Greg Clayton1d8173f2010-09-24 05:15:53 +00001521 bool is_synthesized = false;
Greg Claytonb01000f2011-01-17 03:46:26 +00001522 ClangASTContext::AddObjCClassIVar (ast,
Sean Callanan60a0ced2010-09-16 20:01:08 +00001523 record_clang_type,
Greg Clayton9488b742010-07-28 02:04:09 +00001524 name,
1525 field_type,
1526 access,
1527 bitfield_bit_size,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001528 is_synthesized);
Greg Clayton9488b742010-07-28 02:04:09 +00001529 }
1530 }
Chris Lattner24943d22010-06-08 16:52:24 +00001531 }
1532 return false;
1533}
1534
1535bool
1536ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size)
1537{
1538 return FieldIsBitfield(getASTContext(), field, bitfield_bit_size);
1539}
1540
1541bool
1542ClangASTContext::FieldIsBitfield
1543(
Greg Claytonb01000f2011-01-17 03:46:26 +00001544 ASTContext *ast,
Chris Lattner24943d22010-06-08 16:52:24 +00001545 FieldDecl* field,
1546 uint32_t& bitfield_bit_size
1547)
1548{
Greg Claytonb01000f2011-01-17 03:46:26 +00001549 if (ast == NULL || field == NULL)
Chris Lattner24943d22010-06-08 16:52:24 +00001550 return false;
1551
1552 if (field->isBitField())
1553 {
1554 Expr* bit_width_expr = field->getBitWidth();
1555 if (bit_width_expr)
1556 {
1557 llvm::APSInt bit_width_apsint;
Greg Claytonb01000f2011-01-17 03:46:26 +00001558 if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast))
Chris Lattner24943d22010-06-08 16:52:24 +00001559 {
1560 bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX);
1561 return true;
1562 }
1563 }
1564 }
1565 return false;
1566}
1567
1568bool
1569ClangASTContext::RecordHasFields (const RecordDecl *record_decl)
1570{
1571 if (record_decl == NULL)
1572 return false;
1573
1574 if (!record_decl->field_empty())
1575 return true;
1576
1577 // No fields, lets check this is a CXX record and check the base classes
1578 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1579 if (cxx_record_decl)
1580 {
1581 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1582 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1583 base_class != base_class_end;
1584 ++base_class)
1585 {
1586 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
1587 if (RecordHasFields(base_class_decl))
1588 return true;
1589 }
1590 }
1591 return false;
1592}
1593
1594void
Greg Claytonb01000f2011-01-17 03:46:26 +00001595ClangASTContext::SetDefaultAccessForRecordFields (clang_type_t clang_type, int default_accessibility, int *assigned_accessibilities, size_t num_assigned_accessibilities)
Chris Lattner24943d22010-06-08 16:52:24 +00001596{
Greg Claytonb01000f2011-01-17 03:46:26 +00001597 if (clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00001598 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001599 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
1600
1601 RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr());
1602 if (record_type)
Chris Lattner24943d22010-06-08 16:52:24 +00001603 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001604 RecordDecl *record_decl = record_type->getDecl();
1605 if (record_decl)
Chris Lattner24943d22010-06-08 16:52:24 +00001606 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001607 uint32_t field_idx;
1608 RecordDecl::field_iterator field, field_end;
1609 for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0;
1610 field != field_end;
1611 ++field, ++field_idx)
Chris Lattner24943d22010-06-08 16:52:24 +00001612 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001613 // If no accessibility was assigned, assign the correct one
1614 if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none)
1615 field->setAccess ((AccessSpecifier)default_accessibility);
Chris Lattner24943d22010-06-08 16:52:24 +00001616 }
1617 }
1618 }
1619 }
1620}
1621
1622#pragma mark C++ Base Classes
1623
1624CXXBaseSpecifier *
Greg Clayton462d4142010-09-29 01:12:09 +00001625ClangASTContext::CreateBaseClassSpecifier (clang_type_t base_class_type, AccessType access, bool is_virtual, bool base_of_class)
Chris Lattner24943d22010-06-08 16:52:24 +00001626{
1627 if (base_class_type)
Greg Clayton6e713402010-07-30 20:30:44 +00001628 return new CXXBaseSpecifier (SourceRange(),
1629 is_virtual,
1630 base_of_class,
1631 ConvertAccessTypeToAccessSpecifier (access),
1632 getASTContext()->CreateTypeSourceInfo (QualType::getFromOpaquePtr(base_class_type)));
Chris Lattner24943d22010-06-08 16:52:24 +00001633 return NULL;
1634}
1635
Greg Claytone9d0df42010-07-02 01:29:13 +00001636void
1637ClangASTContext::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes)
1638{
1639 for (unsigned i=0; i<num_base_classes; ++i)
1640 {
1641 delete base_classes[i];
1642 base_classes[i] = NULL;
1643 }
1644}
1645
Chris Lattner24943d22010-06-08 16:52:24 +00001646bool
Greg Clayton462d4142010-09-29 01:12:09 +00001647ClangASTContext::SetBaseClassesForClassType (clang_type_t class_clang_type, CXXBaseSpecifier const * const *base_classes, unsigned num_base_classes)
Chris Lattner24943d22010-06-08 16:52:24 +00001648{
1649 if (class_clang_type)
1650 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001651 CXXRecordDecl *cxx_record_decl = QualType::getFromOpaquePtr(class_clang_type)->getAsCXXRecordDecl();
1652 if (cxx_record_decl)
Chris Lattner24943d22010-06-08 16:52:24 +00001653 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001654 cxx_record_decl->setBases(base_classes, num_base_classes);
1655 return true;
Chris Lattner24943d22010-06-08 16:52:24 +00001656 }
1657 }
1658 return false;
1659}
Greg Clayton84f80752010-07-22 18:30:50 +00001660#pragma mark Objective C Classes
Chris Lattner24943d22010-06-08 16:52:24 +00001661
Greg Clayton462d4142010-09-29 01:12:09 +00001662clang_type_t
Greg Clayton84f80752010-07-22 18:30:50 +00001663ClangASTContext::CreateObjCClass
1664(
1665 const char *name,
1666 DeclContext *decl_ctx,
1667 bool isForwardDecl,
1668 bool isInternal
1669)
1670{
Greg Claytonb01000f2011-01-17 03:46:26 +00001671 ASTContext *ast = getASTContext();
1672 assert (ast != NULL);
Greg Clayton84f80752010-07-22 18:30:50 +00001673 assert (name && name[0]);
1674 if (decl_ctx == NULL)
Greg Claytonb01000f2011-01-17 03:46:26 +00001675 decl_ctx = ast->getTranslationUnitDecl();
Greg Clayton84f80752010-07-22 18:30:50 +00001676
1677 // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1678 // we will need to update this code. I was told to currently always use
1679 // the CXXRecordDecl class since we often don't know from debug information
1680 // if something is struct or a class, so we default to always use the more
1681 // complete definition just in case.
Greg Claytonb01000f2011-01-17 03:46:26 +00001682 ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast,
Greg Clayton84f80752010-07-22 18:30:50 +00001683 decl_ctx,
1684 SourceLocation(),
Greg Claytonb01000f2011-01-17 03:46:26 +00001685 &ast->Idents.get(name),
Greg Clayton84f80752010-07-22 18:30:50 +00001686 SourceLocation(),
1687 isForwardDecl,
1688 isInternal);
Greg Clayton9488b742010-07-28 02:04:09 +00001689
Greg Claytonb01000f2011-01-17 03:46:26 +00001690 return ast->getObjCInterfaceType(decl).getAsOpaquePtr();
Greg Clayton84f80752010-07-22 18:30:50 +00001691}
1692
1693bool
Greg Clayton462d4142010-09-29 01:12:09 +00001694ClangASTContext::SetObjCSuperClass (clang_type_t class_opaque_type, clang_type_t super_opaque_type)
Greg Clayton84f80752010-07-22 18:30:50 +00001695{
1696 if (class_opaque_type && super_opaque_type)
1697 {
1698 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1699 QualType super_qual_type(QualType::getFromOpaquePtr(super_opaque_type));
1700 clang::Type *class_type = class_qual_type.getTypePtr();
1701 clang::Type *super_type = super_qual_type.getTypePtr();
1702 if (class_type && super_type)
1703 {
1704 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1705 ObjCObjectType *objc_super_type = dyn_cast<ObjCObjectType>(super_type);
1706 if (objc_class_type && objc_super_type)
1707 {
1708 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1709 ObjCInterfaceDecl *super_interface_decl = objc_super_type->getInterface();
1710 if (class_interface_decl && super_interface_decl)
1711 {
1712 class_interface_decl->setSuperClass(super_interface_decl);
1713 return true;
1714 }
1715 }
1716 }
1717 }
1718 return false;
1719}
1720
1721
1722bool
1723ClangASTContext::AddObjCClassIVar
1724(
Greg Claytonb01000f2011-01-17 03:46:26 +00001725 ASTContext *ast,
Greg Clayton462d4142010-09-29 01:12:09 +00001726 clang_type_t class_opaque_type,
Greg Clayton84f80752010-07-22 18:30:50 +00001727 const char *name,
Greg Clayton462d4142010-09-29 01:12:09 +00001728 clang_type_t ivar_opaque_type,
Greg Clayton84f80752010-07-22 18:30:50 +00001729 AccessType access,
1730 uint32_t bitfield_bit_size,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001731 bool is_synthesized
Greg Clayton84f80752010-07-22 18:30:50 +00001732)
1733{
1734 if (class_opaque_type == NULL || ivar_opaque_type == NULL)
1735 return false;
1736
Greg Claytonb01000f2011-01-17 03:46:26 +00001737 IdentifierTable *identifier_table = &ast->Idents;
Greg Clayton84f80752010-07-22 18:30:50 +00001738
Greg Claytonb01000f2011-01-17 03:46:26 +00001739 assert (ast != NULL);
Greg Clayton84f80752010-07-22 18:30:50 +00001740 assert (identifier_table != NULL);
1741
1742 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1743
1744 clang::Type *class_type = class_qual_type.getTypePtr();
1745 if (class_type)
1746 {
1747 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1748
1749 if (objc_class_type)
1750 {
1751 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1752
1753 if (class_interface_decl)
1754 {
1755 clang::Expr *bit_width = NULL;
1756 if (bitfield_bit_size != 0)
1757 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001758 APInt bitfield_bit_size_apint(ast->getTypeSize(ast->IntTy), bitfield_bit_size);
1759 bit_width = new (*ast)IntegerLiteral (*ast, bitfield_bit_size_apint, ast->IntTy, SourceLocation());
Greg Clayton84f80752010-07-22 18:30:50 +00001760 }
1761
Greg Claytonb01000f2011-01-17 03:46:26 +00001762 ObjCIvarDecl *field = ObjCIvarDecl::Create (*ast,
Greg Clayton9488b742010-07-28 02:04:09 +00001763 class_interface_decl,
1764 SourceLocation(),
1765 &identifier_table->get(name), // Identifier
1766 QualType::getFromOpaquePtr(ivar_opaque_type), // Field type
1767 NULL, // TypeSourceInfo *
1768 ConvertAccessTypeToObjCIvarAccessControl (access),
1769 bit_width,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001770 is_synthesized);
Greg Clayton9488b742010-07-28 02:04:09 +00001771
1772 if (field)
1773 {
1774 class_interface_decl->addDecl(field);
1775 return true;
1776 }
Greg Clayton84f80752010-07-22 18:30:50 +00001777 }
1778 }
1779 }
1780 return false;
1781}
Chris Lattner24943d22010-06-08 16:52:24 +00001782
Greg Clayton9488b742010-07-28 02:04:09 +00001783
1784bool
Greg Clayton462d4142010-09-29 01:12:09 +00001785ClangASTContext::ObjCTypeHasIVars (clang_type_t class_opaque_type, bool check_superclass)
Greg Clayton9488b742010-07-28 02:04:09 +00001786{
1787 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1788
1789 clang::Type *class_type = class_qual_type.getTypePtr();
1790 if (class_type)
1791 {
1792 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1793
1794 if (objc_class_type)
1795 return ObjCDeclHasIVars (objc_class_type->getInterface(), check_superclass);
1796 }
1797 return false;
1798}
1799
1800bool
1801ClangASTContext::ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
1802{
1803 while (class_interface_decl)
1804 {
1805 if (class_interface_decl->ivar_size() > 0)
1806 return true;
1807
1808 if (check_superclass)
1809 class_interface_decl = class_interface_decl->getSuperClass();
1810 else
1811 break;
1812 }
1813 return false;
1814}
Greg Clayton1d8173f2010-09-24 05:15:53 +00001815
Greg Clayton462d4142010-09-29 01:12:09 +00001816ObjCMethodDecl *
Greg Clayton1d8173f2010-09-24 05:15:53 +00001817ClangASTContext::AddMethodToObjCObjectType
1818(
Greg Claytonb01000f2011-01-17 03:46:26 +00001819 ASTContext *ast,
Greg Clayton462d4142010-09-29 01:12:09 +00001820 clang_type_t class_opaque_type,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001821 const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]")
Greg Clayton462d4142010-09-29 01:12:09 +00001822 clang_type_t method_opaque_type,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001823 lldb::AccessType access
1824)
1825{
1826 if (class_opaque_type == NULL || method_opaque_type == NULL)
1827 return NULL;
1828
Greg Claytonb01000f2011-01-17 03:46:26 +00001829 IdentifierTable *identifier_table = &ast->Idents;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001830
Greg Claytonb01000f2011-01-17 03:46:26 +00001831 assert (ast != NULL);
Greg Clayton1d8173f2010-09-24 05:15:53 +00001832 assert (identifier_table != NULL);
1833
1834 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1835
1836 clang::Type *class_type = class_qual_type.getTypePtr();
1837 if (class_type == NULL)
1838 return NULL;
1839
1840 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1841
1842 if (objc_class_type == NULL)
1843 return NULL;
1844
1845 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1846
1847 if (class_interface_decl == NULL)
1848 return NULL;
Greg Clayton9488b742010-07-28 02:04:09 +00001849
Greg Clayton1d8173f2010-09-24 05:15:53 +00001850 const char *selector_start = ::strchr (name, ' ');
1851 if (selector_start == NULL)
1852 return NULL;
1853
1854 selector_start++;
1855 if (!(::isalpha (selector_start[0]) || selector_start[0] == '_'))
1856 return NULL;
1857 llvm::SmallVector<IdentifierInfo *, 12> selector_idents;
1858
Greg Claytonad60bf42010-10-12 02:24:53 +00001859 size_t len = 0;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001860 const char *start;
Greg Claytonad60bf42010-10-12 02:24:53 +00001861 //printf ("name = '%s'\n", name);
1862
1863 unsigned num_selectors_with_args = 0;
1864 for (start = selector_start;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001865 start && *start != '\0' && *start != ']';
Greg Claytonad60bf42010-10-12 02:24:53 +00001866 start += len)
Greg Clayton1d8173f2010-09-24 05:15:53 +00001867 {
Greg Claytonad60bf42010-10-12 02:24:53 +00001868 len = ::strcspn(start, ":]");
Greg Clayton6bc44a42010-10-27 04:01:14 +00001869 bool has_arg = (start[len] == ':');
1870 if (has_arg)
Greg Claytonad60bf42010-10-12 02:24:53 +00001871 ++num_selectors_with_args;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001872 selector_idents.push_back (&identifier_table->get (StringRef (start, len)));
Greg Clayton6bc44a42010-10-27 04:01:14 +00001873 if (has_arg)
1874 len += 1;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001875 }
1876
1877
1878 if (selector_idents.size() == 0)
1879 return 0;
1880
Greg Claytonb01000f2011-01-17 03:46:26 +00001881 clang::Selector method_selector = ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001882 selector_idents.data());
1883
1884 QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
1885
1886 // Populate the method decl with parameter decls
1887 clang::Type *method_type(method_qual_type.getTypePtr());
1888
1889 if (method_type == NULL)
1890 return NULL;
1891
1892 FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type));
1893
1894 if (!method_function_prototype)
1895 return NULL;
1896
1897
1898 bool is_variadic = false;
1899 bool is_synthesized = false;
1900 bool is_defined = false;
1901 ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None;
1902
1903 const unsigned num_args = method_function_prototype->getNumArgs();
1904
Greg Claytonb01000f2011-01-17 03:46:26 +00001905 ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*ast,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001906 SourceLocation(), // beginLoc,
1907 SourceLocation(), // endLoc,
1908 method_selector,
1909 method_function_prototype->getResultType(),
1910 NULL, // TypeSourceInfo *ResultTInfo,
1911 GetDeclContextForType (class_opaque_type),
1912 name[0] == '-',
1913 is_variadic,
1914 is_synthesized,
1915 is_defined,
1916 imp_control,
1917 num_args);
1918
1919
1920 if (objc_method_decl == NULL)
1921 return NULL;
1922
1923 if (num_args > 0)
1924 {
1925 llvm::SmallVector<ParmVarDecl *, 12> params;
1926
1927 for (int param_index = 0; param_index < num_args; ++param_index)
1928 {
Greg Claytonb01000f2011-01-17 03:46:26 +00001929 params.push_back (ParmVarDecl::Create (*ast,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001930 objc_method_decl,
1931 SourceLocation(),
1932 NULL, // anonymous
1933 method_function_prototype->getArgType(param_index),
1934 NULL,
1935 SC_Auto,
1936 SC_Auto,
1937 NULL));
1938 }
1939
Greg Claytonb01000f2011-01-17 03:46:26 +00001940 objc_method_decl->setMethodParams(*ast, params.data(), params.size(), num_args);
Greg Clayton1d8173f2010-09-24 05:15:53 +00001941 }
1942
1943 class_interface_decl->addDecl (objc_method_decl);
1944
1945
1946 return objc_method_decl;
1947}
1948
1949
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001950uint32_t
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001951ClangASTContext::GetTypeInfo
1952(
1953 clang_type_t clang_type,
Greg Claytonb01000f2011-01-17 03:46:26 +00001954 clang::ASTContext *ast,
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001955 clang_type_t *pointee_or_element_clang_type
1956)
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001957{
1958 if (clang_type == NULL)
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001959 return 0;
1960
1961 if (pointee_or_element_clang_type)
1962 *pointee_or_element_clang_type = NULL;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001963
1964 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
1965
1966 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1967 switch (type_class)
1968 {
Sean Callanan04325062010-10-25 00:29:48 +00001969 case clang::Type::Builtin:
1970 switch (cast<clang::BuiltinType>(qual_type)->getKind())
1971 {
Sean Callanan04325062010-10-25 00:29:48 +00001972 case clang::BuiltinType::ObjCId:
1973 case clang::BuiltinType::ObjCClass:
Greg Claytonb01000f2011-01-17 03:46:26 +00001974 if (ast && pointee_or_element_clang_type)
1975 *pointee_or_element_clang_type = ast->ObjCBuiltinClassTy.getAsOpaquePtr();
Sean Callanan04325062010-10-25 00:29:48 +00001976 return eTypeIsBuiltIn | eTypeIsPointer | eTypeHasValue;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001977
1978 default:
1979 break;
Sean Callanan04325062010-10-25 00:29:48 +00001980 }
1981 return eTypeIsBuiltIn | eTypeHasValue;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001982
1983 case clang::Type::BlockPointer:
1984 if (pointee_or_element_clang_type)
1985 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
1986 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
1987
Greg Claytone52f37b2011-01-15 02:52:14 +00001988 case clang::Type::Complex: return eTypeIsBuiltIn | eTypeHasValue;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001989
1990 case clang::Type::ConstantArray:
1991 case clang::Type::DependentSizedArray:
1992 case clang::Type::IncompleteArray:
1993 case clang::Type::VariableArray:
1994 if (pointee_or_element_clang_type)
1995 *pointee_or_element_clang_type = cast<ArrayType>(qual_type.getTypePtr())->getElementType().getAsOpaquePtr();
1996 return eTypeHasChildren | eTypeIsArray;
1997
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001998 case clang::Type::DependentName: return 0;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001999 case clang::Type::DependentSizedExtVector: return eTypeHasChildren | eTypeIsVector;
2000 case clang::Type::DependentTemplateSpecialization: return eTypeIsTemplate;
2001 case clang::Type::Decltype: return 0;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002002
2003 case clang::Type::Enum:
2004 if (pointee_or_element_clang_type)
2005 *pointee_or_element_clang_type = cast<EnumType>(qual_type)->getDecl()->getIntegerType().getAsOpaquePtr();
2006 return eTypeIsEnumeration | eTypeHasValue;
2007
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002008 case clang::Type::Elaborated: return 0;
2009 case clang::Type::ExtVector: return eTypeHasChildren | eTypeIsVector;
2010 case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue;
2011 case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002012 case clang::Type::InjectedClassName: return 0;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002013
2014 case clang::Type::LValueReference:
2015 case clang::Type::RValueReference:
2016 if (pointee_or_element_clang_type)
2017 *pointee_or_element_clang_type = cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr();
2018 return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
2019
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002020 case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002021
2022 case clang::Type::ObjCObjectPointer:
2023 if (pointee_or_element_clang_type)
2024 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
2025 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue;
2026
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002027 case clang::Type::ObjCObject: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
2028 case clang::Type::ObjCInterface: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002029
2030 case clang::Type::Pointer:
2031 if (pointee_or_element_clang_type)
2032 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
2033 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
2034
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002035 case clang::Type::Record:
2036 if (qual_type->getAsCXXRecordDecl())
2037 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
2038 else
2039 return eTypeHasChildren | eTypeIsStructUnion;
2040 break;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002041 case clang::Type::SubstTemplateTypeParm: return eTypeIsTemplate;
2042 case clang::Type::TemplateTypeParm: return eTypeIsTemplate;
2043 case clang::Type::TemplateSpecialization: return eTypeIsTemplate;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002044
2045 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00002046 return eTypeIsTypedef | ClangASTContext::GetTypeInfo (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
Greg Claytonb01000f2011-01-17 03:46:26 +00002047 ast,
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002048 pointee_or_element_clang_type);
2049
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002050 case clang::Type::TypeOfExpr: return 0;
2051 case clang::Type::TypeOf: return 0;
2052 case clang::Type::UnresolvedUsing: return 0;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002053 case clang::Type::Vector: return eTypeHasChildren | eTypeIsVector;
2054 default: return 0;
2055 }
2056 return 0;
2057}
2058
Greg Clayton9488b742010-07-28 02:04:09 +00002059
Chris Lattner24943d22010-06-08 16:52:24 +00002060#pragma mark Aggregate Types
2061
2062bool
Greg Clayton462d4142010-09-29 01:12:09 +00002063ClangASTContext::IsAggregateType (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00002064{
2065 if (clang_type == NULL)
2066 return false;
2067
2068 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
2069
Greg Clayton03e0f972010-09-13 03:32:57 +00002070 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2071 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00002072 {
Greg Clayton1674b122010-07-21 22:12:05 +00002073 case clang::Type::IncompleteArray:
2074 case clang::Type::VariableArray:
2075 case clang::Type::ConstantArray:
2076 case clang::Type::ExtVector:
2077 case clang::Type::Vector:
2078 case clang::Type::Record:
Greg Clayton9488b742010-07-28 02:04:09 +00002079 case clang::Type::ObjCObject:
2080 case clang::Type::ObjCInterface:
Chris Lattner24943d22010-06-08 16:52:24 +00002081 return true;
2082
Greg Clayton1674b122010-07-21 22:12:05 +00002083 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00002084 return ClangASTContext::IsAggregateType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
Chris Lattner24943d22010-06-08 16:52:24 +00002085
2086 default:
2087 break;
2088 }
2089 // The clang type does have a value
2090 return false;
2091}
2092
2093uint32_t
Greg Claytonb01000f2011-01-17 03:46:26 +00002094ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type, bool omit_empty_base_classes)
Chris Lattner24943d22010-06-08 16:52:24 +00002095{
Greg Claytonb01000f2011-01-17 03:46:26 +00002096 if (clang_type == NULL)
Chris Lattner24943d22010-06-08 16:52:24 +00002097 return 0;
2098
2099 uint32_t num_children = 0;
Greg Claytonb01000f2011-01-17 03:46:26 +00002100 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
Greg Clayton9488b742010-07-28 02:04:09 +00002101 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2102 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00002103 {
Greg Clayton960d6a42010-08-03 00:35:52 +00002104 case clang::Type::Builtin:
2105 switch (cast<clang::BuiltinType>(qual_type)->getKind())
2106 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002107 case clang::BuiltinType::ObjCId: // child is Class
Greg Clayton960d6a42010-08-03 00:35:52 +00002108 case clang::BuiltinType::ObjCClass: // child is Class
Greg Clayton960d6a42010-08-03 00:35:52 +00002109 num_children = 1;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002110 break;
Greg Clayton960d6a42010-08-03 00:35:52 +00002111
2112 default:
2113 break;
2114 }
2115 break;
Greg Claytonc3b61d22010-12-15 05:08:08 +00002116
Greg Claytone52f37b2011-01-15 02:52:14 +00002117 case clang::Type::Complex: return 0;
Greg Claytonc3b61d22010-12-15 05:08:08 +00002118
Greg Clayton1674b122010-07-21 22:12:05 +00002119 case clang::Type::Record:
Greg Claytonb01000f2011-01-17 03:46:26 +00002120 if (ClangASTContext::GetCompleteType (ast, clang_type))
Chris Lattner24943d22010-06-08 16:52:24 +00002121 {
2122 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
2123 const RecordDecl *record_decl = record_type->getDecl();
2124 assert(record_decl);
2125 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2126 if (cxx_record_decl)
2127 {
2128 if (omit_empty_base_classes)
2129 {
2130 // Check each base classes to see if it or any of its
2131 // base classes contain any fields. This can help
2132 // limit the noise in variable views by not having to
2133 // show base classes that contain no members.
2134 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2135 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2136 base_class != base_class_end;
2137 ++base_class)
2138 {
2139 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2140
2141 // Skip empty base classes
2142 if (RecordHasFields(base_class_decl) == false)
2143 continue;
2144
2145 num_children++;
2146 }
2147 }
2148 else
2149 {
2150 // Include all base classes
2151 num_children += cxx_record_decl->getNumBases();
2152 }
2153
2154 }
2155 RecordDecl::field_iterator field, field_end;
2156 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
2157 ++num_children;
2158 }
2159 break;
2160
Greg Clayton9488b742010-07-28 02:04:09 +00002161 case clang::Type::ObjCObject:
2162 case clang::Type::ObjCInterface:
2163 {
2164 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
2165 assert (objc_class_type);
2166 if (objc_class_type)
2167 {
2168 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2169
2170 if (class_interface_decl)
2171 {
2172
2173 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2174 if (superclass_interface_decl)
2175 {
2176 if (omit_empty_base_classes)
2177 {
2178 if (ClangASTContext::ObjCDeclHasIVars (superclass_interface_decl, true))
2179 ++num_children;
2180 }
2181 else
2182 ++num_children;
2183 }
2184
2185 num_children += class_interface_decl->ivar_size();
2186 }
2187 }
2188 }
2189 break;
2190
2191 case clang::Type::ObjCObjectPointer:
Greg Clayton960d6a42010-08-03 00:35:52 +00002192 {
2193 ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr());
2194 QualType pointee_type = pointer_type->getPointeeType();
Greg Claytonb01000f2011-01-17 03:46:26 +00002195 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
2196 pointee_type.getAsOpaquePtr(),
Greg Clayton960d6a42010-08-03 00:35:52 +00002197 omit_empty_base_classes);
2198 // If this type points to a simple type, then it has 1 child
2199 if (num_pointee_children == 0)
2200 num_children = 1;
2201 else
2202 num_children = num_pointee_children;
2203 }
2204 break;
Greg Clayton9488b742010-07-28 02:04:09 +00002205
Greg Clayton1674b122010-07-21 22:12:05 +00002206 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00002207 num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
2208 break;
2209
Greg Clayton1674b122010-07-21 22:12:05 +00002210 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00002211 {
2212 PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
Greg Claytonc3b61d22010-12-15 05:08:08 +00002213 QualType pointee_type (pointer_type->getPointeeType());
Greg Claytonb01000f2011-01-17 03:46:26 +00002214 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
2215 pointee_type.getAsOpaquePtr(),
Greg Clayton9488b742010-07-28 02:04:09 +00002216 omit_empty_base_classes);
Chris Lattner24943d22010-06-08 16:52:24 +00002217 if (num_pointee_children == 0)
Greg Claytonc3b61d22010-12-15 05:08:08 +00002218 {
2219 // We have a pointer to a pointee type that claims it has no children.
2220 // We will want to look at
2221 num_children = ClangASTContext::GetNumPointeeChildren (pointee_type.getAsOpaquePtr());
2222 }
Chris Lattner24943d22010-06-08 16:52:24 +00002223 else
2224 num_children = num_pointee_children;
2225 }
2226 break;
2227
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002228 case clang::Type::LValueReference:
2229 case clang::Type::RValueReference:
2230 {
2231 ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
2232 QualType pointee_type = reference_type->getPointeeType();
Greg Claytonb01000f2011-01-17 03:46:26 +00002233 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
2234 pointee_type.getAsOpaquePtr(),
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002235 omit_empty_base_classes);
2236 // If this type points to a simple type, then it has 1 child
2237 if (num_pointee_children == 0)
2238 num_children = 1;
2239 else
2240 num_children = num_pointee_children;
2241 }
2242 break;
2243
2244
Greg Clayton1674b122010-07-21 22:12:05 +00002245 case clang::Type::Typedef:
Greg Claytonb01000f2011-01-17 03:46:26 +00002246 num_children = ClangASTContext::GetNumChildren (ast,
2247 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
2248 omit_empty_base_classes);
Chris Lattner24943d22010-06-08 16:52:24 +00002249 break;
2250
2251 default:
2252 break;
2253 }
2254 return num_children;
2255}
2256
Greg Claytonc3b61d22010-12-15 05:08:08 +00002257// If a pointer to a pointee type (the clang_type arg) says that it has no
2258// children, then we either need to trust it, or override it and return a
2259// different result. For example, an "int *" has one child that is an integer,
2260// but a function pointer doesn't have any children. Likewise if a Record type
2261// claims it has no children, then there really is nothing to show.
2262uint32_t
2263ClangASTContext::GetNumPointeeChildren (clang_type_t clang_type)
2264{
2265 if (clang_type == NULL)
2266 return 0;
2267
2268 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
2269 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2270 switch (type_class)
2271 {
Greg Clayton9db023b2011-01-08 22:26:47 +00002272 case clang::Type::Builtin:
2273 switch (cast<clang::BuiltinType>(qual_type)->getKind())
2274 {
2275 case clang::BuiltinType::Void:
2276 case clang::BuiltinType::NullPtr:
2277 return 0;
2278 case clang::BuiltinType::Bool:
2279 case clang::BuiltinType::Char_U:
2280 case clang::BuiltinType::UChar:
2281 case clang::BuiltinType::Char16:
2282 case clang::BuiltinType::Char32:
2283 case clang::BuiltinType::UShort:
2284 case clang::BuiltinType::UInt:
2285 case clang::BuiltinType::ULong:
2286 case clang::BuiltinType::ULongLong:
2287 case clang::BuiltinType::UInt128:
2288 case clang::BuiltinType::Char_S:
2289 case clang::BuiltinType::SChar:
2290 case clang::BuiltinType::WChar:
2291 case clang::BuiltinType::Short:
2292 case clang::BuiltinType::Int:
2293 case clang::BuiltinType::Long:
2294 case clang::BuiltinType::LongLong:
2295 case clang::BuiltinType::Int128:
2296 case clang::BuiltinType::Float:
2297 case clang::BuiltinType::Double:
2298 case clang::BuiltinType::LongDouble:
2299 case clang::BuiltinType::Dependent:
2300 case clang::BuiltinType::Overload:
2301 case clang::BuiltinType::UndeducedAuto:
2302 case clang::BuiltinType::ObjCId:
2303 case clang::BuiltinType::ObjCClass:
2304 case clang::BuiltinType::ObjCSel:
2305 return 1;
2306 }
2307 break;
2308
Greg Claytone52f37b2011-01-15 02:52:14 +00002309 case clang::Type::Complex: return 1;
Greg Claytonc3b61d22010-12-15 05:08:08 +00002310 case clang::Type::Pointer: return 1;
2311 case clang::Type::BlockPointer: return 0; // If block pointers don't have debug info, then no children for them
2312 case clang::Type::LValueReference: return 1;
2313 case clang::Type::RValueReference: return 1;
2314 case clang::Type::MemberPointer: return 0;
2315 case clang::Type::ConstantArray: return 0;
2316 case clang::Type::IncompleteArray: return 0;
2317 case clang::Type::VariableArray: return 0;
2318 case clang::Type::DependentSizedArray: return 0;
2319 case clang::Type::DependentSizedExtVector: return 0;
2320 case clang::Type::Vector: return 0;
2321 case clang::Type::ExtVector: return 0;
2322 case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children...
2323 case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children...
2324 case clang::Type::UnresolvedUsing: return 0;
2325 case clang::Type::Paren: return 0;
2326 case clang::Type::Typedef: return ClangASTContext::GetNumPointeeChildren (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
2327 case clang::Type::TypeOfExpr: return 0;
2328 case clang::Type::TypeOf: return 0;
2329 case clang::Type::Decltype: return 0;
2330 case clang::Type::Record: return 0;
2331 case clang::Type::Enum: return 1;
2332 case clang::Type::Elaborated: return 1;
2333 case clang::Type::TemplateTypeParm: return 1;
2334 case clang::Type::SubstTemplateTypeParm: return 1;
2335 case clang::Type::TemplateSpecialization: return 1;
2336 case clang::Type::InjectedClassName: return 0;
2337 case clang::Type::DependentName: return 1;
2338 case clang::Type::DependentTemplateSpecialization: return 1;
2339 case clang::Type::ObjCObject: return 0;
2340 case clang::Type::ObjCInterface: return 0;
2341 case clang::Type::ObjCObjectPointer: return 1;
2342 default:
2343 break;
2344 }
2345 return 0;
2346}
Chris Lattner24943d22010-06-08 16:52:24 +00002347
Greg Clayton462d4142010-09-29 01:12:09 +00002348clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +00002349ClangASTContext::GetChildClangTypeAtIndex
2350(
2351 const char *parent_name,
Greg Clayton462d4142010-09-29 01:12:09 +00002352 clang_type_t parent_clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00002353 uint32_t idx,
2354 bool transparent_pointers,
2355 bool omit_empty_base_classes,
2356 std::string& child_name,
2357 uint32_t &child_byte_size,
2358 int32_t &child_byte_offset,
2359 uint32_t &child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002360 uint32_t &child_bitfield_bit_offset,
2361 bool &child_is_base_class
Chris Lattner24943d22010-06-08 16:52:24 +00002362)
2363{
2364 if (parent_clang_type)
2365
2366 return GetChildClangTypeAtIndex (getASTContext(),
2367 parent_name,
2368 parent_clang_type,
2369 idx,
2370 transparent_pointers,
2371 omit_empty_base_classes,
2372 child_name,
2373 child_byte_size,
2374 child_byte_offset,
2375 child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002376 child_bitfield_bit_offset,
2377 child_is_base_class);
Chris Lattner24943d22010-06-08 16:52:24 +00002378 return NULL;
2379}
2380
Greg Clayton462d4142010-09-29 01:12:09 +00002381clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +00002382ClangASTContext::GetChildClangTypeAtIndex
2383(
Greg Claytonb01000f2011-01-17 03:46:26 +00002384 ASTContext *ast,
Chris Lattner24943d22010-06-08 16:52:24 +00002385 const char *parent_name,
Greg Clayton462d4142010-09-29 01:12:09 +00002386 clang_type_t parent_clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00002387 uint32_t idx,
2388 bool transparent_pointers,
2389 bool omit_empty_base_classes,
2390 std::string& child_name,
2391 uint32_t &child_byte_size,
2392 int32_t &child_byte_offset,
2393 uint32_t &child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002394 uint32_t &child_bitfield_bit_offset,
2395 bool &child_is_base_class
Chris Lattner24943d22010-06-08 16:52:24 +00002396)
2397{
2398 if (parent_clang_type == NULL)
2399 return NULL;
2400
Greg Claytonb01000f2011-01-17 03:46:26 +00002401 if (idx < ClangASTContext::GetNumChildren (ast, parent_clang_type, omit_empty_base_classes))
Chris Lattner24943d22010-06-08 16:52:24 +00002402 {
2403 uint32_t bit_offset;
2404 child_bitfield_bit_size = 0;
2405 child_bitfield_bit_offset = 0;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002406 child_is_base_class = false;
Chris Lattner24943d22010-06-08 16:52:24 +00002407 QualType parent_qual_type(QualType::getFromOpaquePtr(parent_clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00002408 const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass();
2409 switch (parent_type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00002410 {
Greg Clayton960d6a42010-08-03 00:35:52 +00002411 case clang::Type::Builtin:
2412 switch (cast<clang::BuiltinType>(parent_qual_type)->getKind())
2413 {
2414 case clang::BuiltinType::ObjCId:
2415 case clang::BuiltinType::ObjCClass:
Sean Callanan04325062010-10-25 00:29:48 +00002416 child_name = "isa";
Greg Claytonb01000f2011-01-17 03:46:26 +00002417 child_byte_size = ast->getTypeSize(ast->ObjCBuiltinClassTy) / CHAR_BIT;
2418 return ast->ObjCBuiltinClassTy.getAsOpaquePtr();
Greg Clayton960d6a42010-08-03 00:35:52 +00002419
Greg Clayton960d6a42010-08-03 00:35:52 +00002420 default:
2421 break;
2422 }
2423 break;
Greg Clayton960d6a42010-08-03 00:35:52 +00002424
Greg Clayton1674b122010-07-21 22:12:05 +00002425 case clang::Type::Record:
Greg Claytonb01000f2011-01-17 03:46:26 +00002426 if (ClangASTContext::GetCompleteType (ast, parent_clang_type))
Chris Lattner24943d22010-06-08 16:52:24 +00002427 {
2428 const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr());
2429 const RecordDecl *record_decl = record_type->getDecl();
2430 assert(record_decl);
Greg Claytonb01000f2011-01-17 03:46:26 +00002431 const ASTRecordLayout &record_layout = ast->getASTRecordLayout(record_decl);
Chris Lattner24943d22010-06-08 16:52:24 +00002432 uint32_t child_idx = 0;
2433
2434 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2435 if (cxx_record_decl)
2436 {
2437 // We might have base classes to print out first
2438 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2439 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2440 base_class != base_class_end;
2441 ++base_class)
2442 {
2443 const CXXRecordDecl *base_class_decl = NULL;
2444
2445 // Skip empty base classes
2446 if (omit_empty_base_classes)
2447 {
2448 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2449 if (RecordHasFields(base_class_decl) == false)
2450 continue;
2451 }
2452
2453 if (idx == child_idx)
2454 {
2455 if (base_class_decl == NULL)
2456 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2457
2458
2459 if (base_class->isVirtual())
Sean Callanan8a3b0a82010-11-18 02:56:27 +00002460 bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity();
Chris Lattner24943d22010-06-08 16:52:24 +00002461 else
Sean Callanan8a3b0a82010-11-18 02:56:27 +00002462 bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity();
Chris Lattner24943d22010-06-08 16:52:24 +00002463
2464 // Base classes should be a multiple of 8 bits in size
2465 assert (bit_offset % 8 == 0);
2466 child_byte_offset = bit_offset/8;
2467 std::string base_class_type_name(base_class->getType().getAsString());
2468
2469 child_name.assign(base_class_type_name.c_str());
2470
Greg Claytonb01000f2011-01-17 03:46:26 +00002471 uint64_t clang_type_info_bit_size = ast->getTypeSize(base_class->getType());
Chris Lattner24943d22010-06-08 16:52:24 +00002472
2473 // Base classes biut sizes should be a multiple of 8 bits in size
2474 assert (clang_type_info_bit_size % 8 == 0);
2475 child_byte_size = clang_type_info_bit_size / 8;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002476 child_is_base_class = true;
Chris Lattner24943d22010-06-08 16:52:24 +00002477 return base_class->getType().getAsOpaquePtr();
2478 }
2479 // We don't increment the child index in the for loop since we might
2480 // be skipping empty base classes
2481 ++child_idx;
2482 }
2483 }
Chris Lattner24943d22010-06-08 16:52:24 +00002484 // Make sure index is in range...
2485 uint32_t field_idx = 0;
2486 RecordDecl::field_iterator field, field_end;
2487 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
2488 {
2489 if (idx == child_idx)
2490 {
2491 // Print the member type if requested
2492 // Print the member name and equal sign
2493 child_name.assign(field->getNameAsString().c_str());
2494
2495 // Figure out the type byte size (field_type_info.first) and
2496 // alignment (field_type_info.second) from the AST context.
Greg Claytonb01000f2011-01-17 03:46:26 +00002497 std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(field->getType());
Greg Clayton54e7afa2010-07-09 20:39:50 +00002498 assert(field_idx < record_layout.getFieldCount());
Chris Lattner24943d22010-06-08 16:52:24 +00002499
2500 child_byte_size = field_type_info.first / 8;
2501
2502 // Figure out the field offset within the current struct/union/class type
2503 bit_offset = record_layout.getFieldOffset (field_idx);
2504 child_byte_offset = bit_offset / 8;
Greg Claytonb01000f2011-01-17 03:46:26 +00002505 if (ClangASTContext::FieldIsBitfield (ast, *field, child_bitfield_bit_size))
Chris Lattner24943d22010-06-08 16:52:24 +00002506 child_bitfield_bit_offset = bit_offset % 8;
2507
2508 return field->getType().getAsOpaquePtr();
2509 }
2510 }
2511 }
2512 break;
2513
Greg Clayton9488b742010-07-28 02:04:09 +00002514 case clang::Type::ObjCObject:
2515 case clang::Type::ObjCInterface:
2516 {
2517 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr());
2518 assert (objc_class_type);
2519 if (objc_class_type)
2520 {
2521 uint32_t child_idx = 0;
2522 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2523
2524 if (class_interface_decl)
2525 {
2526
Greg Claytonb01000f2011-01-17 03:46:26 +00002527 const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
Greg Clayton9488b742010-07-28 02:04:09 +00002528 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2529 if (superclass_interface_decl)
2530 {
2531 if (omit_empty_base_classes)
2532 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002533 if (ClangASTContext::GetNumChildren(ast, ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(), omit_empty_base_classes) > 0)
Greg Clayton9488b742010-07-28 02:04:09 +00002534 {
2535 if (idx == 0)
2536 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002537 QualType ivar_qual_type(ast->getObjCInterfaceType(superclass_interface_decl));
Greg Clayton9488b742010-07-28 02:04:09 +00002538
2539
2540 child_name.assign(superclass_interface_decl->getNameAsString().c_str());
2541
Greg Claytonb01000f2011-01-17 03:46:26 +00002542 std::pair<uint64_t, unsigned> ivar_type_info = ast->getTypeInfo(ivar_qual_type.getTypePtr());
Greg Clayton9488b742010-07-28 02:04:09 +00002543
2544 child_byte_size = ivar_type_info.first / 8;
Greg Clayton960d6a42010-08-03 00:35:52 +00002545 child_byte_offset = 0;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002546 child_is_base_class = true;
Greg Clayton9488b742010-07-28 02:04:09 +00002547
2548 return ivar_qual_type.getAsOpaquePtr();
2549 }
2550
2551 ++child_idx;
2552 }
2553 }
2554 else
2555 ++child_idx;
2556 }
Greg Clayton960d6a42010-08-03 00:35:52 +00002557
2558 const uint32_t superclass_idx = child_idx;
Greg Clayton9488b742010-07-28 02:04:09 +00002559
2560 if (idx < (child_idx + class_interface_decl->ivar_size()))
2561 {
2562 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
2563
2564 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
2565 {
2566 if (child_idx == idx)
2567 {
2568 const ObjCIvarDecl* ivar_decl = *ivar_pos;
2569
2570 QualType ivar_qual_type(ivar_decl->getType());
2571
2572 child_name.assign(ivar_decl->getNameAsString().c_str());
2573
Greg Claytonb01000f2011-01-17 03:46:26 +00002574 std::pair<uint64_t, unsigned> ivar_type_info = ast->getTypeInfo(ivar_qual_type.getTypePtr());
Greg Clayton9488b742010-07-28 02:04:09 +00002575
2576 child_byte_size = ivar_type_info.first / 8;
2577
2578 // Figure out the field offset within the current struct/union/class type
Greg Clayton960d6a42010-08-03 00:35:52 +00002579 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
Greg Clayton9488b742010-07-28 02:04:09 +00002580 child_byte_offset = bit_offset / 8;
2581
2582 return ivar_qual_type.getAsOpaquePtr();
2583 }
2584 ++child_idx;
2585 }
2586 }
2587 }
2588 }
2589 }
2590 break;
2591
2592 case clang::Type::ObjCObjectPointer:
2593 {
Greg Clayton960d6a42010-08-03 00:35:52 +00002594 ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(parent_qual_type.getTypePtr());
2595 QualType pointee_type = pointer_type->getPointeeType();
2596
2597 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2598 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002599 return GetChildClangTypeAtIndex (ast,
Greg Clayton960d6a42010-08-03 00:35:52 +00002600 parent_name,
2601 pointer_type->getPointeeType().getAsOpaquePtr(),
2602 idx,
2603 transparent_pointers,
2604 omit_empty_base_classes,
2605 child_name,
2606 child_byte_size,
2607 child_byte_offset,
2608 child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002609 child_bitfield_bit_offset,
2610 child_is_base_class);
Greg Clayton960d6a42010-08-03 00:35:52 +00002611 }
2612 else
2613 {
2614 if (parent_name)
2615 {
2616 child_name.assign(1, '*');
2617 child_name += parent_name;
2618 }
2619
2620 // We have a pointer to an simple type
2621 if (idx == 0)
2622 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002623 std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
Greg Clayton960d6a42010-08-03 00:35:52 +00002624 assert(clang_type_info.first % 8 == 0);
2625 child_byte_size = clang_type_info.first / 8;
2626 child_byte_offset = 0;
2627 return pointee_type.getAsOpaquePtr();
2628 }
2629 }
Greg Clayton9488b742010-07-28 02:04:09 +00002630 }
2631 break;
2632
Greg Clayton1674b122010-07-21 22:12:05 +00002633 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00002634 {
2635 const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
2636 const uint64_t element_count = array->getSize().getLimitedValue();
2637
2638 if (idx < element_count)
2639 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002640 if (GetCompleteQualType (ast, array->getElementType()))
2641 {
2642 std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
Chris Lattner24943d22010-06-08 16:52:24 +00002643
Greg Claytonb01000f2011-01-17 03:46:26 +00002644 char element_name[64];
2645 ::snprintf (element_name, sizeof (element_name), "[%u]", idx);
Chris Lattner24943d22010-06-08 16:52:24 +00002646
Greg Claytonb01000f2011-01-17 03:46:26 +00002647 child_name.assign(element_name);
2648 assert(field_type_info.first % 8 == 0);
2649 child_byte_size = field_type_info.first / 8;
2650 child_byte_offset = idx * child_byte_size;
2651 return array->getElementType().getAsOpaquePtr();
2652 }
Chris Lattner24943d22010-06-08 16:52:24 +00002653 }
2654 }
2655 break;
2656
Greg Clayton1674b122010-07-21 22:12:05 +00002657 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00002658 {
2659 PointerType *pointer_type = cast<PointerType>(parent_qual_type.getTypePtr());
2660 QualType pointee_type = pointer_type->getPointeeType();
Greg Clayton9db023b2011-01-08 22:26:47 +00002661
2662 // Don't dereference "void *" pointers
2663 if (pointee_type->isVoidType())
2664 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002665
2666 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2667 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002668 return GetChildClangTypeAtIndex (ast,
Chris Lattner24943d22010-06-08 16:52:24 +00002669 parent_name,
2670 pointer_type->getPointeeType().getAsOpaquePtr(),
2671 idx,
2672 transparent_pointers,
2673 omit_empty_base_classes,
2674 child_name,
2675 child_byte_size,
2676 child_byte_offset,
2677 child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002678 child_bitfield_bit_offset,
2679 child_is_base_class);
Chris Lattner24943d22010-06-08 16:52:24 +00002680 }
2681 else
2682 {
2683 if (parent_name)
2684 {
2685 child_name.assign(1, '*');
2686 child_name += parent_name;
2687 }
2688
2689 // We have a pointer to an simple type
2690 if (idx == 0)
2691 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002692 std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
Chris Lattner24943d22010-06-08 16:52:24 +00002693 assert(clang_type_info.first % 8 == 0);
2694 child_byte_size = clang_type_info.first / 8;
2695 child_byte_offset = 0;
2696 return pointee_type.getAsOpaquePtr();
2697 }
2698 }
2699 }
2700 break;
2701
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002702 case clang::Type::LValueReference:
2703 case clang::Type::RValueReference:
2704 {
2705 ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr());
2706 QualType pointee_type(reference_type->getPointeeType());
2707 clang_type_t pointee_clang_type = pointee_type.getAsOpaquePtr();
2708 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_clang_type))
2709 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002710 return GetChildClangTypeAtIndex (ast,
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002711 parent_name,
2712 pointee_clang_type,
2713 idx,
2714 transparent_pointers,
2715 omit_empty_base_classes,
2716 child_name,
2717 child_byte_size,
2718 child_byte_offset,
2719 child_bitfield_bit_size,
2720 child_bitfield_bit_offset,
2721 child_is_base_class);
2722 }
2723 else
2724 {
2725 if (parent_name)
2726 {
2727 child_name.assign(1, '&');
2728 child_name += parent_name;
2729 }
2730
2731 // We have a pointer to an simple type
2732 if (idx == 0)
2733 {
Greg Claytonb01000f2011-01-17 03:46:26 +00002734 std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002735 assert(clang_type_info.first % 8 == 0);
2736 child_byte_size = clang_type_info.first / 8;
2737 child_byte_offset = 0;
2738 return pointee_type.getAsOpaquePtr();
2739 }
2740 }
2741 }
2742 break;
2743
Greg Clayton1674b122010-07-21 22:12:05 +00002744 case clang::Type::Typedef:
Greg Claytonb01000f2011-01-17 03:46:26 +00002745 return GetChildClangTypeAtIndex (ast,
Chris Lattner24943d22010-06-08 16:52:24 +00002746 parent_name,
Sean Callanan9e7958e2010-12-13 01:26:27 +00002747 cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
Chris Lattner24943d22010-06-08 16:52:24 +00002748 idx,
2749 transparent_pointers,
2750 omit_empty_base_classes,
2751 child_name,
2752 child_byte_size,
2753 child_byte_offset,
2754 child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002755 child_bitfield_bit_offset,
2756 child_is_base_class);
Chris Lattner24943d22010-06-08 16:52:24 +00002757 break;
2758
2759 default:
2760 break;
2761 }
2762 }
Greg Claytonf8e98a62010-07-23 15:37:46 +00002763 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002764}
2765
2766static inline bool
2767BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
2768{
Greg Claytonb01000f2011-01-17 03:46:26 +00002769 return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
Chris Lattner24943d22010-06-08 16:52:24 +00002770}
2771
2772static uint32_t
2773GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes)
2774{
2775 uint32_t num_bases = 0;
2776 if (cxx_record_decl)
2777 {
2778 if (omit_empty_base_classes)
2779 {
2780 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2781 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2782 base_class != base_class_end;
2783 ++base_class)
2784 {
2785 // Skip empty base classes
2786 if (omit_empty_base_classes)
2787 {
2788 if (BaseSpecifierIsEmpty (base_class))
2789 continue;
2790 }
2791 ++num_bases;
2792 }
2793 }
2794 else
2795 num_bases = cxx_record_decl->getNumBases();
2796 }
2797 return num_bases;
2798}
2799
2800
2801static uint32_t
2802GetIndexForRecordBase
2803(
2804 const RecordDecl *record_decl,
2805 const CXXBaseSpecifier *base_spec,
2806 bool omit_empty_base_classes
2807)
2808{
2809 uint32_t child_idx = 0;
2810
2811 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2812
2813// const char *super_name = record_decl->getNameAsCString();
2814// const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString();
2815// printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
2816//
2817 if (cxx_record_decl)
2818 {
2819 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2820 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2821 base_class != base_class_end;
2822 ++base_class)
2823 {
2824 if (omit_empty_base_classes)
2825 {
2826 if (BaseSpecifierIsEmpty (base_class))
2827 continue;
2828 }
2829
2830// printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name,
2831// child_idx,
2832// base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
2833//
2834//
2835 if (base_class == base_spec)
2836 return child_idx;
2837 ++child_idx;
2838 }
2839 }
2840
2841 return UINT32_MAX;
2842}
2843
2844
2845static uint32_t
2846GetIndexForRecordChild
2847(
2848 const RecordDecl *record_decl,
2849 NamedDecl *canonical_decl,
2850 bool omit_empty_base_classes
2851)
2852{
2853 uint32_t child_idx = GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl), omit_empty_base_classes);
2854
2855// const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2856//
2857//// printf ("GetIndexForRecordChild (%s, %s)\n", record_decl->getNameAsCString(), canonical_decl->getNameAsCString());
2858// if (cxx_record_decl)
2859// {
2860// CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2861// for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2862// base_class != base_class_end;
2863// ++base_class)
2864// {
2865// if (omit_empty_base_classes)
2866// {
2867// if (BaseSpecifierIsEmpty (base_class))
2868// continue;
2869// }
2870//
2871//// printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n",
2872//// record_decl->getNameAsCString(),
2873//// canonical_decl->getNameAsCString(),
2874//// child_idx,
2875//// base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
2876//
2877//
2878// CXXRecordDecl *curr_base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2879// if (curr_base_class_decl == canonical_decl)
2880// {
2881// return child_idx;
2882// }
2883// ++child_idx;
2884// }
2885// }
2886//
2887// const uint32_t num_bases = child_idx;
2888 RecordDecl::field_iterator field, field_end;
2889 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
2890 field != field_end;
2891 ++field, ++child_idx)
2892 {
2893// printf ("GetIndexForRecordChild (%s, %s) field[%u] = %s\n",
2894// record_decl->getNameAsCString(),
2895// canonical_decl->getNameAsCString(),
2896// child_idx - num_bases,
2897// field->getNameAsCString());
2898
2899 if (field->getCanonicalDecl() == canonical_decl)
2900 return child_idx;
2901 }
2902
2903 return UINT32_MAX;
2904}
2905
2906// Look for a child member (doesn't include base classes, but it does include
2907// their members) in the type hierarchy. Returns an index path into "clang_type"
2908// on how to reach the appropriate member.
2909//
2910// class A
2911// {
2912// public:
2913// int m_a;
2914// int m_b;
2915// };
2916//
2917// class B
2918// {
2919// };
2920//
2921// class C :
2922// public B,
2923// public A
2924// {
2925// };
2926//
2927// If we have a clang type that describes "class C", and we wanted to looked
2928// "m_b" in it:
2929//
2930// With omit_empty_base_classes == false we would get an integer array back with:
2931// { 1, 1 }
2932// The first index 1 is the child index for "class A" within class C
2933// The second index 1 is the child index for "m_b" within class A
2934//
2935// With omit_empty_base_classes == true we would get an integer array back with:
2936// { 0, 1 }
2937// The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count)
2938// The second index 1 is the child index for "m_b" within class A
2939
2940size_t
2941ClangASTContext::GetIndexOfChildMemberWithName
2942(
Greg Claytonb01000f2011-01-17 03:46:26 +00002943 ASTContext *ast,
Greg Clayton462d4142010-09-29 01:12:09 +00002944 clang_type_t clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00002945 const char *name,
2946 bool omit_empty_base_classes,
2947 std::vector<uint32_t>& child_indexes
2948)
2949{
2950 if (clang_type && name && name[0])
2951 {
2952 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00002953 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2954 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00002955 {
Greg Clayton1674b122010-07-21 22:12:05 +00002956 case clang::Type::Record:
Greg Claytonb01000f2011-01-17 03:46:26 +00002957 if (ClangASTContext::GetCompleteType (ast, clang_type))
Chris Lattner24943d22010-06-08 16:52:24 +00002958 {
2959 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
2960 const RecordDecl *record_decl = record_type->getDecl();
2961
2962 assert(record_decl);
2963 uint32_t child_idx = 0;
2964
2965 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2966
2967 // Try and find a field that matches NAME
2968 RecordDecl::field_iterator field, field_end;
2969 StringRef name_sref(name);
2970 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
2971 field != field_end;
2972 ++field, ++child_idx)
2973 {
2974 if (field->getName().equals (name_sref))
2975 {
2976 // We have to add on the number of base classes to this index!
2977 child_indexes.push_back (child_idx + GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes));
2978 return child_indexes.size();
2979 }
2980 }
2981
2982 if (cxx_record_decl)
2983 {
2984 const RecordDecl *parent_record_decl = cxx_record_decl;
2985
2986 //printf ("parent = %s\n", parent_record_decl->getNameAsCString());
2987
2988 //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
2989 // Didn't find things easily, lets let clang do its thang...
Greg Claytonb01000f2011-01-17 03:46:26 +00002990 IdentifierInfo & ident_ref = ast->Idents.get(name, name + strlen (name));
Chris Lattner24943d22010-06-08 16:52:24 +00002991 DeclarationName decl_name(&ident_ref);
2992
2993 CXXBasePaths paths;
2994 if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember,
2995 decl_name.getAsOpaquePtr(),
2996 paths))
2997 {
Chris Lattner24943d22010-06-08 16:52:24 +00002998 CXXBasePaths::const_paths_iterator path, path_end = paths.end();
2999 for (path = paths.begin(); path != path_end; ++path)
3000 {
3001 const size_t num_path_elements = path->size();
3002 for (size_t e=0; e<num_path_elements; ++e)
3003 {
3004 CXXBasePathElement elem = (*path)[e];
3005
3006 child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes);
3007 if (child_idx == UINT32_MAX)
3008 {
3009 child_indexes.clear();
3010 return 0;
3011 }
3012 else
3013 {
3014 child_indexes.push_back (child_idx);
3015 parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl());
3016 }
3017 }
3018 DeclContext::lookup_iterator named_decl_pos;
3019 for (named_decl_pos = path->Decls.first;
3020 named_decl_pos != path->Decls.second && parent_record_decl;
3021 ++named_decl_pos)
3022 {
3023 //printf ("path[%zu] = %s\n", child_indexes.size(), (*named_decl_pos)->getNameAsCString());
3024
3025 child_idx = GetIndexForRecordChild (parent_record_decl, *named_decl_pos, omit_empty_base_classes);
3026 if (child_idx == UINT32_MAX)
3027 {
3028 child_indexes.clear();
3029 return 0;
3030 }
3031 else
3032 {
3033 child_indexes.push_back (child_idx);
3034 }
3035 }
3036 }
3037 return child_indexes.size();
3038 }
3039 }
3040
3041 }
3042 break;
3043
Greg Clayton9488b742010-07-28 02:04:09 +00003044 case clang::Type::ObjCObject:
3045 case clang::Type::ObjCInterface:
3046 {
3047 StringRef name_sref(name);
3048 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3049 assert (objc_class_type);
3050 if (objc_class_type)
3051 {
3052 uint32_t child_idx = 0;
3053 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3054
3055 if (class_interface_decl)
3056 {
3057 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3058 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3059
Greg Clayton823533e2010-09-18 02:11:07 +00003060 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
Greg Clayton9488b742010-07-28 02:04:09 +00003061 {
3062 const ObjCIvarDecl* ivar_decl = *ivar_pos;
3063
3064 if (ivar_decl->getName().equals (name_sref))
3065 {
3066 if ((!omit_empty_base_classes && superclass_interface_decl) ||
3067 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
3068 ++child_idx;
3069
3070 child_indexes.push_back (child_idx);
3071 return child_indexes.size();
3072 }
3073 }
3074
3075 if (superclass_interface_decl)
3076 {
3077 // The super class index is always zero for ObjC classes,
3078 // so we push it onto the child indexes in case we find
3079 // an ivar in our superclass...
3080 child_indexes.push_back (0);
3081
Greg Claytonb01000f2011-01-17 03:46:26 +00003082 if (GetIndexOfChildMemberWithName (ast,
3083 ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(),
Greg Clayton9488b742010-07-28 02:04:09 +00003084 name,
3085 omit_empty_base_classes,
3086 child_indexes))
3087 {
3088 // We did find an ivar in a superclass so just
3089 // return the results!
3090 return child_indexes.size();
3091 }
3092
3093 // We didn't find an ivar matching "name" in our
3094 // superclass, pop the superclass zero index that
3095 // we pushed on above.
3096 child_indexes.pop_back();
3097 }
3098 }
3099 }
3100 }
3101 break;
3102
3103 case clang::Type::ObjCObjectPointer:
3104 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003105 return GetIndexOfChildMemberWithName (ast,
Greg Clayton9488b742010-07-28 02:04:09 +00003106 cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(),
3107 name,
3108 omit_empty_base_classes,
3109 child_indexes);
3110 }
3111 break;
3112
3113
Greg Clayton1674b122010-07-21 22:12:05 +00003114 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00003115 {
3116// const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
3117// const uint64_t element_count = array->getSize().getLimitedValue();
3118//
3119// if (idx < element_count)
3120// {
Greg Claytonb01000f2011-01-17 03:46:26 +00003121// std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
Chris Lattner24943d22010-06-08 16:52:24 +00003122//
3123// char element_name[32];
3124// ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
3125//
3126// child_name.assign(element_name);
3127// assert(field_type_info.first % 8 == 0);
3128// child_byte_size = field_type_info.first / 8;
3129// child_byte_offset = idx * child_byte_size;
3130// return array->getElementType().getAsOpaquePtr();
3131// }
3132 }
3133 break;
3134
Greg Clayton1674b122010-07-21 22:12:05 +00003135// case clang::Type::MemberPointerType:
Chris Lattner24943d22010-06-08 16:52:24 +00003136// {
3137// MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
3138// QualType pointee_type = mem_ptr_type->getPointeeType();
3139//
3140// if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3141// {
Greg Claytonb01000f2011-01-17 03:46:26 +00003142// return GetIndexOfChildWithName (ast,
Chris Lattner24943d22010-06-08 16:52:24 +00003143// mem_ptr_type->getPointeeType().getAsOpaquePtr(),
3144// name);
3145// }
3146// }
3147// break;
3148//
Greg Clayton1674b122010-07-21 22:12:05 +00003149 case clang::Type::LValueReference:
3150 case clang::Type::RValueReference:
Chris Lattner24943d22010-06-08 16:52:24 +00003151 {
3152 ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3153 QualType pointee_type = reference_type->getPointeeType();
3154
3155 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3156 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003157 return GetIndexOfChildMemberWithName (ast,
Chris Lattner24943d22010-06-08 16:52:24 +00003158 reference_type->getPointeeType().getAsOpaquePtr(),
3159 name,
3160 omit_empty_base_classes,
3161 child_indexes);
3162 }
3163 }
3164 break;
3165
Greg Clayton1674b122010-07-21 22:12:05 +00003166 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003167 {
3168 PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
3169 QualType pointee_type = pointer_type->getPointeeType();
3170
3171 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3172 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003173 return GetIndexOfChildMemberWithName (ast,
Chris Lattner24943d22010-06-08 16:52:24 +00003174 pointer_type->getPointeeType().getAsOpaquePtr(),
3175 name,
3176 omit_empty_base_classes,
3177 child_indexes);
3178 }
3179 else
3180 {
3181// if (parent_name)
3182// {
3183// child_name.assign(1, '*');
3184// child_name += parent_name;
3185// }
3186//
3187// // We have a pointer to an simple type
3188// if (idx == 0)
3189// {
Greg Claytonb01000f2011-01-17 03:46:26 +00003190// std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
Chris Lattner24943d22010-06-08 16:52:24 +00003191// assert(clang_type_info.first % 8 == 0);
3192// child_byte_size = clang_type_info.first / 8;
3193// child_byte_offset = 0;
3194// return pointee_type.getAsOpaquePtr();
3195// }
3196 }
3197 }
3198 break;
3199
Greg Clayton1674b122010-07-21 22:12:05 +00003200 case clang::Type::Typedef:
Greg Claytonb01000f2011-01-17 03:46:26 +00003201 return GetIndexOfChildMemberWithName (ast,
Sean Callanan9e7958e2010-12-13 01:26:27 +00003202 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
Chris Lattner24943d22010-06-08 16:52:24 +00003203 name,
3204 omit_empty_base_classes,
3205 child_indexes);
3206
3207 default:
3208 break;
3209 }
3210 }
3211 return 0;
3212}
3213
3214
3215// Get the index of the child of "clang_type" whose name matches. This function
3216// doesn't descend into the children, but only looks one level deep and name
3217// matches can include base class names.
3218
3219uint32_t
3220ClangASTContext::GetIndexOfChildWithName
3221(
Greg Claytonb01000f2011-01-17 03:46:26 +00003222 ASTContext *ast,
Greg Clayton462d4142010-09-29 01:12:09 +00003223 clang_type_t clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00003224 const char *name,
3225 bool omit_empty_base_classes
3226)
3227{
3228 if (clang_type && name && name[0])
3229 {
3230 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
Greg Clayton9488b742010-07-28 02:04:09 +00003231
Greg Clayton03e0f972010-09-13 03:32:57 +00003232 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
Greg Clayton9488b742010-07-28 02:04:09 +00003233
Greg Clayton03e0f972010-09-13 03:32:57 +00003234 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003235 {
Greg Clayton1674b122010-07-21 22:12:05 +00003236 case clang::Type::Record:
Greg Claytonb01000f2011-01-17 03:46:26 +00003237 if (ClangASTContext::GetCompleteType (ast, clang_type))
Chris Lattner24943d22010-06-08 16:52:24 +00003238 {
3239 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
3240 const RecordDecl *record_decl = record_type->getDecl();
3241
3242 assert(record_decl);
3243 uint32_t child_idx = 0;
3244
3245 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3246
3247 if (cxx_record_decl)
3248 {
3249 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3250 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3251 base_class != base_class_end;
3252 ++base_class)
3253 {
3254 // Skip empty base classes
3255 CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3256 if (omit_empty_base_classes && RecordHasFields(base_class_decl) == false)
3257 continue;
3258
3259 if (base_class->getType().getAsString().compare (name) == 0)
3260 return child_idx;
3261 ++child_idx;
3262 }
3263 }
3264
3265 // Try and find a field that matches NAME
3266 RecordDecl::field_iterator field, field_end;
3267 StringRef name_sref(name);
3268 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3269 field != field_end;
3270 ++field, ++child_idx)
3271 {
3272 if (field->getName().equals (name_sref))
3273 return child_idx;
3274 }
3275
3276 }
3277 break;
3278
Greg Clayton9488b742010-07-28 02:04:09 +00003279 case clang::Type::ObjCObject:
3280 case clang::Type::ObjCInterface:
3281 {
3282 StringRef name_sref(name);
3283 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3284 assert (objc_class_type);
3285 if (objc_class_type)
3286 {
3287 uint32_t child_idx = 0;
3288 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3289
3290 if (class_interface_decl)
3291 {
3292 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3293 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3294
3295 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
3296 {
3297 const ObjCIvarDecl* ivar_decl = *ivar_pos;
3298
3299 if (ivar_decl->getName().equals (name_sref))
3300 {
3301 if ((!omit_empty_base_classes && superclass_interface_decl) ||
3302 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
3303 ++child_idx;
3304
3305 return child_idx;
3306 }
3307 }
3308
3309 if (superclass_interface_decl)
3310 {
3311 if (superclass_interface_decl->getName().equals (name_sref))
3312 return 0;
3313 }
3314 }
3315 }
3316 }
3317 break;
3318
3319 case clang::Type::ObjCObjectPointer:
3320 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003321 return GetIndexOfChildWithName (ast,
Greg Clayton9488b742010-07-28 02:04:09 +00003322 cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(),
3323 name,
3324 omit_empty_base_classes);
3325 }
3326 break;
3327
Greg Clayton1674b122010-07-21 22:12:05 +00003328 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00003329 {
3330// const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
3331// const uint64_t element_count = array->getSize().getLimitedValue();
3332//
3333// if (idx < element_count)
3334// {
Greg Claytonb01000f2011-01-17 03:46:26 +00003335// std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
Chris Lattner24943d22010-06-08 16:52:24 +00003336//
3337// char element_name[32];
3338// ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
3339//
3340// child_name.assign(element_name);
3341// assert(field_type_info.first % 8 == 0);
3342// child_byte_size = field_type_info.first / 8;
3343// child_byte_offset = idx * child_byte_size;
3344// return array->getElementType().getAsOpaquePtr();
3345// }
3346 }
3347 break;
3348
Greg Clayton1674b122010-07-21 22:12:05 +00003349// case clang::Type::MemberPointerType:
Chris Lattner24943d22010-06-08 16:52:24 +00003350// {
3351// MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
3352// QualType pointee_type = mem_ptr_type->getPointeeType();
3353//
3354// if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3355// {
Greg Claytonb01000f2011-01-17 03:46:26 +00003356// return GetIndexOfChildWithName (ast,
Chris Lattner24943d22010-06-08 16:52:24 +00003357// mem_ptr_type->getPointeeType().getAsOpaquePtr(),
3358// name);
3359// }
3360// }
3361// break;
3362//
Greg Clayton1674b122010-07-21 22:12:05 +00003363 case clang::Type::LValueReference:
3364 case clang::Type::RValueReference:
Chris Lattner24943d22010-06-08 16:52:24 +00003365 {
3366 ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3367 QualType pointee_type = reference_type->getPointeeType();
3368
3369 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3370 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003371 return GetIndexOfChildWithName (ast,
Chris Lattner24943d22010-06-08 16:52:24 +00003372 reference_type->getPointeeType().getAsOpaquePtr(),
3373 name,
3374 omit_empty_base_classes);
3375 }
3376 }
3377 break;
3378
Greg Clayton1674b122010-07-21 22:12:05 +00003379 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003380 {
3381 PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
3382 QualType pointee_type = pointer_type->getPointeeType();
3383
3384 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3385 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003386 return GetIndexOfChildWithName (ast,
Chris Lattner24943d22010-06-08 16:52:24 +00003387 pointer_type->getPointeeType().getAsOpaquePtr(),
3388 name,
3389 omit_empty_base_classes);
3390 }
3391 else
3392 {
3393// if (parent_name)
3394// {
3395// child_name.assign(1, '*');
3396// child_name += parent_name;
3397// }
3398//
3399// // We have a pointer to an simple type
3400// if (idx == 0)
3401// {
Greg Claytonb01000f2011-01-17 03:46:26 +00003402// std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
Chris Lattner24943d22010-06-08 16:52:24 +00003403// assert(clang_type_info.first % 8 == 0);
3404// child_byte_size = clang_type_info.first / 8;
3405// child_byte_offset = 0;
3406// return pointee_type.getAsOpaquePtr();
3407// }
3408 }
3409 }
3410 break;
3411
Greg Clayton1674b122010-07-21 22:12:05 +00003412 case clang::Type::Typedef:
Greg Claytonb01000f2011-01-17 03:46:26 +00003413 return GetIndexOfChildWithName (ast,
Sean Callanan9e7958e2010-12-13 01:26:27 +00003414 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
Chris Lattner24943d22010-06-08 16:52:24 +00003415 name,
3416 omit_empty_base_classes);
3417
3418 default:
3419 break;
3420 }
3421 }
3422 return UINT32_MAX;
3423}
3424
3425#pragma mark TagType
3426
3427bool
Greg Clayton462d4142010-09-29 01:12:09 +00003428ClangASTContext::SetTagTypeKind (clang_type_t tag_clang_type, int kind)
Chris Lattner24943d22010-06-08 16:52:24 +00003429{
3430 if (tag_clang_type)
3431 {
3432 QualType tag_qual_type(QualType::getFromOpaquePtr(tag_clang_type));
Greg Clayton1674b122010-07-21 22:12:05 +00003433 clang::Type *clang_type = tag_qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00003434 if (clang_type)
3435 {
3436 TagType *tag_type = dyn_cast<TagType>(clang_type);
3437 if (tag_type)
3438 {
3439 TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl());
3440 if (tag_decl)
3441 {
3442 tag_decl->setTagKind ((TagDecl::TagKind)kind);
3443 return true;
3444 }
3445 }
3446 }
3447 }
3448 return false;
3449}
3450
3451
3452#pragma mark DeclContext Functions
3453
3454DeclContext *
Greg Clayton462d4142010-09-29 01:12:09 +00003455ClangASTContext::GetDeclContextForType (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003456{
3457 if (clang_type == NULL)
3458 return NULL;
3459
3460 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00003461 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3462 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003463 {
Greg Clayton9488b742010-07-28 02:04:09 +00003464 case clang::Type::FunctionNoProto: break;
3465 case clang::Type::FunctionProto: break;
3466 case clang::Type::IncompleteArray: break;
3467 case clang::Type::VariableArray: break;
3468 case clang::Type::ConstantArray: break;
3469 case clang::Type::ExtVector: break;
3470 case clang::Type::Vector: break;
3471 case clang::Type::Builtin: break;
3472 case clang::Type::BlockPointer: break;
3473 case clang::Type::Pointer: break;
3474 case clang::Type::LValueReference: break;
3475 case clang::Type::RValueReference: break;
3476 case clang::Type::MemberPointer: break;
3477 case clang::Type::Complex: break;
3478 case clang::Type::ObjCObject: break;
3479 case clang::Type::ObjCInterface: return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface();
3480 case clang::Type::ObjCObjectPointer: return ClangASTContext::GetDeclContextForType (cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr());
3481 case clang::Type::Record: return cast<RecordType>(qual_type)->getDecl();
3482 case clang::Type::Enum: return cast<EnumType>(qual_type)->getDecl();
Sean Callanan9e7958e2010-12-13 01:26:27 +00003483 case clang::Type::Typedef: return ClangASTContext::GetDeclContextForType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
Chris Lattner24943d22010-06-08 16:52:24 +00003484
Greg Clayton9488b742010-07-28 02:04:09 +00003485 case clang::Type::TypeOfExpr: break;
3486 case clang::Type::TypeOf: break;
3487 case clang::Type::Decltype: break;
3488 //case clang::Type::QualifiedName: break;
3489 case clang::Type::TemplateSpecialization: break;
Chris Lattner24943d22010-06-08 16:52:24 +00003490 }
3491 // No DeclContext in this type...
3492 return NULL;
3493}
3494
3495#pragma mark Namespace Declarations
3496
3497NamespaceDecl *
3498ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, const Declaration &decl, DeclContext *decl_ctx)
3499{
3500 // TODO: Do something intelligent with the Declaration object passed in
3501 // like maybe filling in the SourceLocation with it...
3502 if (name)
3503 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003504 ASTContext *ast = getASTContext();
Chris Lattner24943d22010-06-08 16:52:24 +00003505 if (decl_ctx == NULL)
Greg Claytonb01000f2011-01-17 03:46:26 +00003506 decl_ctx = ast->getTranslationUnitDecl();
3507 return NamespaceDecl::Create(*ast, decl_ctx, SourceLocation(), &ast->Idents.get(name));
Chris Lattner24943d22010-06-08 16:52:24 +00003508 }
3509 return NULL;
3510}
3511
3512
3513#pragma mark Function Types
3514
3515FunctionDecl *
Greg Clayton462d4142010-09-29 01:12:09 +00003516ClangASTContext::CreateFunctionDeclaration (const char *name, clang_type_t function_clang_type, int storage, bool is_inline)
Chris Lattner24943d22010-06-08 16:52:24 +00003517{
3518 if (name)
3519 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003520 ASTContext *ast = getASTContext();
3521 assert (ast != NULL);
Chris Lattner24943d22010-06-08 16:52:24 +00003522
3523 if (name && name[0])
3524 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003525 return FunctionDecl::Create(*ast,
3526 ast->getTranslationUnitDecl(),
Chris Lattner24943d22010-06-08 16:52:24 +00003527 SourceLocation(),
Greg Claytonb01000f2011-01-17 03:46:26 +00003528 DeclarationName (&ast->Idents.get(name)),
Chris Lattner24943d22010-06-08 16:52:24 +00003529 QualType::getFromOpaquePtr(function_clang_type),
3530 NULL,
3531 (FunctionDecl::StorageClass)storage,
3532 (FunctionDecl::StorageClass)storage,
3533 is_inline);
3534 }
3535 else
3536 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003537 return FunctionDecl::Create(*ast,
3538 ast->getTranslationUnitDecl(),
Chris Lattner24943d22010-06-08 16:52:24 +00003539 SourceLocation(),
3540 DeclarationName (),
3541 QualType::getFromOpaquePtr(function_clang_type),
3542 NULL,
3543 (FunctionDecl::StorageClass)storage,
3544 (FunctionDecl::StorageClass)storage,
3545 is_inline);
3546 }
3547 }
3548 return NULL;
3549}
3550
Greg Clayton462d4142010-09-29 01:12:09 +00003551clang_type_t
Greg Claytonb01000f2011-01-17 03:46:26 +00003552ClangASTContext::CreateFunctionType (ASTContext *ast,
Greg Clayton462d4142010-09-29 01:12:09 +00003553 clang_type_t result_type,
3554 clang_type_t *args,
Sean Callanan2ea8f272010-09-16 20:40:25 +00003555 unsigned num_args,
3556 bool is_variadic,
3557 unsigned type_quals)
Chris Lattner24943d22010-06-08 16:52:24 +00003558{
Greg Claytonb01000f2011-01-17 03:46:26 +00003559 assert (ast != NULL);
Chris Lattner24943d22010-06-08 16:52:24 +00003560 std::vector<QualType> qual_type_args;
3561 for (unsigned i=0; i<num_args; ++i)
3562 qual_type_args.push_back (QualType::getFromOpaquePtr(args[i]));
3563
3564 // TODO: Detect calling convention in DWARF?
Greg Claytonb01000f2011-01-17 03:46:26 +00003565 return ast->getFunctionType(QualType::getFromOpaquePtr(result_type),
Greg Clayton53d68e72010-07-20 22:52:08 +00003566 qual_type_args.empty() ? NULL : &qual_type_args.front(),
Chris Lattner24943d22010-06-08 16:52:24 +00003567 qual_type_args.size(),
Sean Callanan2ea8f272010-09-16 20:40:25 +00003568 is_variadic,
3569 type_quals,
Chris Lattner24943d22010-06-08 16:52:24 +00003570 false, // hasExceptionSpec
3571 false, // hasAnyExceptionSpec,
3572 0, // NumExs
3573 0, // const QualType *ExArray
3574 FunctionType::ExtInfo ()).getAsOpaquePtr(); // NoReturn);
3575}
3576
3577ParmVarDecl *
Greg Clayton462d4142010-09-29 01:12:09 +00003578ClangASTContext::CreateParameterDeclaration (const char *name, clang_type_t param_type, int storage)
Chris Lattner24943d22010-06-08 16:52:24 +00003579{
Greg Claytonb01000f2011-01-17 03:46:26 +00003580 ASTContext *ast = getASTContext();
3581 assert (ast != NULL);
3582 return ParmVarDecl::Create(*ast,
3583 ast->getTranslationUnitDecl(),
Chris Lattner24943d22010-06-08 16:52:24 +00003584 SourceLocation(),
Greg Claytonb01000f2011-01-17 03:46:26 +00003585 name && name[0] ? &ast->Idents.get(name) : NULL,
Sean Callanan2ea8f272010-09-16 20:40:25 +00003586 QualType::getFromOpaquePtr(param_type),
Chris Lattner24943d22010-06-08 16:52:24 +00003587 NULL,
3588 (VarDecl::StorageClass)storage,
3589 (VarDecl::StorageClass)storage,
3590 0);
3591}
3592
3593void
3594ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params)
3595{
3596 if (function_decl)
3597 function_decl->setParams (params, num_params);
3598}
3599
3600
3601#pragma mark Array Types
3602
Greg Clayton462d4142010-09-29 01:12:09 +00003603clang_type_t
3604ClangASTContext::CreateArrayType (clang_type_t element_type, size_t element_count, uint32_t bit_stride)
Chris Lattner24943d22010-06-08 16:52:24 +00003605{
3606 if (element_type)
3607 {
Greg Claytonb01000f2011-01-17 03:46:26 +00003608 ASTContext *ast = getASTContext();
3609 assert (ast != NULL);
Chris Lattner24943d22010-06-08 16:52:24 +00003610 llvm::APInt ap_element_count (64, element_count);
Greg Claytonb01000f2011-01-17 03:46:26 +00003611 return ast->getConstantArrayType(QualType::getFromOpaquePtr(element_type),
Chris Lattner24943d22010-06-08 16:52:24 +00003612 ap_element_count,
3613 ArrayType::Normal,
3614 0).getAsOpaquePtr(); // ElemQuals
3615 }
3616 return NULL;
3617}
3618
3619
3620#pragma mark TagDecl
3621
3622bool
Greg Clayton462d4142010-09-29 01:12:09 +00003623ClangASTContext::StartTagDeclarationDefinition (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003624{
3625 if (clang_type)
3626 {
3627 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Clayton1674b122010-07-21 22:12:05 +00003628 clang::Type *t = qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00003629 if (t)
3630 {
3631 TagType *tag_type = dyn_cast<TagType>(t);
3632 if (tag_type)
3633 {
3634 TagDecl *tag_decl = tag_type->getDecl();
3635 if (tag_decl)
3636 {
3637 tag_decl->startDefinition();
3638 return true;
3639 }
3640 }
3641 }
3642 }
3643 return false;
3644}
3645
3646bool
Greg Clayton462d4142010-09-29 01:12:09 +00003647ClangASTContext::CompleteTagDeclarationDefinition (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003648{
3649 if (clang_type)
3650 {
3651 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Clayton55b6c532010-09-29 03:44:17 +00003652
3653 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3654
3655 if (cxx_record_decl)
Chris Lattner24943d22010-06-08 16:52:24 +00003656 {
Greg Clayton55b6c532010-09-29 03:44:17 +00003657 cxx_record_decl->completeDefinition();
3658
3659 return true;
3660 }
3661
Sean Callanan04325062010-10-25 00:29:48 +00003662 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
3663
3664 if (objc_class_type)
3665 {
3666 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3667
3668 class_interface_decl->setForwardDecl(false);
3669 }
3670
Greg Clayton55b6c532010-09-29 03:44:17 +00003671 const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr());
3672
3673 if (enum_type)
3674 {
3675 EnumDecl *enum_decl = enum_type->getDecl();
3676
3677 if (enum_decl)
Chris Lattner24943d22010-06-08 16:52:24 +00003678 {
Greg Clayton55b6c532010-09-29 03:44:17 +00003679 /// TODO This really needs to be fixed.
3680
3681 unsigned NumPositiveBits = 1;
3682 unsigned NumNegativeBits = 0;
3683
Greg Claytonb01000f2011-01-17 03:46:26 +00003684 ASTContext *ast = getASTContext();
Greg Clayton48fbdf72010-10-12 04:29:14 +00003685
3686 QualType promotion_qual_type;
3687 // If the enum integer type is less than an integer in bit width,
3688 // then we must promote it to an integer size.
Greg Claytonb01000f2011-01-17 03:46:26 +00003689 if (ast->getTypeSize(enum_decl->getIntegerType()) < ast->getTypeSize(ast->IntTy))
Greg Clayton48fbdf72010-10-12 04:29:14 +00003690 {
3691 if (enum_decl->getIntegerType()->isSignedIntegerType())
Greg Claytonb01000f2011-01-17 03:46:26 +00003692 promotion_qual_type = ast->IntTy;
Greg Clayton48fbdf72010-10-12 04:29:14 +00003693 else
Greg Claytonb01000f2011-01-17 03:46:26 +00003694 promotion_qual_type = ast->UnsignedIntTy;
Greg Clayton48fbdf72010-10-12 04:29:14 +00003695 }
3696 else
3697 promotion_qual_type = enum_decl->getIntegerType();
3698
3699 enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits);
Greg Clayton55b6c532010-09-29 03:44:17 +00003700 return true;
Chris Lattner24943d22010-06-08 16:52:24 +00003701 }
3702 }
3703 }
3704 return false;
3705}
3706
3707
3708#pragma mark Enumeration Types
3709
Greg Clayton462d4142010-09-29 01:12:09 +00003710clang_type_t
Greg Clayton0d62dfd2011-01-14 04:54:56 +00003711ClangASTContext::CreateEnumerationType
3712(
3713 const char *name,
3714 DeclContext *decl_ctx,
3715 const Declaration &decl,
3716 clang_type_t integer_qual_type
3717)
Chris Lattner24943d22010-06-08 16:52:24 +00003718{
3719 // TODO: Do something intelligent with the Declaration object passed in
3720 // like maybe filling in the SourceLocation with it...
Greg Claytonb01000f2011-01-17 03:46:26 +00003721 ASTContext *ast = getASTContext();
3722 assert (ast != NULL);
Greg Clayton48fbdf72010-10-12 04:29:14 +00003723
3724 // TODO: ask about these...
3725// const bool IsScoped = false;
3726// const bool IsFixed = false;
3727
Greg Claytonb01000f2011-01-17 03:46:26 +00003728 EnumDecl *enum_decl = EnumDecl::Create (*ast,
Greg Clayton0d62dfd2011-01-14 04:54:56 +00003729 decl_ctx,
Greg Clayton48fbdf72010-10-12 04:29:14 +00003730 SourceLocation(),
Greg Claytonb01000f2011-01-17 03:46:26 +00003731 name && name[0] ? &ast->Idents.get(name) : NULL,
Greg Clayton48fbdf72010-10-12 04:29:14 +00003732 SourceLocation(),
Sean Callanan9e7958e2010-12-13 01:26:27 +00003733 NULL,
3734 false, // IsScoped
3735 false, // IsScopedUsingClassTag
3736 false); // IsFixed
Sean Callanan864bfdb2011-01-18 01:03:44 +00003737
3738
Chris Lattner24943d22010-06-08 16:52:24 +00003739 if (enum_decl)
Greg Claytone37f23c2010-09-12 23:17:56 +00003740 {
3741 // TODO: check if we should be setting the promotion type too?
3742 enum_decl->setIntegerType(QualType::getFromOpaquePtr (integer_qual_type));
Sean Callanan864bfdb2011-01-18 01:03:44 +00003743
3744 enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
3745
Greg Claytonb01000f2011-01-17 03:46:26 +00003746 return ast->getTagDeclType(enum_decl).getAsOpaquePtr();
Greg Claytone37f23c2010-09-12 23:17:56 +00003747 }
Chris Lattner24943d22010-06-08 16:52:24 +00003748 return NULL;
3749}
3750
Greg Clayton462d4142010-09-29 01:12:09 +00003751clang_type_t
3752ClangASTContext::GetEnumerationIntegerType (clang_type_t enum_clang_type)
3753{
3754 QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
3755
3756 clang::Type *clang_type = enum_qual_type.getTypePtr();
3757 if (clang_type)
3758 {
3759 const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
3760 if (enum_type)
3761 {
3762 EnumDecl *enum_decl = enum_type->getDecl();
3763 if (enum_decl)
3764 return enum_decl->getIntegerType().getAsOpaquePtr();
3765 }
3766 }
3767 return NULL;
3768}
Chris Lattner24943d22010-06-08 16:52:24 +00003769bool
3770ClangASTContext::AddEnumerationValueToEnumerationType
3771(
Greg Clayton462d4142010-09-29 01:12:09 +00003772 clang_type_t enum_clang_type,
3773 clang_type_t enumerator_clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00003774 const Declaration &decl,
3775 const char *name,
3776 int64_t enum_value,
3777 uint32_t enum_value_bit_size
3778)
3779{
3780 if (enum_clang_type && enumerator_clang_type && name)
3781 {
3782 // TODO: Do something intelligent with the Declaration object passed in
3783 // like maybe filling in the SourceLocation with it...
Greg Claytonb01000f2011-01-17 03:46:26 +00003784 ASTContext *ast = getASTContext();
Chris Lattner24943d22010-06-08 16:52:24 +00003785 IdentifierTable *identifier_table = getIdentifierTable();
3786
Greg Claytonb01000f2011-01-17 03:46:26 +00003787 assert (ast != NULL);
Chris Lattner24943d22010-06-08 16:52:24 +00003788 assert (identifier_table != NULL);
3789 QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
3790
Greg Clayton1674b122010-07-21 22:12:05 +00003791 clang::Type *clang_type = enum_qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00003792 if (clang_type)
3793 {
3794 const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
3795
3796 if (enum_type)
3797 {
3798 llvm::APSInt enum_llvm_apsint(enum_value_bit_size, false);
3799 enum_llvm_apsint = enum_value;
3800 EnumConstantDecl *enumerator_decl =
Greg Claytonb01000f2011-01-17 03:46:26 +00003801 EnumConstantDecl::Create (*ast,
3802 enum_type->getDecl(),
3803 SourceLocation(),
3804 name ? &identifier_table->get(name) : NULL, // Identifier
3805 QualType::getFromOpaquePtr(enumerator_clang_type),
3806 NULL,
3807 enum_llvm_apsint);
3808
Chris Lattner24943d22010-06-08 16:52:24 +00003809 if (enumerator_decl)
3810 {
3811 enum_type->getDecl()->addDecl(enumerator_decl);
3812 return true;
3813 }
3814 }
3815 }
3816 }
3817 return false;
3818}
3819
3820#pragma mark Pointers & References
3821
Greg Clayton462d4142010-09-29 01:12:09 +00003822clang_type_t
3823ClangASTContext::CreatePointerType (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003824{
Greg Clayton427f2902010-12-14 02:59:59 +00003825 return CreatePointerType (getASTContext(), clang_type);
3826}
3827
3828clang_type_t
3829ClangASTContext::CreatePointerType (clang::ASTContext *ast, clang_type_t clang_type)
3830{
3831 if (ast && clang_type)
Greg Clayton7b541032010-07-29 20:06:32 +00003832 {
3833 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3834
Greg Clayton03e0f972010-09-13 03:32:57 +00003835 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3836 switch (type_class)
Greg Clayton7b541032010-07-29 20:06:32 +00003837 {
3838 case clang::Type::ObjCObject:
3839 case clang::Type::ObjCInterface:
Greg Clayton427f2902010-12-14 02:59:59 +00003840 return ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr();
Greg Clayton7b541032010-07-29 20:06:32 +00003841
Greg Clayton7b541032010-07-29 20:06:32 +00003842 default:
Greg Clayton427f2902010-12-14 02:59:59 +00003843 return ast->getPointerType(qual_type).getAsOpaquePtr();
Greg Clayton7b541032010-07-29 20:06:32 +00003844 }
3845 }
Chris Lattner24943d22010-06-08 16:52:24 +00003846 return NULL;
3847}
3848
Greg Clayton462d4142010-09-29 01:12:09 +00003849clang_type_t
Sean Callanan6a925532011-01-13 08:53:35 +00003850ClangASTContext::CreateLValueReferenceType (clang::ASTContext *ast,
3851 clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003852{
3853 if (clang_type)
Sean Callanan6a925532011-01-13 08:53:35 +00003854 return ast->getLValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00003855 return NULL;
3856}
3857
Greg Clayton462d4142010-09-29 01:12:09 +00003858clang_type_t
Sean Callanan6a925532011-01-13 08:53:35 +00003859ClangASTContext::CreateRValueReferenceType (clang::ASTContext *ast,
3860 clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003861{
3862 if (clang_type)
Sean Callanan6a925532011-01-13 08:53:35 +00003863 return ast->getRValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00003864 return NULL;
3865}
3866
Greg Clayton462d4142010-09-29 01:12:09 +00003867clang_type_t
3868ClangASTContext::CreateMemberPointerType (clang_type_t clang_pointee_type, clang_type_t clang_class_type)
Greg Claytonfa970692010-06-12 01:20:30 +00003869{
3870 if (clang_pointee_type && clang_pointee_type)
3871 return getASTContext()->getMemberPointerType(QualType::getFromOpaquePtr(clang_pointee_type),
3872 QualType::getFromOpaquePtr(clang_class_type).getTypePtr()).getAsOpaquePtr();
3873 return NULL;
3874}
3875
Chris Lattner24943d22010-06-08 16:52:24 +00003876size_t
3877ClangASTContext::GetPointerBitSize ()
3878{
Greg Claytonb01000f2011-01-17 03:46:26 +00003879 ASTContext *ast = getASTContext();
3880 return ast->getTypeSize(ast->VoidPtrTy);
Chris Lattner24943d22010-06-08 16:52:24 +00003881}
3882
3883bool
Greg Clayton462d4142010-09-29 01:12:09 +00003884ClangASTContext::IsPointerOrReferenceType (clang_type_t clang_type, clang_type_t*target_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003885{
3886 if (clang_type == NULL)
3887 return false;
3888
3889 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00003890 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3891 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003892 {
Sean Callanan04325062010-10-25 00:29:48 +00003893 case clang::Type::Builtin:
3894 switch (cast<clang::BuiltinType>(qual_type)->getKind())
3895 {
3896 default:
3897 break;
3898 case clang::BuiltinType::ObjCId:
3899 case clang::BuiltinType::ObjCClass:
Sean Callanan04325062010-10-25 00:29:48 +00003900 return true;
3901 }
3902 return false;
Greg Clayton1674b122010-07-21 22:12:05 +00003903 case clang::Type::ObjCObjectPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003904 if (target_type)
3905 *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3906 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003907 case clang::Type::BlockPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003908 if (target_type)
3909 *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3910 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003911 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003912 if (target_type)
3913 *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3914 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003915 case clang::Type::MemberPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003916 if (target_type)
3917 *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3918 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003919 case clang::Type::LValueReference:
Chris Lattner24943d22010-06-08 16:52:24 +00003920 if (target_type)
3921 *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
3922 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003923 case clang::Type::RValueReference:
Chris Lattner24943d22010-06-08 16:52:24 +00003924 if (target_type)
3925 *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
3926 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003927 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00003928 return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
Chris Lattner24943d22010-06-08 16:52:24 +00003929 default:
3930 break;
3931 }
3932 return false;
3933}
3934
Chris Lattner24943d22010-06-08 16:52:24 +00003935bool
Greg Clayton462d4142010-09-29 01:12:09 +00003936ClangASTContext::IsIntegerType (clang_type_t clang_type, bool &is_signed)
Chris Lattner24943d22010-06-08 16:52:24 +00003937{
3938 if (!clang_type)
3939 return false;
3940
3941 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3942 const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal());
3943
3944 if (builtin_type)
3945 {
3946 if (builtin_type->isInteger())
3947 is_signed = builtin_type->isSignedInteger();
3948
3949 return true;
3950 }
3951
3952 return false;
3953}
3954
3955bool
Greg Clayton462d4142010-09-29 01:12:09 +00003956ClangASTContext::IsPointerType (clang_type_t clang_type, clang_type_t*target_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003957{
3958 if (clang_type)
3959 {
3960 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00003961 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3962 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003963 {
Sean Callanan04325062010-10-25 00:29:48 +00003964 case clang::Type::Builtin:
3965 switch (cast<clang::BuiltinType>(qual_type)->getKind())
3966 {
3967 default:
3968 break;
3969 case clang::BuiltinType::ObjCId:
3970 case clang::BuiltinType::ObjCClass:
Sean Callanan04325062010-10-25 00:29:48 +00003971 return true;
3972 }
3973 return false;
Greg Clayton1674b122010-07-21 22:12:05 +00003974 case clang::Type::ObjCObjectPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003975 if (target_type)
3976 *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3977 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003978 case clang::Type::BlockPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003979 if (target_type)
3980 *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3981 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003982 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003983 if (target_type)
3984 *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3985 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003986 case clang::Type::MemberPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003987 if (target_type)
3988 *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3989 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003990 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00003991 return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), target_type);
Chris Lattner24943d22010-06-08 16:52:24 +00003992 default:
3993 break;
3994 }
3995 }
3996 return false;
3997}
3998
3999bool
Greg Clayton462d4142010-09-29 01:12:09 +00004000ClangASTContext::IsFloatingPointType (clang_type_t clang_type, uint32_t &count, bool &is_complex)
Chris Lattner24943d22010-06-08 16:52:24 +00004001{
4002 if (clang_type)
4003 {
4004 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4005
4006 if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()))
4007 {
4008 clang::BuiltinType::Kind kind = BT->getKind();
4009 if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble)
4010 {
4011 count = 1;
4012 is_complex = false;
4013 return true;
4014 }
4015 }
4016 else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal()))
4017 {
4018 if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count, is_complex))
4019 {
4020 count = 2;
4021 is_complex = true;
4022 return true;
4023 }
4024 }
4025 else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal()))
4026 {
4027 if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count, is_complex))
4028 {
4029 count = VT->getNumElements();
4030 is_complex = false;
4031 return true;
4032 }
4033 }
4034 }
4035 return false;
4036}
4037
Greg Claytonbf8e42b2010-10-14 22:52:14 +00004038
4039bool
4040ClangASTContext::GetCXXClassName (clang_type_t clang_type, std::string &class_name)
4041{
4042 if (clang_type)
4043 {
4044 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4045
4046 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
4047 if (cxx_record_decl)
4048 {
4049 class_name.assign (cxx_record_decl->getIdentifier()->getNameStart());
4050 return true;
4051 }
4052 }
4053 class_name.clear();
4054 return false;
4055}
4056
4057
Greg Clayton1d8173f2010-09-24 05:15:53 +00004058bool
Greg Clayton462d4142010-09-29 01:12:09 +00004059ClangASTContext::IsCXXClassType (clang_type_t clang_type)
Greg Clayton1d8173f2010-09-24 05:15:53 +00004060{
4061 if (clang_type)
4062 {
4063 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4064 if (qual_type->getAsCXXRecordDecl() != NULL)
4065 return true;
4066 }
4067 return false;
4068}
4069
4070bool
Greg Clayton462d4142010-09-29 01:12:09 +00004071ClangASTContext::IsObjCClassType (clang_type_t clang_type)
Greg Clayton1d8173f2010-09-24 05:15:53 +00004072{
4073 if (clang_type)
4074 {
4075 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4076 if (qual_type->isObjCObjectOrInterfaceType())
4077 return true;
4078 }
4079 return false;
4080}
4081
4082
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00004083bool
4084ClangASTContext::IsCharType (clang_type_t clang_type)
4085{
4086 if (clang_type)
4087 return QualType::getFromOpaquePtr(clang_type)->isCharType();
4088 return false;
4089}
Chris Lattner24943d22010-06-08 16:52:24 +00004090
4091bool
Greg Clayton462d4142010-09-29 01:12:09 +00004092ClangASTContext::IsCStringType (clang_type_t clang_type, uint32_t &length)
Chris Lattner24943d22010-06-08 16:52:24 +00004093{
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00004094 clang_type_t pointee_or_element_clang_type = NULL;
4095 Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, NULL, &pointee_or_element_clang_type));
4096
4097 if (pointee_or_element_clang_type == NULL)
4098 return false;
4099
4100 if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer))
Chris Lattner24943d22010-06-08 16:52:24 +00004101 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00004102 QualType pointee_or_element_qual_type (QualType::getFromOpaquePtr (pointee_or_element_clang_type));
4103
4104 if (pointee_or_element_qual_type.getUnqualifiedType()->isCharType())
Chris Lattner24943d22010-06-08 16:52:24 +00004105 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00004106 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4107 if (type_flags.Test (eTypeIsArray))
Chris Lattner24943d22010-06-08 16:52:24 +00004108 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00004109 // We know the size of the array and it could be a C string
4110 // since it is an array of characters
4111 length = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
4112 return true;
Chris Lattner24943d22010-06-08 16:52:24 +00004113 }
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00004114 else
Chris Lattner24943d22010-06-08 16:52:24 +00004115 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00004116 length = 0;
4117 return true;
Chris Lattner24943d22010-06-08 16:52:24 +00004118 }
Chris Lattner24943d22010-06-08 16:52:24 +00004119
Chris Lattner24943d22010-06-08 16:52:24 +00004120 }
4121 }
4122 return false;
4123}
4124
4125bool
Greg Clayton462d4142010-09-29 01:12:09 +00004126ClangASTContext::IsFunctionPointerType (clang_type_t clang_type)
Greg Clayton03e0f972010-09-13 03:32:57 +00004127{
4128 if (clang_type)
4129 {
4130 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4131
4132 if (qual_type->isFunctionPointerType())
4133 return true;
4134
4135 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4136 switch (type_class)
4137 {
4138 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00004139 return ClangASTContext::IsFunctionPointerType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
Greg Clayton03e0f972010-09-13 03:32:57 +00004140
4141 case clang::Type::LValueReference:
4142 case clang::Type::RValueReference:
4143 {
4144 ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
4145 if (reference_type)
4146 return ClangASTContext::IsFunctionPointerType (reference_type->getPointeeType().getAsOpaquePtr());
4147 }
4148 break;
4149 }
4150 }
4151 return false;
4152}
4153
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00004154size_t
4155ClangASTContext::GetArraySize (clang_type_t clang_type)
4156{
4157 if (clang_type)
4158 {
4159 ConstantArrayType *array = cast<ConstantArrayType>(QualType::getFromOpaquePtr(clang_type).getTypePtr());
4160 if (array)
4161 return array->getSize().getLimitedValue();
4162 }
4163 return 0;
4164}
Greg Clayton03e0f972010-09-13 03:32:57 +00004165
4166bool
Greg Clayton462d4142010-09-29 01:12:09 +00004167ClangASTContext::IsArrayType (clang_type_t clang_type, clang_type_t*member_type, uint64_t *size)
Chris Lattner24943d22010-06-08 16:52:24 +00004168{
4169 if (!clang_type)
4170 return false;
4171
4172 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4173
Greg Clayton03e0f972010-09-13 03:32:57 +00004174 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4175 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00004176 {
Greg Clayton1674b122010-07-21 22:12:05 +00004177 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00004178 if (member_type)
4179 *member_type = cast<ConstantArrayType>(qual_type)->getElementType().getAsOpaquePtr();
4180 if (size)
4181 *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULONG_LONG_MAX);
4182 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00004183 case clang::Type::IncompleteArray:
Chris Lattner24943d22010-06-08 16:52:24 +00004184 if (member_type)
4185 *member_type = cast<IncompleteArrayType>(qual_type)->getElementType().getAsOpaquePtr();
4186 if (size)
4187 *size = 0;
4188 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00004189 case clang::Type::VariableArray:
Chris Lattner24943d22010-06-08 16:52:24 +00004190 if (member_type)
4191 *member_type = cast<VariableArrayType>(qual_type)->getElementType().getAsOpaquePtr();
4192 if (size)
4193 *size = 0;
Greg Clayton1674b122010-07-21 22:12:05 +00004194 case clang::Type::DependentSizedArray:
Chris Lattner24943d22010-06-08 16:52:24 +00004195 if (member_type)
4196 *member_type = cast<DependentSizedArrayType>(qual_type)->getElementType().getAsOpaquePtr();
4197 if (size)
4198 *size = 0;
4199 return true;
4200 }
4201 return false;
4202}
4203
4204
4205#pragma mark Typedefs
4206
Greg Clayton462d4142010-09-29 01:12:09 +00004207clang_type_t
4208ClangASTContext::CreateTypedefType (const char *name, clang_type_t clang_type, DeclContext *decl_ctx)
Chris Lattner24943d22010-06-08 16:52:24 +00004209{
4210 if (clang_type)
4211 {
4212 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Claytonb01000f2011-01-17 03:46:26 +00004213 ASTContext *ast = getASTContext();
Chris Lattner24943d22010-06-08 16:52:24 +00004214 IdentifierTable *identifier_table = getIdentifierTable();
Greg Claytonb01000f2011-01-17 03:46:26 +00004215 assert (ast != NULL);
Chris Lattner24943d22010-06-08 16:52:24 +00004216 assert (identifier_table != NULL);
4217 if (decl_ctx == NULL)
Greg Claytonb01000f2011-01-17 03:46:26 +00004218 decl_ctx = ast->getTranslationUnitDecl();
4219 TypedefDecl *decl = TypedefDecl::Create (*ast,
4220 decl_ctx,
4221 SourceLocation(),
4222 name ? &identifier_table->get(name) : NULL, // Identifier
4223 ast->CreateTypeSourceInfo(qual_type));
Sean Callanan864bfdb2011-01-18 01:03:44 +00004224
4225 decl->setAccess(AS_public); // TODO respect proper access specifier
Chris Lattner24943d22010-06-08 16:52:24 +00004226
4227 // Get a uniqued QualType for the typedef decl type
Greg Claytonb01000f2011-01-17 03:46:26 +00004228 return ast->getTypedefType (decl).getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00004229 }
4230 return NULL;
4231}
4232
4233
4234std::string
Greg Clayton462d4142010-09-29 01:12:09 +00004235ClangASTContext::GetTypeName (clang_type_t opaque_qual_type)
Chris Lattner24943d22010-06-08 16:52:24 +00004236{
4237 std::string return_name;
4238
Greg Clayton462d4142010-09-29 01:12:09 +00004239 QualType qual_type(QualType::getFromOpaquePtr(opaque_qual_type));
Chris Lattner24943d22010-06-08 16:52:24 +00004240
Greg Clayton462d4142010-09-29 01:12:09 +00004241 const TypedefType *typedef_type = qual_type->getAs<TypedefType>();
Chris Lattner24943d22010-06-08 16:52:24 +00004242 if (typedef_type)
4243 {
Greg Clayton462d4142010-09-29 01:12:09 +00004244 const TypedefDecl *typedef_decl = typedef_type->getDecl();
Chris Lattner24943d22010-06-08 16:52:24 +00004245 return_name = typedef_decl->getQualifiedNameAsString();
4246 }
4247 else
4248 {
4249 return_name = qual_type.getAsString();
4250 }
4251
4252 return return_name;
4253}
4254
4255// Disable this for now since I can't seem to get a nicely formatted float
4256// out of the APFloat class without just getting the float, double or quad
4257// and then using a formatted print on it which defeats the purpose. We ideally
4258// would like to get perfect string values for any kind of float semantics
4259// so we can support remote targets. The code below also requires a patch to
4260// llvm::APInt.
4261//bool
Greg Claytonb01000f2011-01-17 03:46:26 +00004262//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, clang_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str)
Chris Lattner24943d22010-06-08 16:52:24 +00004263//{
4264// uint32_t count = 0;
4265// bool is_complex = false;
4266// if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
4267// {
4268// unsigned num_bytes_per_float = byte_size / count;
4269// unsigned num_bits_per_float = num_bytes_per_float * 8;
4270//
4271// float_str.clear();
4272// uint32_t i;
4273// for (i=0; i<count; i++)
4274// {
4275// APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order);
4276// bool is_ieee = false;
4277// APFloat ap_float(ap_int, is_ieee);
4278// char s[1024];
4279// unsigned int hex_digits = 0;
4280// bool upper_case = false;
4281//
4282// if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0)
4283// {
4284// if (i > 0)
4285// float_str.append(", ");
4286// float_str.append(s);
4287// if (i == 1 && is_complex)
4288// float_str.append(1, 'i');
4289// }
4290// }
4291// return !float_str.empty();
4292// }
4293// return false;
4294//}
4295
4296size_t
Greg Claytonb01000f2011-01-17 03:46:26 +00004297ClangASTContext::ConvertStringToFloatValue (ASTContext *ast, clang_type_t clang_type, const char *s, uint8_t *dst, size_t dst_size)
Chris Lattner24943d22010-06-08 16:52:24 +00004298{
4299 if (clang_type)
4300 {
4301 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4302 uint32_t count = 0;
4303 bool is_complex = false;
4304 if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
4305 {
4306 // TODO: handle complex and vector types
4307 if (count != 1)
4308 return false;
4309
4310 StringRef s_sref(s);
Greg Claytonb01000f2011-01-17 03:46:26 +00004311 APFloat ap_float(ast->getFloatTypeSemantics(qual_type), s_sref);
Chris Lattner24943d22010-06-08 16:52:24 +00004312
Greg Claytonb01000f2011-01-17 03:46:26 +00004313 const uint64_t bit_size = ast->getTypeSize (qual_type);
Chris Lattner24943d22010-06-08 16:52:24 +00004314 const uint64_t byte_size = bit_size / 8;
4315 if (dst_size >= byte_size)
4316 {
4317 if (bit_size == sizeof(float)*8)
4318 {
4319 float float32 = ap_float.convertToFloat();
4320 ::memcpy (dst, &float32, byte_size);
4321 return byte_size;
4322 }
4323 else if (bit_size >= 64)
4324 {
4325 llvm::APInt ap_int(ap_float.bitcastToAPInt());
4326 ::memcpy (dst, ap_int.getRawData(), byte_size);
4327 return byte_size;
4328 }
4329 }
4330 }
4331 }
4332 return 0;
4333}
Sean Callanana751f7b2010-09-17 02:24:29 +00004334
4335unsigned
Greg Clayton462d4142010-09-29 01:12:09 +00004336ClangASTContext::GetTypeQualifiers(clang_type_t clang_type)
Sean Callanana751f7b2010-09-17 02:24:29 +00004337{
4338 assert (clang_type);
4339
4340 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4341
4342 return qual_type.getQualifiers().getCVRQualifiers();
4343}
Greg Claytonb01000f2011-01-17 03:46:26 +00004344
4345bool
4346ClangASTContext::GetCompleteType (clang::ASTContext *ast, lldb::clang_type_t clang_type)
4347{
4348 if (clang_type == NULL)
4349 return false;
4350
4351 clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type));
4352 return GetCompleteQualType (ast, qual_type);
4353}
4354
4355
4356bool
4357ClangASTContext::GetCompleteType (clang_type_t clang_type)
4358{
4359 return ClangASTContext::GetCompleteType (getASTContext(), clang_type);
4360}
4361