blob: 5d8c48967d022b013875b162b56bd29d982d4fc3 [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
Sean Callananbc4f0f52010-07-08 18:16:16 +000017#define NDEBUG
Chris Lattner24943d22010-06-08 16:52:24 +000018#include "clang/AST/ASTContext.h"
19#include "clang/AST/ASTImporter.h"
20#include "clang/AST/CXXInheritance.h"
Greg Clayton84f80752010-07-22 18:30:50 +000021#include "clang/AST/DeclObjC.h"
Chris Lattner24943d22010-06-08 16:52:24 +000022#include "clang/AST/RecordLayout.h"
23#include "clang/AST/Type.h"
24#include "clang/Basic/Builtins.h"
25#include "clang/Basic/FileManager.h"
Sean Callanan8a3b0a82010-11-18 02:56:27 +000026#include "clang/Basic/FileSystemOptions.h"
Chris Lattner24943d22010-06-08 16:52:24 +000027#include "clang/Basic/SourceManager.h"
28#include "clang/Basic/TargetInfo.h"
29#include "clang/Basic/TargetOptions.h"
30#include "clang/Frontend/FrontendOptions.h"
31#include "clang/Frontend/LangStandard.h"
Sean Callananbc4f0f52010-07-08 18:16:16 +000032#undef NDEBUG
Chris Lattner24943d22010-06-08 16:52:24 +000033
Chris Lattner24943d22010-06-08 16:52:24 +000034#include "lldb/Core/dwarf.h"
Greg Claytonf3d0b0c2010-10-27 03:32:59 +000035#include "lldb/Core/Flags.h"
Sean Callanan839fde42010-10-28 18:19:36 +000036#include "lldb/Core/Log.h"
Chris Lattner24943d22010-06-08 16:52:24 +000037
Eli Friedmanf05633b2010-06-13 19:06:42 +000038#include <stdio.h>
39
Greg Clayton585660c2010-08-05 01:57:25 +000040using namespace lldb;
Chris Lattner24943d22010-06-08 16:52:24 +000041using namespace lldb_private;
42using namespace llvm;
43using namespace clang;
44
Greg Clayton84f80752010-07-22 18:30:50 +000045static AccessSpecifier
Greg Clayton585660c2010-08-05 01:57:25 +000046ConvertAccessTypeToAccessSpecifier (AccessType access)
Greg Clayton84f80752010-07-22 18:30:50 +000047{
48 switch (access)
49 {
Greg Clayton585660c2010-08-05 01:57:25 +000050 default: break;
51 case eAccessNone: return AS_none;
52 case eAccessPublic: return AS_public;
53 case eAccessPrivate: return AS_private;
54 case eAccessProtected: return AS_protected;
Greg Clayton84f80752010-07-22 18:30:50 +000055 }
56 return AS_none;
57}
58
59static ObjCIvarDecl::AccessControl
Greg Clayton585660c2010-08-05 01:57:25 +000060ConvertAccessTypeToObjCIvarAccessControl (AccessType access)
Greg Clayton84f80752010-07-22 18:30:50 +000061{
62 switch (access)
63 {
Greg Clayton585660c2010-08-05 01:57:25 +000064 default: break;
65 case eAccessNone: return ObjCIvarDecl::None;
66 case eAccessPublic: return ObjCIvarDecl::Public;
67 case eAccessPrivate: return ObjCIvarDecl::Private;
68 case eAccessProtected: return ObjCIvarDecl::Protected;
69 case eAccessPackage: return ObjCIvarDecl::Package;
Greg Clayton84f80752010-07-22 18:30:50 +000070 }
71 return ObjCIvarDecl::None;
72}
73
74
Chris Lattner24943d22010-06-08 16:52:24 +000075static void
76ParseLangArgs
77(
78 LangOptions &Opts,
Greg Claytone41c4b22010-06-13 17:34:29 +000079 InputKind IK
Chris Lattner24943d22010-06-08 16:52:24 +000080)
81{
82 // FIXME: Cleanup per-file based stuff.
83
84 // Set some properties which depend soley on the input kind; it would be nice
85 // to move these to the language standard, and have the driver resolve the
86 // input kind + language standard.
Greg Claytone41c4b22010-06-13 17:34:29 +000087 if (IK == IK_Asm) {
Chris Lattner24943d22010-06-08 16:52:24 +000088 Opts.AsmPreprocessor = 1;
Greg Claytone41c4b22010-06-13 17:34:29 +000089 } else if (IK == IK_ObjC ||
90 IK == IK_ObjCXX ||
91 IK == IK_PreprocessedObjC ||
92 IK == IK_PreprocessedObjCXX) {
Chris Lattner24943d22010-06-08 16:52:24 +000093 Opts.ObjC1 = Opts.ObjC2 = 1;
94 }
95
96 LangStandard::Kind LangStd = LangStandard::lang_unspecified;
97
98 if (LangStd == LangStandard::lang_unspecified) {
99 // Based on the base language, pick one.
100 switch (IK) {
Greg Claytone41c4b22010-06-13 17:34:29 +0000101 case IK_None:
102 case IK_AST:
Chris Lattner24943d22010-06-08 16:52:24 +0000103 assert(0 && "Invalid input kind!");
Greg Claytone41c4b22010-06-13 17:34:29 +0000104 case IK_OpenCL:
Chris Lattner24943d22010-06-08 16:52:24 +0000105 LangStd = LangStandard::lang_opencl;
106 break;
Greg Claytone41c4b22010-06-13 17:34:29 +0000107 case IK_Asm:
108 case IK_C:
109 case IK_PreprocessedC:
110 case IK_ObjC:
111 case IK_PreprocessedObjC:
Chris Lattner24943d22010-06-08 16:52:24 +0000112 LangStd = LangStandard::lang_gnu99;
113 break;
Greg Claytone41c4b22010-06-13 17:34:29 +0000114 case IK_CXX:
115 case IK_PreprocessedCXX:
116 case IK_ObjCXX:
117 case IK_PreprocessedObjCXX:
Chris Lattner24943d22010-06-08 16:52:24 +0000118 LangStd = LangStandard::lang_gnucxx98;
119 break;
120 }
121 }
122
123 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
124 Opts.BCPLComment = Std.hasBCPLComments();
125 Opts.C99 = Std.isC99();
126 Opts.CPlusPlus = Std.isCPlusPlus();
127 Opts.CPlusPlus0x = Std.isCPlusPlus0x();
128 Opts.Digraphs = Std.hasDigraphs();
129 Opts.GNUMode = Std.isGNUMode();
130 Opts.GNUInline = !Std.isC99();
131 Opts.HexFloats = Std.hasHexFloats();
132 Opts.ImplicitInt = Std.hasImplicitInt();
133
134 // OpenCL has some additional defaults.
135 if (LangStd == LangStandard::lang_opencl) {
136 Opts.OpenCL = 1;
137 Opts.AltiVec = 1;
138 Opts.CXXOperatorNames = 1;
139 Opts.LaxVectorConversions = 1;
140 }
141
142 // OpenCL and C++ both have bool, true, false keywords.
143 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
144
145// if (Opts.CPlusPlus)
146// Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
147//
148// if (Args.hasArg(OPT_fobjc_gc_only))
149// Opts.setGCMode(LangOptions::GCOnly);
150// else if (Args.hasArg(OPT_fobjc_gc))
151// Opts.setGCMode(LangOptions::HybridGC);
152//
153// if (Args.hasArg(OPT_print_ivar_layout))
154// Opts.ObjCGCBitmapPrint = 1;
155//
156// if (Args.hasArg(OPT_faltivec))
157// Opts.AltiVec = 1;
158//
159// if (Args.hasArg(OPT_pthread))
160// Opts.POSIXThreads = 1;
161//
162// llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
163// "default");
164// if (Vis == "default")
Sean Callanan8950c9a2010-10-29 18:38:40 +0000165 Opts.setVisibilityMode(DefaultVisibility);
Chris Lattner24943d22010-06-08 16:52:24 +0000166// else if (Vis == "hidden")
167// Opts.setVisibilityMode(LangOptions::Hidden);
168// else if (Vis == "protected")
169// Opts.setVisibilityMode(LangOptions::Protected);
170// else
171// Diags.Report(diag::err_drv_invalid_value)
172// << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
173
174// Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
175
176 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
177 // is specified, or -std is set to a conforming mode.
178 Opts.Trigraphs = !Opts.GNUMode;
179// if (Args.hasArg(OPT_trigraphs))
180// Opts.Trigraphs = 1;
181//
182// Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
183// OPT_fno_dollars_in_identifiers,
184// !Opts.AsmPreprocessor);
185// Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
186// Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
187// Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
188// if (Args.hasArg(OPT_fno_lax_vector_conversions))
189// Opts.LaxVectorConversions = 0;
190// Opts.Exceptions = Args.hasArg(OPT_fexceptions);
191// Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
192// Opts.Blocks = Args.hasArg(OPT_fblocks);
193// Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
194// Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
195// Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
196// Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
197// Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
198// Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
199// Opts.AccessControl = Args.hasArg(OPT_faccess_control);
200// Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
201// Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno);
202// Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99,
203// Diags);
204// Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
205// Opts.ObjCConstantStringClass = getLastArgValue(Args,
206// OPT_fconstant_string_class);
207// Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
208// Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
209// Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
210// Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
211// Opts.Static = Args.hasArg(OPT_static_define);
212 Opts.OptimizeSize = 0;
213
214 // FIXME: Eliminate this dependency.
215// unsigned Opt =
216// Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
217// Opts.Optimize = Opt != 0;
218 unsigned Opt = 0;
219
220 // This is the __NO_INLINE__ define, which just depends on things like the
221 // optimization level and -fno-inline, not actually whether the backend has
222 // inlining enabled.
223 //
224 // FIXME: This is affected by other options (-fno-inline).
225 Opts.NoInline = !Opt;
226
227// unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
228// switch (SSP) {
229// default:
230// Diags.Report(diag::err_drv_invalid_value)
231// << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
232// break;
233// case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
234// case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break;
235// case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
236// }
237}
238
Chris Lattner24943d22010-06-08 16:52:24 +0000239
Chris Lattner24943d22010-06-08 16:52:24 +0000240ClangASTContext::ClangASTContext(const char *target_triple) :
241 m_target_triple(),
242 m_ast_context_ap(),
243 m_language_options_ap(),
244 m_source_manager_ap(),
245 m_diagnostic_ap(),
246 m_target_options_ap(),
247 m_target_info_ap(),
248 m_identifier_table_ap(),
249 m_selector_table_ap(),
250 m_builtins_ap()
251{
252 if (target_triple && target_triple[0])
253 m_target_triple.assign (target_triple);
254}
255
256//----------------------------------------------------------------------
257// Destructor
258//----------------------------------------------------------------------
259ClangASTContext::~ClangASTContext()
260{
261 m_builtins_ap.reset();
262 m_selector_table_ap.reset();
263 m_identifier_table_ap.reset();
264 m_target_info_ap.reset();
265 m_target_options_ap.reset();
266 m_diagnostic_ap.reset();
267 m_source_manager_ap.reset();
268 m_language_options_ap.reset();
269 m_ast_context_ap.reset();
270}
271
272
273void
274ClangASTContext::Clear()
275{
276 m_ast_context_ap.reset();
277 m_language_options_ap.reset();
278 m_source_manager_ap.reset();
279 m_diagnostic_ap.reset();
280 m_target_options_ap.reset();
281 m_target_info_ap.reset();
282 m_identifier_table_ap.reset();
283 m_selector_table_ap.reset();
284 m_builtins_ap.reset();
285}
286
287const char *
288ClangASTContext::GetTargetTriple ()
289{
290 return m_target_triple.c_str();
291}
292
293void
294ClangASTContext::SetTargetTriple (const char *target_triple)
295{
296 Clear();
297 m_target_triple.assign(target_triple);
298}
299
300
301ASTContext *
302ClangASTContext::getASTContext()
303{
304 if (m_ast_context_ap.get() == NULL)
305 {
306 m_ast_context_ap.reset(
307 new ASTContext(
308 *getLanguageOptions(),
309 *getSourceManager(),
310 *getTargetInfo(),
311 *getIdentifierTable(),
312 *getSelectorTable(),
Greg Clayton6e713402010-07-30 20:30:44 +0000313 *getBuiltinContext(),
314 0));
Sean Callanan887d2512010-12-11 00:08:56 +0000315
316 m_ast_context_ap->getDiagnostics().setClient(getDiagnosticClient(), false);
Chris Lattner24943d22010-06-08 16:52:24 +0000317 }
318 return m_ast_context_ap.get();
319}
320
321Builtin::Context *
322ClangASTContext::getBuiltinContext()
323{
324 if (m_builtins_ap.get() == NULL)
325 m_builtins_ap.reset (new Builtin::Context(*getTargetInfo()));
326 return m_builtins_ap.get();
327}
328
329IdentifierTable *
330ClangASTContext::getIdentifierTable()
331{
332 if (m_identifier_table_ap.get() == NULL)
333 m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), NULL));
334 return m_identifier_table_ap.get();
335}
336
337LangOptions *
338ClangASTContext::getLanguageOptions()
339{
340 if (m_language_options_ap.get() == NULL)
341 {
342 m_language_options_ap.reset(new LangOptions());
Greg Claytone41c4b22010-06-13 17:34:29 +0000343 ParseLangArgs(*m_language_options_ap, IK_ObjCXX);
344// InitializeLangOptions(*m_language_options_ap, IK_ObjCXX);
Chris Lattner24943d22010-06-08 16:52:24 +0000345 }
346 return m_language_options_ap.get();
347}
348
349SelectorTable *
350ClangASTContext::getSelectorTable()
351{
352 if (m_selector_table_ap.get() == NULL)
353 m_selector_table_ap.reset (new SelectorTable());
354 return m_selector_table_ap.get();
355}
356
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000357clang::FileManager *
358ClangASTContext::getFileManager()
359{
360 if (m_file_manager_ap.get() == NULL)
Greg Clayton22defe82010-12-02 23:20:03 +0000361 {
362 clang::FileSystemOptions file_system_options;
363 m_file_manager_ap.reset(new clang::FileManager(file_system_options));
364 }
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000365 return m_file_manager_ap.get();
366}
367
Greg Clayton1674b122010-07-21 22:12:05 +0000368clang::SourceManager *
Chris Lattner24943d22010-06-08 16:52:24 +0000369ClangASTContext::getSourceManager()
370{
371 if (m_source_manager_ap.get() == NULL)
Greg Clayton22defe82010-12-02 23:20:03 +0000372 m_source_manager_ap.reset(new clang::SourceManager(*getDiagnostic(), *getFileManager()));
Chris Lattner24943d22010-06-08 16:52:24 +0000373 return m_source_manager_ap.get();
374}
375
376Diagnostic *
377ClangASTContext::getDiagnostic()
378{
379 if (m_diagnostic_ap.get() == NULL)
Greg Claytoneae91242010-11-19 21:46:54 +0000380 {
381 llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
382 m_diagnostic_ap.reset(new Diagnostic(diag_id_sp));
383 }
Chris Lattner24943d22010-06-08 16:52:24 +0000384 return m_diagnostic_ap.get();
385}
386
Sean Callanan887d2512010-12-11 00:08:56 +0000387class NullDiagnosticClient : public DiagnosticClient
388{
389public:
390 NullDiagnosticClient ()
391 {
392 m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
393 }
394
395 void HandleDiagnostic (Diagnostic::Level DiagLevel, const DiagnosticInfo &info)
396 {
397 if (m_log)
398 {
399 llvm::SmallVectorImpl<char> diag_str(10);
400 info.FormatDiagnostic(diag_str);
401 diag_str.push_back('\0');
402 m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
403 }
404 }
405private:
406 LogSP m_log;
407};
408
409DiagnosticClient *
410ClangASTContext::getDiagnosticClient()
411{
412 if (m_diagnostic_client_ap.get() == NULL)
413 m_diagnostic_client_ap.reset(new NullDiagnosticClient);
414
415 return m_diagnostic_client_ap.get();
416}
417
Chris Lattner24943d22010-06-08 16:52:24 +0000418TargetOptions *
419ClangASTContext::getTargetOptions()
420{
421 if (m_target_options_ap.get() == NULL && !m_target_triple.empty())
422 {
423 m_target_options_ap.reset (new TargetOptions());
424 if (m_target_options_ap.get())
425 m_target_options_ap->Triple = m_target_triple;
426 }
427 return m_target_options_ap.get();
428}
429
430
431TargetInfo *
432ClangASTContext::getTargetInfo()
433{
434 // target_triple should be something like "x86_64-apple-darwin10"
435 if (m_target_info_ap.get() == NULL && !m_target_triple.empty())
436 m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnostic(), *getTargetOptions()));
437 return m_target_info_ap.get();
438}
439
440#pragma mark Basic Types
441
442static inline bool
443QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast_context, QualType qual_type)
444{
445 uint64_t qual_type_bit_size = ast_context->getTypeSize(qual_type);
446 if (qual_type_bit_size == bit_size)
447 return true;
448 return false;
449}
450
Greg Clayton462d4142010-09-29 01:12:09 +0000451clang_type_t
Greg Clayton585660c2010-08-05 01:57:25 +0000452ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size)
Chris Lattner24943d22010-06-08 16:52:24 +0000453{
454 ASTContext *ast_context = getASTContext();
455
456 assert (ast_context != NULL);
457
458 return GetBuiltinTypeForEncodingAndBitSize (ast_context, encoding, bit_size);
459}
460
Greg Clayton462d4142010-09-29 01:12:09 +0000461clang_type_t
462ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast_context, Encoding encoding, uint32_t bit_size)
Chris Lattner24943d22010-06-08 16:52:24 +0000463{
464 if (!ast_context)
465 return NULL;
466
467 switch (encoding)
468 {
Greg Clayton585660c2010-08-05 01:57:25 +0000469 case eEncodingInvalid:
Chris Lattner24943d22010-06-08 16:52:24 +0000470 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->VoidPtrTy))
471 return ast_context->VoidPtrTy.getAsOpaquePtr();
472 break;
473
Greg Clayton585660c2010-08-05 01:57:25 +0000474 case eEncodingUint:
Chris Lattner24943d22010-06-08 16:52:24 +0000475 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedCharTy))
476 return ast_context->UnsignedCharTy.getAsOpaquePtr();
477 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedShortTy))
478 return ast_context->UnsignedShortTy.getAsOpaquePtr();
479 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedIntTy))
480 return ast_context->UnsignedIntTy.getAsOpaquePtr();
481 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedLongTy))
482 return ast_context->UnsignedLongTy.getAsOpaquePtr();
483 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedLongLongTy))
484 return ast_context->UnsignedLongLongTy.getAsOpaquePtr();
485 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedInt128Ty))
486 return ast_context->UnsignedInt128Ty.getAsOpaquePtr();
487 break;
488
Greg Clayton585660c2010-08-05 01:57:25 +0000489 case eEncodingSint:
Chris Lattner24943d22010-06-08 16:52:24 +0000490 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->CharTy))
491 return ast_context->CharTy.getAsOpaquePtr();
492 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->ShortTy))
493 return ast_context->ShortTy.getAsOpaquePtr();
494 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->IntTy))
495 return ast_context->IntTy.getAsOpaquePtr();
496 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongTy))
497 return ast_context->LongTy.getAsOpaquePtr();
498 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongLongTy))
499 return ast_context->LongLongTy.getAsOpaquePtr();
500 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->Int128Ty))
501 return ast_context->Int128Ty.getAsOpaquePtr();
502 break;
503
Greg Clayton585660c2010-08-05 01:57:25 +0000504 case eEncodingIEEE754:
Chris Lattner24943d22010-06-08 16:52:24 +0000505 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->FloatTy))
506 return ast_context->FloatTy.getAsOpaquePtr();
507 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->DoubleTy))
508 return ast_context->DoubleTy.getAsOpaquePtr();
509 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongDoubleTy))
510 return ast_context->LongDoubleTy.getAsOpaquePtr();
511 break;
512
Greg Clayton585660c2010-08-05 01:57:25 +0000513 case eEncodingVector:
Chris Lattner24943d22010-06-08 16:52:24 +0000514 default:
515 break;
516 }
517
518 return NULL;
519}
520
Greg Clayton462d4142010-09-29 01:12:09 +0000521clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +0000522ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size)
523{
524 ASTContext *ast_context = getASTContext();
525
526 #define streq(a,b) strcmp(a,b) == 0
527 assert (ast_context != NULL);
528 if (ast_context)
529 {
530 switch (dw_ate)
531 {
532 default:
533 break;
534
535 case DW_ATE_address:
536 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->VoidPtrTy))
537 return ast_context->VoidPtrTy.getAsOpaquePtr();
538 break;
539
540 case DW_ATE_boolean:
541 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->BoolTy))
542 return ast_context->BoolTy.getAsOpaquePtr();
543 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedCharTy))
544 return ast_context->UnsignedCharTy.getAsOpaquePtr();
545 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedShortTy))
546 return ast_context->UnsignedShortTy.getAsOpaquePtr();
547 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedIntTy))
548 return ast_context->UnsignedIntTy.getAsOpaquePtr();
549 break;
550
551 case DW_ATE_complex_float:
552 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->FloatComplexTy))
553 return ast_context->FloatComplexTy.getAsOpaquePtr();
554 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->DoubleComplexTy))
555 return ast_context->DoubleComplexTy.getAsOpaquePtr();
556 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongDoubleComplexTy))
557 return ast_context->LongDoubleComplexTy.getAsOpaquePtr();
558 break;
559
560 case DW_ATE_float:
561 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->FloatTy))
562 return ast_context->FloatTy.getAsOpaquePtr();
563 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->DoubleTy))
564 return ast_context->DoubleTy.getAsOpaquePtr();
565 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongDoubleTy))
566 return ast_context->LongDoubleTy.getAsOpaquePtr();
567 break;
568
569 case DW_ATE_signed:
570 if (type_name)
571 {
Greg Clayton8ff5d552010-11-02 03:48:39 +0000572 if (strstr(type_name, "long long"))
Chris Lattner24943d22010-06-08 16:52:24 +0000573 {
Chris Lattner24943d22010-06-08 16:52:24 +0000574 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongLongTy))
575 return ast_context->LongLongTy.getAsOpaquePtr();
576 }
Greg Clayton8ff5d552010-11-02 03:48:39 +0000577 else if (strstr(type_name, "long"))
578 {
579 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongTy))
580 return ast_context->LongTy.getAsOpaquePtr();
581 }
582 else if (strstr(type_name, "short"))
Chris Lattner24943d22010-06-08 16:52:24 +0000583 {
584 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->ShortTy))
585 return ast_context->ShortTy.getAsOpaquePtr();
586 }
Greg Clayton8ff5d552010-11-02 03:48:39 +0000587 else if (strstr(type_name, "char"))
Chris Lattner24943d22010-06-08 16:52:24 +0000588 {
589 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->CharTy))
590 return ast_context->CharTy.getAsOpaquePtr();
591 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->SignedCharTy))
592 return ast_context->SignedCharTy.getAsOpaquePtr();
593 }
Greg Clayton8ff5d552010-11-02 03:48:39 +0000594 else if (strstr(type_name, "int"))
595 {
596 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->IntTy))
597 return ast_context->IntTy.getAsOpaquePtr();
598 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->Int128Ty))
599 return ast_context->Int128Ty.getAsOpaquePtr();
600 }
601 else if (streq(type_name, "wchar_t"))
Chris Lattner24943d22010-06-08 16:52:24 +0000602 {
603 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->WCharTy))
604 return ast_context->WCharTy.getAsOpaquePtr();
605 }
Chris Lattner24943d22010-06-08 16:52:24 +0000606 }
607 // We weren't able to match up a type name, just search by size
608 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->CharTy))
609 return ast_context->CharTy.getAsOpaquePtr();
610 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->ShortTy))
611 return ast_context->ShortTy.getAsOpaquePtr();
612 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->IntTy))
613 return ast_context->IntTy.getAsOpaquePtr();
614 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongTy))
615 return ast_context->LongTy.getAsOpaquePtr();
616 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->LongLongTy))
617 return ast_context->LongLongTy.getAsOpaquePtr();
618 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->Int128Ty))
619 return ast_context->Int128Ty.getAsOpaquePtr();
620 break;
621
622 case DW_ATE_signed_char:
623 if (type_name)
624 {
625 if (streq(type_name, "signed char"))
626 {
627 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->SignedCharTy))
628 return ast_context->SignedCharTy.getAsOpaquePtr();
629 }
630 }
631 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->CharTy))
632 return ast_context->CharTy.getAsOpaquePtr();
633 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->SignedCharTy))
634 return ast_context->SignedCharTy.getAsOpaquePtr();
635 break;
636
637 case DW_ATE_unsigned:
638 if (type_name)
639 {
Greg Clayton8ff5d552010-11-02 03:48:39 +0000640 if (strstr(type_name, "long long"))
641 {
642 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedLongLongTy))
643 return ast_context->UnsignedLongLongTy.getAsOpaquePtr();
644 }
645 else if (strstr(type_name, "long"))
646 {
647 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedLongTy))
648 return ast_context->UnsignedLongTy.getAsOpaquePtr();
649 }
650 else if (strstr(type_name, "short"))
651 {
652 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedShortTy))
653 return ast_context->UnsignedShortTy.getAsOpaquePtr();
654 }
655 else if (strstr(type_name, "char"))
656 {
657 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedCharTy))
658 return ast_context->UnsignedCharTy.getAsOpaquePtr();
659 }
660 else if (strstr(type_name, "int"))
Chris Lattner24943d22010-06-08 16:52:24 +0000661 {
662 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedIntTy))
663 return ast_context->UnsignedIntTy.getAsOpaquePtr();
664 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedInt128Ty))
665 return ast_context->UnsignedInt128Ty.getAsOpaquePtr();
666 }
Chris Lattner24943d22010-06-08 16:52:24 +0000667 }
668 // We weren't able to match up a type name, just search by size
669 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedCharTy))
670 return ast_context->UnsignedCharTy.getAsOpaquePtr();
671 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedShortTy))
672 return ast_context->UnsignedShortTy.getAsOpaquePtr();
673 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedIntTy))
674 return ast_context->UnsignedIntTy.getAsOpaquePtr();
675 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedLongTy))
676 return ast_context->UnsignedLongTy.getAsOpaquePtr();
677 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedLongLongTy))
678 return ast_context->UnsignedLongLongTy.getAsOpaquePtr();
679 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedInt128Ty))
680 return ast_context->UnsignedInt128Ty.getAsOpaquePtr();
681 break;
682
683 case DW_ATE_unsigned_char:
684 if (QualTypeMatchesBitSize (bit_size, ast_context, ast_context->UnsignedCharTy))
685 return ast_context->UnsignedCharTy.getAsOpaquePtr();
686 break;
687
688 case DW_ATE_imaginary_float:
689 break;
690 }
691 }
692 // This assert should fire for anything that we don't catch above so we know
693 // to fix any issues we run into.
694 assert (!"error: ClangASTContext::GetClangTypeForDWARFEncodingAndSize() contains an unhandled encoding. Fix this ASAP!");
695 return NULL;
696}
697
Greg Clayton462d4142010-09-29 01:12:09 +0000698clang_type_t
699ClangASTContext::GetBuiltInType_void(ASTContext *ast_context)
Chris Lattner24943d22010-06-08 16:52:24 +0000700{
Sean Callanana751f7b2010-09-17 02:24:29 +0000701 return ast_context->VoidTy.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000702}
703
Greg Clayton462d4142010-09-29 01:12:09 +0000704clang_type_t
Sean Callanana91dd992010-11-19 02:52:21 +0000705ClangASTContext::GetBuiltInType_bool()
706{
707 return getASTContext()->BoolTy.getAsOpaquePtr();
708}
709
710clang_type_t
Greg Clayton960d6a42010-08-03 00:35:52 +0000711ClangASTContext::GetBuiltInType_objc_id()
712{
Sean Callananc4217a62010-12-06 23:53:20 +0000713 return getASTContext()->getPointerType(getASTContext()->ObjCBuiltinIdTy).getAsOpaquePtr();
Greg Clayton960d6a42010-08-03 00:35:52 +0000714}
715
Greg Clayton462d4142010-09-29 01:12:09 +0000716clang_type_t
Greg Clayton960d6a42010-08-03 00:35:52 +0000717ClangASTContext::GetBuiltInType_objc_Class()
718{
Sean Callanan04325062010-10-25 00:29:48 +0000719 return getASTContext()->ObjCBuiltinClassTy.getAsOpaquePtr();
Greg Clayton960d6a42010-08-03 00:35:52 +0000720}
721
Greg Clayton462d4142010-09-29 01:12:09 +0000722clang_type_t
Greg Clayton960d6a42010-08-03 00:35:52 +0000723ClangASTContext::GetBuiltInType_objc_selector()
724{
Sean Callananc4217a62010-12-06 23:53:20 +0000725 return getASTContext()->getPointerType(getASTContext()->ObjCBuiltinSelTy).getAsOpaquePtr();
Greg Clayton960d6a42010-08-03 00:35:52 +0000726}
727
Greg Clayton462d4142010-09-29 01:12:09 +0000728clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +0000729ClangASTContext::GetCStringType (bool is_const)
730{
731 QualType char_type(getASTContext()->CharTy);
732
733 if (is_const)
734 char_type.addConst();
735
736 return getASTContext()->getPointerType(char_type).getAsOpaquePtr();
737}
738
Greg Clayton462d4142010-09-29 01:12:09 +0000739clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +0000740ClangASTContext::GetVoidPtrType (bool is_const)
741{
742 return GetVoidPtrType(getASTContext(), is_const);
743}
744
Greg Clayton462d4142010-09-29 01:12:09 +0000745clang_type_t
746ClangASTContext::GetVoidPtrType (ASTContext *ast_context, bool is_const)
Chris Lattner24943d22010-06-08 16:52:24 +0000747{
748 QualType void_ptr_type(ast_context->VoidPtrTy);
749
750 if (is_const)
751 void_ptr_type.addConst();
752
753 return void_ptr_type.getAsOpaquePtr();
754}
755
Greg Clayton462d4142010-09-29 01:12:09 +0000756clang_type_t
Greg Clayton22defe82010-12-02 23:20:03 +0000757ClangASTContext::CopyType (ASTContext *dst_ast,
758 ASTContext *src_ast,
Greg Clayton462d4142010-09-29 01:12:09 +0000759 clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000760{
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000761 FileSystemOptions file_system_options;
Greg Clayton22defe82010-12-02 23:20:03 +0000762 FileManager file_manager (file_system_options);
763 ASTImporter importer(*dst_ast, file_manager,
764 *src_ast, file_manager);
Sean Callanancf18faa2010-11-09 22:37:10 +0000765
Greg Clayton22defe82010-12-02 23:20:03 +0000766 QualType src (QualType::getFromOpaquePtr(clang_type));
767 QualType dst (importer.Import(src));
Sean Callanancf18faa2010-11-09 22:37:10 +0000768
769 return dst.getAsOpaquePtr();
Chris Lattner24943d22010-06-08 16:52:24 +0000770}
771
Greg Clayton6916e352010-11-13 03:52:47 +0000772
773clang::Decl *
Greg Clayton22defe82010-12-02 23:20:03 +0000774ClangASTContext::CopyDecl (ASTContext *dst_ast,
775 ASTContext *src_ast,
Greg Clayton6916e352010-11-13 03:52:47 +0000776 clang::Decl *source_decl)
Sean Callanan887d2512010-12-11 00:08:56 +0000777{
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000778 FileSystemOptions file_system_options;
Greg Clayton22defe82010-12-02 23:20:03 +0000779 FileManager file_manager (file_system_options);
780 ASTImporter importer(*dst_ast, file_manager,
781 *src_ast, file_manager);
Greg Clayton6916e352010-11-13 03:52:47 +0000782
783 return importer.Import(source_decl);
784}
785
Sean Callanan8d825062010-07-16 00:00:27 +0000786bool
Greg Clayton462d4142010-09-29 01:12:09 +0000787ClangASTContext::AreTypesSame(ASTContext *ast_context,
788 clang_type_t type1,
789 clang_type_t type2)
Sean Callanan5510ddd2010-07-15 22:30:52 +0000790{
791 return ast_context->hasSameType(QualType::getFromOpaquePtr(type1),
792 QualType::getFromOpaquePtr(type2));
793}
794
Chris Lattner24943d22010-06-08 16:52:24 +0000795#pragma mark CVR modifiers
796
Greg Clayton462d4142010-09-29 01:12:09 +0000797clang_type_t
798ClangASTContext::AddConstModifier (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000799{
800 if (clang_type)
801 {
802 QualType result(QualType::getFromOpaquePtr(clang_type));
803 result.addConst();
804 return result.getAsOpaquePtr();
805 }
806 return NULL;
807}
808
Greg Clayton462d4142010-09-29 01:12:09 +0000809clang_type_t
810ClangASTContext::AddRestrictModifier (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000811{
812 if (clang_type)
813 {
814 QualType result(QualType::getFromOpaquePtr(clang_type));
815 result.getQualifiers().setRestrict (true);
816 return result.getAsOpaquePtr();
817 }
818 return NULL;
819}
820
Greg Clayton462d4142010-09-29 01:12:09 +0000821clang_type_t
822ClangASTContext::AddVolatileModifier (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +0000823{
824 if (clang_type)
825 {
826 QualType result(QualType::getFromOpaquePtr(clang_type));
827 result.getQualifiers().setVolatile (true);
828 return result.getAsOpaquePtr();
829 }
830 return NULL;
831}
832
833#pragma mark Structure, Unions, Classes
834
Greg Clayton462d4142010-09-29 01:12:09 +0000835clang_type_t
Greg Clayton585660c2010-08-05 01:57:25 +0000836ClangASTContext::CreateRecordType (const char *name, int kind, DeclContext *decl_ctx, LanguageType language)
Chris Lattner24943d22010-06-08 16:52:24 +0000837{
838 ASTContext *ast_context = getASTContext();
839 assert (ast_context != NULL);
Sean Callanan04325062010-10-25 00:29:48 +0000840
Chris Lattner24943d22010-06-08 16:52:24 +0000841 if (decl_ctx == NULL)
842 decl_ctx = ast_context->getTranslationUnitDecl();
843
Greg Clayton9488b742010-07-28 02:04:09 +0000844
Greg Clayton585660c2010-08-05 01:57:25 +0000845 if (language == eLanguageTypeObjC)
Greg Clayton9488b742010-07-28 02:04:09 +0000846 {
Greg Clayton306edca2010-10-11 02:25:34 +0000847 bool isForwardDecl = true;
Greg Clayton9488b742010-07-28 02:04:09 +0000848 bool isInternal = false;
849 return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal);
850 }
851
Chris Lattner24943d22010-06-08 16:52:24 +0000852 // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
853 // we will need to update this code. I was told to currently always use
854 // the CXXRecordDecl class since we often don't know from debug information
855 // if something is struct or a class, so we default to always use the more
856 // complete definition just in case.
857 CXXRecordDecl *decl = CXXRecordDecl::Create(*ast_context,
858 (TagDecl::TagKind)kind,
859 decl_ctx,
860 SourceLocation(),
861 name && name[0] ? &ast_context->Idents.get(name) : NULL);
862
863 return ast_context->getTagDeclType(decl).getAsOpaquePtr();
864}
865
Greg Claytondbf26152010-10-01 23:13:49 +0000866static bool
867IsOperator (const char *name, OverloadedOperatorKind &op_kind)
868{
869 if (name == NULL || name[0] == '\0')
870 return false;
871
Sean Callanan494735d2010-12-10 19:51:54 +0000872#define OPERATOR_PREFIX "operator"
Greg Clayton427f2902010-12-14 02:59:59 +0000873#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
Sean Callananc2c9a142010-12-10 02:15:55 +0000874
875 const char *post_op_name = NULL;
876
Sean Callanan494735d2010-12-10 19:51:54 +0000877 bool no_space = true;
Sean Callananc2c9a142010-12-10 02:15:55 +0000878
Greg Clayton427f2902010-12-14 02:59:59 +0000879 if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
Greg Claytondbf26152010-10-01 23:13:49 +0000880 return false;
881
Greg Clayton427f2902010-12-14 02:59:59 +0000882 post_op_name = name + OPERATOR_PREFIX_LENGTH;
883
Sean Callanan494735d2010-12-10 19:51:54 +0000884 if (post_op_name[0] == ' ')
885 {
886 post_op_name++;
887 no_space = false;
888 }
889
890#undef OPERATOR_PREFIX
Greg Clayton427f2902010-12-14 02:59:59 +0000891#undef OPERATOR_PREFIX_LENGTH
Sean Callanan494735d2010-12-10 19:51:54 +0000892
Greg Claytondbf26152010-10-01 23:13:49 +0000893 // This is an operator, set the overloaded operator kind to invalid
894 // in case this is a conversion operator...
895 op_kind = NUM_OVERLOADED_OPERATORS;
896
897 switch (post_op_name[0])
898 {
Sean Callananc2c9a142010-12-10 02:15:55 +0000899 default:
900 if (no_space)
901 return false;
902 break;
Greg Claytondbf26152010-10-01 23:13:49 +0000903 case 'n':
Sean Callananc2c9a142010-12-10 02:15:55 +0000904 if (no_space)
905 return false;
Greg Claytondbf26152010-10-01 23:13:49 +0000906 if (strcmp (post_op_name, "new") == 0)
907 op_kind = OO_New;
908 else if (strcmp (post_op_name, "new[]") == 0)
909 op_kind = OO_Array_New;
910 break;
911
912 case 'd':
Sean Callananc2c9a142010-12-10 02:15:55 +0000913 if (no_space)
914 return false;
Greg Claytondbf26152010-10-01 23:13:49 +0000915 if (strcmp (post_op_name, "delete") == 0)
916 op_kind = OO_Delete;
917 else if (strcmp (post_op_name, "delete[]") == 0)
918 op_kind = OO_Array_Delete;
919 break;
920
921 case '+':
922 if (post_op_name[1] == '\0')
923 op_kind = OO_Plus;
924 else if (post_op_name[2] == '\0')
925 {
926 if (post_op_name[1] == '=')
927 op_kind = OO_PlusEqual;
928 else if (post_op_name[1] == '+')
929 op_kind = OO_PlusPlus;
930 }
931 break;
932
933 case '-':
934 if (post_op_name[1] == '\0')
935 op_kind = OO_Minus;
936 else if (post_op_name[2] == '\0')
937 {
938 switch (post_op_name[1])
939 {
940 case '=': op_kind = OO_MinusEqual; break;
941 case '-': op_kind = OO_MinusMinus; break;
942 case '>': op_kind = OO_Arrow; break;
943 }
944 }
945 else if (post_op_name[3] == '\0')
946 {
947 if (post_op_name[2] == '*')
948 op_kind = OO_ArrowStar; break;
949 }
950 break;
951
952 case '*':
953 if (post_op_name[1] == '\0')
954 op_kind = OO_Star;
955 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
956 op_kind = OO_StarEqual;
957 break;
958
959 case '/':
960 if (post_op_name[1] == '\0')
961 op_kind = OO_Slash;
962 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
963 op_kind = OO_SlashEqual;
964 break;
965
966 case '%':
967 if (post_op_name[1] == '\0')
968 op_kind = OO_Percent;
969 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
970 op_kind = OO_PercentEqual;
971 break;
972
973
974 case '^':
975 if (post_op_name[1] == '\0')
976 op_kind = OO_Caret;
977 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
978 op_kind = OO_CaretEqual;
979 break;
980
981 case '&':
982 if (post_op_name[1] == '\0')
983 op_kind = OO_Amp;
984 else if (post_op_name[2] == '\0')
985 {
986 switch (post_op_name[1])
987 {
988 case '=': op_kind = OO_AmpEqual; break;
989 case '&': op_kind = OO_AmpAmp; break;
990 }
991 }
992 break;
993
994 case '|':
995 if (post_op_name[1] == '\0')
996 op_kind = OO_Pipe;
997 else if (post_op_name[2] == '\0')
998 {
999 switch (post_op_name[1])
1000 {
1001 case '=': op_kind = OO_PipeEqual; break;
1002 case '|': op_kind = OO_PipePipe; break;
1003 }
1004 }
1005 break;
1006
1007 case '~':
1008 if (post_op_name[1] == '\0')
1009 op_kind = OO_Tilde;
1010 break;
1011
1012 case '!':
1013 if (post_op_name[1] == '\0')
1014 op_kind = OO_Exclaim;
1015 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1016 op_kind = OO_ExclaimEqual;
1017 break;
1018
1019 case '=':
1020 if (post_op_name[1] == '\0')
1021 op_kind = OO_Equal;
1022 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1023 op_kind = OO_EqualEqual;
1024 break;
1025
1026 case '<':
1027 if (post_op_name[1] == '\0')
1028 op_kind = OO_Less;
1029 else if (post_op_name[2] == '\0')
1030 {
1031 switch (post_op_name[1])
1032 {
1033 case '<': op_kind = OO_LessLess; break;
1034 case '=': op_kind = OO_LessEqual; break;
1035 }
1036 }
1037 else if (post_op_name[3] == '\0')
1038 {
1039 if (post_op_name[2] == '=')
1040 op_kind = OO_LessLessEqual;
1041 }
1042 break;
1043
1044 case '>':
1045 if (post_op_name[1] == '\0')
1046 op_kind = OO_Greater;
1047 else if (post_op_name[2] == '\0')
1048 {
1049 switch (post_op_name[1])
1050 {
1051 case '>': op_kind = OO_GreaterGreater; break;
1052 case '=': op_kind = OO_GreaterEqual; break;
1053 }
1054 }
1055 else if (post_op_name[1] == '>' &&
1056 post_op_name[2] == '=' &&
1057 post_op_name[3] == '\0')
1058 {
1059 op_kind = OO_GreaterGreaterEqual;
1060 }
1061 break;
1062
1063 case ',':
1064 if (post_op_name[1] == '\0')
1065 op_kind = OO_Comma;
1066 break;
1067
1068 case '(':
1069 if (post_op_name[1] == ')' && post_op_name[2] == '\0')
1070 op_kind = OO_Call;
1071 break;
1072
1073 case '[':
1074 if (post_op_name[1] == ']' && post_op_name[2] == '\0')
1075 op_kind = OO_Subscript;
1076 break;
1077 }
1078
1079 return true;
1080}
Greg Clayton412440a2010-09-23 01:09:21 +00001081CXXMethodDecl *
Sean Callanan79523002010-09-17 02:58:26 +00001082ClangASTContext::AddMethodToCXXRecordType
1083(
Greg Clayton462d4142010-09-29 01:12:09 +00001084 ASTContext *ast_context,
1085 clang_type_t record_opaque_type,
Greg Clayton412440a2010-09-23 01:09:21 +00001086 const char *name,
Greg Clayton462d4142010-09-29 01:12:09 +00001087 clang_type_t method_opaque_type,
Greg Clayton412440a2010-09-23 01:09:21 +00001088 lldb::AccessType access,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001089 bool is_virtual,
1090 bool is_static,
Greg Clayton30449d52010-10-01 02:31:07 +00001091 bool is_inline,
1092 bool is_explicit
Greg Clayton412440a2010-09-23 01:09:21 +00001093)
Sean Callanan79523002010-09-17 02:58:26 +00001094{
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001095 if (!record_opaque_type || !method_opaque_type || !name)
Johnny Chen974fddb2010-09-28 16:10:54 +00001096 return NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001097
1098 assert(ast_context);
1099
1100 IdentifierTable *identifier_table = &ast_context->Idents;
1101
1102 assert(identifier_table);
1103
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001104 QualType record_qual_type(QualType::getFromOpaquePtr(record_opaque_type));
Greg Clayton1d8173f2010-09-24 05:15:53 +00001105
1106 clang::Type *clang_type(record_qual_type.getTypePtr());
Sean Callanan79523002010-09-17 02:58:26 +00001107
Greg Clayton1d8173f2010-09-24 05:15:53 +00001108 if (clang_type == NULL)
Greg Clayton412440a2010-09-23 01:09:21 +00001109 return NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001110
Greg Clayton1d8173f2010-09-24 05:15:53 +00001111 RecordType *record_clang_type(dyn_cast<RecordType>(clang_type));
Sean Callanan79523002010-09-17 02:58:26 +00001112
Greg Clayton1d8173f2010-09-24 05:15:53 +00001113 if (record_clang_type == NULL)
Greg Clayton412440a2010-09-23 01:09:21 +00001114 return NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001115
Greg Clayton1d8173f2010-09-24 05:15:53 +00001116 RecordDecl *record_decl = record_clang_type->getDecl();
Sean Callanan79523002010-09-17 02:58:26 +00001117
Greg Clayton1d8173f2010-09-24 05:15:53 +00001118 if (record_decl == NULL)
Greg Clayton412440a2010-09-23 01:09:21 +00001119 return NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001120
1121 CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1122
Greg Clayton1d8173f2010-09-24 05:15:53 +00001123 if (cxx_record_decl == NULL)
Greg Clayton412440a2010-09-23 01:09:21 +00001124 return NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001125
Greg Clayton1d8173f2010-09-24 05:15:53 +00001126 QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001127
Greg Clayton30449d52010-10-01 02:31:07 +00001128 CXXMethodDecl *cxx_method_decl = NULL;
Sean Callanan79523002010-09-17 02:58:26 +00001129
Greg Clayton30449d52010-10-01 02:31:07 +00001130 DeclarationName decl_name (&identifier_table->get(name));
Greg Clayton90e325d2010-10-01 03:45:20 +00001131
Greg Clayton90e325d2010-10-01 03:45:20 +00001132 const bool is_implicitly_declared = false;
Greg Clayton30449d52010-10-01 02:31:07 +00001133
Greg Clayton5325a362010-10-02 01:40:05 +00001134 clang::FunctionType *function_Type = dyn_cast<FunctionType>(method_qual_type.getTypePtr());
Greg Clayton90e325d2010-10-01 03:45:20 +00001135
Greg Clayton5325a362010-10-02 01:40:05 +00001136 if (function_Type == NULL)
Greg Clayton90e325d2010-10-01 03:45:20 +00001137 return NULL;
1138
Greg Clayton5325a362010-10-02 01:40:05 +00001139 FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_Type));
Greg Clayton90e325d2010-10-01 03:45:20 +00001140
1141 if (!method_function_prototype)
1142 return NULL;
1143
1144 unsigned int num_params = method_function_prototype->getNumArgs();
1145
1146 if (name[0] == '~')
Greg Clayton30449d52010-10-01 02:31:07 +00001147 {
Greg Clayton90e325d2010-10-01 03:45:20 +00001148 cxx_method_decl = CXXDestructorDecl::Create (*ast_context,
1149 cxx_record_decl,
Greg Clayton5325a362010-10-02 01:40:05 +00001150 DeclarationNameInfo (ast_context->DeclarationNames.getCXXDestructorName (ast_context->getCanonicalType (record_qual_type)), SourceLocation()),
Greg Clayton90e325d2010-10-01 03:45:20 +00001151 method_qual_type,
Sean Callanan8950c9a2010-10-29 18:38:40 +00001152 NULL,
Greg Clayton90e325d2010-10-01 03:45:20 +00001153 is_inline,
1154 is_implicitly_declared);
1155 }
1156 else if (decl_name == record_decl->getDeclName())
1157 {
Greg Clayton30449d52010-10-01 02:31:07 +00001158 cxx_method_decl = CXXConstructorDecl::Create (*ast_context,
1159 cxx_record_decl,
Greg Clayton5325a362010-10-02 01:40:05 +00001160 DeclarationNameInfo (ast_context->DeclarationNames.getCXXConstructorName (ast_context->getCanonicalType (record_qual_type)), SourceLocation()),
Greg Clayton30449d52010-10-01 02:31:07 +00001161 method_qual_type,
1162 NULL, // TypeSourceInfo *
1163 is_explicit,
1164 is_inline,
1165 is_implicitly_declared);
1166 }
1167 else
Greg Clayton90e325d2010-10-01 03:45:20 +00001168 {
Greg Claytondbf26152010-10-01 23:13:49 +00001169
1170 OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS;
1171 if (IsOperator (name, op_kind))
Greg Clayton90e325d2010-10-01 03:45:20 +00001172 {
Greg Claytondbf26152010-10-01 23:13:49 +00001173 if (op_kind != NUM_OVERLOADED_OPERATORS)
1174 {
1175 cxx_method_decl = CXXMethodDecl::Create (*ast_context,
Greg Clayton90e325d2010-10-01 03:45:20 +00001176 cxx_record_decl,
Greg Claytondbf26152010-10-01 23:13:49 +00001177 DeclarationNameInfo (ast_context->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()),
Greg Clayton90e325d2010-10-01 03:45:20 +00001178 method_qual_type,
1179 NULL, // TypeSourceInfo *
Greg Claytondbf26152010-10-01 23:13:49 +00001180 is_static,
1181 SC_None,
1182 is_inline);
1183 }
1184 else if (num_params == 0)
1185 {
1186 // Conversion operators don't take params...
1187 cxx_method_decl = CXXConversionDecl::Create (*ast_context,
1188 cxx_record_decl,
Greg Clayton5325a362010-10-02 01:40:05 +00001189 DeclarationNameInfo (ast_context->DeclarationNames.getCXXConversionFunctionName (ast_context->getCanonicalType (function_Type->getResultType())), SourceLocation()),
Greg Claytondbf26152010-10-01 23:13:49 +00001190 method_qual_type,
1191 NULL, // TypeSourceInfo *
1192 is_inline,
1193 is_explicit);
1194 }
Greg Clayton90e325d2010-10-01 03:45:20 +00001195 }
Greg Claytondbf26152010-10-01 23:13:49 +00001196
1197 if (cxx_method_decl == NULL)
Greg Clayton90e325d2010-10-01 03:45:20 +00001198 {
1199 cxx_method_decl = CXXMethodDecl::Create (*ast_context,
1200 cxx_record_decl,
Greg Claytondbf26152010-10-01 23:13:49 +00001201 DeclarationNameInfo (decl_name, SourceLocation()),
Greg Clayton90e325d2010-10-01 03:45:20 +00001202 method_qual_type,
1203 NULL, // TypeSourceInfo *
1204 is_static,
1205 SC_None,
1206 is_inline);
1207 }
Greg Clayton30449d52010-10-01 02:31:07 +00001208 }
Greg Claytondbf26152010-10-01 23:13:49 +00001209
Greg Clayton462d4142010-09-29 01:12:09 +00001210 AccessSpecifier access_specifier = ConvertAccessTypeToAccessSpecifier (access);
Greg Clayton1d8173f2010-09-24 05:15:53 +00001211
1212 cxx_method_decl->setAccess (access_specifier);
1213 cxx_method_decl->setVirtualAsWritten (is_virtual);
Sean Callanan47a5c4c2010-09-23 03:01:22 +00001214
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001215 // Populate the method decl with parameter decls
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001216
1217 ParmVarDecl *params[num_params];
1218
1219 for (int param_index = 0;
1220 param_index < num_params;
1221 ++param_index)
1222 {
Greg Clayton1d8173f2010-09-24 05:15:53 +00001223 params[param_index] = ParmVarDecl::Create (*ast_context,
1224 cxx_method_decl,
1225 SourceLocation(),
1226 NULL, // anonymous
1227 method_function_prototype->getArgType(param_index),
1228 NULL,
1229 SC_None,
1230 SC_None,
1231 NULL);
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001232 }
1233
Greg Clayton1d8173f2010-09-24 05:15:53 +00001234 cxx_method_decl->setParams (params, num_params);
Sean Callanan3c9c5eb2010-09-21 00:44:12 +00001235
Greg Clayton1d8173f2010-09-24 05:15:53 +00001236 cxx_record_decl->addDecl (cxx_method_decl);
Sean Callanan79523002010-09-17 02:58:26 +00001237
Greg Clayton412440a2010-09-23 01:09:21 +00001238 return cxx_method_decl;
Sean Callanan79523002010-09-17 02:58:26 +00001239}
1240
1241bool
Greg Clayton84f80752010-07-22 18:30:50 +00001242ClangASTContext::AddFieldToRecordType
1243(
Greg Clayton462d4142010-09-29 01:12:09 +00001244 ASTContext *ast_context,
1245 clang_type_t record_clang_type,
Greg Clayton84f80752010-07-22 18:30:50 +00001246 const char *name,
Greg Clayton462d4142010-09-29 01:12:09 +00001247 clang_type_t field_type,
Greg Clayton84f80752010-07-22 18:30:50 +00001248 AccessType access,
1249 uint32_t bitfield_bit_size
1250)
Chris Lattner24943d22010-06-08 16:52:24 +00001251{
1252 if (record_clang_type == NULL || field_type == NULL)
1253 return false;
1254
Sean Callanan60a0ced2010-09-16 20:01:08 +00001255 IdentifierTable *identifier_table = &ast_context->Idents;
Chris Lattner24943d22010-06-08 16:52:24 +00001256
1257 assert (ast_context != NULL);
1258 assert (identifier_table != NULL);
1259
1260 QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type));
1261
Greg Clayton1674b122010-07-21 22:12:05 +00001262 clang::Type *clang_type = record_qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00001263 if (clang_type)
1264 {
1265 const RecordType *record_type = dyn_cast<RecordType>(clang_type);
1266
1267 if (record_type)
1268 {
1269 RecordDecl *record_decl = record_type->getDecl();
1270
Chris Lattner24943d22010-06-08 16:52:24 +00001271 clang::Expr *bit_width = NULL;
1272 if (bitfield_bit_size != 0)
1273 {
1274 APInt bitfield_bit_size_apint(ast_context->getTypeSize(ast_context->IntTy), bitfield_bit_size);
Sean Callanan47a5c4c2010-09-23 03:01:22 +00001275 bit_width = new (*ast_context)IntegerLiteral (*ast_context, bitfield_bit_size_apint, ast_context->IntTy, SourceLocation());
Chris Lattner24943d22010-06-08 16:52:24 +00001276 }
Greg Clayton84f80752010-07-22 18:30:50 +00001277 FieldDecl *field = FieldDecl::Create (*ast_context,
1278 record_decl,
1279 SourceLocation(),
1280 name ? &identifier_table->get(name) : NULL, // Identifier
1281 QualType::getFromOpaquePtr(field_type), // Field type
1282 NULL, // DeclaratorInfo *
1283 bit_width, // BitWidth
1284 false); // Mutable
Chris Lattner24943d22010-06-08 16:52:24 +00001285
Greg Clayton84f80752010-07-22 18:30:50 +00001286 field->setAccess (ConvertAccessTypeToAccessSpecifier (access));
Chris Lattner24943d22010-06-08 16:52:24 +00001287
1288 if (field)
1289 {
1290 record_decl->addDecl(field);
Chris Lattner24943d22010-06-08 16:52:24 +00001291 }
1292 }
Greg Clayton9488b742010-07-28 02:04:09 +00001293 else
1294 {
1295 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(clang_type);
1296 if (objc_class_type)
1297 {
Greg Clayton1d8173f2010-09-24 05:15:53 +00001298 bool is_synthesized = false;
Sean Callanan60a0ced2010-09-16 20:01:08 +00001299 ClangASTContext::AddObjCClassIVar (ast_context,
1300 record_clang_type,
Greg Clayton9488b742010-07-28 02:04:09 +00001301 name,
1302 field_type,
1303 access,
1304 bitfield_bit_size,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001305 is_synthesized);
Greg Clayton9488b742010-07-28 02:04:09 +00001306 }
1307 }
Chris Lattner24943d22010-06-08 16:52:24 +00001308 }
1309 return false;
1310}
1311
1312bool
1313ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size)
1314{
1315 return FieldIsBitfield(getASTContext(), field, bitfield_bit_size);
1316}
1317
1318bool
1319ClangASTContext::FieldIsBitfield
1320(
1321 ASTContext *ast_context,
1322 FieldDecl* field,
1323 uint32_t& bitfield_bit_size
1324)
1325{
1326 if (ast_context == NULL || field == NULL)
1327 return false;
1328
1329 if (field->isBitField())
1330 {
1331 Expr* bit_width_expr = field->getBitWidth();
1332 if (bit_width_expr)
1333 {
1334 llvm::APSInt bit_width_apsint;
1335 if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast_context))
1336 {
1337 bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX);
1338 return true;
1339 }
1340 }
1341 }
1342 return false;
1343}
1344
1345bool
1346ClangASTContext::RecordHasFields (const RecordDecl *record_decl)
1347{
1348 if (record_decl == NULL)
1349 return false;
1350
1351 if (!record_decl->field_empty())
1352 return true;
1353
1354 // No fields, lets check this is a CXX record and check the base classes
1355 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1356 if (cxx_record_decl)
1357 {
1358 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1359 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1360 base_class != base_class_end;
1361 ++base_class)
1362 {
1363 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
1364 if (RecordHasFields(base_class_decl))
1365 return true;
1366 }
1367 }
1368 return false;
1369}
1370
1371void
Greg Clayton462d4142010-09-29 01:12:09 +00001372ClangASTContext::SetDefaultAccessForRecordFields (clang_type_t clang_qual_type, int default_accessibility, int *assigned_accessibilities, size_t num_assigned_accessibilities)
Chris Lattner24943d22010-06-08 16:52:24 +00001373{
1374 if (clang_qual_type)
1375 {
1376 QualType qual_type(QualType::getFromOpaquePtr(clang_qual_type));
Greg Clayton1674b122010-07-21 22:12:05 +00001377 clang::Type *clang_type = qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00001378 if (clang_type)
1379 {
1380 RecordType *record_type = dyn_cast<RecordType>(clang_type);
1381 if (record_type)
1382 {
1383 RecordDecl *record_decl = record_type->getDecl();
1384 if (record_decl)
1385 {
1386 uint32_t field_idx;
1387 RecordDecl::field_iterator field, field_end;
1388 for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0;
1389 field != field_end;
1390 ++field, ++field_idx)
1391 {
1392 // If no accessibility was assigned, assign the correct one
1393 if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none)
1394 field->setAccess ((AccessSpecifier)default_accessibility);
1395 }
1396 }
1397 }
1398 }
1399 }
1400}
1401
1402#pragma mark C++ Base Classes
1403
1404CXXBaseSpecifier *
Greg Clayton462d4142010-09-29 01:12:09 +00001405ClangASTContext::CreateBaseClassSpecifier (clang_type_t base_class_type, AccessType access, bool is_virtual, bool base_of_class)
Chris Lattner24943d22010-06-08 16:52:24 +00001406{
1407 if (base_class_type)
Greg Clayton6e713402010-07-30 20:30:44 +00001408 return new CXXBaseSpecifier (SourceRange(),
1409 is_virtual,
1410 base_of_class,
1411 ConvertAccessTypeToAccessSpecifier (access),
1412 getASTContext()->CreateTypeSourceInfo (QualType::getFromOpaquePtr(base_class_type)));
Chris Lattner24943d22010-06-08 16:52:24 +00001413 return NULL;
1414}
1415
Greg Claytone9d0df42010-07-02 01:29:13 +00001416void
1417ClangASTContext::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes)
1418{
1419 for (unsigned i=0; i<num_base_classes; ++i)
1420 {
1421 delete base_classes[i];
1422 base_classes[i] = NULL;
1423 }
1424}
1425
Chris Lattner24943d22010-06-08 16:52:24 +00001426bool
Greg Clayton462d4142010-09-29 01:12:09 +00001427ClangASTContext::SetBaseClassesForClassType (clang_type_t class_clang_type, CXXBaseSpecifier const * const *base_classes, unsigned num_base_classes)
Chris Lattner24943d22010-06-08 16:52:24 +00001428{
1429 if (class_clang_type)
1430 {
Greg Clayton1674b122010-07-21 22:12:05 +00001431 clang::Type *clang_type = QualType::getFromOpaquePtr(class_clang_type).getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00001432 if (clang_type)
1433 {
1434 RecordType *record_type = dyn_cast<RecordType>(clang_type);
1435 if (record_type)
1436 {
1437 CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_type->getDecl());
1438 if (cxx_record_decl)
1439 {
Chris Lattner24943d22010-06-08 16:52:24 +00001440 cxx_record_decl->setBases(base_classes, num_base_classes);
1441 return true;
1442 }
1443 }
1444 }
1445 }
1446 return false;
1447}
Greg Clayton84f80752010-07-22 18:30:50 +00001448#pragma mark Objective C Classes
Chris Lattner24943d22010-06-08 16:52:24 +00001449
Greg Clayton462d4142010-09-29 01:12:09 +00001450clang_type_t
Greg Clayton84f80752010-07-22 18:30:50 +00001451ClangASTContext::CreateObjCClass
1452(
1453 const char *name,
1454 DeclContext *decl_ctx,
1455 bool isForwardDecl,
1456 bool isInternal
1457)
1458{
1459 ASTContext *ast_context = getASTContext();
1460 assert (ast_context != NULL);
1461 assert (name && name[0]);
1462 if (decl_ctx == NULL)
1463 decl_ctx = ast_context->getTranslationUnitDecl();
1464
1465 // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1466 // we will need to update this code. I was told to currently always use
1467 // the CXXRecordDecl class since we often don't know from debug information
1468 // if something is struct or a class, so we default to always use the more
1469 // complete definition just in case.
1470 ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast_context,
1471 decl_ctx,
1472 SourceLocation(),
1473 &ast_context->Idents.get(name),
1474 SourceLocation(),
1475 isForwardDecl,
1476 isInternal);
Greg Clayton9488b742010-07-28 02:04:09 +00001477
1478 return ast_context->getObjCInterfaceType(decl).getAsOpaquePtr();
Greg Clayton84f80752010-07-22 18:30:50 +00001479}
1480
1481bool
Greg Clayton462d4142010-09-29 01:12:09 +00001482ClangASTContext::SetObjCSuperClass (clang_type_t class_opaque_type, clang_type_t super_opaque_type)
Greg Clayton84f80752010-07-22 18:30:50 +00001483{
1484 if (class_opaque_type && super_opaque_type)
1485 {
1486 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1487 QualType super_qual_type(QualType::getFromOpaquePtr(super_opaque_type));
1488 clang::Type *class_type = class_qual_type.getTypePtr();
1489 clang::Type *super_type = super_qual_type.getTypePtr();
1490 if (class_type && super_type)
1491 {
1492 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1493 ObjCObjectType *objc_super_type = dyn_cast<ObjCObjectType>(super_type);
1494 if (objc_class_type && objc_super_type)
1495 {
1496 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1497 ObjCInterfaceDecl *super_interface_decl = objc_super_type->getInterface();
1498 if (class_interface_decl && super_interface_decl)
1499 {
1500 class_interface_decl->setSuperClass(super_interface_decl);
1501 return true;
1502 }
1503 }
1504 }
1505 }
1506 return false;
1507}
1508
1509
1510bool
1511ClangASTContext::AddObjCClassIVar
1512(
Greg Clayton462d4142010-09-29 01:12:09 +00001513 ASTContext *ast_context,
1514 clang_type_t class_opaque_type,
Greg Clayton84f80752010-07-22 18:30:50 +00001515 const char *name,
Greg Clayton462d4142010-09-29 01:12:09 +00001516 clang_type_t ivar_opaque_type,
Greg Clayton84f80752010-07-22 18:30:50 +00001517 AccessType access,
1518 uint32_t bitfield_bit_size,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001519 bool is_synthesized
Greg Clayton84f80752010-07-22 18:30:50 +00001520)
1521{
1522 if (class_opaque_type == NULL || ivar_opaque_type == NULL)
1523 return false;
1524
Sean Callanan60a0ced2010-09-16 20:01:08 +00001525 IdentifierTable *identifier_table = &ast_context->Idents;
Greg Clayton84f80752010-07-22 18:30:50 +00001526
1527 assert (ast_context != NULL);
1528 assert (identifier_table != NULL);
1529
1530 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1531
1532 clang::Type *class_type = class_qual_type.getTypePtr();
1533 if (class_type)
1534 {
1535 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1536
1537 if (objc_class_type)
1538 {
1539 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1540
1541 if (class_interface_decl)
1542 {
1543 clang::Expr *bit_width = NULL;
1544 if (bitfield_bit_size != 0)
1545 {
1546 APInt bitfield_bit_size_apint(ast_context->getTypeSize(ast_context->IntTy), bitfield_bit_size);
Sean Callanan47a5c4c2010-09-23 03:01:22 +00001547 bit_width = new (*ast_context)IntegerLiteral (*ast_context, bitfield_bit_size_apint, ast_context->IntTy, SourceLocation());
Greg Clayton84f80752010-07-22 18:30:50 +00001548 }
1549
Greg Clayton9488b742010-07-28 02:04:09 +00001550 ObjCIvarDecl *field = ObjCIvarDecl::Create (*ast_context,
1551 class_interface_decl,
1552 SourceLocation(),
1553 &identifier_table->get(name), // Identifier
1554 QualType::getFromOpaquePtr(ivar_opaque_type), // Field type
1555 NULL, // TypeSourceInfo *
1556 ConvertAccessTypeToObjCIvarAccessControl (access),
1557 bit_width,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001558 is_synthesized);
Greg Clayton9488b742010-07-28 02:04:09 +00001559
1560 if (field)
1561 {
1562 class_interface_decl->addDecl(field);
1563 return true;
1564 }
Greg Clayton84f80752010-07-22 18:30:50 +00001565 }
1566 }
1567 }
1568 return false;
1569}
Chris Lattner24943d22010-06-08 16:52:24 +00001570
Greg Clayton9488b742010-07-28 02:04:09 +00001571
1572bool
Greg Clayton462d4142010-09-29 01:12:09 +00001573ClangASTContext::ObjCTypeHasIVars (clang_type_t class_opaque_type, bool check_superclass)
Greg Clayton9488b742010-07-28 02:04:09 +00001574{
1575 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1576
1577 clang::Type *class_type = class_qual_type.getTypePtr();
1578 if (class_type)
1579 {
1580 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1581
1582 if (objc_class_type)
1583 return ObjCDeclHasIVars (objc_class_type->getInterface(), check_superclass);
1584 }
1585 return false;
1586}
1587
1588bool
1589ClangASTContext::ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
1590{
1591 while (class_interface_decl)
1592 {
1593 if (class_interface_decl->ivar_size() > 0)
1594 return true;
1595
1596 if (check_superclass)
1597 class_interface_decl = class_interface_decl->getSuperClass();
1598 else
1599 break;
1600 }
1601 return false;
1602}
Greg Clayton1d8173f2010-09-24 05:15:53 +00001603
Greg Clayton462d4142010-09-29 01:12:09 +00001604ObjCMethodDecl *
Greg Clayton1d8173f2010-09-24 05:15:53 +00001605ClangASTContext::AddMethodToObjCObjectType
1606(
Greg Clayton462d4142010-09-29 01:12:09 +00001607 ASTContext *ast_context,
1608 clang_type_t class_opaque_type,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001609 const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]")
Greg Clayton462d4142010-09-29 01:12:09 +00001610 clang_type_t method_opaque_type,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001611 lldb::AccessType access
1612)
1613{
1614 if (class_opaque_type == NULL || method_opaque_type == NULL)
1615 return NULL;
1616
1617 IdentifierTable *identifier_table = &ast_context->Idents;
1618
1619 assert (ast_context != NULL);
1620 assert (identifier_table != NULL);
1621
1622 QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1623
1624 clang::Type *class_type = class_qual_type.getTypePtr();
1625 if (class_type == NULL)
1626 return NULL;
1627
1628 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1629
1630 if (objc_class_type == NULL)
1631 return NULL;
1632
1633 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1634
1635 if (class_interface_decl == NULL)
1636 return NULL;
Greg Clayton9488b742010-07-28 02:04:09 +00001637
Greg Clayton1d8173f2010-09-24 05:15:53 +00001638 const char *selector_start = ::strchr (name, ' ');
1639 if (selector_start == NULL)
1640 return NULL;
1641
1642 selector_start++;
1643 if (!(::isalpha (selector_start[0]) || selector_start[0] == '_'))
1644 return NULL;
1645 llvm::SmallVector<IdentifierInfo *, 12> selector_idents;
1646
Greg Claytonad60bf42010-10-12 02:24:53 +00001647 size_t len = 0;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001648 const char *start;
Greg Claytonad60bf42010-10-12 02:24:53 +00001649 //printf ("name = '%s'\n", name);
1650
1651 unsigned num_selectors_with_args = 0;
1652 for (start = selector_start;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001653 start && *start != '\0' && *start != ']';
Greg Claytonad60bf42010-10-12 02:24:53 +00001654 start += len)
Greg Clayton1d8173f2010-09-24 05:15:53 +00001655 {
Greg Claytonad60bf42010-10-12 02:24:53 +00001656 len = ::strcspn(start, ":]");
Greg Clayton6bc44a42010-10-27 04:01:14 +00001657 bool has_arg = (start[len] == ':');
1658 if (has_arg)
Greg Claytonad60bf42010-10-12 02:24:53 +00001659 ++num_selectors_with_args;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001660 selector_idents.push_back (&identifier_table->get (StringRef (start, len)));
Greg Clayton6bc44a42010-10-27 04:01:14 +00001661 if (has_arg)
1662 len += 1;
Greg Clayton1d8173f2010-09-24 05:15:53 +00001663 }
1664
1665
1666 if (selector_idents.size() == 0)
1667 return 0;
1668
Greg Claytonad60bf42010-10-12 02:24:53 +00001669 clang::Selector method_selector = ast_context->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
Greg Clayton1d8173f2010-09-24 05:15:53 +00001670 selector_idents.data());
1671
1672 QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
1673
1674 // Populate the method decl with parameter decls
1675 clang::Type *method_type(method_qual_type.getTypePtr());
1676
1677 if (method_type == NULL)
1678 return NULL;
1679
1680 FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type));
1681
1682 if (!method_function_prototype)
1683 return NULL;
1684
1685
1686 bool is_variadic = false;
1687 bool is_synthesized = false;
1688 bool is_defined = false;
1689 ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None;
1690
1691 const unsigned num_args = method_function_prototype->getNumArgs();
1692
1693 ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*ast_context,
1694 SourceLocation(), // beginLoc,
1695 SourceLocation(), // endLoc,
1696 method_selector,
1697 method_function_prototype->getResultType(),
1698 NULL, // TypeSourceInfo *ResultTInfo,
1699 GetDeclContextForType (class_opaque_type),
1700 name[0] == '-',
1701 is_variadic,
1702 is_synthesized,
1703 is_defined,
1704 imp_control,
1705 num_args);
1706
1707
1708 if (objc_method_decl == NULL)
1709 return NULL;
1710
1711 if (num_args > 0)
1712 {
1713 llvm::SmallVector<ParmVarDecl *, 12> params;
1714
1715 for (int param_index = 0; param_index < num_args; ++param_index)
1716 {
1717 params.push_back (ParmVarDecl::Create (*ast_context,
1718 objc_method_decl,
1719 SourceLocation(),
1720 NULL, // anonymous
1721 method_function_prototype->getArgType(param_index),
1722 NULL,
1723 SC_Auto,
1724 SC_Auto,
1725 NULL));
1726 }
1727
1728 objc_method_decl->setMethodParams(*ast_context, params.data(), params.size(), num_args);
1729 }
1730
1731 class_interface_decl->addDecl (objc_method_decl);
1732
1733
1734 return objc_method_decl;
1735}
1736
1737
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001738uint32_t
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001739ClangASTContext::GetTypeInfo
1740(
1741 clang_type_t clang_type,
1742 clang::ASTContext *ast_context,
1743 clang_type_t *pointee_or_element_clang_type
1744)
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001745{
1746 if (clang_type == NULL)
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001747 return 0;
1748
1749 if (pointee_or_element_clang_type)
1750 *pointee_or_element_clang_type = NULL;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001751
1752 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
1753
1754 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1755 switch (type_class)
1756 {
Sean Callanan04325062010-10-25 00:29:48 +00001757 case clang::Type::Builtin:
1758 switch (cast<clang::BuiltinType>(qual_type)->getKind())
1759 {
Sean Callanan04325062010-10-25 00:29:48 +00001760 case clang::BuiltinType::ObjCId:
1761 case clang::BuiltinType::ObjCClass:
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001762 if (ast_context && pointee_or_element_clang_type)
1763 *pointee_or_element_clang_type = ast_context->ObjCBuiltinClassTy.getAsOpaquePtr();
Sean Callanan04325062010-10-25 00:29:48 +00001764 return eTypeIsBuiltIn | eTypeIsPointer | eTypeHasValue;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001765
1766 default:
1767 break;
Sean Callanan04325062010-10-25 00:29:48 +00001768 }
1769 return eTypeIsBuiltIn | eTypeHasValue;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001770
1771 case clang::Type::BlockPointer:
1772 if (pointee_or_element_clang_type)
1773 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
1774 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
1775
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001776 case clang::Type::Complex: return eTypeHasChildren | eTypeIsBuiltIn | eTypeHasValue;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001777
1778 case clang::Type::ConstantArray:
1779 case clang::Type::DependentSizedArray:
1780 case clang::Type::IncompleteArray:
1781 case clang::Type::VariableArray:
1782 if (pointee_or_element_clang_type)
1783 *pointee_or_element_clang_type = cast<ArrayType>(qual_type.getTypePtr())->getElementType().getAsOpaquePtr();
1784 return eTypeHasChildren | eTypeIsArray;
1785
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001786 case clang::Type::DependentName: return 0;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001787 case clang::Type::DependentSizedExtVector: return eTypeHasChildren | eTypeIsVector;
1788 case clang::Type::DependentTemplateSpecialization: return eTypeIsTemplate;
1789 case clang::Type::Decltype: return 0;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001790
1791 case clang::Type::Enum:
1792 if (pointee_or_element_clang_type)
1793 *pointee_or_element_clang_type = cast<EnumType>(qual_type)->getDecl()->getIntegerType().getAsOpaquePtr();
1794 return eTypeIsEnumeration | eTypeHasValue;
1795
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001796 case clang::Type::Elaborated: return 0;
1797 case clang::Type::ExtVector: return eTypeHasChildren | eTypeIsVector;
1798 case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue;
1799 case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001800 case clang::Type::InjectedClassName: return 0;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001801
1802 case clang::Type::LValueReference:
1803 case clang::Type::RValueReference:
1804 if (pointee_or_element_clang_type)
1805 *pointee_or_element_clang_type = cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr();
1806 return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
1807
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001808 case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001809
1810 case clang::Type::ObjCObjectPointer:
1811 if (pointee_or_element_clang_type)
1812 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
1813 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue;
1814
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001815 case clang::Type::ObjCObject: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
1816 case clang::Type::ObjCInterface: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001817
1818 case clang::Type::Pointer:
1819 if (pointee_or_element_clang_type)
1820 *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
1821 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
1822
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001823 case clang::Type::Record:
1824 if (qual_type->getAsCXXRecordDecl())
1825 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
1826 else
1827 return eTypeHasChildren | eTypeIsStructUnion;
1828 break;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001829 case clang::Type::SubstTemplateTypeParm: return eTypeIsTemplate;
1830 case clang::Type::TemplateTypeParm: return eTypeIsTemplate;
1831 case clang::Type::TemplateSpecialization: return eTypeIsTemplate;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001832
1833 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00001834 return eTypeIsTypedef | ClangASTContext::GetTypeInfo (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001835 ast_context,
1836 pointee_or_element_clang_type);
1837
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001838 case clang::Type::TypeOfExpr: return 0;
1839 case clang::Type::TypeOf: return 0;
1840 case clang::Type::UnresolvedUsing: return 0;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00001841 case clang::Type::Vector: return eTypeHasChildren | eTypeIsVector;
1842 default: return 0;
1843 }
1844 return 0;
1845}
1846
Greg Clayton9488b742010-07-28 02:04:09 +00001847
Chris Lattner24943d22010-06-08 16:52:24 +00001848#pragma mark Aggregate Types
1849
1850bool
Greg Clayton462d4142010-09-29 01:12:09 +00001851ClangASTContext::IsAggregateType (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00001852{
1853 if (clang_type == NULL)
1854 return false;
1855
1856 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
1857
Greg Clayton03e0f972010-09-13 03:32:57 +00001858 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1859 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00001860 {
Greg Clayton1674b122010-07-21 22:12:05 +00001861 case clang::Type::IncompleteArray:
1862 case clang::Type::VariableArray:
1863 case clang::Type::ConstantArray:
1864 case clang::Type::ExtVector:
1865 case clang::Type::Vector:
1866 case clang::Type::Record:
Greg Clayton9488b742010-07-28 02:04:09 +00001867 case clang::Type::ObjCObject:
1868 case clang::Type::ObjCInterface:
Chris Lattner24943d22010-06-08 16:52:24 +00001869 return true;
1870
Greg Clayton1674b122010-07-21 22:12:05 +00001871 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00001872 return ClangASTContext::IsAggregateType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
Chris Lattner24943d22010-06-08 16:52:24 +00001873
1874 default:
1875 break;
1876 }
1877 // The clang type does have a value
1878 return false;
1879}
1880
1881uint32_t
Greg Clayton462d4142010-09-29 01:12:09 +00001882ClangASTContext::GetNumChildren (clang_type_t clang_qual_type, bool omit_empty_base_classes)
Chris Lattner24943d22010-06-08 16:52:24 +00001883{
1884 if (clang_qual_type == NULL)
1885 return 0;
1886
1887 uint32_t num_children = 0;
1888 QualType qual_type(QualType::getFromOpaquePtr(clang_qual_type));
Greg Clayton9488b742010-07-28 02:04:09 +00001889 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1890 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00001891 {
Greg Clayton960d6a42010-08-03 00:35:52 +00001892 case clang::Type::Builtin:
1893 switch (cast<clang::BuiltinType>(qual_type)->getKind())
1894 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001895 case clang::BuiltinType::ObjCId: // child is Class
Greg Clayton960d6a42010-08-03 00:35:52 +00001896 case clang::BuiltinType::ObjCClass: // child is Class
Greg Clayton960d6a42010-08-03 00:35:52 +00001897 num_children = 1;
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00001898 break;
Greg Clayton960d6a42010-08-03 00:35:52 +00001899
1900 default:
1901 break;
1902 }
1903 break;
Greg Claytonc3b61d22010-12-15 05:08:08 +00001904
1905 case clang::Type::Complex:
1906 return 2;
1907
Greg Clayton1674b122010-07-21 22:12:05 +00001908 case clang::Type::Record:
Greg Clayton53d287b2010-11-11 02:14:53 +00001909 if (ClangASTType::IsDefined (clang_qual_type))
Chris Lattner24943d22010-06-08 16:52:24 +00001910 {
1911 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
1912 const RecordDecl *record_decl = record_type->getDecl();
1913 assert(record_decl);
1914 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1915 if (cxx_record_decl)
1916 {
1917 if (omit_empty_base_classes)
1918 {
1919 // Check each base classes to see if it or any of its
1920 // base classes contain any fields. This can help
1921 // limit the noise in variable views by not having to
1922 // show base classes that contain no members.
1923 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1924 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1925 base_class != base_class_end;
1926 ++base_class)
1927 {
1928 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
1929
1930 // Skip empty base classes
1931 if (RecordHasFields(base_class_decl) == false)
1932 continue;
1933
1934 num_children++;
1935 }
1936 }
1937 else
1938 {
1939 // Include all base classes
1940 num_children += cxx_record_decl->getNumBases();
1941 }
1942
1943 }
1944 RecordDecl::field_iterator field, field_end;
1945 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
1946 ++num_children;
1947 }
1948 break;
1949
Greg Clayton9488b742010-07-28 02:04:09 +00001950 case clang::Type::ObjCObject:
1951 case clang::Type::ObjCInterface:
1952 {
1953 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
1954 assert (objc_class_type);
1955 if (objc_class_type)
1956 {
1957 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1958
1959 if (class_interface_decl)
1960 {
1961
1962 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
1963 if (superclass_interface_decl)
1964 {
1965 if (omit_empty_base_classes)
1966 {
1967 if (ClangASTContext::ObjCDeclHasIVars (superclass_interface_decl, true))
1968 ++num_children;
1969 }
1970 else
1971 ++num_children;
1972 }
1973
1974 num_children += class_interface_decl->ivar_size();
1975 }
1976 }
1977 }
1978 break;
1979
1980 case clang::Type::ObjCObjectPointer:
Greg Clayton960d6a42010-08-03 00:35:52 +00001981 {
1982 ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr());
1983 QualType pointee_type = pointer_type->getPointeeType();
1984 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (pointee_type.getAsOpaquePtr(),
1985 omit_empty_base_classes);
1986 // If this type points to a simple type, then it has 1 child
1987 if (num_pointee_children == 0)
1988 num_children = 1;
1989 else
1990 num_children = num_pointee_children;
1991 }
1992 break;
Greg Clayton9488b742010-07-28 02:04:09 +00001993
Greg Clayton1674b122010-07-21 22:12:05 +00001994 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00001995 num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
1996 break;
1997
Greg Clayton1674b122010-07-21 22:12:05 +00001998 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00001999 {
2000 PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
Greg Claytonc3b61d22010-12-15 05:08:08 +00002001 QualType pointee_type (pointer_type->getPointeeType());
Greg Clayton9488b742010-07-28 02:04:09 +00002002 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (pointee_type.getAsOpaquePtr(),
2003 omit_empty_base_classes);
Chris Lattner24943d22010-06-08 16:52:24 +00002004 if (num_pointee_children == 0)
Greg Claytonc3b61d22010-12-15 05:08:08 +00002005 {
2006 // We have a pointer to a pointee type that claims it has no children.
2007 // We will want to look at
2008 num_children = ClangASTContext::GetNumPointeeChildren (pointee_type.getAsOpaquePtr());
2009 }
Chris Lattner24943d22010-06-08 16:52:24 +00002010 else
2011 num_children = num_pointee_children;
2012 }
2013 break;
2014
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002015 case clang::Type::LValueReference:
2016 case clang::Type::RValueReference:
2017 {
2018 ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
2019 QualType pointee_type = reference_type->getPointeeType();
2020 uint32_t num_pointee_children = ClangASTContext::GetNumChildren (pointee_type.getAsOpaquePtr(),
2021 omit_empty_base_classes);
2022 // If this type points to a simple type, then it has 1 child
2023 if (num_pointee_children == 0)
2024 num_children = 1;
2025 else
2026 num_children = num_pointee_children;
2027 }
2028 break;
2029
2030
Greg Clayton1674b122010-07-21 22:12:05 +00002031 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00002032 num_children = ClangASTContext::GetNumChildren (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), omit_empty_base_classes);
Chris Lattner24943d22010-06-08 16:52:24 +00002033 break;
2034
2035 default:
2036 break;
2037 }
2038 return num_children;
2039}
2040
Greg Claytonc3b61d22010-12-15 05:08:08 +00002041// If a pointer to a pointee type (the clang_type arg) says that it has no
2042// children, then we either need to trust it, or override it and return a
2043// different result. For example, an "int *" has one child that is an integer,
2044// but a function pointer doesn't have any children. Likewise if a Record type
2045// claims it has no children, then there really is nothing to show.
2046uint32_t
2047ClangASTContext::GetNumPointeeChildren (clang_type_t clang_type)
2048{
2049 if (clang_type == NULL)
2050 return 0;
2051
2052 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
2053 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2054 switch (type_class)
2055 {
Greg Clayton9db023b2011-01-08 22:26:47 +00002056 case clang::Type::Builtin:
2057 switch (cast<clang::BuiltinType>(qual_type)->getKind())
2058 {
2059 case clang::BuiltinType::Void:
2060 case clang::BuiltinType::NullPtr:
2061 return 0;
2062 case clang::BuiltinType::Bool:
2063 case clang::BuiltinType::Char_U:
2064 case clang::BuiltinType::UChar:
2065 case clang::BuiltinType::Char16:
2066 case clang::BuiltinType::Char32:
2067 case clang::BuiltinType::UShort:
2068 case clang::BuiltinType::UInt:
2069 case clang::BuiltinType::ULong:
2070 case clang::BuiltinType::ULongLong:
2071 case clang::BuiltinType::UInt128:
2072 case clang::BuiltinType::Char_S:
2073 case clang::BuiltinType::SChar:
2074 case clang::BuiltinType::WChar:
2075 case clang::BuiltinType::Short:
2076 case clang::BuiltinType::Int:
2077 case clang::BuiltinType::Long:
2078 case clang::BuiltinType::LongLong:
2079 case clang::BuiltinType::Int128:
2080 case clang::BuiltinType::Float:
2081 case clang::BuiltinType::Double:
2082 case clang::BuiltinType::LongDouble:
2083 case clang::BuiltinType::Dependent:
2084 case clang::BuiltinType::Overload:
2085 case clang::BuiltinType::UndeducedAuto:
2086 case clang::BuiltinType::ObjCId:
2087 case clang::BuiltinType::ObjCClass:
2088 case clang::BuiltinType::ObjCSel:
2089 return 1;
2090 }
2091 break;
2092
Greg Claytonc3b61d22010-12-15 05:08:08 +00002093 case clang::Type::Complex: return 2;
2094 case clang::Type::Pointer: return 1;
2095 case clang::Type::BlockPointer: return 0; // If block pointers don't have debug info, then no children for them
2096 case clang::Type::LValueReference: return 1;
2097 case clang::Type::RValueReference: return 1;
2098 case clang::Type::MemberPointer: return 0;
2099 case clang::Type::ConstantArray: return 0;
2100 case clang::Type::IncompleteArray: return 0;
2101 case clang::Type::VariableArray: return 0;
2102 case clang::Type::DependentSizedArray: return 0;
2103 case clang::Type::DependentSizedExtVector: return 0;
2104 case clang::Type::Vector: return 0;
2105 case clang::Type::ExtVector: return 0;
2106 case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children...
2107 case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children...
2108 case clang::Type::UnresolvedUsing: return 0;
2109 case clang::Type::Paren: return 0;
2110 case clang::Type::Typedef: return ClangASTContext::GetNumPointeeChildren (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
2111 case clang::Type::TypeOfExpr: return 0;
2112 case clang::Type::TypeOf: return 0;
2113 case clang::Type::Decltype: return 0;
2114 case clang::Type::Record: return 0;
2115 case clang::Type::Enum: return 1;
2116 case clang::Type::Elaborated: return 1;
2117 case clang::Type::TemplateTypeParm: return 1;
2118 case clang::Type::SubstTemplateTypeParm: return 1;
2119 case clang::Type::TemplateSpecialization: return 1;
2120 case clang::Type::InjectedClassName: return 0;
2121 case clang::Type::DependentName: return 1;
2122 case clang::Type::DependentTemplateSpecialization: return 1;
2123 case clang::Type::ObjCObject: return 0;
2124 case clang::Type::ObjCInterface: return 0;
2125 case clang::Type::ObjCObjectPointer: return 1;
2126 default:
2127 break;
2128 }
2129 return 0;
2130}
Chris Lattner24943d22010-06-08 16:52:24 +00002131
Greg Clayton462d4142010-09-29 01:12:09 +00002132clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +00002133ClangASTContext::GetChildClangTypeAtIndex
2134(
2135 const char *parent_name,
Greg Clayton462d4142010-09-29 01:12:09 +00002136 clang_type_t parent_clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00002137 uint32_t idx,
2138 bool transparent_pointers,
2139 bool omit_empty_base_classes,
2140 std::string& child_name,
2141 uint32_t &child_byte_size,
2142 int32_t &child_byte_offset,
2143 uint32_t &child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002144 uint32_t &child_bitfield_bit_offset,
2145 bool &child_is_base_class
Chris Lattner24943d22010-06-08 16:52:24 +00002146)
2147{
2148 if (parent_clang_type)
2149
2150 return GetChildClangTypeAtIndex (getASTContext(),
2151 parent_name,
2152 parent_clang_type,
2153 idx,
2154 transparent_pointers,
2155 omit_empty_base_classes,
2156 child_name,
2157 child_byte_size,
2158 child_byte_offset,
2159 child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002160 child_bitfield_bit_offset,
2161 child_is_base_class);
Chris Lattner24943d22010-06-08 16:52:24 +00002162 return NULL;
2163}
2164
Greg Clayton462d4142010-09-29 01:12:09 +00002165clang_type_t
Chris Lattner24943d22010-06-08 16:52:24 +00002166ClangASTContext::GetChildClangTypeAtIndex
2167(
2168 ASTContext *ast_context,
2169 const char *parent_name,
Greg Clayton462d4142010-09-29 01:12:09 +00002170 clang_type_t parent_clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00002171 uint32_t idx,
2172 bool transparent_pointers,
2173 bool omit_empty_base_classes,
2174 std::string& child_name,
2175 uint32_t &child_byte_size,
2176 int32_t &child_byte_offset,
2177 uint32_t &child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002178 uint32_t &child_bitfield_bit_offset,
2179 bool &child_is_base_class
Chris Lattner24943d22010-06-08 16:52:24 +00002180)
2181{
2182 if (parent_clang_type == NULL)
2183 return NULL;
2184
2185 if (idx < ClangASTContext::GetNumChildren (parent_clang_type, omit_empty_base_classes))
2186 {
2187 uint32_t bit_offset;
2188 child_bitfield_bit_size = 0;
2189 child_bitfield_bit_offset = 0;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002190 child_is_base_class = false;
Chris Lattner24943d22010-06-08 16:52:24 +00002191 QualType parent_qual_type(QualType::getFromOpaquePtr(parent_clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00002192 const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass();
2193 switch (parent_type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00002194 {
Greg Clayton960d6a42010-08-03 00:35:52 +00002195 case clang::Type::Builtin:
2196 switch (cast<clang::BuiltinType>(parent_qual_type)->getKind())
2197 {
2198 case clang::BuiltinType::ObjCId:
2199 case clang::BuiltinType::ObjCClass:
Sean Callanan04325062010-10-25 00:29:48 +00002200 child_name = "isa";
2201 child_byte_size = ast_context->getTypeSize(ast_context->ObjCBuiltinClassTy) / CHAR_BIT;
Greg Clayton960d6a42010-08-03 00:35:52 +00002202 return ast_context->ObjCBuiltinClassTy.getAsOpaquePtr();
2203
Greg Clayton960d6a42010-08-03 00:35:52 +00002204 default:
2205 break;
2206 }
2207 break;
2208
2209
Greg Clayton1674b122010-07-21 22:12:05 +00002210 case clang::Type::Record:
Chris Lattner24943d22010-06-08 16:52:24 +00002211 {
2212 const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr());
2213 const RecordDecl *record_decl = record_type->getDecl();
2214 assert(record_decl);
2215 const ASTRecordLayout &record_layout = ast_context->getASTRecordLayout(record_decl);
2216 uint32_t child_idx = 0;
2217
2218 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2219 if (cxx_record_decl)
2220 {
2221 // We might have base classes to print out first
2222 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2223 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2224 base_class != base_class_end;
2225 ++base_class)
2226 {
2227 const CXXRecordDecl *base_class_decl = NULL;
2228
2229 // Skip empty base classes
2230 if (omit_empty_base_classes)
2231 {
2232 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2233 if (RecordHasFields(base_class_decl) == false)
2234 continue;
2235 }
2236
2237 if (idx == child_idx)
2238 {
2239 if (base_class_decl == NULL)
2240 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2241
2242
2243 if (base_class->isVirtual())
Sean Callanan8a3b0a82010-11-18 02:56:27 +00002244 bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity();
Chris Lattner24943d22010-06-08 16:52:24 +00002245 else
Sean Callanan8a3b0a82010-11-18 02:56:27 +00002246 bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity();
Chris Lattner24943d22010-06-08 16:52:24 +00002247
2248 // Base classes should be a multiple of 8 bits in size
2249 assert (bit_offset % 8 == 0);
2250 child_byte_offset = bit_offset/8;
2251 std::string base_class_type_name(base_class->getType().getAsString());
2252
2253 child_name.assign(base_class_type_name.c_str());
2254
2255 uint64_t clang_type_info_bit_size = ast_context->getTypeSize(base_class->getType());
2256
2257 // Base classes biut sizes should be a multiple of 8 bits in size
2258 assert (clang_type_info_bit_size % 8 == 0);
2259 child_byte_size = clang_type_info_bit_size / 8;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002260 child_is_base_class = true;
Chris Lattner24943d22010-06-08 16:52:24 +00002261 return base_class->getType().getAsOpaquePtr();
2262 }
2263 // We don't increment the child index in the for loop since we might
2264 // be skipping empty base classes
2265 ++child_idx;
2266 }
2267 }
Chris Lattner24943d22010-06-08 16:52:24 +00002268 // Make sure index is in range...
2269 uint32_t field_idx = 0;
2270 RecordDecl::field_iterator field, field_end;
2271 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
2272 {
2273 if (idx == child_idx)
2274 {
2275 // Print the member type if requested
2276 // Print the member name and equal sign
2277 child_name.assign(field->getNameAsString().c_str());
2278
2279 // Figure out the type byte size (field_type_info.first) and
2280 // alignment (field_type_info.second) from the AST context.
2281 std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(field->getType());
Greg Clayton54e7afa2010-07-09 20:39:50 +00002282 assert(field_idx < record_layout.getFieldCount());
Chris Lattner24943d22010-06-08 16:52:24 +00002283
2284 child_byte_size = field_type_info.first / 8;
2285
2286 // Figure out the field offset within the current struct/union/class type
2287 bit_offset = record_layout.getFieldOffset (field_idx);
2288 child_byte_offset = bit_offset / 8;
2289 if (ClangASTContext::FieldIsBitfield (ast_context, *field, child_bitfield_bit_size))
2290 child_bitfield_bit_offset = bit_offset % 8;
2291
2292 return field->getType().getAsOpaquePtr();
2293 }
2294 }
2295 }
2296 break;
2297
Greg Clayton9488b742010-07-28 02:04:09 +00002298 case clang::Type::ObjCObject:
2299 case clang::Type::ObjCInterface:
2300 {
2301 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr());
2302 assert (objc_class_type);
2303 if (objc_class_type)
2304 {
2305 uint32_t child_idx = 0;
2306 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2307
2308 if (class_interface_decl)
2309 {
2310
2311 const ASTRecordLayout &interface_layout = ast_context->getASTObjCInterfaceLayout(class_interface_decl);
2312 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2313 if (superclass_interface_decl)
2314 {
2315 if (omit_empty_base_classes)
2316 {
Greg Clayton960d6a42010-08-03 00:35:52 +00002317 if (ClangASTContext::GetNumChildren(ast_context->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(), omit_empty_base_classes) > 0)
Greg Clayton9488b742010-07-28 02:04:09 +00002318 {
2319 if (idx == 0)
2320 {
2321 QualType ivar_qual_type(ast_context->getObjCInterfaceType(superclass_interface_decl));
2322
2323
2324 child_name.assign(superclass_interface_decl->getNameAsString().c_str());
2325
2326 std::pair<uint64_t, unsigned> ivar_type_info = ast_context->getTypeInfo(ivar_qual_type.getTypePtr());
2327
2328 child_byte_size = ivar_type_info.first / 8;
Greg Clayton960d6a42010-08-03 00:35:52 +00002329 child_byte_offset = 0;
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002330 child_is_base_class = true;
Greg Clayton9488b742010-07-28 02:04:09 +00002331
2332 return ivar_qual_type.getAsOpaquePtr();
2333 }
2334
2335 ++child_idx;
2336 }
2337 }
2338 else
2339 ++child_idx;
2340 }
Greg Clayton960d6a42010-08-03 00:35:52 +00002341
2342 const uint32_t superclass_idx = child_idx;
Greg Clayton9488b742010-07-28 02:04:09 +00002343
2344 if (idx < (child_idx + class_interface_decl->ivar_size()))
2345 {
2346 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
2347
2348 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
2349 {
2350 if (child_idx == idx)
2351 {
2352 const ObjCIvarDecl* ivar_decl = *ivar_pos;
2353
2354 QualType ivar_qual_type(ivar_decl->getType());
2355
2356 child_name.assign(ivar_decl->getNameAsString().c_str());
2357
2358 std::pair<uint64_t, unsigned> ivar_type_info = ast_context->getTypeInfo(ivar_qual_type.getTypePtr());
2359
2360 child_byte_size = ivar_type_info.first / 8;
2361
2362 // Figure out the field offset within the current struct/union/class type
Greg Clayton960d6a42010-08-03 00:35:52 +00002363 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
Greg Clayton9488b742010-07-28 02:04:09 +00002364 child_byte_offset = bit_offset / 8;
2365
2366 return ivar_qual_type.getAsOpaquePtr();
2367 }
2368 ++child_idx;
2369 }
2370 }
2371 }
2372 }
2373 }
2374 break;
2375
2376 case clang::Type::ObjCObjectPointer:
2377 {
Greg Clayton960d6a42010-08-03 00:35:52 +00002378 ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(parent_qual_type.getTypePtr());
2379 QualType pointee_type = pointer_type->getPointeeType();
2380
2381 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2382 {
2383 return GetChildClangTypeAtIndex (ast_context,
2384 parent_name,
2385 pointer_type->getPointeeType().getAsOpaquePtr(),
2386 idx,
2387 transparent_pointers,
2388 omit_empty_base_classes,
2389 child_name,
2390 child_byte_size,
2391 child_byte_offset,
2392 child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002393 child_bitfield_bit_offset,
2394 child_is_base_class);
Greg Clayton960d6a42010-08-03 00:35:52 +00002395 }
2396 else
2397 {
2398 if (parent_name)
2399 {
2400 child_name.assign(1, '*');
2401 child_name += parent_name;
2402 }
2403
2404 // We have a pointer to an simple type
2405 if (idx == 0)
2406 {
2407 std::pair<uint64_t, unsigned> clang_type_info = ast_context->getTypeInfo(pointee_type);
2408 assert(clang_type_info.first % 8 == 0);
2409 child_byte_size = clang_type_info.first / 8;
2410 child_byte_offset = 0;
2411 return pointee_type.getAsOpaquePtr();
2412 }
2413 }
Greg Clayton9488b742010-07-28 02:04:09 +00002414 }
2415 break;
2416
Greg Clayton1674b122010-07-21 22:12:05 +00002417 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00002418 {
2419 const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
2420 const uint64_t element_count = array->getSize().getLimitedValue();
2421
2422 if (idx < element_count)
2423 {
2424 std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(array->getElementType());
2425
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002426 char element_name[64];
2427 ::snprintf (element_name, sizeof (element_name), "[%u]", idx);
Chris Lattner24943d22010-06-08 16:52:24 +00002428
2429 child_name.assign(element_name);
2430 assert(field_type_info.first % 8 == 0);
2431 child_byte_size = field_type_info.first / 8;
2432 child_byte_offset = idx * child_byte_size;
2433 return array->getElementType().getAsOpaquePtr();
2434 }
2435 }
2436 break;
2437
Greg Clayton1674b122010-07-21 22:12:05 +00002438 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00002439 {
2440 PointerType *pointer_type = cast<PointerType>(parent_qual_type.getTypePtr());
2441 QualType pointee_type = pointer_type->getPointeeType();
Greg Clayton9db023b2011-01-08 22:26:47 +00002442
2443 // Don't dereference "void *" pointers
2444 if (pointee_type->isVoidType())
2445 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002446
2447 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2448 {
2449 return GetChildClangTypeAtIndex (ast_context,
2450 parent_name,
2451 pointer_type->getPointeeType().getAsOpaquePtr(),
2452 idx,
2453 transparent_pointers,
2454 omit_empty_base_classes,
2455 child_name,
2456 child_byte_size,
2457 child_byte_offset,
2458 child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002459 child_bitfield_bit_offset,
2460 child_is_base_class);
Chris Lattner24943d22010-06-08 16:52:24 +00002461 }
2462 else
2463 {
2464 if (parent_name)
2465 {
2466 child_name.assign(1, '*');
2467 child_name += parent_name;
2468 }
2469
2470 // We have a pointer to an simple type
2471 if (idx == 0)
2472 {
2473 std::pair<uint64_t, unsigned> clang_type_info = ast_context->getTypeInfo(pointee_type);
2474 assert(clang_type_info.first % 8 == 0);
2475 child_byte_size = clang_type_info.first / 8;
2476 child_byte_offset = 0;
2477 return pointee_type.getAsOpaquePtr();
2478 }
2479 }
2480 }
2481 break;
2482
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00002483 case clang::Type::LValueReference:
2484 case clang::Type::RValueReference:
2485 {
2486 ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr());
2487 QualType pointee_type(reference_type->getPointeeType());
2488 clang_type_t pointee_clang_type = pointee_type.getAsOpaquePtr();
2489 if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_clang_type))
2490 {
2491 return GetChildClangTypeAtIndex (ast_context,
2492 parent_name,
2493 pointee_clang_type,
2494 idx,
2495 transparent_pointers,
2496 omit_empty_base_classes,
2497 child_name,
2498 child_byte_size,
2499 child_byte_offset,
2500 child_bitfield_bit_size,
2501 child_bitfield_bit_offset,
2502 child_is_base_class);
2503 }
2504 else
2505 {
2506 if (parent_name)
2507 {
2508 child_name.assign(1, '&');
2509 child_name += parent_name;
2510 }
2511
2512 // We have a pointer to an simple type
2513 if (idx == 0)
2514 {
2515 std::pair<uint64_t, unsigned> clang_type_info = ast_context->getTypeInfo(pointee_type);
2516 assert(clang_type_info.first % 8 == 0);
2517 child_byte_size = clang_type_info.first / 8;
2518 child_byte_offset = 0;
2519 return pointee_type.getAsOpaquePtr();
2520 }
2521 }
2522 }
2523 break;
2524
Greg Clayton1674b122010-07-21 22:12:05 +00002525 case clang::Type::Typedef:
Chris Lattner24943d22010-06-08 16:52:24 +00002526 return GetChildClangTypeAtIndex (ast_context,
2527 parent_name,
Sean Callanan9e7958e2010-12-13 01:26:27 +00002528 cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
Chris Lattner24943d22010-06-08 16:52:24 +00002529 idx,
2530 transparent_pointers,
2531 omit_empty_base_classes,
2532 child_name,
2533 child_byte_size,
2534 child_byte_offset,
2535 child_bitfield_bit_size,
Greg Claytonbf8e42b2010-10-14 22:52:14 +00002536 child_bitfield_bit_offset,
2537 child_is_base_class);
Chris Lattner24943d22010-06-08 16:52:24 +00002538 break;
2539
2540 default:
2541 break;
2542 }
2543 }
Greg Claytonf8e98a62010-07-23 15:37:46 +00002544 return NULL;
Chris Lattner24943d22010-06-08 16:52:24 +00002545}
2546
2547static inline bool
2548BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
2549{
2550 return ClangASTContext::RecordHasFields(cast<CXXRecordDecl>(b->getType()->getAs<RecordType>()->getDecl())) == false;
2551}
2552
2553static uint32_t
2554GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes)
2555{
2556 uint32_t num_bases = 0;
2557 if (cxx_record_decl)
2558 {
2559 if (omit_empty_base_classes)
2560 {
2561 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2562 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2563 base_class != base_class_end;
2564 ++base_class)
2565 {
2566 // Skip empty base classes
2567 if (omit_empty_base_classes)
2568 {
2569 if (BaseSpecifierIsEmpty (base_class))
2570 continue;
2571 }
2572 ++num_bases;
2573 }
2574 }
2575 else
2576 num_bases = cxx_record_decl->getNumBases();
2577 }
2578 return num_bases;
2579}
2580
2581
2582static uint32_t
2583GetIndexForRecordBase
2584(
2585 const RecordDecl *record_decl,
2586 const CXXBaseSpecifier *base_spec,
2587 bool omit_empty_base_classes
2588)
2589{
2590 uint32_t child_idx = 0;
2591
2592 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2593
2594// const char *super_name = record_decl->getNameAsCString();
2595// const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString();
2596// printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
2597//
2598 if (cxx_record_decl)
2599 {
2600 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2601 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2602 base_class != base_class_end;
2603 ++base_class)
2604 {
2605 if (omit_empty_base_classes)
2606 {
2607 if (BaseSpecifierIsEmpty (base_class))
2608 continue;
2609 }
2610
2611// printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name,
2612// child_idx,
2613// base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
2614//
2615//
2616 if (base_class == base_spec)
2617 return child_idx;
2618 ++child_idx;
2619 }
2620 }
2621
2622 return UINT32_MAX;
2623}
2624
2625
2626static uint32_t
2627GetIndexForRecordChild
2628(
2629 const RecordDecl *record_decl,
2630 NamedDecl *canonical_decl,
2631 bool omit_empty_base_classes
2632)
2633{
2634 uint32_t child_idx = GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl), omit_empty_base_classes);
2635
2636// const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2637//
2638//// printf ("GetIndexForRecordChild (%s, %s)\n", record_decl->getNameAsCString(), canonical_decl->getNameAsCString());
2639// if (cxx_record_decl)
2640// {
2641// CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2642// for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2643// base_class != base_class_end;
2644// ++base_class)
2645// {
2646// if (omit_empty_base_classes)
2647// {
2648// if (BaseSpecifierIsEmpty (base_class))
2649// continue;
2650// }
2651//
2652//// printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n",
2653//// record_decl->getNameAsCString(),
2654//// canonical_decl->getNameAsCString(),
2655//// child_idx,
2656//// base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
2657//
2658//
2659// CXXRecordDecl *curr_base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2660// if (curr_base_class_decl == canonical_decl)
2661// {
2662// return child_idx;
2663// }
2664// ++child_idx;
2665// }
2666// }
2667//
2668// const uint32_t num_bases = child_idx;
2669 RecordDecl::field_iterator field, field_end;
2670 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
2671 field != field_end;
2672 ++field, ++child_idx)
2673 {
2674// printf ("GetIndexForRecordChild (%s, %s) field[%u] = %s\n",
2675// record_decl->getNameAsCString(),
2676// canonical_decl->getNameAsCString(),
2677// child_idx - num_bases,
2678// field->getNameAsCString());
2679
2680 if (field->getCanonicalDecl() == canonical_decl)
2681 return child_idx;
2682 }
2683
2684 return UINT32_MAX;
2685}
2686
2687// Look for a child member (doesn't include base classes, but it does include
2688// their members) in the type hierarchy. Returns an index path into "clang_type"
2689// on how to reach the appropriate member.
2690//
2691// class A
2692// {
2693// public:
2694// int m_a;
2695// int m_b;
2696// };
2697//
2698// class B
2699// {
2700// };
2701//
2702// class C :
2703// public B,
2704// public A
2705// {
2706// };
2707//
2708// If we have a clang type that describes "class C", and we wanted to looked
2709// "m_b" in it:
2710//
2711// With omit_empty_base_classes == false we would get an integer array back with:
2712// { 1, 1 }
2713// The first index 1 is the child index for "class A" within class C
2714// The second index 1 is the child index for "m_b" within class A
2715//
2716// With omit_empty_base_classes == true we would get an integer array back with:
2717// { 0, 1 }
2718// 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)
2719// The second index 1 is the child index for "m_b" within class A
2720
2721size_t
2722ClangASTContext::GetIndexOfChildMemberWithName
2723(
2724 ASTContext *ast_context,
Greg Clayton462d4142010-09-29 01:12:09 +00002725 clang_type_t clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00002726 const char *name,
2727 bool omit_empty_base_classes,
2728 std::vector<uint32_t>& child_indexes
2729)
2730{
2731 if (clang_type && name && name[0])
2732 {
2733 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00002734 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2735 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00002736 {
Greg Clayton1674b122010-07-21 22:12:05 +00002737 case clang::Type::Record:
Chris Lattner24943d22010-06-08 16:52:24 +00002738 {
2739 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
2740 const RecordDecl *record_decl = record_type->getDecl();
2741
2742 assert(record_decl);
2743 uint32_t child_idx = 0;
2744
2745 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2746
2747 // Try and find a field that matches NAME
2748 RecordDecl::field_iterator field, field_end;
2749 StringRef name_sref(name);
2750 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
2751 field != field_end;
2752 ++field, ++child_idx)
2753 {
2754 if (field->getName().equals (name_sref))
2755 {
2756 // We have to add on the number of base classes to this index!
2757 child_indexes.push_back (child_idx + GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes));
2758 return child_indexes.size();
2759 }
2760 }
2761
2762 if (cxx_record_decl)
2763 {
2764 const RecordDecl *parent_record_decl = cxx_record_decl;
2765
2766 //printf ("parent = %s\n", parent_record_decl->getNameAsCString());
2767
2768 //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
2769 // Didn't find things easily, lets let clang do its thang...
2770 IdentifierInfo & ident_ref = ast_context->Idents.get(name, name + strlen (name));
2771 DeclarationName decl_name(&ident_ref);
2772
2773 CXXBasePaths paths;
2774 if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember,
2775 decl_name.getAsOpaquePtr(),
2776 paths))
2777 {
Chris Lattner24943d22010-06-08 16:52:24 +00002778 CXXBasePaths::const_paths_iterator path, path_end = paths.end();
2779 for (path = paths.begin(); path != path_end; ++path)
2780 {
2781 const size_t num_path_elements = path->size();
2782 for (size_t e=0; e<num_path_elements; ++e)
2783 {
2784 CXXBasePathElement elem = (*path)[e];
2785
2786 child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes);
2787 if (child_idx == UINT32_MAX)
2788 {
2789 child_indexes.clear();
2790 return 0;
2791 }
2792 else
2793 {
2794 child_indexes.push_back (child_idx);
2795 parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl());
2796 }
2797 }
2798 DeclContext::lookup_iterator named_decl_pos;
2799 for (named_decl_pos = path->Decls.first;
2800 named_decl_pos != path->Decls.second && parent_record_decl;
2801 ++named_decl_pos)
2802 {
2803 //printf ("path[%zu] = %s\n", child_indexes.size(), (*named_decl_pos)->getNameAsCString());
2804
2805 child_idx = GetIndexForRecordChild (parent_record_decl, *named_decl_pos, omit_empty_base_classes);
2806 if (child_idx == UINT32_MAX)
2807 {
2808 child_indexes.clear();
2809 return 0;
2810 }
2811 else
2812 {
2813 child_indexes.push_back (child_idx);
2814 }
2815 }
2816 }
2817 return child_indexes.size();
2818 }
2819 }
2820
2821 }
2822 break;
2823
Greg Clayton9488b742010-07-28 02:04:09 +00002824 case clang::Type::ObjCObject:
2825 case clang::Type::ObjCInterface:
2826 {
2827 StringRef name_sref(name);
2828 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
2829 assert (objc_class_type);
2830 if (objc_class_type)
2831 {
2832 uint32_t child_idx = 0;
2833 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2834
2835 if (class_interface_decl)
2836 {
2837 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
2838 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2839
Greg Clayton823533e2010-09-18 02:11:07 +00002840 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
Greg Clayton9488b742010-07-28 02:04:09 +00002841 {
2842 const ObjCIvarDecl* ivar_decl = *ivar_pos;
2843
2844 if (ivar_decl->getName().equals (name_sref))
2845 {
2846 if ((!omit_empty_base_classes && superclass_interface_decl) ||
2847 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
2848 ++child_idx;
2849
2850 child_indexes.push_back (child_idx);
2851 return child_indexes.size();
2852 }
2853 }
2854
2855 if (superclass_interface_decl)
2856 {
2857 // The super class index is always zero for ObjC classes,
2858 // so we push it onto the child indexes in case we find
2859 // an ivar in our superclass...
2860 child_indexes.push_back (0);
2861
2862 if (GetIndexOfChildMemberWithName (ast_context,
2863 ast_context->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(),
2864 name,
2865 omit_empty_base_classes,
2866 child_indexes))
2867 {
2868 // We did find an ivar in a superclass so just
2869 // return the results!
2870 return child_indexes.size();
2871 }
2872
2873 // We didn't find an ivar matching "name" in our
2874 // superclass, pop the superclass zero index that
2875 // we pushed on above.
2876 child_indexes.pop_back();
2877 }
2878 }
2879 }
2880 }
2881 break;
2882
2883 case clang::Type::ObjCObjectPointer:
2884 {
2885 return GetIndexOfChildMemberWithName (ast_context,
2886 cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(),
2887 name,
2888 omit_empty_base_classes,
2889 child_indexes);
2890 }
2891 break;
2892
2893
Greg Clayton1674b122010-07-21 22:12:05 +00002894 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00002895 {
2896// const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
2897// const uint64_t element_count = array->getSize().getLimitedValue();
2898//
2899// if (idx < element_count)
2900// {
2901// std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(array->getElementType());
2902//
2903// char element_name[32];
2904// ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
2905//
2906// child_name.assign(element_name);
2907// assert(field_type_info.first % 8 == 0);
2908// child_byte_size = field_type_info.first / 8;
2909// child_byte_offset = idx * child_byte_size;
2910// return array->getElementType().getAsOpaquePtr();
2911// }
2912 }
2913 break;
2914
Greg Clayton1674b122010-07-21 22:12:05 +00002915// case clang::Type::MemberPointerType:
Chris Lattner24943d22010-06-08 16:52:24 +00002916// {
2917// MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
2918// QualType pointee_type = mem_ptr_type->getPointeeType();
2919//
2920// if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2921// {
2922// return GetIndexOfChildWithName (ast_context,
2923// mem_ptr_type->getPointeeType().getAsOpaquePtr(),
2924// name);
2925// }
2926// }
2927// break;
2928//
Greg Clayton1674b122010-07-21 22:12:05 +00002929 case clang::Type::LValueReference:
2930 case clang::Type::RValueReference:
Chris Lattner24943d22010-06-08 16:52:24 +00002931 {
2932 ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
2933 QualType pointee_type = reference_type->getPointeeType();
2934
2935 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2936 {
2937 return GetIndexOfChildMemberWithName (ast_context,
2938 reference_type->getPointeeType().getAsOpaquePtr(),
2939 name,
2940 omit_empty_base_classes,
2941 child_indexes);
2942 }
2943 }
2944 break;
2945
Greg Clayton1674b122010-07-21 22:12:05 +00002946 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00002947 {
2948 PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
2949 QualType pointee_type = pointer_type->getPointeeType();
2950
2951 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2952 {
2953 return GetIndexOfChildMemberWithName (ast_context,
2954 pointer_type->getPointeeType().getAsOpaquePtr(),
2955 name,
2956 omit_empty_base_classes,
2957 child_indexes);
2958 }
2959 else
2960 {
2961// if (parent_name)
2962// {
2963// child_name.assign(1, '*');
2964// child_name += parent_name;
2965// }
2966//
2967// // We have a pointer to an simple type
2968// if (idx == 0)
2969// {
2970// std::pair<uint64_t, unsigned> clang_type_info = ast_context->getTypeInfo(pointee_type);
2971// assert(clang_type_info.first % 8 == 0);
2972// child_byte_size = clang_type_info.first / 8;
2973// child_byte_offset = 0;
2974// return pointee_type.getAsOpaquePtr();
2975// }
2976 }
2977 }
2978 break;
2979
Greg Clayton1674b122010-07-21 22:12:05 +00002980 case clang::Type::Typedef:
Chris Lattner24943d22010-06-08 16:52:24 +00002981 return GetIndexOfChildMemberWithName (ast_context,
Sean Callanan9e7958e2010-12-13 01:26:27 +00002982 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
Chris Lattner24943d22010-06-08 16:52:24 +00002983 name,
2984 omit_empty_base_classes,
2985 child_indexes);
2986
2987 default:
2988 break;
2989 }
2990 }
2991 return 0;
2992}
2993
2994
2995// Get the index of the child of "clang_type" whose name matches. This function
2996// doesn't descend into the children, but only looks one level deep and name
2997// matches can include base class names.
2998
2999uint32_t
3000ClangASTContext::GetIndexOfChildWithName
3001(
3002 ASTContext *ast_context,
Greg Clayton462d4142010-09-29 01:12:09 +00003003 clang_type_t clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00003004 const char *name,
3005 bool omit_empty_base_classes
3006)
3007{
3008 if (clang_type && name && name[0])
3009 {
3010 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
Greg Clayton9488b742010-07-28 02:04:09 +00003011
Greg Clayton03e0f972010-09-13 03:32:57 +00003012 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
Greg Clayton9488b742010-07-28 02:04:09 +00003013
Greg Clayton03e0f972010-09-13 03:32:57 +00003014 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003015 {
Greg Clayton1674b122010-07-21 22:12:05 +00003016 case clang::Type::Record:
Chris Lattner24943d22010-06-08 16:52:24 +00003017 {
3018 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
3019 const RecordDecl *record_decl = record_type->getDecl();
3020
3021 assert(record_decl);
3022 uint32_t child_idx = 0;
3023
3024 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3025
3026 if (cxx_record_decl)
3027 {
3028 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3029 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3030 base_class != base_class_end;
3031 ++base_class)
3032 {
3033 // Skip empty base classes
3034 CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3035 if (omit_empty_base_classes && RecordHasFields(base_class_decl) == false)
3036 continue;
3037
3038 if (base_class->getType().getAsString().compare (name) == 0)
3039 return child_idx;
3040 ++child_idx;
3041 }
3042 }
3043
3044 // Try and find a field that matches NAME
3045 RecordDecl::field_iterator field, field_end;
3046 StringRef name_sref(name);
3047 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3048 field != field_end;
3049 ++field, ++child_idx)
3050 {
3051 if (field->getName().equals (name_sref))
3052 return child_idx;
3053 }
3054
3055 }
3056 break;
3057
Greg Clayton9488b742010-07-28 02:04:09 +00003058 case clang::Type::ObjCObject:
3059 case clang::Type::ObjCInterface:
3060 {
3061 StringRef name_sref(name);
3062 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3063 assert (objc_class_type);
3064 if (objc_class_type)
3065 {
3066 uint32_t child_idx = 0;
3067 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3068
3069 if (class_interface_decl)
3070 {
3071 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3072 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3073
3074 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
3075 {
3076 const ObjCIvarDecl* ivar_decl = *ivar_pos;
3077
3078 if (ivar_decl->getName().equals (name_sref))
3079 {
3080 if ((!omit_empty_base_classes && superclass_interface_decl) ||
3081 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
3082 ++child_idx;
3083
3084 return child_idx;
3085 }
3086 }
3087
3088 if (superclass_interface_decl)
3089 {
3090 if (superclass_interface_decl->getName().equals (name_sref))
3091 return 0;
3092 }
3093 }
3094 }
3095 }
3096 break;
3097
3098 case clang::Type::ObjCObjectPointer:
3099 {
3100 return GetIndexOfChildWithName (ast_context,
3101 cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(),
3102 name,
3103 omit_empty_base_classes);
3104 }
3105 break;
3106
Greg Clayton1674b122010-07-21 22:12:05 +00003107 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00003108 {
3109// const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
3110// const uint64_t element_count = array->getSize().getLimitedValue();
3111//
3112// if (idx < element_count)
3113// {
3114// std::pair<uint64_t, unsigned> field_type_info = ast_context->getTypeInfo(array->getElementType());
3115//
3116// char element_name[32];
3117// ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
3118//
3119// child_name.assign(element_name);
3120// assert(field_type_info.first % 8 == 0);
3121// child_byte_size = field_type_info.first / 8;
3122// child_byte_offset = idx * child_byte_size;
3123// return array->getElementType().getAsOpaquePtr();
3124// }
3125 }
3126 break;
3127
Greg Clayton1674b122010-07-21 22:12:05 +00003128// case clang::Type::MemberPointerType:
Chris Lattner24943d22010-06-08 16:52:24 +00003129// {
3130// MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
3131// QualType pointee_type = mem_ptr_type->getPointeeType();
3132//
3133// if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3134// {
3135// return GetIndexOfChildWithName (ast_context,
3136// mem_ptr_type->getPointeeType().getAsOpaquePtr(),
3137// name);
3138// }
3139// }
3140// break;
3141//
Greg Clayton1674b122010-07-21 22:12:05 +00003142 case clang::Type::LValueReference:
3143 case clang::Type::RValueReference:
Chris Lattner24943d22010-06-08 16:52:24 +00003144 {
3145 ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3146 QualType pointee_type = reference_type->getPointeeType();
3147
3148 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3149 {
3150 return GetIndexOfChildWithName (ast_context,
3151 reference_type->getPointeeType().getAsOpaquePtr(),
3152 name,
3153 omit_empty_base_classes);
3154 }
3155 }
3156 break;
3157
Greg Clayton1674b122010-07-21 22:12:05 +00003158 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003159 {
3160 PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
3161 QualType pointee_type = pointer_type->getPointeeType();
3162
3163 if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3164 {
3165 return GetIndexOfChildWithName (ast_context,
3166 pointer_type->getPointeeType().getAsOpaquePtr(),
3167 name,
3168 omit_empty_base_classes);
3169 }
3170 else
3171 {
3172// if (parent_name)
3173// {
3174// child_name.assign(1, '*');
3175// child_name += parent_name;
3176// }
3177//
3178// // We have a pointer to an simple type
3179// if (idx == 0)
3180// {
3181// std::pair<uint64_t, unsigned> clang_type_info = ast_context->getTypeInfo(pointee_type);
3182// assert(clang_type_info.first % 8 == 0);
3183// child_byte_size = clang_type_info.first / 8;
3184// child_byte_offset = 0;
3185// return pointee_type.getAsOpaquePtr();
3186// }
3187 }
3188 }
3189 break;
3190
Greg Clayton1674b122010-07-21 22:12:05 +00003191 case clang::Type::Typedef:
Chris Lattner24943d22010-06-08 16:52:24 +00003192 return GetIndexOfChildWithName (ast_context,
Sean Callanan9e7958e2010-12-13 01:26:27 +00003193 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
Chris Lattner24943d22010-06-08 16:52:24 +00003194 name,
3195 omit_empty_base_classes);
3196
3197 default:
3198 break;
3199 }
3200 }
3201 return UINT32_MAX;
3202}
3203
3204#pragma mark TagType
3205
3206bool
Greg Clayton462d4142010-09-29 01:12:09 +00003207ClangASTContext::SetTagTypeKind (clang_type_t tag_clang_type, int kind)
Chris Lattner24943d22010-06-08 16:52:24 +00003208{
3209 if (tag_clang_type)
3210 {
3211 QualType tag_qual_type(QualType::getFromOpaquePtr(tag_clang_type));
Greg Clayton1674b122010-07-21 22:12:05 +00003212 clang::Type *clang_type = tag_qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00003213 if (clang_type)
3214 {
3215 TagType *tag_type = dyn_cast<TagType>(clang_type);
3216 if (tag_type)
3217 {
3218 TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl());
3219 if (tag_decl)
3220 {
3221 tag_decl->setTagKind ((TagDecl::TagKind)kind);
3222 return true;
3223 }
3224 }
3225 }
3226 }
3227 return false;
3228}
3229
3230
3231#pragma mark DeclContext Functions
3232
3233DeclContext *
Greg Clayton462d4142010-09-29 01:12:09 +00003234ClangASTContext::GetDeclContextForType (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003235{
3236 if (clang_type == NULL)
3237 return NULL;
3238
3239 QualType qual_type(QualType::getFromOpaquePtr(clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00003240 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3241 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003242 {
Greg Clayton9488b742010-07-28 02:04:09 +00003243 case clang::Type::FunctionNoProto: break;
3244 case clang::Type::FunctionProto: break;
3245 case clang::Type::IncompleteArray: break;
3246 case clang::Type::VariableArray: break;
3247 case clang::Type::ConstantArray: break;
3248 case clang::Type::ExtVector: break;
3249 case clang::Type::Vector: break;
3250 case clang::Type::Builtin: break;
3251 case clang::Type::BlockPointer: break;
3252 case clang::Type::Pointer: break;
3253 case clang::Type::LValueReference: break;
3254 case clang::Type::RValueReference: break;
3255 case clang::Type::MemberPointer: break;
3256 case clang::Type::Complex: break;
3257 case clang::Type::ObjCObject: break;
3258 case clang::Type::ObjCInterface: return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface();
3259 case clang::Type::ObjCObjectPointer: return ClangASTContext::GetDeclContextForType (cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr());
3260 case clang::Type::Record: return cast<RecordType>(qual_type)->getDecl();
3261 case clang::Type::Enum: return cast<EnumType>(qual_type)->getDecl();
Sean Callanan9e7958e2010-12-13 01:26:27 +00003262 case clang::Type::Typedef: return ClangASTContext::GetDeclContextForType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
Chris Lattner24943d22010-06-08 16:52:24 +00003263
Greg Clayton9488b742010-07-28 02:04:09 +00003264 case clang::Type::TypeOfExpr: break;
3265 case clang::Type::TypeOf: break;
3266 case clang::Type::Decltype: break;
3267 //case clang::Type::QualifiedName: break;
3268 case clang::Type::TemplateSpecialization: break;
Chris Lattner24943d22010-06-08 16:52:24 +00003269 }
3270 // No DeclContext in this type...
3271 return NULL;
3272}
3273
3274#pragma mark Namespace Declarations
3275
3276NamespaceDecl *
3277ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, const Declaration &decl, DeclContext *decl_ctx)
3278{
3279 // TODO: Do something intelligent with the Declaration object passed in
3280 // like maybe filling in the SourceLocation with it...
3281 if (name)
3282 {
3283 ASTContext *ast_context = getASTContext();
3284 if (decl_ctx == NULL)
3285 decl_ctx = ast_context->getTranslationUnitDecl();
3286 return NamespaceDecl::Create(*ast_context, decl_ctx, SourceLocation(), &ast_context->Idents.get(name));
3287 }
3288 return NULL;
3289}
3290
3291
3292#pragma mark Function Types
3293
3294FunctionDecl *
Greg Clayton462d4142010-09-29 01:12:09 +00003295ClangASTContext::CreateFunctionDeclaration (const char *name, clang_type_t function_clang_type, int storage, bool is_inline)
Chris Lattner24943d22010-06-08 16:52:24 +00003296{
3297 if (name)
3298 {
3299 ASTContext *ast_context = getASTContext();
3300 assert (ast_context != NULL);
3301
3302 if (name && name[0])
3303 {
3304 return FunctionDecl::Create(*ast_context,
3305 ast_context->getTranslationUnitDecl(),
3306 SourceLocation(),
3307 DeclarationName (&ast_context->Idents.get(name)),
3308 QualType::getFromOpaquePtr(function_clang_type),
3309 NULL,
3310 (FunctionDecl::StorageClass)storage,
3311 (FunctionDecl::StorageClass)storage,
3312 is_inline);
3313 }
3314 else
3315 {
3316 return FunctionDecl::Create(*ast_context,
3317 ast_context->getTranslationUnitDecl(),
3318 SourceLocation(),
3319 DeclarationName (),
3320 QualType::getFromOpaquePtr(function_clang_type),
3321 NULL,
3322 (FunctionDecl::StorageClass)storage,
3323 (FunctionDecl::StorageClass)storage,
3324 is_inline);
3325 }
3326 }
3327 return NULL;
3328}
3329
Greg Clayton462d4142010-09-29 01:12:09 +00003330clang_type_t
3331ClangASTContext::CreateFunctionType (ASTContext *ast_context,
3332 clang_type_t result_type,
3333 clang_type_t *args,
Sean Callanan2ea8f272010-09-16 20:40:25 +00003334 unsigned num_args,
3335 bool is_variadic,
3336 unsigned type_quals)
Chris Lattner24943d22010-06-08 16:52:24 +00003337{
Chris Lattner24943d22010-06-08 16:52:24 +00003338 assert (ast_context != NULL);
3339 std::vector<QualType> qual_type_args;
3340 for (unsigned i=0; i<num_args; ++i)
3341 qual_type_args.push_back (QualType::getFromOpaquePtr(args[i]));
3342
3343 // TODO: Detect calling convention in DWARF?
3344 return ast_context->getFunctionType(QualType::getFromOpaquePtr(result_type),
Greg Clayton53d68e72010-07-20 22:52:08 +00003345 qual_type_args.empty() ? NULL : &qual_type_args.front(),
Chris Lattner24943d22010-06-08 16:52:24 +00003346 qual_type_args.size(),
Sean Callanan2ea8f272010-09-16 20:40:25 +00003347 is_variadic,
3348 type_quals,
Chris Lattner24943d22010-06-08 16:52:24 +00003349 false, // hasExceptionSpec
3350 false, // hasAnyExceptionSpec,
3351 0, // NumExs
3352 0, // const QualType *ExArray
3353 FunctionType::ExtInfo ()).getAsOpaquePtr(); // NoReturn);
3354}
3355
3356ParmVarDecl *
Greg Clayton462d4142010-09-29 01:12:09 +00003357ClangASTContext::CreateParameterDeclaration (const char *name, clang_type_t param_type, int storage)
Chris Lattner24943d22010-06-08 16:52:24 +00003358{
3359 ASTContext *ast_context = getASTContext();
3360 assert (ast_context != NULL);
3361 return ParmVarDecl::Create(*ast_context,
3362 ast_context->getTranslationUnitDecl(),
3363 SourceLocation(),
3364 name && name[0] ? &ast_context->Idents.get(name) : NULL,
Sean Callanan2ea8f272010-09-16 20:40:25 +00003365 QualType::getFromOpaquePtr(param_type),
Chris Lattner24943d22010-06-08 16:52:24 +00003366 NULL,
3367 (VarDecl::StorageClass)storage,
3368 (VarDecl::StorageClass)storage,
3369 0);
3370}
3371
3372void
3373ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params)
3374{
3375 if (function_decl)
3376 function_decl->setParams (params, num_params);
3377}
3378
3379
3380#pragma mark Array Types
3381
Greg Clayton462d4142010-09-29 01:12:09 +00003382clang_type_t
3383ClangASTContext::CreateArrayType (clang_type_t element_type, size_t element_count, uint32_t bit_stride)
Chris Lattner24943d22010-06-08 16:52:24 +00003384{
3385 if (element_type)
3386 {
3387 ASTContext *ast_context = getASTContext();
3388 assert (ast_context != NULL);
3389 llvm::APInt ap_element_count (64, element_count);
3390 return ast_context->getConstantArrayType(QualType::getFromOpaquePtr(element_type),
3391 ap_element_count,
3392 ArrayType::Normal,
3393 0).getAsOpaquePtr(); // ElemQuals
3394 }
3395 return NULL;
3396}
3397
3398
3399#pragma mark TagDecl
3400
3401bool
Greg Clayton462d4142010-09-29 01:12:09 +00003402ClangASTContext::StartTagDeclarationDefinition (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003403{
3404 if (clang_type)
3405 {
3406 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Clayton1674b122010-07-21 22:12:05 +00003407 clang::Type *t = qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00003408 if (t)
3409 {
3410 TagType *tag_type = dyn_cast<TagType>(t);
3411 if (tag_type)
3412 {
3413 TagDecl *tag_decl = tag_type->getDecl();
3414 if (tag_decl)
3415 {
3416 tag_decl->startDefinition();
3417 return true;
3418 }
3419 }
3420 }
3421 }
3422 return false;
3423}
3424
3425bool
Greg Clayton462d4142010-09-29 01:12:09 +00003426ClangASTContext::CompleteTagDeclarationDefinition (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003427{
3428 if (clang_type)
3429 {
3430 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Clayton55b6c532010-09-29 03:44:17 +00003431
3432 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3433
3434 if (cxx_record_decl)
Chris Lattner24943d22010-06-08 16:52:24 +00003435 {
Greg Clayton55b6c532010-09-29 03:44:17 +00003436 cxx_record_decl->completeDefinition();
3437
3438 return true;
3439 }
3440
Sean Callanan04325062010-10-25 00:29:48 +00003441 ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
3442
3443 if (objc_class_type)
3444 {
3445 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3446
3447 class_interface_decl->setForwardDecl(false);
3448 }
3449
Greg Clayton55b6c532010-09-29 03:44:17 +00003450 const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr());
3451
3452 if (enum_type)
3453 {
3454 EnumDecl *enum_decl = enum_type->getDecl();
3455
3456 if (enum_decl)
Chris Lattner24943d22010-06-08 16:52:24 +00003457 {
Greg Clayton55b6c532010-09-29 03:44:17 +00003458 /// TODO This really needs to be fixed.
3459
3460 unsigned NumPositiveBits = 1;
3461 unsigned NumNegativeBits = 0;
3462
Greg Clayton48fbdf72010-10-12 04:29:14 +00003463 ASTContext *ast_context = getASTContext();
3464
3465 QualType promotion_qual_type;
3466 // If the enum integer type is less than an integer in bit width,
3467 // then we must promote it to an integer size.
3468 if (ast_context->getTypeSize(enum_decl->getIntegerType()) < ast_context->getTypeSize(ast_context->IntTy))
3469 {
3470 if (enum_decl->getIntegerType()->isSignedIntegerType())
3471 promotion_qual_type = ast_context->IntTy;
3472 else
3473 promotion_qual_type = ast_context->UnsignedIntTy;
3474 }
3475 else
3476 promotion_qual_type = enum_decl->getIntegerType();
3477
3478 enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits);
Greg Clayton55b6c532010-09-29 03:44:17 +00003479 return true;
Chris Lattner24943d22010-06-08 16:52:24 +00003480 }
3481 }
3482 }
3483 return false;
3484}
3485
3486
3487#pragma mark Enumeration Types
3488
Greg Clayton462d4142010-09-29 01:12:09 +00003489clang_type_t
3490ClangASTContext::CreateEnumerationType (const Declaration &decl, const char *name, clang_type_t integer_qual_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003491{
3492 // TODO: Do something intelligent with the Declaration object passed in
3493 // like maybe filling in the SourceLocation with it...
3494 ASTContext *ast_context = getASTContext();
3495 assert (ast_context != NULL);
Greg Clayton48fbdf72010-10-12 04:29:14 +00003496
3497 // TODO: ask about these...
3498// const bool IsScoped = false;
3499// const bool IsFixed = false;
3500
3501 EnumDecl *enum_decl = EnumDecl::Create (*ast_context,
3502 ast_context->getTranslationUnitDecl(),
3503 SourceLocation(),
3504 name && name[0] ? &ast_context->Idents.get(name) : NULL,
3505 SourceLocation(),
Sean Callanan9e7958e2010-12-13 01:26:27 +00003506 NULL,
3507 false, // IsScoped
3508 false, // IsScopedUsingClassTag
3509 false); // IsFixed
Chris Lattner24943d22010-06-08 16:52:24 +00003510 if (enum_decl)
Greg Claytone37f23c2010-09-12 23:17:56 +00003511 {
3512 // TODO: check if we should be setting the promotion type too?
3513 enum_decl->setIntegerType(QualType::getFromOpaquePtr (integer_qual_type));
Chris Lattner24943d22010-06-08 16:52:24 +00003514 return ast_context->getTagDeclType(enum_decl).getAsOpaquePtr();
Greg Claytone37f23c2010-09-12 23:17:56 +00003515 }
Chris Lattner24943d22010-06-08 16:52:24 +00003516 return NULL;
3517}
3518
Greg Clayton462d4142010-09-29 01:12:09 +00003519clang_type_t
3520ClangASTContext::GetEnumerationIntegerType (clang_type_t enum_clang_type)
3521{
3522 QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
3523
3524 clang::Type *clang_type = enum_qual_type.getTypePtr();
3525 if (clang_type)
3526 {
3527 const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
3528 if (enum_type)
3529 {
3530 EnumDecl *enum_decl = enum_type->getDecl();
3531 if (enum_decl)
3532 return enum_decl->getIntegerType().getAsOpaquePtr();
3533 }
3534 }
3535 return NULL;
3536}
Chris Lattner24943d22010-06-08 16:52:24 +00003537bool
3538ClangASTContext::AddEnumerationValueToEnumerationType
3539(
Greg Clayton462d4142010-09-29 01:12:09 +00003540 clang_type_t enum_clang_type,
3541 clang_type_t enumerator_clang_type,
Chris Lattner24943d22010-06-08 16:52:24 +00003542 const Declaration &decl,
3543 const char *name,
3544 int64_t enum_value,
3545 uint32_t enum_value_bit_size
3546)
3547{
3548 if (enum_clang_type && enumerator_clang_type && name)
3549 {
3550 // TODO: Do something intelligent with the Declaration object passed in
3551 // like maybe filling in the SourceLocation with it...
3552 ASTContext *ast_context = getASTContext();
3553 IdentifierTable *identifier_table = getIdentifierTable();
3554
3555 assert (ast_context != NULL);
3556 assert (identifier_table != NULL);
3557 QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
3558
Greg Clayton1674b122010-07-21 22:12:05 +00003559 clang::Type *clang_type = enum_qual_type.getTypePtr();
Chris Lattner24943d22010-06-08 16:52:24 +00003560 if (clang_type)
3561 {
3562 const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
3563
3564 if (enum_type)
3565 {
3566 llvm::APSInt enum_llvm_apsint(enum_value_bit_size, false);
3567 enum_llvm_apsint = enum_value;
3568 EnumConstantDecl *enumerator_decl =
3569 EnumConstantDecl::Create(*ast_context,
3570 enum_type->getDecl(),
3571 SourceLocation(),
3572 name ? &identifier_table->get(name) : NULL, // Identifier
3573 QualType::getFromOpaquePtr(enumerator_clang_type),
3574 NULL,
3575 enum_llvm_apsint);
3576
3577 if (enumerator_decl)
3578 {
3579 enum_type->getDecl()->addDecl(enumerator_decl);
3580 return true;
3581 }
3582 }
3583 }
3584 }
3585 return false;
3586}
3587
3588#pragma mark Pointers & References
3589
Greg Clayton462d4142010-09-29 01:12:09 +00003590clang_type_t
3591ClangASTContext::CreatePointerType (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003592{
Greg Clayton427f2902010-12-14 02:59:59 +00003593 return CreatePointerType (getASTContext(), clang_type);
3594}
3595
3596clang_type_t
3597ClangASTContext::CreatePointerType (clang::ASTContext *ast, clang_type_t clang_type)
3598{
3599 if (ast && clang_type)
Greg Clayton7b541032010-07-29 20:06:32 +00003600 {
3601 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3602
Greg Clayton03e0f972010-09-13 03:32:57 +00003603 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3604 switch (type_class)
Greg Clayton7b541032010-07-29 20:06:32 +00003605 {
3606 case clang::Type::ObjCObject:
3607 case clang::Type::ObjCInterface:
Greg Clayton427f2902010-12-14 02:59:59 +00003608 return ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr();
Greg Clayton7b541032010-07-29 20:06:32 +00003609
Greg Clayton7b541032010-07-29 20:06:32 +00003610 default:
Greg Clayton427f2902010-12-14 02:59:59 +00003611 return ast->getPointerType(qual_type).getAsOpaquePtr();
Greg Clayton7b541032010-07-29 20:06:32 +00003612 }
3613 }
Chris Lattner24943d22010-06-08 16:52:24 +00003614 return NULL;
3615}
3616
Greg Clayton462d4142010-09-29 01:12:09 +00003617clang_type_t
3618ClangASTContext::CreateLValueReferenceType (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003619{
3620 if (clang_type)
3621 return getASTContext()->getLValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr();
3622 return NULL;
3623}
3624
Greg Clayton462d4142010-09-29 01:12:09 +00003625clang_type_t
3626ClangASTContext::CreateRValueReferenceType (clang_type_t clang_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003627{
3628 if (clang_type)
3629 return getASTContext()->getRValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr();
3630 return NULL;
3631}
3632
Greg Clayton462d4142010-09-29 01:12:09 +00003633clang_type_t
3634ClangASTContext::CreateMemberPointerType (clang_type_t clang_pointee_type, clang_type_t clang_class_type)
Greg Claytonfa970692010-06-12 01:20:30 +00003635{
3636 if (clang_pointee_type && clang_pointee_type)
3637 return getASTContext()->getMemberPointerType(QualType::getFromOpaquePtr(clang_pointee_type),
3638 QualType::getFromOpaquePtr(clang_class_type).getTypePtr()).getAsOpaquePtr();
3639 return NULL;
3640}
3641
Chris Lattner24943d22010-06-08 16:52:24 +00003642size_t
3643ClangASTContext::GetPointerBitSize ()
3644{
3645 ASTContext *ast_context = getASTContext();
3646 return ast_context->getTypeSize(ast_context->VoidPtrTy);
3647}
3648
3649bool
Greg Clayton462d4142010-09-29 01:12:09 +00003650ClangASTContext::IsPointerOrReferenceType (clang_type_t clang_type, clang_type_t*target_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003651{
3652 if (clang_type == NULL)
3653 return false;
3654
3655 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00003656 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3657 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003658 {
Sean Callanan04325062010-10-25 00:29:48 +00003659 case clang::Type::Builtin:
3660 switch (cast<clang::BuiltinType>(qual_type)->getKind())
3661 {
3662 default:
3663 break;
3664 case clang::BuiltinType::ObjCId:
3665 case clang::BuiltinType::ObjCClass:
Sean Callanan04325062010-10-25 00:29:48 +00003666 return true;
3667 }
3668 return false;
Greg Clayton1674b122010-07-21 22:12:05 +00003669 case clang::Type::ObjCObjectPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003670 if (target_type)
3671 *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3672 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003673 case clang::Type::BlockPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003674 if (target_type)
3675 *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3676 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003677 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003678 if (target_type)
3679 *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3680 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003681 case clang::Type::MemberPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003682 if (target_type)
3683 *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3684 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003685 case clang::Type::LValueReference:
Chris Lattner24943d22010-06-08 16:52:24 +00003686 if (target_type)
3687 *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
3688 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003689 case clang::Type::RValueReference:
Chris Lattner24943d22010-06-08 16:52:24 +00003690 if (target_type)
3691 *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
3692 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003693 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00003694 return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
Chris Lattner24943d22010-06-08 16:52:24 +00003695 default:
3696 break;
3697 }
3698 return false;
3699}
3700
Chris Lattner24943d22010-06-08 16:52:24 +00003701bool
Greg Clayton462d4142010-09-29 01:12:09 +00003702ClangASTContext::IsIntegerType (clang_type_t clang_type, bool &is_signed)
Chris Lattner24943d22010-06-08 16:52:24 +00003703{
3704 if (!clang_type)
3705 return false;
3706
3707 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3708 const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal());
3709
3710 if (builtin_type)
3711 {
3712 if (builtin_type->isInteger())
3713 is_signed = builtin_type->isSignedInteger();
3714
3715 return true;
3716 }
3717
3718 return false;
3719}
3720
3721bool
Greg Clayton462d4142010-09-29 01:12:09 +00003722ClangASTContext::IsPointerType (clang_type_t clang_type, clang_type_t*target_type)
Chris Lattner24943d22010-06-08 16:52:24 +00003723{
3724 if (clang_type)
3725 {
3726 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
Greg Clayton03e0f972010-09-13 03:32:57 +00003727 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3728 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003729 {
Sean Callanan04325062010-10-25 00:29:48 +00003730 case clang::Type::Builtin:
3731 switch (cast<clang::BuiltinType>(qual_type)->getKind())
3732 {
3733 default:
3734 break;
3735 case clang::BuiltinType::ObjCId:
3736 case clang::BuiltinType::ObjCClass:
Sean Callanan04325062010-10-25 00:29:48 +00003737 return true;
3738 }
3739 return false;
Greg Clayton1674b122010-07-21 22:12:05 +00003740 case clang::Type::ObjCObjectPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003741 if (target_type)
3742 *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3743 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003744 case clang::Type::BlockPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003745 if (target_type)
3746 *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3747 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003748 case clang::Type::Pointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003749 if (target_type)
3750 *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3751 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003752 case clang::Type::MemberPointer:
Chris Lattner24943d22010-06-08 16:52:24 +00003753 if (target_type)
3754 *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
3755 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003756 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00003757 return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), target_type);
Chris Lattner24943d22010-06-08 16:52:24 +00003758 default:
3759 break;
3760 }
3761 }
3762 return false;
3763}
3764
3765bool
Greg Clayton462d4142010-09-29 01:12:09 +00003766ClangASTContext::IsFloatingPointType (clang_type_t clang_type, uint32_t &count, bool &is_complex)
Chris Lattner24943d22010-06-08 16:52:24 +00003767{
3768 if (clang_type)
3769 {
3770 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3771
3772 if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()))
3773 {
3774 clang::BuiltinType::Kind kind = BT->getKind();
3775 if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble)
3776 {
3777 count = 1;
3778 is_complex = false;
3779 return true;
3780 }
3781 }
3782 else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal()))
3783 {
3784 if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count, is_complex))
3785 {
3786 count = 2;
3787 is_complex = true;
3788 return true;
3789 }
3790 }
3791 else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal()))
3792 {
3793 if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count, is_complex))
3794 {
3795 count = VT->getNumElements();
3796 is_complex = false;
3797 return true;
3798 }
3799 }
3800 }
3801 return false;
3802}
3803
Greg Claytonbf8e42b2010-10-14 22:52:14 +00003804
3805bool
3806ClangASTContext::GetCXXClassName (clang_type_t clang_type, std::string &class_name)
3807{
3808 if (clang_type)
3809 {
3810 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3811
3812 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3813 if (cxx_record_decl)
3814 {
3815 class_name.assign (cxx_record_decl->getIdentifier()->getNameStart());
3816 return true;
3817 }
3818 }
3819 class_name.clear();
3820 return false;
3821}
3822
3823
Greg Clayton1d8173f2010-09-24 05:15:53 +00003824bool
Greg Clayton462d4142010-09-29 01:12:09 +00003825ClangASTContext::IsCXXClassType (clang_type_t clang_type)
Greg Clayton1d8173f2010-09-24 05:15:53 +00003826{
3827 if (clang_type)
3828 {
3829 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3830 if (qual_type->getAsCXXRecordDecl() != NULL)
3831 return true;
3832 }
3833 return false;
3834}
3835
3836bool
Greg Clayton462d4142010-09-29 01:12:09 +00003837ClangASTContext::IsObjCClassType (clang_type_t clang_type)
Greg Clayton1d8173f2010-09-24 05:15:53 +00003838{
3839 if (clang_type)
3840 {
3841 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3842 if (qual_type->isObjCObjectOrInterfaceType())
3843 return true;
3844 }
3845 return false;
3846}
3847
3848
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00003849bool
3850ClangASTContext::IsCharType (clang_type_t clang_type)
3851{
3852 if (clang_type)
3853 return QualType::getFromOpaquePtr(clang_type)->isCharType();
3854 return false;
3855}
Chris Lattner24943d22010-06-08 16:52:24 +00003856
3857bool
Greg Clayton462d4142010-09-29 01:12:09 +00003858ClangASTContext::IsCStringType (clang_type_t clang_type, uint32_t &length)
Chris Lattner24943d22010-06-08 16:52:24 +00003859{
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00003860 clang_type_t pointee_or_element_clang_type = NULL;
3861 Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, NULL, &pointee_or_element_clang_type));
3862
3863 if (pointee_or_element_clang_type == NULL)
3864 return false;
3865
3866 if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer))
Chris Lattner24943d22010-06-08 16:52:24 +00003867 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00003868 QualType pointee_or_element_qual_type (QualType::getFromOpaquePtr (pointee_or_element_clang_type));
3869
3870 if (pointee_or_element_qual_type.getUnqualifiedType()->isCharType())
Chris Lattner24943d22010-06-08 16:52:24 +00003871 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00003872 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3873 if (type_flags.Test (eTypeIsArray))
Chris Lattner24943d22010-06-08 16:52:24 +00003874 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00003875 // We know the size of the array and it could be a C string
3876 // since it is an array of characters
3877 length = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
3878 return true;
Chris Lattner24943d22010-06-08 16:52:24 +00003879 }
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00003880 else
Chris Lattner24943d22010-06-08 16:52:24 +00003881 {
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00003882 length = 0;
3883 return true;
Chris Lattner24943d22010-06-08 16:52:24 +00003884 }
Chris Lattner24943d22010-06-08 16:52:24 +00003885
Chris Lattner24943d22010-06-08 16:52:24 +00003886 }
3887 }
3888 return false;
3889}
3890
3891bool
Greg Clayton462d4142010-09-29 01:12:09 +00003892ClangASTContext::IsFunctionPointerType (clang_type_t clang_type)
Greg Clayton03e0f972010-09-13 03:32:57 +00003893{
3894 if (clang_type)
3895 {
3896 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3897
3898 if (qual_type->isFunctionPointerType())
3899 return true;
3900
3901 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3902 switch (type_class)
3903 {
3904 case clang::Type::Typedef:
Sean Callanan9e7958e2010-12-13 01:26:27 +00003905 return ClangASTContext::IsFunctionPointerType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
Greg Clayton03e0f972010-09-13 03:32:57 +00003906
3907 case clang::Type::LValueReference:
3908 case clang::Type::RValueReference:
3909 {
3910 ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3911 if (reference_type)
3912 return ClangASTContext::IsFunctionPointerType (reference_type->getPointeeType().getAsOpaquePtr());
3913 }
3914 break;
3915 }
3916 }
3917 return false;
3918}
3919
Greg Claytonf3d0b0c2010-10-27 03:32:59 +00003920size_t
3921ClangASTContext::GetArraySize (clang_type_t clang_type)
3922{
3923 if (clang_type)
3924 {
3925 ConstantArrayType *array = cast<ConstantArrayType>(QualType::getFromOpaquePtr(clang_type).getTypePtr());
3926 if (array)
3927 return array->getSize().getLimitedValue();
3928 }
3929 return 0;
3930}
Greg Clayton03e0f972010-09-13 03:32:57 +00003931
3932bool
Greg Clayton462d4142010-09-29 01:12:09 +00003933ClangASTContext::IsArrayType (clang_type_t clang_type, clang_type_t*member_type, uint64_t *size)
Chris Lattner24943d22010-06-08 16:52:24 +00003934{
3935 if (!clang_type)
3936 return false;
3937
3938 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3939
Greg Clayton03e0f972010-09-13 03:32:57 +00003940 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3941 switch (type_class)
Chris Lattner24943d22010-06-08 16:52:24 +00003942 {
Greg Clayton1674b122010-07-21 22:12:05 +00003943 case clang::Type::ConstantArray:
Chris Lattner24943d22010-06-08 16:52:24 +00003944 if (member_type)
3945 *member_type = cast<ConstantArrayType>(qual_type)->getElementType().getAsOpaquePtr();
3946 if (size)
3947 *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULONG_LONG_MAX);
3948 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003949 case clang::Type::IncompleteArray:
Chris Lattner24943d22010-06-08 16:52:24 +00003950 if (member_type)
3951 *member_type = cast<IncompleteArrayType>(qual_type)->getElementType().getAsOpaquePtr();
3952 if (size)
3953 *size = 0;
3954 return true;
Greg Clayton1674b122010-07-21 22:12:05 +00003955 case clang::Type::VariableArray:
Chris Lattner24943d22010-06-08 16:52:24 +00003956 if (member_type)
3957 *member_type = cast<VariableArrayType>(qual_type)->getElementType().getAsOpaquePtr();
3958 if (size)
3959 *size = 0;
Greg Clayton1674b122010-07-21 22:12:05 +00003960 case clang::Type::DependentSizedArray:
Chris Lattner24943d22010-06-08 16:52:24 +00003961 if (member_type)
3962 *member_type = cast<DependentSizedArrayType>(qual_type)->getElementType().getAsOpaquePtr();
3963 if (size)
3964 *size = 0;
3965 return true;
3966 }
3967 return false;
3968}
3969
3970
3971#pragma mark Typedefs
3972
Greg Clayton462d4142010-09-29 01:12:09 +00003973clang_type_t
3974ClangASTContext::CreateTypedefType (const char *name, clang_type_t clang_type, DeclContext *decl_ctx)
Chris Lattner24943d22010-06-08 16:52:24 +00003975{
3976 if (clang_type)
3977 {
3978 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3979 ASTContext *ast_context = getASTContext();
3980 IdentifierTable *identifier_table = getIdentifierTable();
3981 assert (ast_context != NULL);
3982 assert (identifier_table != NULL);
3983 if (decl_ctx == NULL)
3984 decl_ctx = ast_context->getTranslationUnitDecl();
3985 TypedefDecl *decl = TypedefDecl::Create(*ast_context,
3986 decl_ctx,
3987 SourceLocation(),
3988 name ? &identifier_table->get(name) : NULL, // Identifier
3989 ast_context->CreateTypeSourceInfo(qual_type));
3990
3991 // Get a uniqued QualType for the typedef decl type
3992 return ast_context->getTypedefType (decl).getAsOpaquePtr();
3993 }
3994 return NULL;
3995}
3996
3997
3998std::string
Greg Clayton462d4142010-09-29 01:12:09 +00003999ClangASTContext::GetTypeName (clang_type_t opaque_qual_type)
Chris Lattner24943d22010-06-08 16:52:24 +00004000{
4001 std::string return_name;
4002
Greg Clayton462d4142010-09-29 01:12:09 +00004003 QualType qual_type(QualType::getFromOpaquePtr(opaque_qual_type));
Chris Lattner24943d22010-06-08 16:52:24 +00004004
Greg Clayton462d4142010-09-29 01:12:09 +00004005 const TypedefType *typedef_type = qual_type->getAs<TypedefType>();
Chris Lattner24943d22010-06-08 16:52:24 +00004006 if (typedef_type)
4007 {
Greg Clayton462d4142010-09-29 01:12:09 +00004008 const TypedefDecl *typedef_decl = typedef_type->getDecl();
Chris Lattner24943d22010-06-08 16:52:24 +00004009 return_name = typedef_decl->getQualifiedNameAsString();
4010 }
4011 else
4012 {
4013 return_name = qual_type.getAsString();
4014 }
4015
4016 return return_name;
4017}
4018
4019// Disable this for now since I can't seem to get a nicely formatted float
4020// out of the APFloat class without just getting the float, double or quad
4021// and then using a formatted print on it which defeats the purpose. We ideally
4022// would like to get perfect string values for any kind of float semantics
4023// so we can support remote targets. The code below also requires a patch to
4024// llvm::APInt.
4025//bool
Greg Clayton462d4142010-09-29 01:12:09 +00004026//ClangASTContext::ConvertFloatValueToString (ASTContext *ast_context, 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 +00004027//{
4028// uint32_t count = 0;
4029// bool is_complex = false;
4030// if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
4031// {
4032// unsigned num_bytes_per_float = byte_size / count;
4033// unsigned num_bits_per_float = num_bytes_per_float * 8;
4034//
4035// float_str.clear();
4036// uint32_t i;
4037// for (i=0; i<count; i++)
4038// {
4039// APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order);
4040// bool is_ieee = false;
4041// APFloat ap_float(ap_int, is_ieee);
4042// char s[1024];
4043// unsigned int hex_digits = 0;
4044// bool upper_case = false;
4045//
4046// if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0)
4047// {
4048// if (i > 0)
4049// float_str.append(", ");
4050// float_str.append(s);
4051// if (i == 1 && is_complex)
4052// float_str.append(1, 'i');
4053// }
4054// }
4055// return !float_str.empty();
4056// }
4057// return false;
4058//}
4059
4060size_t
Greg Clayton462d4142010-09-29 01:12:09 +00004061ClangASTContext::ConvertStringToFloatValue (ASTContext *ast_context, clang_type_t clang_type, const char *s, uint8_t *dst, size_t dst_size)
Chris Lattner24943d22010-06-08 16:52:24 +00004062{
4063 if (clang_type)
4064 {
4065 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4066 uint32_t count = 0;
4067 bool is_complex = false;
4068 if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
4069 {
4070 // TODO: handle complex and vector types
4071 if (count != 1)
4072 return false;
4073
4074 StringRef s_sref(s);
4075 APFloat ap_float(ast_context->getFloatTypeSemantics(qual_type), s_sref);
4076
4077 const uint64_t bit_size = ast_context->getTypeSize (qual_type);
4078 const uint64_t byte_size = bit_size / 8;
4079 if (dst_size >= byte_size)
4080 {
4081 if (bit_size == sizeof(float)*8)
4082 {
4083 float float32 = ap_float.convertToFloat();
4084 ::memcpy (dst, &float32, byte_size);
4085 return byte_size;
4086 }
4087 else if (bit_size >= 64)
4088 {
4089 llvm::APInt ap_int(ap_float.bitcastToAPInt());
4090 ::memcpy (dst, ap_int.getRawData(), byte_size);
4091 return byte_size;
4092 }
4093 }
4094 }
4095 }
4096 return 0;
4097}
Sean Callanana751f7b2010-09-17 02:24:29 +00004098
4099unsigned
Greg Clayton462d4142010-09-29 01:12:09 +00004100ClangASTContext::GetTypeQualifiers(clang_type_t clang_type)
Sean Callanana751f7b2010-09-17 02:24:29 +00004101{
4102 assert (clang_type);
4103
4104 QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4105
4106 return qual_type.getQualifiers().getCVRQualifiers();
4107}