1 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis for declarations.
12 //===----------------------------------------------------------------------===//
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Attr.h"
18 #include "clang/AST/Builtins.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/Type.h"
22 #include "clang/Parse/DeclSpec.h"
23 #include "clang/Parse/Scope.h"
24 #include "clang/Basic/LangOptions.h"
25 #include "clang/Basic/TargetInfo.h"
26 #include "clang/Basic/SourceManager.h"
27 // FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
28 #include "clang/Lex/Preprocessor.h"
29 #include "clang/Lex/HeaderSearch.h"
30 #include "llvm/ADT/SmallString.h"
31 #include "llvm/ADT/SmallSet.h"
32 #include "llvm/ADT/DenseSet.h"
33 using namespace clang;
35 Sema::DeclTy *Sema::isTypeName(const IdentifierInfo &II, Scope *S) const {
36 Decl *IIDecl = II.getFETokenInfo<Decl>();
37 // Find first occurance of none-tagged declaration
38 while(IIDecl && IIDecl->getIdentifierNamespace() != Decl::IDNS_Ordinary)
39 IIDecl = cast<ScopedDecl>(IIDecl)->getNext();
42 if (isa<TypedefDecl>(IIDecl) || isa<ObjCInterfaceDecl>(IIDecl))
44 if (ObjCCompatibleAliasDecl *ADecl =
45 dyn_cast<ObjCCompatibleAliasDecl>(IIDecl))
46 return ADecl->getClassInterface();
50 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
51 if (S->decl_empty()) return;
52 assert((S->getFlags() & Scope::DeclScope) &&"Scope shouldn't contain decls!");
54 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
56 Decl *TmpD = static_cast<Decl*>(*I);
57 assert(TmpD && "This decl didn't get pushed??");
58 ScopedDecl *D = dyn_cast<ScopedDecl>(TmpD);
59 assert(D && "This decl isn't a ScopedDecl?");
61 IdentifierInfo *II = D->getIdentifier();
64 // Unlink this decl from the identifier. Because the scope contains decls
65 // in an unordered collection, and because we have multiple identifier
66 // namespaces (e.g. tag, normal, label),the decl may not be the first entry.
67 if (II->getFETokenInfo<Decl>() == D) {
68 // Normal case, no multiple decls in different namespaces.
69 II->setFETokenInfo(D->getNext());
71 // Scan ahead. There are only three namespaces in C, so this loop can
72 // never execute more than 3 times.
73 ScopedDecl *SomeDecl = II->getFETokenInfo<ScopedDecl>();
74 while (SomeDecl->getNext() != D) {
75 SomeDecl = SomeDecl->getNext();
76 assert(SomeDecl && "Didn't find this decl on its identifier's chain!");
78 SomeDecl->setNext(D->getNext());
81 // This will have to be revisited for C++: there we want to nest stuff in
82 // namespace decls etc. Even for C, we might want a top-level translation
83 // unit decl or something.
87 // Chain this decl to the containing function, it now owns the memory for
89 D->setNext(CurFunctionDecl->getDeclChain());
90 CurFunctionDecl->setDeclChain(D);
94 /// LookupInterfaceDecl - Lookup interface declaration in the scope chain.
95 /// Return the first declaration found (which may or may not be a class
96 /// declaration. Caller is responsible for handling the none-class case.
97 /// Bypassing the alias of a class by returning the aliased class.
98 ScopedDecl *Sema::LookupInterfaceDecl(IdentifierInfo *ClassName) {
100 // Scan up the scope chain looking for a decl that matches this identifier
101 // that is in the appropriate namespace.
102 for (IDecl = ClassName->getFETokenInfo<ScopedDecl>(); IDecl;
103 IDecl = IDecl->getNext())
104 if (IDecl->getIdentifierNamespace() == Decl::IDNS_Ordinary)
107 if (ObjCCompatibleAliasDecl *ADecl =
108 dyn_cast_or_null<ObjCCompatibleAliasDecl>(IDecl))
109 return ADecl->getClassInterface();
113 /// getObjCInterfaceDecl - Look up a for a class declaration in the scope.
114 /// return 0 if one not found.
115 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *Id) {
116 ScopedDecl *IdDecl = LookupInterfaceDecl(Id);
117 return cast_or_null<ObjCInterfaceDecl>(IdDecl);
120 /// LookupScopedDecl - Look up the inner-most declaration in the specified
122 ScopedDecl *Sema::LookupScopedDecl(IdentifierInfo *II, unsigned NSI,
123 SourceLocation IdLoc, Scope *S) {
124 if (II == 0) return 0;
125 Decl::IdentifierNamespace NS = (Decl::IdentifierNamespace)NSI;
127 // Scan up the scope chain looking for a decl that matches this identifier
128 // that is in the appropriate namespace. This search should not take long, as
129 // shadowing of names is uncommon, and deep shadowing is extremely uncommon.
130 for (ScopedDecl *D = II->getFETokenInfo<ScopedDecl>(); D; D = D->getNext())
131 if (D->getIdentifierNamespace() == NS)
134 // If we didn't find a use of this identifier, and if the identifier
135 // corresponds to a compiler builtin, create the decl object for the builtin
136 // now, injecting it into translation unit scope, and return it.
137 if (NS == Decl::IDNS_Ordinary) {
138 // If this is a builtin on some other target, or if this builtin varies
139 // across targets (e.g. in type), emit a diagnostic and mark the translation
140 // unit non-portable for using it.
141 if (II->isNonPortableBuiltin()) {
142 // Only emit this diagnostic once for this builtin.
143 II->setNonPortableBuiltin(false);
144 Context.Target.DiagnoseNonPortability(Context.getFullLoc(IdLoc),
145 diag::port_target_builtin_use);
147 // If this is a builtin on this (or all) targets, create the decl.
148 if (unsigned BuiltinID = II->getBuiltinID())
149 return LazilyCreateBuiltin(II, BuiltinID, S);
154 void Sema::InitBuiltinVaListType()
156 if (!Context.getBuiltinVaListType().isNull())
159 IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
160 ScopedDecl *VaDecl = LookupScopedDecl(VaIdent, Decl::IDNS_Ordinary,
161 SourceLocation(), TUScope);
162 TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
163 Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
166 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope.
167 /// lazily create a decl for it.
168 ScopedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
170 Builtin::ID BID = (Builtin::ID)bid;
172 if (BID == Builtin::BI__builtin_va_start ||
173 BID == Builtin::BI__builtin_va_copy ||
174 BID == Builtin::BI__builtin_va_end)
175 InitBuiltinVaListType();
177 QualType R = Context.BuiltinInfo.GetBuiltinType(BID, Context);
178 FunctionDecl *New = new FunctionDecl(SourceLocation(), II, R,
179 FunctionDecl::Extern, false, 0);
181 // Find translation-unit scope to insert this function into.
182 if (Scope *FnS = S->getFnParent())
183 S = FnS->getParent(); // Skip all scopes in a function at once.
184 while (S->getParent())
188 // Add this decl to the end of the identifier info.
189 if (ScopedDecl *LastDecl = II->getFETokenInfo<ScopedDecl>()) {
190 // Scan until we find the last (outermost) decl in the id chain.
191 while (LastDecl->getNext())
192 LastDecl = LastDecl->getNext();
193 // Insert before (outside) it.
194 LastDecl->setNext(New);
196 II->setFETokenInfo(New);
201 /// MergeTypeDefDecl - We just parsed a typedef 'New' which has the same name
202 /// and scope as a previous declaration 'Old'. Figure out how to resolve this
203 /// situation, merging decls or emitting diagnostics as appropriate.
205 TypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, ScopedDecl *OldD) {
206 // Verify the old decl was also a typedef.
207 TypedefDecl *Old = dyn_cast<TypedefDecl>(OldD);
209 Diag(New->getLocation(), diag::err_redefinition_different_kind,
211 Diag(OldD->getLocation(), diag::err_previous_definition);
215 // Allow multiple definitions for ObjC built-in typedefs.
216 // FIXME: Verify the underlying types are equivalent!
217 if (getLangOptions().ObjC1 && isBuiltinObjCType(New))
220 // Redeclaration of a type is a constraint violation (6.7.2.3p1).
221 // Apparently GCC, Intel, and Sun all silently ignore the redeclaration if
222 // *either* declaration is in a system header. The code below implements
223 // this adhoc compatibility rule. FIXME: The following code will not
224 // work properly when compiling ".i" files (containing preprocessed output).
225 SourceManager &SrcMgr = Context.getSourceManager();
226 const FileEntry *OldDeclFile = SrcMgr.getFileEntryForLoc(Old->getLocation());
227 const FileEntry *NewDeclFile = SrcMgr.getFileEntryForLoc(New->getLocation());
228 HeaderSearch &HdrInfo = PP.getHeaderSearchInfo();
229 DirectoryLookup::DirType OldDirType = HdrInfo.getFileDirFlavor(OldDeclFile);
230 DirectoryLookup::DirType NewDirType = HdrInfo.getFileDirFlavor(NewDeclFile);
232 if ((OldDirType == DirectoryLookup::ExternCSystemHeaderDir ||
233 NewDirType == DirectoryLookup::ExternCSystemHeaderDir) ||
234 getLangOptions().Microsoft)
237 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
238 // TODO: This is totally simplistic. It should handle merging functions
239 // together etc, merging extern int X; int X; ...
240 Diag(New->getLocation(), diag::err_redefinition, New->getName());
241 Diag(Old->getLocation(), diag::err_previous_definition);
245 /// MergeFunctionDecl - We just parsed a function 'New' which has the same name
246 /// and scope as a previous declaration 'Old'. Figure out how to resolve this
247 /// situation, merging decls or emitting diagnostics as appropriate.
249 FunctionDecl *Sema::MergeFunctionDecl(FunctionDecl *New, ScopedDecl *OldD) {
250 // Verify the old decl was also a function.
251 FunctionDecl *Old = dyn_cast<FunctionDecl>(OldD);
253 Diag(New->getLocation(), diag::err_redefinition_different_kind,
255 Diag(OldD->getLocation(), diag::err_previous_definition);
259 QualType OldQType = Old->getCanonicalType();
260 QualType NewQType = New->getCanonicalType();
262 // Function types need to be compatible, not identical. This handles
263 // duplicate function decls like "void f(int); void f(enum X);" properly.
264 if (Context.functionTypesAreCompatible(OldQType, NewQType))
267 // A function that has already been declared has been redeclared or defined
268 // with a different type- show appropriate diagnostic
269 diag::kind PrevDiag = Old->getBody() ? diag::err_previous_definition :
270 diag::err_previous_declaration;
272 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
273 // TODO: This is totally simplistic. It should handle merging functions
274 // together etc, merging extern int X; int X; ...
275 Diag(New->getLocation(), diag::err_conflicting_types, New->getName());
276 Diag(Old->getLocation(), PrevDiag);
280 /// equivalentArrayTypes - Used to determine whether two array types are
282 /// We need to check this explicitly as an incomplete array definition is
283 /// considered a VariableArrayType, so will not match a complete array
284 /// definition that would be otherwise equivalent.
285 static bool areEquivalentArrayTypes(QualType NewQType, QualType OldQType) {
286 const ArrayType *NewAT = NewQType->getAsArrayType();
287 const ArrayType *OldAT = OldQType->getAsArrayType();
289 if (!NewAT || !OldAT)
292 // If either (or both) array types in incomplete we need to strip off the
293 // outer VariableArrayType. Once the outer VAT is removed the remaining
294 // types must be identical if the array types are to be considered
296 // eg. int[][1] and int[1][1] become
297 // VAT(null, CAT(1, int)) and CAT(1, CAT(1, int))
298 // removing the outermost VAT gives
299 // CAT(1, int) and CAT(1, int)
300 // which are equal, therefore the array types are equivalent.
301 if (NewAT->isIncompleteArrayType() || OldAT->isIncompleteArrayType()) {
302 if (NewAT->getIndexTypeQualifier() != OldAT->getIndexTypeQualifier())
304 NewQType = NewAT->getElementType().getCanonicalType();
305 OldQType = OldAT->getElementType().getCanonicalType();
308 return NewQType == OldQType;
311 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
312 /// and scope as a previous declaration 'Old'. Figure out how to resolve this
313 /// situation, merging decls or emitting diagnostics as appropriate.
315 /// FIXME: Need to carefully consider tentative definition rules (C99 6.9.2p2).
316 /// For example, we incorrectly complain about i1, i4 from C99 6.9.2p4.
318 VarDecl *Sema::MergeVarDecl(VarDecl *New, ScopedDecl *OldD) {
319 // Verify the old decl was also a variable.
320 VarDecl *Old = dyn_cast<VarDecl>(OldD);
322 Diag(New->getLocation(), diag::err_redefinition_different_kind,
324 Diag(OldD->getLocation(), diag::err_previous_definition);
327 // Verify the types match.
328 if (Old->getCanonicalType() != New->getCanonicalType() &&
329 !areEquivalentArrayTypes(New->getCanonicalType(), Old->getCanonicalType())) {
330 Diag(New->getLocation(), diag::err_redefinition, New->getName());
331 Diag(Old->getLocation(), diag::err_previous_definition);
334 // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
335 if (New->getStorageClass() == VarDecl::Static &&
336 (Old->getStorageClass() == VarDecl::None ||
337 Old->getStorageClass() == VarDecl::Extern)) {
338 Diag(New->getLocation(), diag::err_static_non_static, New->getName());
339 Diag(Old->getLocation(), diag::err_previous_definition);
342 // C99 6.2.2p4: Check if we have a non-static decl followed by a static.
343 if (New->getStorageClass() != VarDecl::Static &&
344 Old->getStorageClass() == VarDecl::Static) {
345 Diag(New->getLocation(), diag::err_non_static_static, New->getName());
346 Diag(Old->getLocation(), diag::err_previous_definition);
349 // We've verified the types match, now handle "tentative" definitions.
350 FileVarDecl *OldFSDecl = dyn_cast<FileVarDecl>(Old);
351 FileVarDecl *NewFSDecl = dyn_cast<FileVarDecl>(New);
353 if (OldFSDecl && NewFSDecl) {
354 // Handle C "tentative" external object definitions (C99 6.9.2).
355 bool OldIsTentative = false;
356 bool NewIsTentative = false;
358 if (!OldFSDecl->getInit() &&
359 (OldFSDecl->getStorageClass() == VarDecl::None ||
360 OldFSDecl->getStorageClass() == VarDecl::Static))
361 OldIsTentative = true;
363 // FIXME: this check doesn't work (since the initializer hasn't been
364 // attached yet). This check should be moved to FinalizeDeclaratorGroup.
365 // Unfortunately, by the time we get to FinializeDeclaratorGroup, we've
366 // thrown out the old decl.
367 if (!NewFSDecl->getInit() &&
368 (NewFSDecl->getStorageClass() == VarDecl::None ||
369 NewFSDecl->getStorageClass() == VarDecl::Static))
370 ; // change to NewIsTentative = true; once the code is moved.
372 if (NewIsTentative || OldIsTentative)
375 if (Old->getStorageClass() != VarDecl::Extern &&
376 New->getStorageClass() != VarDecl::Extern) {
377 Diag(New->getLocation(), diag::err_redefinition, New->getName());
378 Diag(Old->getLocation(), diag::err_previous_definition);
383 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
384 /// no declarator (e.g. "struct foo;") is parsed.
385 Sema::DeclTy *Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
386 // TODO: emit error on 'int;' or 'const enum foo;'.
387 // TODO: emit error on 'typedef int;'
388 // if (!DS.isMissingDeclaratorOk()) Diag(...);
390 return dyn_cast_or_null<TagDecl>(static_cast<Decl *>(DS.getTypeRep()));
393 bool Sema::CheckSingleInitializer(Expr *&Init, QualType DeclType) {
394 // Get the type before calling CheckSingleAssignmentConstraints(), since
395 // it can promote the expression.
396 QualType InitType = Init->getType();
398 AssignConvertType ConvTy = CheckSingleAssignmentConstraints(DeclType, Init);
399 return DiagnoseAssignmentResult(ConvTy, Init->getLocStart(), DeclType,
400 InitType, Init, "initializing");
403 bool Sema::CheckInitExpr(Expr *expr, InitListExpr *IList, unsigned slot,
404 QualType ElementType) {
405 Expr *savExpr = expr; // Might be promoted by CheckSingleInitializer.
406 if (CheckSingleInitializer(expr, ElementType))
407 return true; // types weren't compatible.
409 if (savExpr != expr) // The type was promoted, update initializer list.
410 IList->setInit(slot, expr);
414 bool Sema::CheckStringLiteralInit(StringLiteral *strLiteral, QualType &DeclT) {
415 if (const IncompleteArrayType *IAT = DeclT->getAsIncompleteArrayType()) {
416 // C99 6.7.8p14. We have an array of character type with unknown size
417 // being initialized to a string literal.
418 llvm::APSInt ConstVal(32);
419 ConstVal = strLiteral->getByteLength() + 1;
420 // Return a new array type (C99 6.7.8p22).
421 DeclT = Context.getConstantArrayType(IAT->getElementType(), ConstVal,
422 ArrayType::Normal, 0);
423 } else if (const ConstantArrayType *CAT = DeclT->getAsConstantArrayType()) {
424 // C99 6.7.8p14. We have an array of character type with known size.
425 if (strLiteral->getByteLength() > (unsigned)CAT->getMaximumElements())
426 Diag(strLiteral->getSourceRange().getBegin(),
427 diag::warn_initializer_string_for_char_array_too_long,
428 strLiteral->getSourceRange());
430 assert(0 && "HandleStringLiteralInit(): Invalid array type");
432 // Set type from "char *" to "constant array of char".
433 strLiteral->setType(DeclT);
434 // For now, we always return false (meaning success).
438 StringLiteral *Sema::IsStringLiteralInit(Expr *Init, QualType DeclType) {
439 const ArrayType *AT = DeclType->getAsArrayType();
440 if (AT && AT->getElementType()->isCharType()) {
441 return dyn_cast<StringLiteral>(Init);
446 // CheckInitializerListTypes - Checks the types of elements of an initializer
447 // list. This function is recursive: it calls itself to initialize subelements
448 // of aggregate types. Note that the topLevel parameter essentially refers to
449 // whether this expression "owns" the initializer list passed in, or if this
450 // initialization is taking elements out of a parent initializer. Each
451 // call to this function adds zero or more to startIndex, reports any errors,
452 // and returns true if it found any inconsistent types.
453 bool Sema::CheckInitializerListTypes(InitListExpr*& IList, QualType &DeclType,
454 bool topLevel, unsigned& startIndex) {
455 bool hadError = false;
457 if (DeclType->isScalarType()) {
458 // The simplest case: initializing a single scalar
460 Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init,
461 IList->getSourceRange());
463 if (startIndex < IList->getNumInits()) {
464 Expr* expr = IList->getInit(startIndex);
465 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
466 // FIXME: Should an error be reported here instead?
467 unsigned newIndex = 0;
468 CheckInitializerListTypes(SubInitList, DeclType, true, newIndex);
470 hadError |= CheckInitExpr(expr, IList, startIndex, DeclType);
474 // FIXME: Should an error be reported for empty initializer list + scalar?
475 } else if (DeclType->isVectorType()) {
476 if (startIndex < IList->getNumInits()) {
477 const VectorType *VT = DeclType->getAsVectorType();
478 int maxElements = VT->getNumElements();
479 QualType elementType = VT->getElementType();
481 for (int i = 0; i < maxElements; ++i) {
482 // Don't attempt to go past the end of the init list
483 if (startIndex >= IList->getNumInits())
485 Expr* expr = IList->getInit(startIndex);
486 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
487 unsigned newIndex = 0;
488 hadError |= CheckInitializerListTypes(SubInitList, elementType,
492 hadError |= CheckInitializerListTypes(IList, elementType,
497 } else if (DeclType->isAggregateType() || DeclType->isUnionType()) {
498 if (DeclType->isStructureType() || DeclType->isUnionType()) {
499 if (startIndex < IList->getNumInits() && !topLevel &&
500 Context.typesAreCompatible(IList->getInit(startIndex)->getType(),
502 // We found a compatible struct; per the standard, this initializes the
503 // struct. (The C standard technically says that this only applies for
504 // initializers for declarations with automatic scope; however, this
505 // construct is unambiguous anyway because a struct cannot contain
506 // a type compatible with itself. We'll output an error when we check
507 // if the initializer is constant.)
508 // FIXME: Is a call to CheckSingleInitializer required here?
511 RecordDecl* structDecl = DeclType->getAsRecordType()->getDecl();
513 // If the record is invalid, some of it's members are invalid. To avoid
514 // confusion, we forgo checking the intializer for the entire record.
515 if (structDecl->isInvalidDecl())
518 // If structDecl is a forward declaration, this loop won't do anything;
519 // That's okay, because an error should get printed out elsewhere. It
520 // might be worthwhile to skip over the rest of the initializer, though.
521 int numMembers = structDecl->getNumMembers() -
522 structDecl->hasFlexibleArrayMember();
523 for (int i = 0; i < numMembers; i++) {
524 // Don't attempt to go past the end of the init list
525 if (startIndex >= IList->getNumInits())
527 FieldDecl * curField = structDecl->getMember(i);
528 if (!curField->getIdentifier()) {
529 // Don't initialize unnamed fields, e.g. "int : 20;"
532 QualType fieldType = curField->getType();
533 Expr* expr = IList->getInit(startIndex);
534 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
535 unsigned newStart = 0;
536 hadError |= CheckInitializerListTypes(SubInitList, fieldType,
540 hadError |= CheckInitializerListTypes(IList, fieldType,
543 if (DeclType->isUnionType())
546 // FIXME: Implement flexible array initialization GCC extension (it's a
547 // really messy extension to implement, unfortunately...the necessary
548 // information isn't actually even here!)
550 } else if (DeclType->isArrayType()) {
551 // Check for the special-case of initializing an array with a string.
552 if (startIndex < IList->getNumInits()) {
553 if (StringLiteral *lit = IsStringLiteralInit(IList->getInit(startIndex),
555 CheckStringLiteralInit(lit, DeclType);
557 if (topLevel && startIndex < IList->getNumInits()) {
558 // We have leftover initializers; warn
559 Diag(IList->getInit(startIndex)->getLocStart(),
560 diag::err_excess_initializers_in_char_array_initializer,
561 IList->getInit(startIndex)->getSourceRange());
567 if (DeclType->isIncompleteArrayType()) {
568 // FIXME: use a proper constant
569 maxElements = 0x7FFFFFFF;
570 } else if (const VariableArrayType *VAT =
571 DeclType->getAsVariableArrayType()) {
572 // Check for VLAs; in standard C it would be possible to check this
573 // earlier, but I don't know where clang accepts VLAs (gcc accepts
574 // them in all sorts of strange places).
575 Diag(VAT->getSizeExpr()->getLocStart(),
576 diag::err_variable_object_no_init,
577 VAT->getSizeExpr()->getSourceRange());
579 maxElements = 0x7FFFFFFF;
581 const ConstantArrayType *CAT = DeclType->getAsConstantArrayType();
582 maxElements = static_cast<int>(CAT->getSize().getZExtValue());
584 QualType elementType = DeclType->getAsArrayType()->getElementType();
586 for (int i = 0; i < maxElements; ++i, ++numElements) {
587 // Don't attempt to go past the end of the init list
588 if (startIndex >= IList->getNumInits())
590 Expr* expr = IList->getInit(startIndex);
591 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
592 unsigned newIndex = 0;
593 hadError |= CheckInitializerListTypes(SubInitList, elementType,
597 hadError |= CheckInitializerListTypes(IList, elementType,
601 if (DeclType->isIncompleteArrayType()) {
602 // If this is an incomplete array type, the actual type needs to
603 // be calculated here
604 if (numElements == 0) {
605 // Sizing an array implicitly to zero is not allowed
606 // (It could in theory be allowed, but it doesn't really matter.)
607 Diag(IList->getLocStart(),
608 diag::err_at_least_one_initializer_needed_to_size_array);
611 llvm::APSInt ConstVal(32);
612 ConstVal = numElements;
613 DeclType = Context.getConstantArrayType(elementType, ConstVal,
614 ArrayType::Normal, 0);
618 assert(0 && "Aggregate that isn't a function or array?!");
621 // In C, all types are either scalars or aggregates, but
622 // additional handling is needed here for C++ (and possibly others?).
623 assert(0 && "Unsupported initializer type");
626 // If this init list is a base list, we set the type; an initializer doesn't
627 // fundamentally have a type, but this makes the ASTs a bit easier to read
629 IList->setType(DeclType);
631 if (topLevel && startIndex < IList->getNumInits()) {
632 // We have leftover initializers; warn
633 Diag(IList->getInit(startIndex)->getLocStart(),
634 diag::warn_excess_initializers,
635 IList->getInit(startIndex)->getSourceRange());
640 bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType) {
641 // C99 6.7.8p3: The type of the entity to be initialized shall be an array
642 // of unknown size ("[]") or an object type that is not a variable array type.
643 if (const VariableArrayType *VAT = DeclType->getAsVariableArrayType())
644 return Diag(VAT->getSizeExpr()->getLocStart(),
645 diag::err_variable_object_no_init,
646 VAT->getSizeExpr()->getSourceRange());
648 InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
650 // FIXME: Handle wide strings
651 if (StringLiteral *strLiteral = IsStringLiteralInit(Init, DeclType))
652 return CheckStringLiteralInit(strLiteral, DeclType);
654 if (DeclType->isArrayType())
655 return Diag(Init->getLocStart(),
656 diag::err_array_init_list_required,
657 Init->getSourceRange());
659 return CheckSingleInitializer(Init, DeclType);
661 unsigned newIndex = 0;
662 return CheckInitializerListTypes(InitList, DeclType, true, newIndex);
666 Sema::ActOnDeclarator(Scope *S, Declarator &D, DeclTy *lastDecl) {
667 ScopedDecl *LastDeclarator = dyn_cast_or_null<ScopedDecl>((Decl *)lastDecl);
668 IdentifierInfo *II = D.getIdentifier();
670 // All of these full declarators require an identifier. If it doesn't have
671 // one, the ParsedFreeStandingDeclSpec action should be used.
673 Diag(D.getDeclSpec().getSourceRange().getBegin(),
674 diag::err_declarator_need_ident,
675 D.getDeclSpec().getSourceRange(), D.getSourceRange());
679 // The scope passed in may not be a decl scope. Zip up the scope tree until
680 // we find one that is.
681 while ((S->getFlags() & Scope::DeclScope) == 0)
684 // See if this is a redefinition of a variable in the same scope.
685 ScopedDecl *PrevDecl = LookupScopedDecl(II, Decl::IDNS_Ordinary,
686 D.getIdentifierLoc(), S);
688 bool InvalidDecl = false;
690 QualType R = GetTypeForDeclarator(D, S);
691 assert(!R.isNull() && "GetTypeForDeclarator() returned null type");
693 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
694 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, LastDeclarator);
695 if (!NewTD) return 0;
697 // Handle attributes prior to checking for duplicates in MergeVarDecl
698 HandleDeclAttributes(NewTD, D.getDeclSpec().getAttributes(),
700 // Merge the decl with the existing one if appropriate. If the decl is
701 // in an outer scope, it isn't the same thing.
702 if (PrevDecl && S->isDeclScope(PrevDecl)) {
703 NewTD = MergeTypeDefDecl(NewTD, PrevDecl);
704 if (NewTD == 0) return 0;
707 if (S->getParent() == 0) {
708 // C99 6.7.7p2: If a typedef name specifies a variably modified type
709 // then it shall have block scope.
710 if (NewTD->getUnderlyingType()->isVariablyModifiedType()) {
711 // FIXME: Diagnostic needs to be fixed.
712 Diag(D.getIdentifierLoc(), diag::err_typecheck_illegal_vla);
716 } else if (R.getTypePtr()->isFunctionType()) {
717 FunctionDecl::StorageClass SC = FunctionDecl::None;
718 switch (D.getDeclSpec().getStorageClassSpec()) {
719 default: assert(0 && "Unknown storage class!");
720 case DeclSpec::SCS_auto:
721 case DeclSpec::SCS_register:
722 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_func,
726 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
727 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break;
728 case DeclSpec::SCS_static: SC = FunctionDecl::Static; break;
729 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
732 FunctionDecl *NewFD = new FunctionDecl(D.getIdentifierLoc(), II, R, SC,
733 D.getDeclSpec().isInlineSpecified(),
735 // FIXME: Handle attributes.
736 D.getDeclSpec().clearAttributes();
738 // Merge the decl with the existing one if appropriate. Since C functions
739 // are in a flat namespace, make sure we consider decls in outer scopes.
741 NewFD = MergeFunctionDecl(NewFD, PrevDecl);
742 if (NewFD == 0) return 0;
746 if (R.getTypePtr()->isObjCInterfaceType()) {
747 Diag(D.getIdentifierLoc(), diag::err_statically_allocated_object,
748 D.getIdentifier()->getName());
753 VarDecl::StorageClass SC;
754 switch (D.getDeclSpec().getStorageClassSpec()) {
755 default: assert(0 && "Unknown storage class!");
756 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break;
757 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break;
758 case DeclSpec::SCS_static: SC = VarDecl::Static; break;
759 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break;
760 case DeclSpec::SCS_register: SC = VarDecl::Register; break;
761 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
763 if (S->getParent() == 0) {
764 // C99 6.9p2: The storage-class specifiers auto and register shall not
765 // appear in the declaration specifiers in an external declaration.
766 if (SC == VarDecl::Auto || SC == VarDecl::Register) {
767 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope,
771 NewVD = new FileVarDecl(D.getIdentifierLoc(), II, R, SC, LastDeclarator);
773 NewVD = new BlockVarDecl(D.getIdentifierLoc(), II, R, SC, LastDeclarator);
775 // Handle attributes prior to checking for duplicates in MergeVarDecl
776 HandleDeclAttributes(NewVD, D.getDeclSpec().getAttributes(),
779 // Merge the decl with the existing one if appropriate. If the decl is
780 // in an outer scope, it isn't the same thing.
781 if (PrevDecl && S->isDeclScope(PrevDecl)) {
782 NewVD = MergeVarDecl(NewVD, PrevDecl);
783 if (NewVD == 0) return 0;
788 // If this has an identifier, add it to the scope stack.
790 New->setNext(II->getFETokenInfo<ScopedDecl>());
791 II->setFETokenInfo(New);
794 // If any semantic error occurred, mark the decl as invalid.
795 if (D.getInvalidType() || InvalidDecl)
796 New->setInvalidDecl();
801 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
803 // FIXME: Remove the isReference check and handle assignment to a reference.
804 if (!DclT->isReferenceType() && !Init->isConstantExpr(Context, &loc)) {
805 assert(loc.isValid() && "isConstantExpr didn't return a loc!");
806 Diag(loc, diag::err_init_element_not_constant, Init->getSourceRange());
812 void Sema::AddInitializerToDecl(DeclTy *dcl, ExprTy *init) {
813 Decl *RealDecl = static_cast<Decl *>(dcl);
814 Expr *Init = static_cast<Expr *>(init);
815 assert(Init && "missing initializer");
817 // If there is no declaration, there was an error parsing it. Just ignore
824 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
826 Diag(dyn_cast<ScopedDecl>(RealDecl)->getLocation(),
827 diag::err_illegal_initializer);
828 RealDecl->setInvalidDecl();
831 // Get the decls type and save a reference for later, since
832 // CheckInitializerTypes may change it.
833 QualType DclT = VDecl->getType(), SavT = DclT;
834 if (BlockVarDecl *BVD = dyn_cast<BlockVarDecl>(VDecl)) {
835 VarDecl::StorageClass SC = BVD->getStorageClass();
836 if (SC == VarDecl::Extern) { // C99 6.7.8p5
837 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
838 BVD->setInvalidDecl();
839 } else if (!BVD->isInvalidDecl()) {
840 if (CheckInitializerTypes(Init, DclT))
841 BVD->setInvalidDecl();
842 if (SC == VarDecl::Static) // C99 6.7.8p4.
843 CheckForConstantInitializer(Init, DclT);
845 } else if (FileVarDecl *FVD = dyn_cast<FileVarDecl>(VDecl)) {
846 if (FVD->getStorageClass() == VarDecl::Extern)
847 Diag(VDecl->getLocation(), diag::warn_extern_init);
848 if (!FVD->isInvalidDecl())
849 if (CheckInitializerTypes(Init, DclT))
850 FVD->setInvalidDecl();
852 // C99 6.7.8p4. All file scoped initializers need to be constant.
853 CheckForConstantInitializer(Init, DclT);
855 // If the type changed, it means we had an incomplete type that was
856 // completed by the initializer. For example:
857 // int ary[] = { 1, 3, 5 };
858 // "ary" transitions from a VariableArrayType to a ConstantArrayType.
859 if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
860 VDecl->setType(DclT);
864 // Attach the initializer to the decl.
865 VDecl->setInit(Init);
869 /// The declarators are chained together backwards, reverse the list.
870 Sema::DeclTy *Sema::FinalizeDeclaratorGroup(Scope *S, DeclTy *group) {
871 // Often we have single declarators, handle them quickly.
872 Decl *GroupDecl = static_cast<Decl*>(group);
876 ScopedDecl *Group = dyn_cast<ScopedDecl>(GroupDecl);
877 ScopedDecl *NewGroup = 0;
878 if (Group->getNextDeclarator() == 0)
880 else { // reverse the list.
882 ScopedDecl *Next = Group->getNextDeclarator();
883 Group->setNextDeclarator(NewGroup);
888 // Perform semantic analysis that depends on having fully processed both
889 // the declarator and initializer.
890 for (ScopedDecl *ID = NewGroup; ID; ID = ID->getNextDeclarator()) {
891 VarDecl *IDecl = dyn_cast<VarDecl>(ID);
894 FileVarDecl *FVD = dyn_cast<FileVarDecl>(IDecl);
895 BlockVarDecl *BVD = dyn_cast<BlockVarDecl>(IDecl);
896 QualType T = IDecl->getType();
898 // C99 6.7.5.2p2: If an identifier is declared to be an object with
899 // static storage duration, it shall not have a variable length array.
900 if ((FVD || BVD) && IDecl->getStorageClass() == VarDecl::Static) {
901 if (T->getAsVariableArrayType()) {
902 Diag(IDecl->getLocation(), diag::err_typecheck_illegal_vla);
903 IDecl->setInvalidDecl();
906 // Block scope. C99 6.7p7: If an identifier for an object is declared with
907 // no linkage (C99 6.2.2p6), the type for the object shall be complete...
908 if (BVD && IDecl->getStorageClass() != VarDecl::Extern) {
909 if (T->isIncompleteType()) {
910 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type,
912 IDecl->setInvalidDecl();
915 // File scope. C99 6.9.2p2: A declaration of an identifier for and
916 // object that has file scope without an initializer, and without a
917 // storage-class specifier or with the storage-class specifier "static",
918 // constitutes a tentative definition. Note: A tentative definition with
919 // external linkage is valid (C99 6.2.2p5).
920 if (FVD && !FVD->getInit() && (FVD->getStorageClass() == VarDecl::Static ||
921 FVD->getStorageClass() == VarDecl::None)) {
922 if (T->isIncompleteArrayType()) {
923 // C99 6.9.2 (p2, p5): Implicit initialization causes an incomplete
924 // array to be completed. Don't issue a diagnostic.
925 } else if (T->isIncompleteType()) {
926 // C99 6.9.2p3: If the declaration of an identifier for an object is
927 // a tentative definition and has internal linkage (C99 6.2.2p3), the
928 // declared type shall not be an incomplete type.
929 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type,
931 IDecl->setInvalidDecl();
938 // Called from Sema::ParseStartOfFunctionDef().
940 Sema::ActOnParamDeclarator(struct DeclaratorChunk::ParamInfo &PI,
942 IdentifierInfo *II = PI.Ident;
943 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
944 // Can this happen for params? We already checked that they don't conflict
945 // among each other. Here they can only shadow globals, which is ok.
946 if (/*Decl *PrevDecl = */LookupScopedDecl(II, Decl::IDNS_Ordinary,
947 PI.IdentLoc, FnScope)) {
951 // FIXME: Handle storage class (auto, register). No declarator?
952 // TODO: Chain to previous parameter with the prevdeclarator chain?
954 // Perform the default function/array conversion (C99 6.7.5.3p[7,8]).
955 // Doing the promotion here has a win and a loss. The win is the type for
956 // both Decl's and DeclRefExpr's will match (a convenient invariant for the
957 // code generator). The loss is the orginal type isn't preserved. For example:
959 // void func(int parmvardecl[5]) { // convert "int [5]" to "int *"
960 // int blockvardecl[5];
961 // sizeof(parmvardecl); // size == 4
962 // sizeof(blockvardecl); // size == 20
965 // For expressions, all implicit conversions are captured using the
966 // ImplicitCastExpr AST node (we have no such mechanism for Decl's).
968 // FIXME: If a source translation tool needs to see the original type, then
969 // we need to consider storing both types (in ParmVarDecl)...
971 QualType parmDeclType = QualType::getFromOpaquePtr(PI.TypeInfo);
972 if (const ArrayType *AT = parmDeclType->getAsArrayType()) {
973 // int x[restrict 4] -> int *restrict
974 parmDeclType = Context.getPointerType(AT->getElementType());
975 parmDeclType = parmDeclType.getQualifiedType(AT->getIndexTypeQualifier());
976 } else if (parmDeclType->isFunctionType())
977 parmDeclType = Context.getPointerType(parmDeclType);
979 ParmVarDecl *New = new ParmVarDecl(PI.IdentLoc, II, parmDeclType,
983 New->setInvalidDecl();
985 // If this has an identifier, add it to the scope stack.
987 New->setNext(II->getFETokenInfo<ScopedDecl>());
988 II->setFETokenInfo(New);
989 FnScope->AddDecl(New);
992 HandleDeclAttributes(New, PI.AttrList, 0);
996 Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
997 assert(CurFunctionDecl == 0 && "Function parsing confused");
998 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
999 "Not a function declarator!");
1000 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
1002 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
1003 // for a K&R function.
1004 if (!FTI.hasPrototype) {
1005 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
1006 if (FTI.ArgInfo[i].TypeInfo == 0) {
1007 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared,
1008 FTI.ArgInfo[i].Ident->getName());
1009 // Implicitly declare the argument as type 'int' for lack of a better
1011 FTI.ArgInfo[i].TypeInfo = Context.IntTy.getAsOpaquePtr();
1015 // Since this is a function definition, act as though we have information
1016 // about the arguments.
1018 FTI.hasPrototype = true;
1020 // FIXME: Diagnose arguments without names in C.
1024 Scope *GlobalScope = FnBodyScope->getParent();
1026 // See if this is a redefinition.
1027 ScopedDecl *PrevDcl = LookupScopedDecl(D.getIdentifier(), Decl::IDNS_Ordinary,
1028 D.getIdentifierLoc(), GlobalScope);
1029 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(PrevDcl)) {
1030 if (FD->getBody()) {
1031 Diag(D.getIdentifierLoc(), diag::err_redefinition,
1032 D.getIdentifier()->getName());
1033 Diag(FD->getLocation(), diag::err_previous_definition);
1036 Decl *decl = static_cast<Decl*>(ActOnDeclarator(GlobalScope, D, 0));
1037 FunctionDecl *FD = cast<FunctionDecl>(decl);
1038 CurFunctionDecl = FD;
1040 // Create Decl objects for each parameter, adding them to the FunctionDecl.
1041 llvm::SmallVector<ParmVarDecl*, 16> Params;
1043 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs function that takes
1044 // no arguments, not a function that takes a single void argument.
1045 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
1046 !QualType::getFromOpaquePtr(FTI.ArgInfo[0].TypeInfo).getCVRQualifiers() &&
1047 QualType::getFromOpaquePtr(FTI.ArgInfo[0].TypeInfo)->isVoidType()) {
1048 // empty arg list, don't push any params.
1050 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
1051 Params.push_back(ActOnParamDeclarator(D.getTypeObject(0).Fun.ArgInfo[i],
1056 FD->setParams(&Params[0], Params.size());
1061 Sema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtTy *Body) {
1062 Decl *dcl = static_cast<Decl *>(D);
1063 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(dcl)) {
1064 FD->setBody((Stmt*)Body);
1065 assert(FD == CurFunctionDecl && "Function parsing confused");
1066 CurFunctionDecl = 0;
1067 } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(dcl)) {
1068 MD->setBody((Stmt*)Body);
1071 // Verify and clean out per-function state.
1073 // Check goto/label use.
1074 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
1075 I = LabelMap.begin(), E = LabelMap.end(); I != E; ++I) {
1076 // Verify that we have no forward references left. If so, there was a goto
1077 // or address of a label taken, but no definition of it. Label fwd
1078 // definitions are indicated with a null substmt.
1079 if (I->second->getSubStmt() == 0) {
1080 LabelStmt *L = I->second;
1082 Diag(L->getIdentLoc(), diag::err_undeclared_label_use, L->getName());
1084 // At this point, we have gotos that use the bogus label. Stitch it into
1085 // the function body so that they aren't leaked and that the AST is well
1088 L->setSubStmt(new NullStmt(L->getIdentLoc()));
1089 cast<CompoundStmt>((Stmt*)Body)->push_back(L);
1091 // The whole function wasn't parsed correctly, just delete this.
1101 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
1102 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
1103 ScopedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
1104 IdentifierInfo &II, Scope *S) {
1105 if (getLangOptions().C99) // Extension in C99.
1106 Diag(Loc, diag::ext_implicit_function_decl, II.getName());
1107 else // Legal in C90, but warn about it.
1108 Diag(Loc, diag::warn_implicit_function_decl, II.getName());
1110 // FIXME: handle stuff like:
1111 // void foo() { extern float X(); }
1112 // void bar() { X(); } <-- implicit decl for X in another scope.
1114 // Set a Declarator for the implicit definition: int foo();
1117 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy);
1118 Error = Error; // Silence warning.
1119 assert(!Error && "Error setting up implicit decl!");
1120 Declarator D(DS, Declarator::BlockContext);
1121 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, 0, 0, Loc));
1122 D.SetIdentifier(&II, Loc);
1124 // Find translation-unit scope to insert this function into.
1125 if (Scope *FnS = S->getFnParent())
1126 S = FnS->getParent(); // Skip all scopes in a function at once.
1127 while (S->getParent())
1130 return dyn_cast<ScopedDecl>(static_cast<Decl*>(ActOnDeclarator(S, D, 0)));
1134 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
1135 ScopedDecl *LastDeclarator) {
1136 assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
1137 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
1139 // Scope manipulation handled by caller.
1140 TypedefDecl *NewTD = new TypedefDecl(D.getIdentifierLoc(), D.getIdentifier(),
1142 if (D.getInvalidType())
1143 NewTD->setInvalidDecl();
1147 /// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
1148 /// former case, Name will be non-null. In the later case, Name will be null.
1149 /// TagType indicates what kind of tag this is. TK indicates whether this is a
1150 /// reference/declaration/definition of a tag.
1151 Sema::DeclTy *Sema::ActOnTag(Scope *S, unsigned TagType, TagKind TK,
1152 SourceLocation KWLoc, IdentifierInfo *Name,
1153 SourceLocation NameLoc, AttributeList *Attr) {
1154 // If this is a use of an existing tag, it must have a name.
1155 assert((Name != 0 || TK == TK_Definition) &&
1156 "Nameless record must be a definition!");
1160 default: assert(0 && "Unknown tag type!");
1161 case DeclSpec::TST_struct: Kind = Decl::Struct; break;
1162 case DeclSpec::TST_union: Kind = Decl::Union; break;
1163 //case DeclSpec::TST_class: Kind = Decl::Class; break;
1164 case DeclSpec::TST_enum: Kind = Decl::Enum; break;
1167 // If this is a named struct, check to see if there was a previous forward
1168 // declaration or definition.
1169 if (TagDecl *PrevDecl =
1170 dyn_cast_or_null<TagDecl>(LookupScopedDecl(Name, Decl::IDNS_Tag,
1173 // If this is a use of a previous tag, or if the tag is already declared in
1174 // the same scope (so that the definition/declaration completes or
1175 // rementions the tag), reuse the decl.
1176 if (TK == TK_Reference || S->isDeclScope(PrevDecl)) {
1177 // Make sure that this wasn't declared as an enum and now used as a struct
1178 // or something similar.
1179 if (PrevDecl->getKind() != Kind) {
1180 Diag(KWLoc, diag::err_use_with_wrong_tag, Name->getName());
1181 Diag(PrevDecl->getLocation(), diag::err_previous_use);
1184 // If this is a use or a forward declaration, we're good.
1185 if (TK != TK_Definition)
1188 // Diagnose attempts to redefine a tag.
1189 if (PrevDecl->isDefinition()) {
1190 Diag(NameLoc, diag::err_redefinition, Name->getName());
1191 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
1192 // If this is a redefinition, recover by making this struct be
1193 // anonymous, which will make any later references get the previous
1197 // Okay, this is definition of a previously declared or referenced tag.
1198 // Move the location of the decl to be the definition site.
1199 PrevDecl->setLocation(NameLoc);
1203 // If we get here, this is a definition of a new struct type in a nested
1204 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a new
1208 // If there is an identifier, use the location of the identifier as the
1209 // location of the decl, otherwise use the location of the struct/union
1211 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
1213 // Otherwise, if this is the first time we've seen this tag, create the decl.
1216 default: assert(0 && "Unknown tag kind!");
1218 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
1219 // enum X { A, B, C } D; D should chain to X.
1220 New = new EnumDecl(Loc, Name, 0);
1221 // If this is an undefined enum, warn.
1222 if (TK != TK_Definition) Diag(Loc, diag::ext_forward_ref_enum);
1227 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
1228 // struct X { int A; } D; D should chain to X.
1229 New = new RecordDecl(Kind, Loc, Name, 0);
1233 // If this has an identifier, add it to the scope stack.
1235 // The scope passed in may not be a decl scope. Zip up the scope tree until
1236 // we find one that is.
1237 while ((S->getFlags() & Scope::DeclScope) == 0)
1240 // Add it to the decl chain.
1241 New->setNext(Name->getFETokenInfo<ScopedDecl>());
1242 Name->setFETokenInfo(New);
1246 HandleDeclAttributes(New, Attr, 0);
1250 /// ActOnField - Each field of a struct/union/class is passed into this in order
1251 /// to create a FieldDecl object for it.
1252 Sema::DeclTy *Sema::ActOnField(Scope *S, DeclTy *TagDecl,
1253 SourceLocation DeclStart,
1254 Declarator &D, ExprTy *BitfieldWidth) {
1255 IdentifierInfo *II = D.getIdentifier();
1256 Expr *BitWidth = (Expr*)BitfieldWidth;
1257 SourceLocation Loc = DeclStart;
1258 if (II) Loc = D.getIdentifierLoc();
1260 // FIXME: Unnamed fields can be handled in various different ways, for
1261 // example, unnamed unions inject all members into the struct namespace!
1266 //printf("WARNING: BITFIELDS IGNORED!\n");
1278 QualType T = GetTypeForDeclarator(D, S);
1279 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
1280 bool InvalidDecl = false;
1282 // C99 6.7.2.1p8: A member of a structure or union may have any type other
1283 // than a variably modified type.
1284 if (T->isVariablyModifiedType()) {
1285 // FIXME: This diagnostic needs work
1286 Diag(Loc, diag::err_typecheck_illegal_vla, Loc);
1289 // FIXME: Chain fielddecls together.
1292 if (isa<RecordDecl>(static_cast<Decl *>(TagDecl)))
1293 NewFD = new FieldDecl(Loc, II, T, BitWidth);
1294 else if (isa<ObjCInterfaceDecl>(static_cast<Decl *>(TagDecl)) ||
1295 isa<ObjCImplementationDecl>(static_cast<Decl *>(TagDecl)) ||
1296 isa<ObjCCategoryDecl>(static_cast<Decl *>(TagDecl)) ||
1297 // FIXME: ivars are currently used to model properties, and
1298 // properties can appear within a protocol.
1299 // See corresponding FIXME in DeclObjC.h:ObjCPropertyDecl.
1300 isa<ObjCProtocolDecl>(static_cast<Decl *>(TagDecl)))
1301 NewFD = new ObjCIvarDecl(Loc, II, T);
1303 assert(0 && "Sema::ActOnField(): Unknown TagDecl");
1305 HandleDeclAttributes(NewFD, D.getDeclSpec().getAttributes(),
1308 if (D.getInvalidType() || InvalidDecl)
1309 NewFD->setInvalidDecl();
1313 /// TranslateIvarVisibility - Translate visibility from a token ID to an
1315 static ObjCIvarDecl::AccessControl
1316 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
1317 switch (ivarVisibility) {
1318 case tok::objc_private: return ObjCIvarDecl::Private;
1319 case tok::objc_public: return ObjCIvarDecl::Public;
1320 case tok::objc_protected: return ObjCIvarDecl::Protected;
1321 case tok::objc_package: return ObjCIvarDecl::Package;
1322 default: assert(false && "Unknown visitibility kind");
1326 void Sema::ActOnFields(Scope* S,
1327 SourceLocation RecLoc, DeclTy *RecDecl,
1328 DeclTy **Fields, unsigned NumFields,
1329 SourceLocation LBrac, SourceLocation RBrac,
1330 tok::ObjCKeywordKind *visibility) {
1331 Decl *EnclosingDecl = static_cast<Decl*>(RecDecl);
1332 assert(EnclosingDecl && "missing record or interface decl");
1333 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
1335 if (Record && Record->isDefinition()) {
1336 // Diagnose code like:
1337 // struct S { struct S {} X; };
1338 // We discover this when we complete the outer S. Reject and ignore the
1340 Diag(Record->getLocation(), diag::err_nested_redefinition,
1341 Record->getKindName());
1342 Diag(RecLoc, diag::err_previous_definition);
1343 Record->setInvalidDecl();
1346 // Verify that all the fields are okay.
1347 unsigned NumNamedMembers = 0;
1348 llvm::SmallVector<FieldDecl*, 32> RecFields;
1349 llvm::SmallSet<const IdentifierInfo*, 32> FieldIDs;
1351 for (unsigned i = 0; i != NumFields; ++i) {
1353 FieldDecl *FD = cast_or_null<FieldDecl>(static_cast<Decl*>(Fields[i]));
1354 assert(FD && "missing field decl");
1356 // Remember all fields.
1357 RecFields.push_back(FD);
1359 // Get the type for the field.
1360 Type *FDTy = FD->getType().getTypePtr();
1362 // If we have visibility info, make sure the AST is set accordingly.
1364 cast<ObjCIvarDecl>(FD)->setAccessControl(
1365 TranslateIvarVisibility(visibility[i]));
1367 // C99 6.7.2.1p2 - A field may not be a function type.
1368 if (FDTy->isFunctionType()) {
1369 Diag(FD->getLocation(), diag::err_field_declared_as_function,
1371 FD->setInvalidDecl();
1372 EnclosingDecl->setInvalidDecl();
1375 // C99 6.7.2.1p2 - A field may not be an incomplete type except...
1376 if (FDTy->isIncompleteType()) {
1377 if (!Record) { // Incomplete ivar type is always an error.
1378 Diag(FD->getLocation(), diag::err_field_incomplete, FD->getName());
1379 FD->setInvalidDecl();
1380 EnclosingDecl->setInvalidDecl();
1383 if (i != NumFields-1 || // ... that the last member ...
1384 Record->getKind() != Decl::Struct || // ... of a structure ...
1385 !FDTy->isArrayType()) { //... may have incomplete array type.
1386 Diag(FD->getLocation(), diag::err_field_incomplete, FD->getName());
1387 FD->setInvalidDecl();
1388 EnclosingDecl->setInvalidDecl();
1391 if (NumNamedMembers < 1) { //... must have more than named member ...
1392 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct,
1394 FD->setInvalidDecl();
1395 EnclosingDecl->setInvalidDecl();
1398 // Okay, we have a legal flexible array member at the end of the struct.
1400 Record->setHasFlexibleArrayMember(true);
1402 /// C99 6.7.2.1p2 - a struct ending in a flexible array member cannot be the
1403 /// field of another structure or the element of an array.
1404 if (const RecordType *FDTTy = FDTy->getAsRecordType()) {
1405 if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
1406 // If this is a member of a union, then entire union becomes "flexible".
1407 if (Record && Record->getKind() == Decl::Union) {
1408 Record->setHasFlexibleArrayMember(true);
1410 // If this is a struct/class and this is not the last element, reject
1411 // it. Note that GCC supports variable sized arrays in the middle of
1413 if (i != NumFields-1) {
1414 Diag(FD->getLocation(), diag::err_variable_sized_type_in_struct,
1416 FD->setInvalidDecl();
1417 EnclosingDecl->setInvalidDecl();
1420 // We support flexible arrays at the end of structs in other structs
1422 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct,
1425 Record->setHasFlexibleArrayMember(true);
1429 /// A field cannot be an Objective-c object
1430 if (FDTy->isObjCInterfaceType()) {
1431 Diag(FD->getLocation(), diag::err_statically_allocated_object,
1433 FD->setInvalidDecl();
1434 EnclosingDecl->setInvalidDecl();
1437 // Keep track of the number of named members.
1438 if (IdentifierInfo *II = FD->getIdentifier()) {
1439 // Detect duplicate member names.
1440 if (!FieldIDs.insert(II)) {
1441 Diag(FD->getLocation(), diag::err_duplicate_member, II->getName());
1442 // Find the previous decl.
1443 SourceLocation PrevLoc;
1444 for (unsigned i = 0, e = RecFields.size(); ; ++i) {
1445 assert(i != e && "Didn't find previous def!");
1446 if (RecFields[i]->getIdentifier() == II) {
1447 PrevLoc = RecFields[i]->getLocation();
1451 Diag(PrevLoc, diag::err_previous_definition);
1452 FD->setInvalidDecl();
1453 EnclosingDecl->setInvalidDecl();
1460 // Okay, we successfully defined 'Record'.
1462 Record->defineBody(&RecFields[0], RecFields.size());
1463 Consumer.HandleTagDeclDefinition(Record);
1465 ObjCIvarDecl **ClsFields = reinterpret_cast<ObjCIvarDecl**>(&RecFields[0]);
1466 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl))
1467 ID->addInstanceVariablesToClass(ClsFields, RecFields.size(), RBrac);
1468 else if (ObjCImplementationDecl *IMPDecl =
1469 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
1470 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
1471 IMPDecl->ObjCAddInstanceVariablesToClassImpl(ClsFields, RecFields.size());
1472 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
1477 Sema::DeclTy *Sema::ActOnEnumConstant(Scope *S, DeclTy *theEnumDecl,
1478 DeclTy *lastEnumConst,
1479 SourceLocation IdLoc, IdentifierInfo *Id,
1480 SourceLocation EqualLoc, ExprTy *val) {
1481 theEnumDecl = theEnumDecl; // silence unused warning.
1482 EnumConstantDecl *LastEnumConst =
1483 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(lastEnumConst));
1484 Expr *Val = static_cast<Expr*>(val);
1486 // The scope passed in may not be a decl scope. Zip up the scope tree until
1487 // we find one that is.
1488 while ((S->getFlags() & Scope::DeclScope) == 0)
1491 // Verify that there isn't already something declared with this name in this
1493 if (ScopedDecl *PrevDecl = LookupScopedDecl(Id, Decl::IDNS_Ordinary,
1495 if (S->isDeclScope(PrevDecl)) {
1496 if (isa<EnumConstantDecl>(PrevDecl))
1497 Diag(IdLoc, diag::err_redefinition_of_enumerator, Id->getName());
1499 Diag(IdLoc, diag::err_redefinition, Id->getName());
1500 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
1501 // FIXME: Don't leak memory: delete Val;
1506 llvm::APSInt EnumVal(32);
1509 // Make sure to promote the operand type to int.
1510 UsualUnaryConversions(Val);
1512 // C99 6.7.2.2p2: Make sure we have an integer constant expression.
1513 SourceLocation ExpLoc;
1514 if (!Val->isIntegerConstantExpr(EnumVal, Context, &ExpLoc)) {
1515 Diag(ExpLoc, diag::err_enum_value_not_integer_constant_expr,
1517 // FIXME: Don't leak memory: delete Val;
1518 Val = 0; // Just forget about it.
1520 EltTy = Val->getType();
1525 if (LastEnumConst) {
1526 // Assign the last value + 1.
1527 EnumVal = LastEnumConst->getInitVal();
1530 // Check for overflow on increment.
1531 if (EnumVal < LastEnumConst->getInitVal())
1532 Diag(IdLoc, diag::warn_enum_value_overflow);
1534 EltTy = LastEnumConst->getType();
1536 // First value, set to zero.
1537 EltTy = Context.IntTy;
1538 EnumVal.zextOrTrunc(
1539 static_cast<uint32_t>(Context.getTypeSize(EltTy, IdLoc)));
1543 EnumConstantDecl *New = new EnumConstantDecl(IdLoc, Id, EltTy, Val, EnumVal,
1546 // Register this decl in the current scope stack.
1547 New->setNext(Id->getFETokenInfo<ScopedDecl>());
1548 Id->setFETokenInfo(New);
1553 void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX,
1554 DeclTy **Elements, unsigned NumElements) {
1555 EnumDecl *Enum = cast<EnumDecl>(static_cast<Decl*>(EnumDeclX));
1556 assert(!Enum->isDefinition() && "Enum redefinitions can't reach here");
1558 // TODO: If the result value doesn't fit in an int, it must be a long or long
1559 // long value. ISO C does not support this, but GCC does as an extension,
1562 Context.Target.getIntWidth(Context.getFullLoc(Enum->getLocation()));
1565 // Verify that all the values are okay, compute the size of the values, and
1566 // reverse the list.
1567 unsigned NumNegativeBits = 0;
1568 unsigned NumPositiveBits = 0;
1570 // Keep track of whether all elements have type int.
1571 bool AllElementsInt = true;
1573 EnumConstantDecl *EltList = 0;
1574 for (unsigned i = 0; i != NumElements; ++i) {
1575 EnumConstantDecl *ECD =
1576 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i]));
1577 if (!ECD) continue; // Already issued a diagnostic.
1579 // If the enum value doesn't fit in an int, emit an extension warning.
1580 assert(ECD->getInitVal().getBitWidth() >= IntWidth &&
1581 "Should have promoted value to int");
1582 const llvm::APSInt &InitVal = ECD->getInitVal();
1583 if (InitVal.getBitWidth() > IntWidth) {
1584 llvm::APSInt V(InitVal);
1586 V.extend(InitVal.getBitWidth());
1588 Diag(ECD->getLocation(), diag::ext_enum_value_not_int,
1589 InitVal.toString());
1592 // Keep track of the size of positive and negative values.
1593 if (InitVal.isUnsigned() || !InitVal.isNegative())
1594 NumPositiveBits = std::max(NumPositiveBits,
1595 (unsigned)InitVal.getActiveBits());
1597 NumNegativeBits = std::max(NumNegativeBits,
1598 (unsigned)InitVal.getMinSignedBits());
1600 // Keep track of whether every enum element has type int (very commmon).
1602 AllElementsInt = ECD->getType() == Context.IntTy;
1604 ECD->setNextDeclarator(EltList);
1608 // Figure out the type that should be used for this enum.
1609 // FIXME: Support attribute(packed) on enums and -fshort-enums.
1613 if (NumNegativeBits) {
1614 // If there is a negative value, figure out the smallest integer type (of
1615 // int/long/longlong) that fits.
1616 if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
1617 BestType = Context.IntTy;
1618 BestWidth = IntWidth;
1621 Context.Target.getLongWidth(Context.getFullLoc(Enum->getLocation()));
1623 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth)
1624 BestType = Context.LongTy;
1626 BestWidth = Context.Target.getLongLongWidth(
1627 Context.getFullLoc(Enum->getLocation()));
1629 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
1630 Diag(Enum->getLocation(), diag::warn_enum_too_large);
1631 BestType = Context.LongLongTy;
1635 // If there is no negative value, figure out which of uint, ulong, ulonglong
1637 if (NumPositiveBits <= IntWidth) {
1638 BestType = Context.UnsignedIntTy;
1639 BestWidth = IntWidth;
1640 } else if (NumPositiveBits <=
1641 (BestWidth = Context.Target.getLongWidth(
1642 Context.getFullLoc(Enum->getLocation()))))
1644 BestType = Context.UnsignedLongTy;
1647 Context.Target.getLongLongWidth(Context.getFullLoc(Enum->getLocation()));
1649 assert(NumPositiveBits <= BestWidth &&
1650 "How could an initializer get larger than ULL?");
1651 BestType = Context.UnsignedLongLongTy;
1655 // Loop over all of the enumerator constants, changing their types to match
1656 // the type of the enum if needed.
1657 for (unsigned i = 0; i != NumElements; ++i) {
1658 EnumConstantDecl *ECD =
1659 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i]));
1660 if (!ECD) continue; // Already issued a diagnostic.
1662 // Standard C says the enumerators have int type, but we allow, as an
1663 // extension, the enumerators to be larger than int size. If each
1664 // enumerator value fits in an int, type it as an int, otherwise type it the
1665 // same as the enumerator decl itself. This means that in "enum { X = 1U }"
1666 // that X has type 'int', not 'unsigned'.
1667 if (ECD->getType() == Context.IntTy)
1668 continue; // Already int type.
1670 // Determine whether the value fits into an int.
1671 llvm::APSInt InitVal = ECD->getInitVal();
1673 if (InitVal.isUnsigned() || !InitVal.isNegative())
1674 FitsInInt = InitVal.getActiveBits() < IntWidth;
1676 FitsInInt = InitVal.getMinSignedBits() <= IntWidth;
1678 // If it fits into an integer type, force it. Otherwise force it to match
1679 // the enum decl type.
1684 NewTy = Context.IntTy;
1685 NewWidth = IntWidth;
1687 } else if (ECD->getType() == BestType) {
1688 // Already the right type!
1692 NewWidth = BestWidth;
1693 NewSign = BestType->isSignedIntegerType();
1696 // Adjust the APSInt value.
1697 InitVal.extOrTrunc(NewWidth);
1698 InitVal.setIsSigned(NewSign);
1699 ECD->setInitVal(InitVal);
1701 // Adjust the Expr initializer and type.
1702 ECD->setInitExpr(new ImplicitCastExpr(NewTy, ECD->getInitExpr()));
1703 ECD->setType(NewTy);
1706 Enum->defineElements(EltList, BestType);
1707 Consumer.HandleTagDeclDefinition(Enum);
1710 Sema::DeclTy *Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
1712 StringLiteral *AsmString = cast<StringLiteral>((Expr*)expr);
1714 return new FileScopeAsmDecl(Loc, AsmString);
1717 Sema::DeclTy* Sema::ActOnLinkageSpec(SourceLocation Loc,
1718 SourceLocation LBrace,
1719 SourceLocation RBrace,
1723 LinkageSpecDecl::LanguageIDs Language;
1724 Decl *dcl = static_cast<Decl *>(D);
1725 if (strncmp(Lang, "\"C\"", StrSize) == 0)
1726 Language = LinkageSpecDecl::lang_c;
1727 else if (strncmp(Lang, "\"C++\"", StrSize) == 0)
1728 Language = LinkageSpecDecl::lang_cxx;
1730 Diag(Loc, diag::err_bad_language);
1734 // FIXME: Add all the various semantics of linkage specifications
1735 return new LinkageSpecDecl(Loc, Language, dcl);
1738 void Sema::HandleDeclAttribute(Decl *New, AttributeList *rawAttr) {
1740 switch (rawAttr->getKind()) {
1741 case AttributeList::AT_vector_size:
1742 if (ValueDecl *vDecl = dyn_cast<ValueDecl>(New)) {
1743 QualType newType = HandleVectorTypeAttribute(vDecl->getType(), rawAttr);
1744 if (!newType.isNull()) // install the new vector type into the decl
1745 vDecl->setType(newType);
1747 if (TypedefDecl *tDecl = dyn_cast<TypedefDecl>(New)) {
1748 QualType newType = HandleVectorTypeAttribute(tDecl->getUnderlyingType(),
1750 if (!newType.isNull()) // install the new vector type into the decl
1751 tDecl->setUnderlyingType(newType);
1754 case AttributeList::AT_ocu_vector_type:
1755 if (TypedefDecl *tDecl = dyn_cast<TypedefDecl>(New))
1756 HandleOCUVectorTypeAttribute(tDecl, rawAttr);
1758 Diag(rawAttr->getAttributeLoc(),
1759 diag::err_typecheck_ocu_vector_not_typedef);
1761 case AttributeList::AT_address_space:
1762 if (TypedefDecl *tDecl = dyn_cast<TypedefDecl>(New)) {
1763 QualType newType = HandleAddressSpaceTypeAttribute(
1764 tDecl->getUnderlyingType(),
1766 if (!newType.isNull()) // install the new addr spaced type into the decl
1767 tDecl->setUnderlyingType(newType);
1768 } else if (ValueDecl *vDecl = dyn_cast<ValueDecl>(New)) {
1769 QualType newType = HandleAddressSpaceTypeAttribute(vDecl->getType(),
1771 if (!newType.isNull()) // install the new addr spaced type into the decl
1772 vDecl->setType(newType);
1775 case AttributeList::AT_aligned:
1776 HandleAlignedAttribute(New, rawAttr);
1778 case AttributeList::AT_packed:
1779 HandlePackedAttribute(New, rawAttr);
1782 // FIXME: add other attributes...
1787 void Sema::HandleDeclAttributes(Decl *New, AttributeList *declspec_prefix,
1788 AttributeList *declarator_postfix) {
1789 while (declspec_prefix) {
1790 HandleDeclAttribute(New, declspec_prefix);
1791 declspec_prefix = declspec_prefix->getNext();
1793 while (declarator_postfix) {
1794 HandleDeclAttribute(New, declarator_postfix);
1795 declarator_postfix = declarator_postfix->getNext();
1799 QualType Sema::HandleAddressSpaceTypeAttribute(QualType curType,
1800 AttributeList *rawAttr) {
1801 // check the attribute arguments.
1802 if (rawAttr->getNumArgs() != 1) {
1803 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_wrong_number_arguments,
1807 Expr *addrSpaceExpr = static_cast<Expr *>(rawAttr->getArg(0));
1808 llvm::APSInt addrSpace(32);
1809 if (!addrSpaceExpr->isIntegerConstantExpr(addrSpace, Context)) {
1810 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_address_space_not_int,
1811 addrSpaceExpr->getSourceRange());
1814 unsigned addressSpace = static_cast<unsigned>(addrSpace.getZExtValue());
1816 // Zero is the default memory space, so no qualification is needed
1817 if (addressSpace == 0)
1820 // TODO: Should we convert contained types of address space
1821 // qualified types here or or where they directly participate in conversions
1823 return Context.getASQualType(curType, addressSpace);
1826 void Sema::HandleOCUVectorTypeAttribute(TypedefDecl *tDecl,
1827 AttributeList *rawAttr) {
1828 QualType curType = tDecl->getUnderlyingType();
1829 // check the attribute arguments.
1830 if (rawAttr->getNumArgs() != 1) {
1831 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_wrong_number_arguments,
1835 Expr *sizeExpr = static_cast<Expr *>(rawAttr->getArg(0));
1836 llvm::APSInt vecSize(32);
1837 if (!sizeExpr->isIntegerConstantExpr(vecSize, Context)) {
1838 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_argument_not_int,
1839 "ocu_vector_type", sizeExpr->getSourceRange());
1842 // unlike gcc's vector_size attribute, we do not allow vectors to be defined
1843 // in conjunction with complex types (pointers, arrays, functions, etc.).
1844 Type *canonType = curType.getCanonicalType().getTypePtr();
1845 if (!(canonType->isIntegerType() || canonType->isRealFloatingType())) {
1846 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_invalid_vector_type,
1847 curType.getCanonicalType().getAsString());
1850 // unlike gcc's vector_size attribute, the size is specified as the
1851 // number of elements, not the number of bytes.
1852 unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue());
1854 if (vectorSize == 0) {
1855 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_zero_size,
1856 sizeExpr->getSourceRange());
1859 // Instantiate/Install the vector type, the number of elements is > 0.
1860 tDecl->setUnderlyingType(Context.getOCUVectorType(curType, vectorSize));
1861 // Remember this typedef decl, we will need it later for diagnostics.
1862 OCUVectorDecls.push_back(tDecl);
1865 QualType Sema::HandleVectorTypeAttribute(QualType curType,
1866 AttributeList *rawAttr) {
1867 // check the attribute arugments.
1868 if (rawAttr->getNumArgs() != 1) {
1869 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_wrong_number_arguments,
1873 Expr *sizeExpr = static_cast<Expr *>(rawAttr->getArg(0));
1874 llvm::APSInt vecSize(32);
1875 if (!sizeExpr->isIntegerConstantExpr(vecSize, Context)) {
1876 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_argument_not_int,
1877 "vector_size", sizeExpr->getSourceRange());
1880 // navigate to the base type - we need to provide for vector pointers,
1881 // vector arrays, and functions returning vectors.
1882 Type *canonType = curType.getCanonicalType().getTypePtr();
1884 if (canonType->isPointerType() || canonType->isArrayType() ||
1885 canonType->isFunctionType()) {
1886 assert(0 && "HandleVector(): Complex type construction unimplemented");
1887 /* FIXME: rebuild the type from the inside out, vectorizing the inner type.
1889 if (PointerType *PT = dyn_cast<PointerType>(canonType))
1890 canonType = PT->getPointeeType().getTypePtr();
1891 else if (ArrayType *AT = dyn_cast<ArrayType>(canonType))
1892 canonType = AT->getElementType().getTypePtr();
1893 else if (FunctionType *FT = dyn_cast<FunctionType>(canonType))
1894 canonType = FT->getResultType().getTypePtr();
1895 } while (canonType->isPointerType() || canonType->isArrayType() ||
1896 canonType->isFunctionType());
1899 // the base type must be integer or float.
1900 if (!(canonType->isIntegerType() || canonType->isRealFloatingType())) {
1901 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_invalid_vector_type,
1902 curType.getCanonicalType().getAsString());
1905 unsigned typeSize = static_cast<unsigned>(
1906 Context.getTypeSize(curType, rawAttr->getAttributeLoc()));
1907 // vecSize is specified in bytes - convert to bits.
1908 unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8);
1910 // the vector size needs to be an integral multiple of the type size.
1911 if (vectorSize % typeSize) {
1912 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_invalid_size,
1913 sizeExpr->getSourceRange());
1916 if (vectorSize == 0) {
1917 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_zero_size,
1918 sizeExpr->getSourceRange());
1921 // Since OpenCU requires 3 element vectors (OpenCU 5.1.2), we don't restrict
1922 // the number of elements to be a power of two (unlike GCC).
1923 // Instantiate the vector type, the number of elements is > 0.
1924 return Context.getVectorType(curType, vectorSize/typeSize);
1927 void Sema::HandlePackedAttribute(Decl *d, AttributeList *rawAttr)
1929 // check the attribute arguments.
1930 if (rawAttr->getNumArgs() > 0) {
1931 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_wrong_number_arguments,
1936 if (TagDecl *TD = dyn_cast<TagDecl>(d))
1937 TD->addAttr(new PackedAttr);
1938 else if (FieldDecl *FD = dyn_cast<FieldDecl>(d)) {
1939 // If the alignment is less than or equal to 8 bits, the packed attribute
1941 if (Context.getTypeAlign(FD->getType(), SourceLocation()) <= 8)
1942 Diag(rawAttr->getAttributeLoc(),
1943 diag::warn_attribute_ignored_for_field_of_type,
1944 rawAttr->getAttributeName()->getName(),
1945 FD->getType().getAsString());
1947 FD->addAttr(new PackedAttr);
1949 Diag(rawAttr->getAttributeLoc(), diag::warn_attribute_ignored,
1950 rawAttr->getAttributeName()->getName());
1953 void Sema::HandleAlignedAttribute(Decl *d, AttributeList *rawAttr)
1955 // check the attribute arguments.
1956 if (rawAttr->getNumArgs() > 1) {
1957 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_wrong_number_arguments,
1964 if (rawAttr->getNumArgs() == 0) {
1965 // FIXME: This should be the target specific maximum alignment.
1966 // (For now we just use 128 bits which is the maximum on X86.
1970 Expr *alignmentExpr = static_cast<Expr *>(rawAttr->getArg(0));
1971 llvm::APSInt alignment(32);
1972 if (!alignmentExpr->isIntegerConstantExpr(alignment, Context)) {
1973 Diag(rawAttr->getAttributeLoc(), diag::err_attribute_argument_not_int,
1974 "aligned", alignmentExpr->getSourceRange());
1978 Align = alignment.getZExtValue() * 8;
1981 d->addAttr(new AlignedAttr(Align));