SemaDecl.cpp revision 0f84a23cc542a76f97aee735cdf3ff948b149879
1//===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements semantic analysis for declarations. 11// 12//===----------------------------------------------------------------------===// 13 14#include "Sema.h" 15#include "clang/AST/APValue.h" 16#include "clang/AST/ASTConsumer.h" 17#include "clang/AST/ASTContext.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/ExprCXX.h" 20#include "clang/Parse/DeclSpec.h" 21#include "clang/Basic/Diagnostic.h" 22#include "clang/Basic/TargetInfo.h" 23#include "clang/Basic/SourceManager.h" 24// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's) 25#include "clang/Lex/Preprocessor.h" 26#include "clang/Lex/HeaderSearch.h" 27#include "llvm/ADT/SmallSet.h" 28#include "llvm/ADT/StringExtras.h" 29using namespace clang; 30 31Sema::TypeTy *Sema::isTypeName(const IdentifierInfo &II, Scope *S, 32 const CXXScopeSpec *SS) { 33 DeclContext *DC = 0; 34 if (SS) { 35 if (SS->isInvalid()) 36 return 0; 37 DC = static_cast<DeclContext*>(SS->getScopeRep()); 38 } 39 Decl *IIDecl = LookupDecl(&II, Decl::IDNS_Ordinary, S, DC, false); 40 41 if (IIDecl && (isa<TypedefDecl>(IIDecl) || 42 isa<ObjCInterfaceDecl>(IIDecl) || 43 isa<TagDecl>(IIDecl))) 44 return IIDecl; 45 return 0; 46} 47 48std::string Sema::getTypeAsString(TypeTy *Type) { 49 QualType Ty = QualType::getFromOpaquePtr(Type); 50 return Ty.getAsString(); 51} 52 53DeclContext *Sema::getContainingDC(DeclContext *DC) { 54 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) { 55 // A C++ out-of-line method will return to the file declaration context. 56 if (!MD->isInlineDefinition()) 57 return LexicalFileContext; 58 59 // A C++ inline method is parsed *after* the topmost class it was declared in 60 // is fully parsed (it's "complete"). 61 // The parsing of a C++ inline method happens at the declaration context of 62 // the topmost (non-nested) class it is declared in. 63 assert(isa<CXXRecordDecl>(MD->getParent()) && "C++ method not in Record."); 64 DC = MD->getParent(); 65 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getParent())) 66 DC = RD; 67 68 // Return the declaration context of the topmost class the inline method is 69 // declared in. 70 return DC; 71 } 72 73 if (isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC)) 74 return LexicalFileContext; 75 76 return DC->getParent(); 77} 78 79void Sema::PushDeclContext(DeclContext *DC) { 80 assert(getContainingDC(DC) == CurContext && 81 "The next DeclContext should be directly contained in the current one."); 82 CurContext = DC; 83 if (CurContext->isFileContext()) 84 LexicalFileContext = CurContext; 85} 86 87void Sema::PopDeclContext() { 88 assert(CurContext && "DeclContext imbalance!"); 89 CurContext = getContainingDC(CurContext); 90 if (CurContext->isFileContext()) 91 LexicalFileContext = CurContext; 92} 93 94/// Add this decl to the scope shadowed decl chains. 95void Sema::PushOnScopeChains(NamedDecl *D, Scope *S) { 96 S->AddDecl(D); 97 98 // C++ [basic.scope]p4: 99 // -- exactly one declaration shall declare a class name or 100 // enumeration name that is not a typedef name and the other 101 // declarations shall all refer to the same object or 102 // enumerator, or all refer to functions and function templates; 103 // in this case the class name or enumeration name is hidden. 104 if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 105 // We are pushing the name of a tag (enum or class). 106 IdentifierResolver::iterator 107 I = IdResolver.begin(TD->getIdentifier(), 108 TD->getDeclContext(), false/*LookInParentCtx*/); 109 if (I != IdResolver.end() && isDeclInScope(*I, TD->getDeclContext(), S)) { 110 // There is already a declaration with the same name in the same 111 // scope. It must be found before we find the new declaration, 112 // so swap the order on the shadowed declaration chain. 113 114 IdResolver.AddShadowedDecl(TD, *I); 115 return; 116 } 117 } else if (getLangOptions().CPlusPlus && isa<FunctionDecl>(D)) { 118 FunctionDecl *FD = cast<FunctionDecl>(D); 119 // We are pushing the name of a function, which might be an 120 // overloaded name. 121 IdentifierResolver::iterator 122 I = IdResolver.begin(FD->getIdentifier(), 123 FD->getDeclContext(), false/*LookInParentCtx*/); 124 if (I != IdResolver.end() && 125 IdResolver.isDeclInScope(*I, FD->getDeclContext(), S) && 126 (isa<OverloadedFunctionDecl>(*I) || isa<FunctionDecl>(*I))) { 127 // There is already a declaration with the same name in the same 128 // scope. It must be a function or an overloaded function. 129 OverloadedFunctionDecl* Ovl = dyn_cast<OverloadedFunctionDecl>(*I); 130 if (!Ovl) { 131 // We haven't yet overloaded this function. Take the existing 132 // FunctionDecl and put it into an OverloadedFunctionDecl. 133 Ovl = OverloadedFunctionDecl::Create(Context, 134 FD->getDeclContext(), 135 FD->getIdentifier()); 136 Ovl->addOverload(dyn_cast<FunctionDecl>(*I)); 137 138 // Remove the name binding to the existing FunctionDecl... 139 IdResolver.RemoveDecl(*I); 140 141 // ... and put the OverloadedFunctionDecl in its place. 142 IdResolver.AddDecl(Ovl); 143 } 144 145 // We have an OverloadedFunctionDecl. Add the new FunctionDecl 146 // to its list of overloads. 147 Ovl->addOverload(FD); 148 149 return; 150 } 151 } 152 153 IdResolver.AddDecl(D); 154} 155 156void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 157 if (S->decl_empty()) return; 158 assert((S->getFlags() & Scope::DeclScope) &&"Scope shouldn't contain decls!"); 159 160 for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end(); 161 I != E; ++I) { 162 Decl *TmpD = static_cast<Decl*>(*I); 163 assert(TmpD && "This decl didn't get pushed??"); 164 165 if (isa<CXXFieldDecl>(TmpD)) continue; 166 167 assert(isa<ScopedDecl>(TmpD) && "Decl isn't ScopedDecl?"); 168 ScopedDecl *D = cast<ScopedDecl>(TmpD); 169 170 IdentifierInfo *II = D->getIdentifier(); 171 if (!II) continue; 172 173 // We only want to remove the decls from the identifier decl chains for 174 // local scopes, when inside a function/method. 175 if (S->getFnParent() != 0) 176 IdResolver.RemoveDecl(D); 177 178 // Chain this decl to the containing DeclContext. 179 D->setNext(CurContext->getDeclChain()); 180 CurContext->setDeclChain(D); 181 } 182} 183 184/// getObjCInterfaceDecl - Look up a for a class declaration in the scope. 185/// return 0 if one not found. 186ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *Id) { 187 // The third "scope" argument is 0 since we aren't enabling lazy built-in 188 // creation from this context. 189 Decl *IDecl = LookupDecl(Id, Decl::IDNS_Ordinary, 0, false); 190 191 return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 192} 193 194/// LookupDecl - Look up the inner-most declaration in the specified 195/// namespace. 196Decl *Sema::LookupDecl(const IdentifierInfo *II, unsigned NSI, Scope *S, 197 DeclContext *LookupCtx, bool enableLazyBuiltinCreation) { 198 if (II == 0) return 0; 199 unsigned NS = NSI; 200 if (getLangOptions().CPlusPlus && (NS & Decl::IDNS_Ordinary)) 201 NS |= Decl::IDNS_Tag; 202 203 IdentifierResolver::iterator 204 I = LookupCtx ? IdResolver.begin(II, LookupCtx, false/*LookInParentCtx*/) : 205 IdResolver.begin(II, CurContext, true/*LookInParentCtx*/); 206 // Scan up the scope chain looking for a decl that matches this identifier 207 // that is in the appropriate namespace. This search should not take long, as 208 // shadowing of names is uncommon, and deep shadowing is extremely uncommon. 209 for (; I != IdResolver.end(); ++I) 210 if ((*I)->getIdentifierNamespace() & NS) 211 return *I; 212 213 // If we didn't find a use of this identifier, and if the identifier 214 // corresponds to a compiler builtin, create the decl object for the builtin 215 // now, injecting it into translation unit scope, and return it. 216 if (NS & Decl::IDNS_Ordinary) { 217 if (enableLazyBuiltinCreation && 218 (LookupCtx == 0 || isa<TranslationUnitDecl>(LookupCtx))) { 219 // If this is a builtin on this (or all) targets, create the decl. 220 if (unsigned BuiltinID = II->getBuiltinID()) 221 return LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, S); 222 } 223 if (getLangOptions().ObjC1) { 224 // @interface and @compatibility_alias introduce typedef-like names. 225 // Unlike typedef's, they can only be introduced at file-scope (and are 226 // therefore not scoped decls). They can, however, be shadowed by 227 // other names in IDNS_Ordinary. 228 ObjCInterfaceDeclsTy::iterator IDI = ObjCInterfaceDecls.find(II); 229 if (IDI != ObjCInterfaceDecls.end()) 230 return IDI->second; 231 ObjCAliasTy::iterator I = ObjCAliasDecls.find(II); 232 if (I != ObjCAliasDecls.end()) 233 return I->second->getClassInterface(); 234 } 235 } 236 return 0; 237} 238 239void Sema::InitBuiltinVaListType() { 240 if (!Context.getBuiltinVaListType().isNull()) 241 return; 242 243 IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list"); 244 Decl *VaDecl = LookupDecl(VaIdent, Decl::IDNS_Ordinary, TUScope); 245 TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl); 246 Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef)); 247} 248 249/// LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope. 250/// lazily create a decl for it. 251ScopedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, 252 Scope *S) { 253 Builtin::ID BID = (Builtin::ID)bid; 254 255 if (Context.BuiltinInfo.hasVAListUse(BID)) 256 InitBuiltinVaListType(); 257 258 QualType R = Context.BuiltinInfo.GetBuiltinType(BID, Context); 259 FunctionDecl *New = FunctionDecl::Create(Context, 260 Context.getTranslationUnitDecl(), 261 SourceLocation(), II, R, 262 FunctionDecl::Extern, false, 0); 263 264 // Create Decl objects for each parameter, adding them to the 265 // FunctionDecl. 266 if (FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(R)) { 267 llvm::SmallVector<ParmVarDecl*, 16> Params; 268 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) 269 Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0, 270 FT->getArgType(i), VarDecl::None, 0, 271 0)); 272 New->setParams(&Params[0], Params.size()); 273 } 274 275 276 277 // TUScope is the translation-unit scope to insert this function into. 278 PushOnScopeChains(New, TUScope); 279 return New; 280} 281 282/// MergeTypeDefDecl - We just parsed a typedef 'New' which has the same name 283/// and scope as a previous declaration 'Old'. Figure out how to resolve this 284/// situation, merging decls or emitting diagnostics as appropriate. 285/// 286TypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) { 287 // Allow multiple definitions for ObjC built-in typedefs. 288 // FIXME: Verify the underlying types are equivalent! 289 if (getLangOptions().ObjC1) { 290 const IdentifierInfo *typeIdent = New->getIdentifier(); 291 if (typeIdent == Ident_id) { 292 Context.setObjCIdType(New); 293 return New; 294 } else if (typeIdent == Ident_Class) { 295 Context.setObjCClassType(New); 296 return New; 297 } else if (typeIdent == Ident_SEL) { 298 Context.setObjCSelType(New); 299 return New; 300 } else if (typeIdent == Ident_Protocol) { 301 Context.setObjCProtoType(New->getUnderlyingType()); 302 return New; 303 } 304 // Fall through - the typedef name was not a builtin type. 305 } 306 // Verify the old decl was also a typedef. 307 TypedefDecl *Old = dyn_cast<TypedefDecl>(OldD); 308 if (!Old) { 309 Diag(New->getLocation(), diag::err_redefinition_different_kind, 310 New->getName()); 311 Diag(OldD->getLocation(), diag::err_previous_definition); 312 return New; 313 } 314 315 // If the typedef types are not identical, reject them in all languages and 316 // with any extensions enabled. 317 if (Old->getUnderlyingType() != New->getUnderlyingType() && 318 Context.getCanonicalType(Old->getUnderlyingType()) != 319 Context.getCanonicalType(New->getUnderlyingType())) { 320 Diag(New->getLocation(), diag::err_redefinition_different_typedef, 321 New->getUnderlyingType().getAsString(), 322 Old->getUnderlyingType().getAsString()); 323 Diag(Old->getLocation(), diag::err_previous_definition); 324 return Old; 325 } 326 327 if (getLangOptions().Microsoft) return New; 328 329 // Redeclaration of a type is a constraint violation (6.7.2.3p1). 330 // Apparently GCC, Intel, and Sun all silently ignore the redeclaration if 331 // *either* declaration is in a system header. The code below implements 332 // this adhoc compatibility rule. FIXME: The following code will not 333 // work properly when compiling ".i" files (containing preprocessed output). 334 if (PP.getDiagnostics().getSuppressSystemWarnings()) { 335 SourceManager &SrcMgr = Context.getSourceManager(); 336 if (SrcMgr.isInSystemHeader(Old->getLocation())) 337 return New; 338 if (SrcMgr.isInSystemHeader(New->getLocation())) 339 return New; 340 } 341 342 Diag(New->getLocation(), diag::err_redefinition, New->getName()); 343 Diag(Old->getLocation(), diag::err_previous_definition); 344 return New; 345} 346 347/// DeclhasAttr - returns true if decl Declaration already has the target 348/// attribute. 349static bool DeclHasAttr(const Decl *decl, const Attr *target) { 350 for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext()) 351 if (attr->getKind() == target->getKind()) 352 return true; 353 354 return false; 355} 356 357/// MergeAttributes - append attributes from the Old decl to the New one. 358static void MergeAttributes(Decl *New, Decl *Old) { 359 Attr *attr = const_cast<Attr*>(Old->getAttrs()), *tmp; 360 361 while (attr) { 362 tmp = attr; 363 attr = attr->getNext(); 364 365 if (!DeclHasAttr(New, tmp)) { 366 New->addAttr(tmp); 367 } else { 368 tmp->setNext(0); 369 delete(tmp); 370 } 371 } 372 373 Old->invalidateAttrs(); 374} 375 376/// MergeFunctionDecl - We just parsed a function 'New' from 377/// declarator D which has the same name and scope as a previous 378/// declaration 'Old'. Figure out how to resolve this situation, 379/// merging decls or emitting diagnostics as appropriate. 380/// Redeclaration will be set true if this New is a redeclaration OldD. 381/// 382/// In C++, New and Old must be declarations that are not 383/// overloaded. Use IsOverload to determine whether New and Old are 384/// overloaded, and to select the Old declaration that New should be 385/// merged with. 386FunctionDecl * 387Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, bool &Redeclaration) { 388 assert(!isa<OverloadedFunctionDecl>(OldD) && 389 "Cannot merge with an overloaded function declaration"); 390 391 Redeclaration = false; 392 // Verify the old decl was also a function. 393 FunctionDecl *Old = dyn_cast<FunctionDecl>(OldD); 394 if (!Old) { 395 Diag(New->getLocation(), diag::err_redefinition_different_kind, 396 New->getName()); 397 Diag(OldD->getLocation(), diag::err_previous_definition); 398 return New; 399 } 400 401 // Determine whether the previous declaration was a definition, 402 // implicit declaration, or a declaration. 403 diag::kind PrevDiag; 404 if (Old->isThisDeclarationADefinition()) 405 PrevDiag = diag::err_previous_definition; 406 else if (Old->isImplicit()) 407 PrevDiag = diag::err_previous_implicit_declaration; 408 else 409 PrevDiag = diag::err_previous_declaration; 410 411 QualType OldQType = Context.getCanonicalType(Old->getType()); 412 QualType NewQType = Context.getCanonicalType(New->getType()); 413 414 if (getLangOptions().CPlusPlus) { 415 // (C++98 13.1p2): 416 // Certain function declarations cannot be overloaded: 417 // -- Function declarations that differ only in the return type 418 // cannot be overloaded. 419 QualType OldReturnType 420 = cast<FunctionType>(OldQType.getTypePtr())->getResultType(); 421 QualType NewReturnType 422 = cast<FunctionType>(NewQType.getTypePtr())->getResultType(); 423 if (OldReturnType != NewReturnType) { 424 Diag(New->getLocation(), diag::err_ovl_diff_return_type); 425 Diag(Old->getLocation(), PrevDiag); 426 return New; 427 } 428 429 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old); 430 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New); 431 if (OldMethod && NewMethod) { 432 // -- Member function declarations with the same name and the 433 // same parameter types cannot be overloaded if any of them 434 // is a static member function declaration. 435 if (OldMethod->isStatic() || NewMethod->isStatic()) { 436 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 437 Diag(Old->getLocation(), PrevDiag); 438 return New; 439 } 440 } 441 442 // (C++98 8.3.5p3): 443 // All declarations for a function shall agree exactly in both the 444 // return type and the parameter-type-list. 445 if (OldQType == NewQType) { 446 // We have a redeclaration. 447 MergeAttributes(New, Old); 448 Redeclaration = true; 449 return MergeCXXFunctionDecl(New, Old); 450 } 451 452 // Fall through for conflicting redeclarations and redefinitions. 453 } 454 455 // C: Function types need to be compatible, not identical. This handles 456 // duplicate function decls like "void f(int); void f(enum X);" properly. 457 if (!getLangOptions().CPlusPlus && 458 Context.typesAreCompatible(OldQType, NewQType)) { 459 MergeAttributes(New, Old); 460 Redeclaration = true; 461 return New; 462 } 463 464 // A function that has already been declared has been redeclared or defined 465 // with a different type- show appropriate diagnostic 466 467 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope. 468 // TODO: This is totally simplistic. It should handle merging functions 469 // together etc, merging extern int X; int X; ... 470 Diag(New->getLocation(), diag::err_conflicting_types, New->getName()); 471 Diag(Old->getLocation(), PrevDiag); 472 return New; 473} 474 475/// Predicate for C "tentative" external object definitions (C99 6.9.2). 476static bool isTentativeDefinition(VarDecl *VD) { 477 if (VD->isFileVarDecl()) 478 return (!VD->getInit() && 479 (VD->getStorageClass() == VarDecl::None || 480 VD->getStorageClass() == VarDecl::Static)); 481 return false; 482} 483 484/// CheckForFileScopedRedefinitions - Make sure we forgo redefinition errors 485/// when dealing with C "tentative" external object definitions (C99 6.9.2). 486void Sema::CheckForFileScopedRedefinitions(Scope *S, VarDecl *VD) { 487 bool VDIsTentative = isTentativeDefinition(VD); 488 bool VDIsIncompleteArray = VD->getType()->isIncompleteArrayType(); 489 490 for (IdentifierResolver::iterator 491 I = IdResolver.begin(VD->getIdentifier(), 492 VD->getDeclContext(), false/*LookInParentCtx*/), 493 E = IdResolver.end(); I != E; ++I) { 494 if (*I != VD && isDeclInScope(*I, VD->getDeclContext(), S)) { 495 VarDecl *OldDecl = dyn_cast<VarDecl>(*I); 496 497 // Handle the following case: 498 // int a[10]; 499 // int a[]; - the code below makes sure we set the correct type. 500 // int a[11]; - this is an error, size isn't 10. 501 if (OldDecl && VDIsTentative && VDIsIncompleteArray && 502 OldDecl->getType()->isConstantArrayType()) 503 VD->setType(OldDecl->getType()); 504 505 // Check for "tentative" definitions. We can't accomplish this in 506 // MergeVarDecl since the initializer hasn't been attached. 507 if (!OldDecl || isTentativeDefinition(OldDecl) || VDIsTentative) 508 continue; 509 510 // Handle __private_extern__ just like extern. 511 if (OldDecl->getStorageClass() != VarDecl::Extern && 512 OldDecl->getStorageClass() != VarDecl::PrivateExtern && 513 VD->getStorageClass() != VarDecl::Extern && 514 VD->getStorageClass() != VarDecl::PrivateExtern) { 515 Diag(VD->getLocation(), diag::err_redefinition, VD->getName()); 516 Diag(OldDecl->getLocation(), diag::err_previous_definition); 517 } 518 } 519 } 520} 521 522/// MergeVarDecl - We just parsed a variable 'New' which has the same name 523/// and scope as a previous declaration 'Old'. Figure out how to resolve this 524/// situation, merging decls or emitting diagnostics as appropriate. 525/// 526/// Tentative definition rules (C99 6.9.2p2) are checked by 527/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 528/// definitions here, since the initializer hasn't been attached. 529/// 530VarDecl *Sema::MergeVarDecl(VarDecl *New, Decl *OldD) { 531 // Verify the old decl was also a variable. 532 VarDecl *Old = dyn_cast<VarDecl>(OldD); 533 if (!Old) { 534 Diag(New->getLocation(), diag::err_redefinition_different_kind, 535 New->getName()); 536 Diag(OldD->getLocation(), diag::err_previous_definition); 537 return New; 538 } 539 540 MergeAttributes(New, Old); 541 542 // Verify the types match. 543 QualType OldCType = Context.getCanonicalType(Old->getType()); 544 QualType NewCType = Context.getCanonicalType(New->getType()); 545 if (OldCType != NewCType && !Context.typesAreCompatible(OldCType, NewCType)) { 546 Diag(New->getLocation(), diag::err_redefinition, New->getName()); 547 Diag(Old->getLocation(), diag::err_previous_definition); 548 return New; 549 } 550 // C99 6.2.2p4: Check if we have a static decl followed by a non-static. 551 if (New->getStorageClass() == VarDecl::Static && 552 (Old->getStorageClass() == VarDecl::None || 553 Old->getStorageClass() == VarDecl::Extern)) { 554 Diag(New->getLocation(), diag::err_static_non_static, New->getName()); 555 Diag(Old->getLocation(), diag::err_previous_definition); 556 return New; 557 } 558 // C99 6.2.2p4: Check if we have a non-static decl followed by a static. 559 if (New->getStorageClass() != VarDecl::Static && 560 Old->getStorageClass() == VarDecl::Static) { 561 Diag(New->getLocation(), diag::err_non_static_static, New->getName()); 562 Diag(Old->getLocation(), diag::err_previous_definition); 563 return New; 564 } 565 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 566 if (New->getStorageClass() != VarDecl::Extern && !New->isFileVarDecl()) { 567 Diag(New->getLocation(), diag::err_redefinition, New->getName()); 568 Diag(Old->getLocation(), diag::err_previous_definition); 569 } 570 return New; 571} 572 573/// CheckParmsForFunctionDef - Check that the parameters of the given 574/// function are appropriate for the definition of a function. This 575/// takes care of any checks that cannot be performed on the 576/// declaration itself, e.g., that the types of each of the function 577/// parameters are complete. 578bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) { 579 bool HasInvalidParm = false; 580 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 581 ParmVarDecl *Param = FD->getParamDecl(p); 582 583 // C99 6.7.5.3p4: the parameters in a parameter type list in a 584 // function declarator that is part of a function definition of 585 // that function shall not have incomplete type. 586 if (Param->getType()->isIncompleteType() && 587 !Param->isInvalidDecl()) { 588 Diag(Param->getLocation(), diag::err_typecheck_decl_incomplete_type, 589 Param->getType().getAsString()); 590 Param->setInvalidDecl(); 591 HasInvalidParm = true; 592 } 593 } 594 595 return HasInvalidParm; 596} 597 598/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 599/// no declarator (e.g. "struct foo;") is parsed. 600Sema::DeclTy *Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) { 601 // TODO: emit error on 'int;' or 'const enum foo;'. 602 // TODO: emit error on 'typedef int;' 603 // if (!DS.isMissingDeclaratorOk()) Diag(...); 604 605 return dyn_cast_or_null<TagDecl>(static_cast<Decl *>(DS.getTypeRep())); 606} 607 608bool Sema::CheckSingleInitializer(Expr *&Init, QualType DeclType) { 609 // Get the type before calling CheckSingleAssignmentConstraints(), since 610 // it can promote the expression. 611 QualType InitType = Init->getType(); 612 613 AssignConvertType ConvTy = CheckSingleAssignmentConstraints(DeclType, Init); 614 return DiagnoseAssignmentResult(ConvTy, Init->getLocStart(), DeclType, 615 InitType, Init, "initializing"); 616} 617 618bool Sema::CheckStringLiteralInit(StringLiteral *strLiteral, QualType &DeclT) { 619 const ArrayType *AT = Context.getAsArrayType(DeclT); 620 621 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 622 // C99 6.7.8p14. We have an array of character type with unknown size 623 // being initialized to a string literal. 624 llvm::APSInt ConstVal(32); 625 ConstVal = strLiteral->getByteLength() + 1; 626 // Return a new array type (C99 6.7.8p22). 627 DeclT = Context.getConstantArrayType(IAT->getElementType(), ConstVal, 628 ArrayType::Normal, 0); 629 } else { 630 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT); 631 // C99 6.7.8p14. We have an array of character type with known size. 632 // FIXME: Avoid truncation for 64-bit length strings. 633 if (strLiteral->getByteLength() > (unsigned)CAT->getSize().getZExtValue()) 634 Diag(strLiteral->getSourceRange().getBegin(), 635 diag::warn_initializer_string_for_char_array_too_long, 636 strLiteral->getSourceRange()); 637 } 638 // Set type from "char *" to "constant array of char". 639 strLiteral->setType(DeclT); 640 // For now, we always return false (meaning success). 641 return false; 642} 643 644StringLiteral *Sema::IsStringLiteralInit(Expr *Init, QualType DeclType) { 645 const ArrayType *AT = Context.getAsArrayType(DeclType); 646 if (AT && AT->getElementType()->isCharType()) { 647 return dyn_cast<StringLiteral>(Init); 648 } 649 return 0; 650} 651 652bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType, 653 SourceLocation InitLoc, 654 std::string InitEntity) { 655 // C++ [dcl.init.ref]p1: 656 // A variable declared to be a T&, that is “reference to type T” 657 // (8.3.2), shall be initialized by an object, or function, of 658 // type T or by an object that can be converted into a T. 659 if (DeclType->isReferenceType()) 660 return CheckReferenceInit(Init, DeclType); 661 662 // C99 6.7.8p3: The type of the entity to be initialized shall be an array 663 // of unknown size ("[]") or an object type that is not a variable array type. 664 if (const VariableArrayType *VAT = Context.getAsVariableArrayType(DeclType)) 665 return Diag(InitLoc, 666 diag::err_variable_object_no_init, 667 VAT->getSizeExpr()->getSourceRange()); 668 669 InitListExpr *InitList = dyn_cast<InitListExpr>(Init); 670 if (!InitList) { 671 // FIXME: Handle wide strings 672 if (StringLiteral *strLiteral = IsStringLiteralInit(Init, DeclType)) 673 return CheckStringLiteralInit(strLiteral, DeclType); 674 675 // C++ [dcl.init]p14: 676 // -- If the destination type is a (possibly cv-qualified) class 677 // type: 678 if (getLangOptions().CPlusPlus && DeclType->isRecordType()) { 679 QualType DeclTypeC = Context.getCanonicalType(DeclType); 680 QualType InitTypeC = Context.getCanonicalType(Init->getType()); 681 682 // -- If the initialization is direct-initialization, or if it is 683 // copy-initialization where the cv-unqualified version of the 684 // source type is the same class as, or a derived class of, the 685 // class of the destination, constructors are considered. 686 if ((DeclTypeC.getUnqualifiedType() == InitTypeC.getUnqualifiedType()) || 687 IsDerivedFrom(InitTypeC, DeclTypeC)) { 688 CXXConstructorDecl *Constructor 689 = PerformInitializationByConstructor(DeclType, &Init, 1, 690 InitLoc, Init->getSourceRange(), 691 InitEntity, IK_Copy); 692 return Constructor == 0; 693 } 694 695 // -- Otherwise (i.e., for the remaining copy-initialization 696 // cases), user-defined conversion sequences that can 697 // convert from the source type to the destination type or 698 // (when a conversion function is used) to a derived class 699 // thereof are enumerated as described in 13.3.1.4, and the 700 // best one is chosen through overload resolution 701 // (13.3). If the conversion cannot be done or is 702 // ambiguous, the initialization is ill-formed. The 703 // function selected is called with the initializer 704 // expression as its argument; if the function is a 705 // constructor, the call initializes a temporary of the 706 // destination type. 707 // FIXME: We're pretending to do copy elision here; return to 708 // this when we have ASTs for such things. 709 if (PerformImplicitConversion(Init, DeclType)) 710 return Diag(InitLoc, 711 diag::err_typecheck_convert_incompatible, 712 DeclType.getAsString(), InitEntity, 713 "initializing", 714 Init->getSourceRange()); 715 else 716 return false; 717 } 718 719 // C99 6.7.8p16. 720 if (DeclType->isArrayType()) 721 return Diag(Init->getLocStart(), 722 diag::err_array_init_list_required, 723 Init->getSourceRange()); 724 725 return CheckSingleInitializer(Init, DeclType); 726 } else if (getLangOptions().CPlusPlus) { 727 // C++ [dcl.init]p14: 728 // [...] If the class is an aggregate (8.5.1), and the initializer 729 // is a brace-enclosed list, see 8.5.1. 730 // 731 // Note: 8.5.1 is handled below; here, we diagnose the case where 732 // we have an initializer list and a destination type that is not 733 // an aggregate. 734 // FIXME: In C++0x, this is yet another form of initialization. 735 if (const RecordType *ClassRec = DeclType->getAsRecordType()) { 736 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassRec->getDecl()); 737 if (!ClassDecl->isAggregate()) 738 return Diag(InitLoc, 739 diag::err_init_non_aggr_init_list, 740 DeclType.getAsString(), 741 Init->getSourceRange()); 742 } 743 } 744 745 InitListChecker CheckInitList(this, InitList, DeclType); 746 return CheckInitList.HadError(); 747} 748 749Sema::DeclTy * 750Sema::ActOnDeclarator(Scope *S, Declarator &D, DeclTy *lastDecl) { 751 ScopedDecl *LastDeclarator = dyn_cast_or_null<ScopedDecl>((Decl *)lastDecl); 752 IdentifierInfo *II = D.getIdentifier(); 753 754 // All of these full declarators require an identifier. If it doesn't have 755 // one, the ParsedFreeStandingDeclSpec action should be used. 756 if (II == 0) { 757 Diag(D.getDeclSpec().getSourceRange().getBegin(), 758 diag::err_declarator_need_ident, 759 D.getDeclSpec().getSourceRange(), D.getSourceRange()); 760 return 0; 761 } 762 763 // The scope passed in may not be a decl scope. Zip up the scope tree until 764 // we find one that is. 765 while ((S->getFlags() & Scope::DeclScope) == 0) 766 S = S->getParent(); 767 768 DeclContext *DC; 769 Decl *PrevDecl; 770 ScopedDecl *New; 771 bool InvalidDecl = false; 772 773 // See if this is a redefinition of a variable in the same scope. 774 if (!D.getCXXScopeSpec().isSet()) { 775 DC = CurContext; 776 PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S); 777 } else { // Something like "int foo::x;" 778 DC = static_cast<DeclContext*>(D.getCXXScopeSpec().getScopeRep()); 779 PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S, DC); 780 781 // C++ 7.3.1.2p2: 782 // Members (including explicit specializations of templates) of a named 783 // namespace can also be defined outside that namespace by explicit 784 // qualification of the name being defined, provided that the entity being 785 // defined was already declared in the namespace and the definition appears 786 // after the point of declaration in a namespace that encloses the 787 // declarations namespace. 788 // 789 if (PrevDecl == 0) { 790 // No previous declaration in the qualifying scope. 791 Diag(D.getIdentifierLoc(), diag::err_typecheck_no_member, 792 II->getName(), D.getCXXScopeSpec().getRange()); 793 } else if (!CurContext->Encloses(DC)) { 794 // The qualifying scope doesn't enclose the original declaration. 795 // Emit diagnostic based on current scope. 796 SourceLocation L = D.getIdentifierLoc(); 797 SourceRange R = D.getCXXScopeSpec().getRange(); 798 if (isa<FunctionDecl>(CurContext)) { 799 Diag(L, diag::err_invalid_declarator_in_function, II->getName(), R); 800 } else { 801 Diag(L, diag::err_invalid_declarator_scope, II->getName(), 802 cast<NamedDecl>(DC)->getName(), R); 803 } 804 } 805 } 806 807 // In C++, the previous declaration we find might be a tag type 808 // (class or enum). In this case, the new declaration will hide the 809 // tag type. 810 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 811 PrevDecl = 0; 812 813 QualType R = GetTypeForDeclarator(D, S); 814 assert(!R.isNull() && "GetTypeForDeclarator() returned null type"); 815 816 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 817 // Check that there are no default arguments (C++ only). 818 if (getLangOptions().CPlusPlus) 819 CheckExtraCXXDefaultArguments(D); 820 821 TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, LastDeclarator); 822 if (!NewTD) return 0; 823 824 // Handle attributes prior to checking for duplicates in MergeVarDecl 825 ProcessDeclAttributes(NewTD, D); 826 // Merge the decl with the existing one if appropriate. If the decl is 827 // in an outer scope, it isn't the same thing. 828 if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) { 829 NewTD = MergeTypeDefDecl(NewTD, PrevDecl); 830 if (NewTD == 0) return 0; 831 } 832 New = NewTD; 833 if (S->getFnParent() == 0) { 834 // C99 6.7.7p2: If a typedef name specifies a variably modified type 835 // then it shall have block scope. 836 if (NewTD->getUnderlyingType()->isVariablyModifiedType()) { 837 // FIXME: Diagnostic needs to be fixed. 838 Diag(D.getIdentifierLoc(), diag::err_typecheck_illegal_vla); 839 InvalidDecl = true; 840 } 841 } 842 } else if (R.getTypePtr()->isFunctionType()) { 843 FunctionDecl::StorageClass SC = FunctionDecl::None; 844 switch (D.getDeclSpec().getStorageClassSpec()) { 845 default: assert(0 && "Unknown storage class!"); 846 case DeclSpec::SCS_auto: 847 case DeclSpec::SCS_register: 848 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_func, 849 R.getAsString()); 850 InvalidDecl = true; 851 break; 852 case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break; 853 case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break; 854 case DeclSpec::SCS_static: SC = FunctionDecl::Static; break; 855 case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break; 856 } 857 858 bool isInline = D.getDeclSpec().isInlineSpecified(); 859 // bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 860 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 861 862 FunctionDecl *NewFD; 863 if (D.getKind() == Declarator::DK_Constructor) { 864 // This is a C++ constructor declaration. 865 assert(DC->isCXXRecord() && 866 "Constructors can only be declared in a member context"); 867 868 bool isInvalidDecl = CheckConstructorDeclarator(D, R, SC); 869 870 // Create the new declaration 871 NewFD = CXXConstructorDecl::Create(Context, 872 cast<CXXRecordDecl>(DC), 873 D.getIdentifierLoc(), II, R, 874 isExplicit, isInline, 875 /*isImplicitlyDeclared=*/false); 876 877 if (isInvalidDecl) 878 NewFD->setInvalidDecl(); 879 } else if (D.getKind() == Declarator::DK_Destructor) { 880 // This is a C++ destructor declaration. 881 if (DC->isCXXRecord()) { 882 bool isInvalidDecl = CheckDestructorDeclarator(D, R, SC); 883 884 NewFD = CXXDestructorDecl::Create(Context, 885 cast<CXXRecordDecl>(DC), 886 D.getIdentifierLoc(), II, R, 887 isInline, 888 /*isImplicitlyDeclared=*/false); 889 890 if (isInvalidDecl) 891 NewFD->setInvalidDecl(); 892 } else { 893 Diag(D.getIdentifierLoc(), diag::err_destructor_not_member); 894 // Create a FunctionDecl to satisfy the function definition parsing 895 // code path. 896 NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(), 897 II, R, SC, isInline, LastDeclarator, 898 // FIXME: Move to DeclGroup... 899 D.getDeclSpec().getSourceRange().getBegin()); 900 NewFD->setInvalidDecl(); 901 } 902 } else if (D.getKind() == Declarator::DK_Conversion) { 903 if (!DC->isCXXRecord()) { 904 Diag(D.getIdentifierLoc(), 905 diag::err_conv_function_not_member); 906 return 0; 907 } else { 908 bool isInvalidDecl = CheckConversionDeclarator(D, R, SC); 909 910 NewFD = CXXConversionDecl::Create(Context, 911 cast<CXXRecordDecl>(DC), 912 D.getIdentifierLoc(), II, R, 913 isInline, isExplicit); 914 915 if (isInvalidDecl) 916 NewFD->setInvalidDecl(); 917 } 918 } else if (DC->isCXXRecord()) { 919 // This is a C++ method declaration. 920 NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC), 921 D.getIdentifierLoc(), II, R, 922 (SC == FunctionDecl::Static), isInline, 923 LastDeclarator); 924 } else { 925 NewFD = FunctionDecl::Create(Context, DC, 926 D.getIdentifierLoc(), 927 II, R, SC, isInline, LastDeclarator, 928 // FIXME: Move to DeclGroup... 929 D.getDeclSpec().getSourceRange().getBegin()); 930 } 931 // Handle attributes. 932 ProcessDeclAttributes(NewFD, D); 933 934 // Handle GNU asm-label extension (encoded as an attribute). 935 if (Expr *E = (Expr*) D.getAsmLabel()) { 936 // The parser guarantees this is a string. 937 StringLiteral *SE = cast<StringLiteral>(E); 938 NewFD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(), 939 SE->getByteLength()))); 940 } 941 942 // Copy the parameter declarations from the declarator D to 943 // the function declaration NewFD, if they are available. 944 if (D.getNumTypeObjects() > 0) { 945 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun; 946 947 // Create Decl objects for each parameter, adding them to the 948 // FunctionDecl. 949 llvm::SmallVector<ParmVarDecl*, 16> Params; 950 951 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 952 // function that takes no arguments, not a function that takes a 953 // single void argument. 954 // We let through "const void" here because Sema::GetTypeForDeclarator 955 // already checks for that case. 956 if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 957 FTI.ArgInfo[0].Param && 958 ((ParmVarDecl*)FTI.ArgInfo[0].Param)->getType()->isVoidType()) { 959 // empty arg list, don't push any params. 960 ParmVarDecl *Param = (ParmVarDecl*)FTI.ArgInfo[0].Param; 961 962 // In C++, the empty parameter-type-list must be spelled "void"; a 963 // typedef of void is not permitted. 964 if (getLangOptions().CPlusPlus && 965 Param->getType().getUnqualifiedType() != Context.VoidTy) { 966 Diag(Param->getLocation(), diag::ext_param_typedef_of_void); 967 } 968 } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) { 969 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) 970 Params.push_back((ParmVarDecl *)FTI.ArgInfo[i].Param); 971 } 972 973 NewFD->setParams(&Params[0], Params.size()); 974 } else if (R->getAsTypedefType()) { 975 // When we're declaring a function with a typedef, as in the 976 // following example, we'll need to synthesize (unnamed) 977 // parameters for use in the declaration. 978 // 979 // @code 980 // typedef void fn(int); 981 // fn f; 982 // @endcode 983 const FunctionTypeProto *FT = R->getAsFunctionTypeProto(); 984 if (!FT) { 985 // This is a typedef of a function with no prototype, so we 986 // don't need to do anything. 987 } else if ((FT->getNumArgs() == 0) || 988 (FT->getNumArgs() == 1 && !FT->isVariadic() && 989 FT->getArgType(0)->isVoidType())) { 990 // This is a zero-argument function. We don't need to do anything. 991 } else { 992 // Synthesize a parameter for each argument type. 993 llvm::SmallVector<ParmVarDecl*, 16> Params; 994 for (FunctionTypeProto::arg_type_iterator ArgType = FT->arg_type_begin(); 995 ArgType != FT->arg_type_end(); ++ArgType) { 996 Params.push_back(ParmVarDecl::Create(Context, DC, 997 SourceLocation(), 0, 998 *ArgType, VarDecl::None, 999 0, 0)); 1000 } 1001 1002 NewFD->setParams(&Params[0], Params.size()); 1003 } 1004 } 1005 1006 // C++ constructors and destructors are handled by separate 1007 // routines, since they don't require any declaration merging (C++ 1008 // [class.mfct]p2) and they aren't ever pushed into scope, because 1009 // they can't be found by name lookup anyway (C++ [class.ctor]p2). 1010 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) 1011 return ActOnConstructorDeclarator(Constructor); 1012 else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(NewFD)) 1013 return ActOnDestructorDeclarator(Destructor); 1014 else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(NewFD)) 1015 return ActOnConversionDeclarator(Conversion); 1016 1017 // Extra checking for C++ overloaded operators (C++ [over.oper]). 1018 if (NewFD->isOverloadedOperator() && 1019 CheckOverloadedOperatorDeclaration(NewFD)) 1020 NewFD->setInvalidDecl(); 1021 1022 // Merge the decl with the existing one if appropriate. Since C functions 1023 // are in a flat namespace, make sure we consider decls in outer scopes. 1024 if (PrevDecl && 1025 (!getLangOptions().CPlusPlus||isDeclInScope(PrevDecl, DC, S))) { 1026 bool Redeclaration = false; 1027 1028 // If C++, determine whether NewFD is an overload of PrevDecl or 1029 // a declaration that requires merging. If it's an overload, 1030 // there's no more work to do here; we'll just add the new 1031 // function to the scope. 1032 OverloadedFunctionDecl::function_iterator MatchedDecl; 1033 if (!getLangOptions().CPlusPlus || 1034 !IsOverload(NewFD, PrevDecl, MatchedDecl)) { 1035 Decl *OldDecl = PrevDecl; 1036 1037 // If PrevDecl was an overloaded function, extract the 1038 // FunctionDecl that matched. 1039 if (isa<OverloadedFunctionDecl>(PrevDecl)) 1040 OldDecl = *MatchedDecl; 1041 1042 // NewFD and PrevDecl represent declarations that need to be 1043 // merged. 1044 NewFD = MergeFunctionDecl(NewFD, OldDecl, Redeclaration); 1045 1046 if (NewFD == 0) return 0; 1047 if (Redeclaration) { 1048 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl)); 1049 1050 if (OldDecl == PrevDecl) { 1051 // Remove the name binding for the previous 1052 // declaration. We'll add the binding back later, but then 1053 // it will refer to the new declaration (which will 1054 // contain more information). 1055 IdResolver.RemoveDecl(cast<NamedDecl>(PrevDecl)); 1056 } else { 1057 // We need to update the OverloadedFunctionDecl with the 1058 // latest declaration of this function, so that name 1059 // lookup will always refer to the latest declaration of 1060 // this function. 1061 *MatchedDecl = NewFD; 1062 1063 // Add the redeclaration to the current scope, since we'll 1064 // be skipping PushOnScopeChains. 1065 S->AddDecl(NewFD); 1066 1067 return NewFD; 1068 } 1069 } 1070 } 1071 } 1072 New = NewFD; 1073 1074 // In C++, check default arguments now that we have merged decls. 1075 if (getLangOptions().CPlusPlus) 1076 CheckCXXDefaultArguments(NewFD); 1077 } else { 1078 // Check that there are no default arguments (C++ only). 1079 if (getLangOptions().CPlusPlus) 1080 CheckExtraCXXDefaultArguments(D); 1081 1082 if (R.getTypePtr()->isObjCInterfaceType()) { 1083 Diag(D.getIdentifierLoc(), diag::err_statically_allocated_object, 1084 D.getIdentifier()->getName()); 1085 InvalidDecl = true; 1086 } 1087 1088 VarDecl *NewVD; 1089 VarDecl::StorageClass SC; 1090 switch (D.getDeclSpec().getStorageClassSpec()) { 1091 default: assert(0 && "Unknown storage class!"); 1092 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break; 1093 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break; 1094 case DeclSpec::SCS_static: SC = VarDecl::Static; break; 1095 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break; 1096 case DeclSpec::SCS_register: SC = VarDecl::Register; break; 1097 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break; 1098 } 1099 if (DC->isCXXRecord()) { 1100 assert(SC == VarDecl::Static && "Invalid storage class for member!"); 1101 // This is a static data member for a C++ class. 1102 NewVD = CXXClassVarDecl::Create(Context, cast<CXXRecordDecl>(DC), 1103 D.getIdentifierLoc(), II, 1104 R, LastDeclarator); 1105 } else { 1106 bool ThreadSpecified = D.getDeclSpec().isThreadSpecified(); 1107 if (S->getFnParent() == 0) { 1108 // C99 6.9p2: The storage-class specifiers auto and register shall not 1109 // appear in the declaration specifiers in an external declaration. 1110 if (SC == VarDecl::Auto || SC == VarDecl::Register) { 1111 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope, 1112 R.getAsString()); 1113 InvalidDecl = true; 1114 } 1115 } 1116 NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(), 1117 II, R, SC, LastDeclarator, 1118 // FIXME: Move to DeclGroup... 1119 D.getDeclSpec().getSourceRange().getBegin()); 1120 NewVD->setThreadSpecified(ThreadSpecified); 1121 } 1122 // Handle attributes prior to checking for duplicates in MergeVarDecl 1123 ProcessDeclAttributes(NewVD, D); 1124 1125 // Handle GNU asm-label extension (encoded as an attribute). 1126 if (Expr *E = (Expr*) D.getAsmLabel()) { 1127 // The parser guarantees this is a string. 1128 StringLiteral *SE = cast<StringLiteral>(E); 1129 NewVD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(), 1130 SE->getByteLength()))); 1131 } 1132 1133 // Emit an error if an address space was applied to decl with local storage. 1134 // This includes arrays of objects with address space qualifiers, but not 1135 // automatic variables that point to other address spaces. 1136 // ISO/IEC TR 18037 S5.1.2 1137 if (NewVD->hasLocalStorage() && (NewVD->getType().getAddressSpace() != 0)) { 1138 Diag(D.getIdentifierLoc(), diag::err_as_qualified_auto_decl); 1139 InvalidDecl = true; 1140 } 1141 // Merge the decl with the existing one if appropriate. If the decl is 1142 // in an outer scope, it isn't the same thing. 1143 if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) { 1144 NewVD = MergeVarDecl(NewVD, PrevDecl); 1145 if (NewVD == 0) return 0; 1146 } 1147 New = NewVD; 1148 } 1149 1150 // If this has an identifier, add it to the scope stack. 1151 if (II) 1152 PushOnScopeChains(New, S); 1153 // If any semantic error occurred, mark the decl as invalid. 1154 if (D.getInvalidType() || InvalidDecl) 1155 New->setInvalidDecl(); 1156 1157 return New; 1158} 1159 1160void Sema::InitializerElementNotConstant(const Expr *Init) { 1161 Diag(Init->getExprLoc(), 1162 diag::err_init_element_not_constant, Init->getSourceRange()); 1163} 1164 1165bool Sema::CheckAddressConstantExpressionLValue(const Expr* Init) { 1166 switch (Init->getStmtClass()) { 1167 default: 1168 InitializerElementNotConstant(Init); 1169 return true; 1170 case Expr::ParenExprClass: { 1171 const ParenExpr* PE = cast<ParenExpr>(Init); 1172 return CheckAddressConstantExpressionLValue(PE->getSubExpr()); 1173 } 1174 case Expr::CompoundLiteralExprClass: 1175 return cast<CompoundLiteralExpr>(Init)->isFileScope(); 1176 case Expr::DeclRefExprClass: { 1177 const Decl *D = cast<DeclRefExpr>(Init)->getDecl(); 1178 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1179 if (VD->hasGlobalStorage()) 1180 return false; 1181 InitializerElementNotConstant(Init); 1182 return true; 1183 } 1184 if (isa<FunctionDecl>(D)) 1185 return false; 1186 InitializerElementNotConstant(Init); 1187 return true; 1188 } 1189 case Expr::MemberExprClass: { 1190 const MemberExpr *M = cast<MemberExpr>(Init); 1191 if (M->isArrow()) 1192 return CheckAddressConstantExpression(M->getBase()); 1193 return CheckAddressConstantExpressionLValue(M->getBase()); 1194 } 1195 case Expr::ArraySubscriptExprClass: { 1196 // FIXME: Should we pedwarn for "x[0+0]" (where x is a pointer)? 1197 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(Init); 1198 return CheckAddressConstantExpression(ASE->getBase()) || 1199 CheckArithmeticConstantExpression(ASE->getIdx()); 1200 } 1201 case Expr::StringLiteralClass: 1202 case Expr::PredefinedExprClass: 1203 return false; 1204 case Expr::UnaryOperatorClass: { 1205 const UnaryOperator *Exp = cast<UnaryOperator>(Init); 1206 1207 // C99 6.6p9 1208 if (Exp->getOpcode() == UnaryOperator::Deref) 1209 return CheckAddressConstantExpression(Exp->getSubExpr()); 1210 1211 InitializerElementNotConstant(Init); 1212 return true; 1213 } 1214 } 1215} 1216 1217bool Sema::CheckAddressConstantExpression(const Expr* Init) { 1218 switch (Init->getStmtClass()) { 1219 default: 1220 InitializerElementNotConstant(Init); 1221 return true; 1222 case Expr::ParenExprClass: 1223 return CheckAddressConstantExpression(cast<ParenExpr>(Init)->getSubExpr()); 1224 case Expr::StringLiteralClass: 1225 case Expr::ObjCStringLiteralClass: 1226 return false; 1227 case Expr::CallExprClass: 1228 // __builtin___CFStringMakeConstantString is a valid constant l-value. 1229 if (cast<CallExpr>(Init)->isBuiltinCall() == 1230 Builtin::BI__builtin___CFStringMakeConstantString) 1231 return false; 1232 1233 InitializerElementNotConstant(Init); 1234 return true; 1235 1236 case Expr::UnaryOperatorClass: { 1237 const UnaryOperator *Exp = cast<UnaryOperator>(Init); 1238 1239 // C99 6.6p9 1240 if (Exp->getOpcode() == UnaryOperator::AddrOf) 1241 return CheckAddressConstantExpressionLValue(Exp->getSubExpr()); 1242 1243 if (Exp->getOpcode() == UnaryOperator::Extension) 1244 return CheckAddressConstantExpression(Exp->getSubExpr()); 1245 1246 InitializerElementNotConstant(Init); 1247 return true; 1248 } 1249 case Expr::BinaryOperatorClass: { 1250 // FIXME: Should we pedwarn for expressions like "a + 1 + 2"? 1251 const BinaryOperator *Exp = cast<BinaryOperator>(Init); 1252 1253 Expr *PExp = Exp->getLHS(); 1254 Expr *IExp = Exp->getRHS(); 1255 if (IExp->getType()->isPointerType()) 1256 std::swap(PExp, IExp); 1257 1258 // FIXME: Should we pedwarn if IExp isn't an integer constant expression? 1259 return CheckAddressConstantExpression(PExp) || 1260 CheckArithmeticConstantExpression(IExp); 1261 } 1262 case Expr::ImplicitCastExprClass: 1263 case Expr::CStyleCastExprClass: { 1264 const Expr* SubExpr = cast<CastExpr>(Init)->getSubExpr(); 1265 if (Init->getStmtClass() == Expr::ImplicitCastExprClass) { 1266 // Check for implicit promotion 1267 if (SubExpr->getType()->isFunctionType() || 1268 SubExpr->getType()->isArrayType()) 1269 return CheckAddressConstantExpressionLValue(SubExpr); 1270 } 1271 1272 // Check for pointer->pointer cast 1273 if (SubExpr->getType()->isPointerType()) 1274 return CheckAddressConstantExpression(SubExpr); 1275 1276 if (SubExpr->getType()->isIntegralType()) { 1277 // Check for the special-case of a pointer->int->pointer cast; 1278 // this isn't standard, but some code requires it. See 1279 // PR2720 for an example. 1280 if (const CastExpr* SubCast = dyn_cast<CastExpr>(SubExpr)) { 1281 if (SubCast->getSubExpr()->getType()->isPointerType()) { 1282 unsigned IntWidth = Context.getIntWidth(SubCast->getType()); 1283 unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy); 1284 if (IntWidth >= PointerWidth) { 1285 return CheckAddressConstantExpression(SubCast->getSubExpr()); 1286 } 1287 } 1288 } 1289 } 1290 if (SubExpr->getType()->isArithmeticType()) { 1291 return CheckArithmeticConstantExpression(SubExpr); 1292 } 1293 1294 InitializerElementNotConstant(Init); 1295 return true; 1296 } 1297 case Expr::ConditionalOperatorClass: { 1298 // FIXME: Should we pedwarn here? 1299 const ConditionalOperator *Exp = cast<ConditionalOperator>(Init); 1300 if (!Exp->getCond()->getType()->isArithmeticType()) { 1301 InitializerElementNotConstant(Init); 1302 return true; 1303 } 1304 if (CheckArithmeticConstantExpression(Exp->getCond())) 1305 return true; 1306 if (Exp->getLHS() && 1307 CheckAddressConstantExpression(Exp->getLHS())) 1308 return true; 1309 return CheckAddressConstantExpression(Exp->getRHS()); 1310 } 1311 case Expr::AddrLabelExprClass: 1312 return false; 1313 } 1314} 1315 1316static const Expr* FindExpressionBaseAddress(const Expr* E); 1317 1318static const Expr* FindExpressionBaseAddressLValue(const Expr* E) { 1319 switch (E->getStmtClass()) { 1320 default: 1321 return E; 1322 case Expr::ParenExprClass: { 1323 const ParenExpr* PE = cast<ParenExpr>(E); 1324 return FindExpressionBaseAddressLValue(PE->getSubExpr()); 1325 } 1326 case Expr::MemberExprClass: { 1327 const MemberExpr *M = cast<MemberExpr>(E); 1328 if (M->isArrow()) 1329 return FindExpressionBaseAddress(M->getBase()); 1330 return FindExpressionBaseAddressLValue(M->getBase()); 1331 } 1332 case Expr::ArraySubscriptExprClass: { 1333 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(E); 1334 return FindExpressionBaseAddress(ASE->getBase()); 1335 } 1336 case Expr::UnaryOperatorClass: { 1337 const UnaryOperator *Exp = cast<UnaryOperator>(E); 1338 1339 if (Exp->getOpcode() == UnaryOperator::Deref) 1340 return FindExpressionBaseAddress(Exp->getSubExpr()); 1341 1342 return E; 1343 } 1344 } 1345} 1346 1347static const Expr* FindExpressionBaseAddress(const Expr* E) { 1348 switch (E->getStmtClass()) { 1349 default: 1350 return E; 1351 case Expr::ParenExprClass: { 1352 const ParenExpr* PE = cast<ParenExpr>(E); 1353 return FindExpressionBaseAddress(PE->getSubExpr()); 1354 } 1355 case Expr::UnaryOperatorClass: { 1356 const UnaryOperator *Exp = cast<UnaryOperator>(E); 1357 1358 // C99 6.6p9 1359 if (Exp->getOpcode() == UnaryOperator::AddrOf) 1360 return FindExpressionBaseAddressLValue(Exp->getSubExpr()); 1361 1362 if (Exp->getOpcode() == UnaryOperator::Extension) 1363 return FindExpressionBaseAddress(Exp->getSubExpr()); 1364 1365 return E; 1366 } 1367 case Expr::BinaryOperatorClass: { 1368 const BinaryOperator *Exp = cast<BinaryOperator>(E); 1369 1370 Expr *PExp = Exp->getLHS(); 1371 Expr *IExp = Exp->getRHS(); 1372 if (IExp->getType()->isPointerType()) 1373 std::swap(PExp, IExp); 1374 1375 return FindExpressionBaseAddress(PExp); 1376 } 1377 case Expr::ImplicitCastExprClass: { 1378 const Expr* SubExpr = cast<ImplicitCastExpr>(E)->getSubExpr(); 1379 1380 // Check for implicit promotion 1381 if (SubExpr->getType()->isFunctionType() || 1382 SubExpr->getType()->isArrayType()) 1383 return FindExpressionBaseAddressLValue(SubExpr); 1384 1385 // Check for pointer->pointer cast 1386 if (SubExpr->getType()->isPointerType()) 1387 return FindExpressionBaseAddress(SubExpr); 1388 1389 // We assume that we have an arithmetic expression here; 1390 // if we don't, we'll figure it out later 1391 return 0; 1392 } 1393 case Expr::CStyleCastExprClass: { 1394 const Expr* SubExpr = cast<CastExpr>(E)->getSubExpr(); 1395 1396 // Check for pointer->pointer cast 1397 if (SubExpr->getType()->isPointerType()) 1398 return FindExpressionBaseAddress(SubExpr); 1399 1400 // We assume that we have an arithmetic expression here; 1401 // if we don't, we'll figure it out later 1402 return 0; 1403 } 1404 } 1405} 1406 1407bool Sema::CheckArithmeticConstantExpression(const Expr* Init) { 1408 switch (Init->getStmtClass()) { 1409 default: 1410 InitializerElementNotConstant(Init); 1411 return true; 1412 case Expr::ParenExprClass: { 1413 const ParenExpr* PE = cast<ParenExpr>(Init); 1414 return CheckArithmeticConstantExpression(PE->getSubExpr()); 1415 } 1416 case Expr::FloatingLiteralClass: 1417 case Expr::IntegerLiteralClass: 1418 case Expr::CharacterLiteralClass: 1419 case Expr::ImaginaryLiteralClass: 1420 case Expr::TypesCompatibleExprClass: 1421 case Expr::CXXBoolLiteralExprClass: 1422 return false; 1423 case Expr::CallExprClass: { 1424 const CallExpr *CE = cast<CallExpr>(Init); 1425 1426 // Allow any constant foldable calls to builtins. 1427 if (CE->isBuiltinCall() && CE->isEvaluatable(Context)) 1428 return false; 1429 1430 InitializerElementNotConstant(Init); 1431 return true; 1432 } 1433 case Expr::DeclRefExprClass: { 1434 const Decl *D = cast<DeclRefExpr>(Init)->getDecl(); 1435 if (isa<EnumConstantDecl>(D)) 1436 return false; 1437 InitializerElementNotConstant(Init); 1438 return true; 1439 } 1440 case Expr::CompoundLiteralExprClass: 1441 // Allow "(vector type){2,4}"; normal C constraints don't allow this, 1442 // but vectors are allowed to be magic. 1443 if (Init->getType()->isVectorType()) 1444 return false; 1445 InitializerElementNotConstant(Init); 1446 return true; 1447 case Expr::UnaryOperatorClass: { 1448 const UnaryOperator *Exp = cast<UnaryOperator>(Init); 1449 1450 switch (Exp->getOpcode()) { 1451 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 1452 // See C99 6.6p3. 1453 default: 1454 InitializerElementNotConstant(Init); 1455 return true; 1456 case UnaryOperator::SizeOf: 1457 case UnaryOperator::AlignOf: 1458 case UnaryOperator::OffsetOf: 1459 // sizeof(E) is a constantexpr if and only if E is not evaluted. 1460 // See C99 6.5.3.4p2 and 6.6p3. 1461 if (Exp->getSubExpr()->getType()->isConstantSizeType()) 1462 return false; 1463 InitializerElementNotConstant(Init); 1464 return true; 1465 case UnaryOperator::Extension: 1466 case UnaryOperator::LNot: 1467 case UnaryOperator::Plus: 1468 case UnaryOperator::Minus: 1469 case UnaryOperator::Not: 1470 return CheckArithmeticConstantExpression(Exp->getSubExpr()); 1471 } 1472 } 1473 case Expr::SizeOfAlignOfTypeExprClass: { 1474 const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(Init); 1475 // Special check for void types, which are allowed as an extension 1476 if (Exp->getArgumentType()->isVoidType()) 1477 return false; 1478 // alignof always evaluates to a constant. 1479 // FIXME: is sizeof(int[3.0]) a constant expression? 1480 if (Exp->isSizeOf() && !Exp->getArgumentType()->isConstantSizeType()) { 1481 InitializerElementNotConstant(Init); 1482 return true; 1483 } 1484 return false; 1485 } 1486 case Expr::BinaryOperatorClass: { 1487 const BinaryOperator *Exp = cast<BinaryOperator>(Init); 1488 1489 if (Exp->getLHS()->getType()->isArithmeticType() && 1490 Exp->getRHS()->getType()->isArithmeticType()) { 1491 return CheckArithmeticConstantExpression(Exp->getLHS()) || 1492 CheckArithmeticConstantExpression(Exp->getRHS()); 1493 } 1494 1495 if (Exp->getLHS()->getType()->isPointerType() && 1496 Exp->getRHS()->getType()->isPointerType()) { 1497 const Expr* LHSBase = FindExpressionBaseAddress(Exp->getLHS()); 1498 const Expr* RHSBase = FindExpressionBaseAddress(Exp->getRHS()); 1499 1500 // Only allow a null (constant integer) base; we could 1501 // allow some additional cases if necessary, but this 1502 // is sufficient to cover offsetof-like constructs. 1503 if (!LHSBase && !RHSBase) { 1504 return CheckAddressConstantExpression(Exp->getLHS()) || 1505 CheckAddressConstantExpression(Exp->getRHS()); 1506 } 1507 } 1508 1509 InitializerElementNotConstant(Init); 1510 return true; 1511 } 1512 case Expr::ImplicitCastExprClass: 1513 case Expr::CStyleCastExprClass: { 1514 const Expr *SubExpr = cast<CastExpr>(Init)->getSubExpr(); 1515 if (SubExpr->getType()->isArithmeticType()) 1516 return CheckArithmeticConstantExpression(SubExpr); 1517 1518 if (SubExpr->getType()->isPointerType()) { 1519 const Expr* Base = FindExpressionBaseAddress(SubExpr); 1520 // If the pointer has a null base, this is an offsetof-like construct 1521 if (!Base) 1522 return CheckAddressConstantExpression(SubExpr); 1523 } 1524 1525 InitializerElementNotConstant(Init); 1526 return true; 1527 } 1528 case Expr::ConditionalOperatorClass: { 1529 const ConditionalOperator *Exp = cast<ConditionalOperator>(Init); 1530 1531 // If GNU extensions are disabled, we require all operands to be arithmetic 1532 // constant expressions. 1533 if (getLangOptions().NoExtensions) { 1534 return CheckArithmeticConstantExpression(Exp->getCond()) || 1535 (Exp->getLHS() && CheckArithmeticConstantExpression(Exp->getLHS())) || 1536 CheckArithmeticConstantExpression(Exp->getRHS()); 1537 } 1538 1539 // Otherwise, we have to emulate some of the behavior of fold here. 1540 // Basically GCC treats things like "4 ? 1 : somefunc()" as a constant 1541 // because it can constant fold things away. To retain compatibility with 1542 // GCC code, we see if we can fold the condition to a constant (which we 1543 // should always be able to do in theory). If so, we only require the 1544 // specified arm of the conditional to be a constant. This is a horrible 1545 // hack, but is require by real world code that uses __builtin_constant_p. 1546 APValue Val; 1547 if (!Exp->getCond()->tryEvaluate(Val, Context)) { 1548 // If the tryEvaluate couldn't fold it, CheckArithmeticConstantExpression 1549 // won't be able to either. Use it to emit the diagnostic though. 1550 bool Res = CheckArithmeticConstantExpression(Exp->getCond()); 1551 assert(Res && "tryEvaluate couldn't evaluate this constant?"); 1552 return Res; 1553 } 1554 1555 // Verify that the side following the condition is also a constant. 1556 const Expr *TrueSide = Exp->getLHS(), *FalseSide = Exp->getRHS(); 1557 if (Val.getInt() == 0) 1558 std::swap(TrueSide, FalseSide); 1559 1560 if (TrueSide && CheckArithmeticConstantExpression(TrueSide)) 1561 return true; 1562 1563 // Okay, the evaluated side evaluates to a constant, so we accept this. 1564 // Check to see if the other side is obviously not a constant. If so, 1565 // emit a warning that this is a GNU extension. 1566 if (FalseSide && !FalseSide->isEvaluatable(Context)) 1567 Diag(Init->getExprLoc(), 1568 diag::ext_typecheck_expression_not_constant_but_accepted, 1569 FalseSide->getSourceRange()); 1570 return false; 1571 } 1572 } 1573} 1574 1575bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 1576 Init = Init->IgnoreParens(); 1577 1578 // Look through CXXDefaultArgExprs; they have no meaning in this context. 1579 if (CXXDefaultArgExpr* DAE = dyn_cast<CXXDefaultArgExpr>(Init)) 1580 return CheckForConstantInitializer(DAE->getExpr(), DclT); 1581 1582 if (CompoundLiteralExpr *e = dyn_cast<CompoundLiteralExpr>(Init)) 1583 return CheckForConstantInitializer(e->getInitializer(), DclT); 1584 1585 if (InitListExpr *Exp = dyn_cast<InitListExpr>(Init)) { 1586 unsigned numInits = Exp->getNumInits(); 1587 for (unsigned i = 0; i < numInits; i++) { 1588 // FIXME: Need to get the type of the declaration for C++, 1589 // because it could be a reference? 1590 if (CheckForConstantInitializer(Exp->getInit(i), 1591 Exp->getInit(i)->getType())) 1592 return true; 1593 } 1594 return false; 1595 } 1596 1597 if (Init->isNullPointerConstant(Context)) 1598 return false; 1599 if (Init->getType()->isArithmeticType()) { 1600 QualType InitTy = Context.getCanonicalType(Init->getType()) 1601 .getUnqualifiedType(); 1602 if (InitTy == Context.BoolTy) { 1603 // Special handling for pointers implicitly cast to bool; 1604 // (e.g. "_Bool rr = &rr;"). This is only legal at the top level. 1605 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Init)) { 1606 Expr* SubE = ICE->getSubExpr(); 1607 if (SubE->getType()->isPointerType() || 1608 SubE->getType()->isArrayType() || 1609 SubE->getType()->isFunctionType()) { 1610 return CheckAddressConstantExpression(Init); 1611 } 1612 } 1613 } else if (InitTy->isIntegralType()) { 1614 Expr* SubE = 0; 1615 if (CastExpr* CE = dyn_cast<CastExpr>(Init)) 1616 SubE = CE->getSubExpr(); 1617 // Special check for pointer cast to int; we allow as an extension 1618 // an address constant cast to an integer if the integer 1619 // is of an appropriate width (this sort of code is apparently used 1620 // in some places). 1621 // FIXME: Add pedwarn? 1622 // FIXME: Don't allow bitfields here! Need the FieldDecl for that. 1623 if (SubE && (SubE->getType()->isPointerType() || 1624 SubE->getType()->isArrayType() || 1625 SubE->getType()->isFunctionType())) { 1626 unsigned IntWidth = Context.getTypeSize(Init->getType()); 1627 unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy); 1628 if (IntWidth >= PointerWidth) 1629 return CheckAddressConstantExpression(Init); 1630 } 1631 } 1632 1633 return CheckArithmeticConstantExpression(Init); 1634 } 1635 1636 if (Init->getType()->isPointerType()) 1637 return CheckAddressConstantExpression(Init); 1638 1639 // An array type at the top level that isn't an init-list must 1640 // be a string literal 1641 if (Init->getType()->isArrayType()) 1642 return false; 1643 1644 if (Init->getType()->isFunctionType()) 1645 return false; 1646 1647 // Allow block exprs at top level. 1648 if (Init->getType()->isBlockPointerType()) 1649 return false; 1650 1651 InitializerElementNotConstant(Init); 1652 return true; 1653} 1654 1655void Sema::AddInitializerToDecl(DeclTy *dcl, ExprTy *init) { 1656 Decl *RealDecl = static_cast<Decl *>(dcl); 1657 Expr *Init = static_cast<Expr *>(init); 1658 assert(Init && "missing initializer"); 1659 1660 // If there is no declaration, there was an error parsing it. Just ignore 1661 // the initializer. 1662 if (RealDecl == 0) { 1663 delete Init; 1664 return; 1665 } 1666 1667 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 1668 if (!VDecl) { 1669 Diag(dyn_cast<ScopedDecl>(RealDecl)->getLocation(), 1670 diag::err_illegal_initializer); 1671 RealDecl->setInvalidDecl(); 1672 return; 1673 } 1674 // Get the decls type and save a reference for later, since 1675 // CheckInitializerTypes may change it. 1676 QualType DclT = VDecl->getType(), SavT = DclT; 1677 if (VDecl->isBlockVarDecl()) { 1678 VarDecl::StorageClass SC = VDecl->getStorageClass(); 1679 if (SC == VarDecl::Extern) { // C99 6.7.8p5 1680 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 1681 VDecl->setInvalidDecl(); 1682 } else if (!VDecl->isInvalidDecl()) { 1683 if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(), 1684 VDecl->getName())) 1685 VDecl->setInvalidDecl(); 1686 1687 // C++ 3.6.2p2, allow dynamic initialization of static initializers. 1688 if (!getLangOptions().CPlusPlus) { 1689 if (SC == VarDecl::Static) // C99 6.7.8p4. 1690 CheckForConstantInitializer(Init, DclT); 1691 } 1692 } 1693 } else if (VDecl->isFileVarDecl()) { 1694 if (VDecl->getStorageClass() == VarDecl::Extern) 1695 Diag(VDecl->getLocation(), diag::warn_extern_init); 1696 if (!VDecl->isInvalidDecl()) 1697 if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(), 1698 VDecl->getName())) 1699 VDecl->setInvalidDecl(); 1700 1701 // C++ 3.6.2p2, allow dynamic initialization of static initializers. 1702 if (!getLangOptions().CPlusPlus) { 1703 // C99 6.7.8p4. All file scoped initializers need to be constant. 1704 CheckForConstantInitializer(Init, DclT); 1705 } 1706 } 1707 // If the type changed, it means we had an incomplete type that was 1708 // completed by the initializer. For example: 1709 // int ary[] = { 1, 3, 5 }; 1710 // "ary" transitions from a VariableArrayType to a ConstantArrayType. 1711 if (!VDecl->isInvalidDecl() && (DclT != SavT)) { 1712 VDecl->setType(DclT); 1713 Init->setType(DclT); 1714 } 1715 1716 // Attach the initializer to the decl. 1717 VDecl->setInit(Init); 1718 return; 1719} 1720 1721void Sema::ActOnUninitializedDecl(DeclTy *dcl) { 1722 Decl *RealDecl = static_cast<Decl *>(dcl); 1723 1724 // If there is no declaration, there was an error parsing it. Just ignore it. 1725 if (RealDecl == 0) 1726 return; 1727 1728 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) { 1729 QualType Type = Var->getType(); 1730 // C++ [dcl.init.ref]p3: 1731 // The initializer can be omitted for a reference only in a 1732 // parameter declaration (8.3.5), in the declaration of a 1733 // function return type, in the declaration of a class member 1734 // within its class declaration (9.2), and where the extern 1735 // specifier is explicitly used. 1736 if (Type->isReferenceType() && Var->getStorageClass() != VarDecl::Extern) { 1737 Diag(Var->getLocation(), 1738 diag::err_reference_var_requires_init, 1739 Var->getName(), 1740 SourceRange(Var->getLocation(), Var->getLocation())); 1741 Var->setInvalidDecl(); 1742 return; 1743 } 1744 1745 // C++ [dcl.init]p9: 1746 // 1747 // If no initializer is specified for an object, and the object 1748 // is of (possibly cv-qualified) non-POD class type (or array 1749 // thereof), the object shall be default-initialized; if the 1750 // object is of const-qualified type, the underlying class type 1751 // shall have a user-declared default constructor. 1752 if (getLangOptions().CPlusPlus) { 1753 QualType InitType = Type; 1754 if (const ArrayType *Array = Context.getAsArrayType(Type)) 1755 InitType = Array->getElementType(); 1756 if (InitType->isRecordType()) { 1757 const CXXConstructorDecl *Constructor 1758 = PerformInitializationByConstructor(InitType, 0, 0, 1759 Var->getLocation(), 1760 SourceRange(Var->getLocation(), 1761 Var->getLocation()), 1762 Var->getName(), 1763 IK_Default); 1764 if (!Constructor) 1765 Var->setInvalidDecl(); 1766 } 1767 } 1768 1769#if 0 1770 // FIXME: Temporarily disabled because we are not properly parsing 1771 // linkage specifications on declarations, e.g., 1772 // 1773 // extern "C" const CGPoint CGPointerZero; 1774 // 1775 // C++ [dcl.init]p9: 1776 // 1777 // If no initializer is specified for an object, and the 1778 // object is of (possibly cv-qualified) non-POD class type (or 1779 // array thereof), the object shall be default-initialized; if 1780 // the object is of const-qualified type, the underlying class 1781 // type shall have a user-declared default 1782 // constructor. Otherwise, if no initializer is specified for 1783 // an object, the object and its subobjects, if any, have an 1784 // indeterminate initial value; if the object or any of its 1785 // subobjects are of const-qualified type, the program is 1786 // ill-formed. 1787 // 1788 // This isn't technically an error in C, so we don't diagnose it. 1789 // 1790 // FIXME: Actually perform the POD/user-defined default 1791 // constructor check. 1792 if (getLangOptions().CPlusPlus && 1793 Context.getCanonicalType(Type).isConstQualified() && 1794 Var->getStorageClass() != VarDecl::Extern) 1795 Diag(Var->getLocation(), 1796 diag::err_const_var_requires_init, 1797 Var->getName(), 1798 SourceRange(Var->getLocation(), Var->getLocation())); 1799#endif 1800 } 1801} 1802 1803/// The declarators are chained together backwards, reverse the list. 1804Sema::DeclTy *Sema::FinalizeDeclaratorGroup(Scope *S, DeclTy *group) { 1805 // Often we have single declarators, handle them quickly. 1806 Decl *GroupDecl = static_cast<Decl*>(group); 1807 if (GroupDecl == 0) 1808 return 0; 1809 1810 ScopedDecl *Group = dyn_cast<ScopedDecl>(GroupDecl); 1811 ScopedDecl *NewGroup = 0; 1812 if (Group->getNextDeclarator() == 0) 1813 NewGroup = Group; 1814 else { // reverse the list. 1815 while (Group) { 1816 ScopedDecl *Next = Group->getNextDeclarator(); 1817 Group->setNextDeclarator(NewGroup); 1818 NewGroup = Group; 1819 Group = Next; 1820 } 1821 } 1822 // Perform semantic analysis that depends on having fully processed both 1823 // the declarator and initializer. 1824 for (ScopedDecl *ID = NewGroup; ID; ID = ID->getNextDeclarator()) { 1825 VarDecl *IDecl = dyn_cast<VarDecl>(ID); 1826 if (!IDecl) 1827 continue; 1828 QualType T = IDecl->getType(); 1829 1830 // C99 6.7.5.2p2: If an identifier is declared to be an object with 1831 // static storage duration, it shall not have a variable length array. 1832 if ((IDecl->isFileVarDecl() || IDecl->isBlockVarDecl()) && 1833 IDecl->getStorageClass() == VarDecl::Static) { 1834 if (T->isVariableArrayType()) { 1835 Diag(IDecl->getLocation(), diag::err_typecheck_illegal_vla); 1836 IDecl->setInvalidDecl(); 1837 } 1838 } 1839 // Block scope. C99 6.7p7: If an identifier for an object is declared with 1840 // no linkage (C99 6.2.2p6), the type for the object shall be complete... 1841 if (IDecl->isBlockVarDecl() && 1842 IDecl->getStorageClass() != VarDecl::Extern) { 1843 if (T->isIncompleteType() && !IDecl->isInvalidDecl()) { 1844 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type, 1845 T.getAsString()); 1846 IDecl->setInvalidDecl(); 1847 } 1848 } 1849 // File scope. C99 6.9.2p2: A declaration of an identifier for and 1850 // object that has file scope without an initializer, and without a 1851 // storage-class specifier or with the storage-class specifier "static", 1852 // constitutes a tentative definition. Note: A tentative definition with 1853 // external linkage is valid (C99 6.2.2p5). 1854 if (isTentativeDefinition(IDecl)) { 1855 if (T->isIncompleteArrayType()) { 1856 // C99 6.9.2 (p2, p5): Implicit initialization causes an incomplete 1857 // array to be completed. Don't issue a diagnostic. 1858 } else if (T->isIncompleteType() && !IDecl->isInvalidDecl()) { 1859 // C99 6.9.2p3: If the declaration of an identifier for an object is 1860 // a tentative definition and has internal linkage (C99 6.2.2p3), the 1861 // declared type shall not be an incomplete type. 1862 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type, 1863 T.getAsString()); 1864 IDecl->setInvalidDecl(); 1865 } 1866 } 1867 if (IDecl->isFileVarDecl()) 1868 CheckForFileScopedRedefinitions(S, IDecl); 1869 } 1870 return NewGroup; 1871} 1872 1873/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 1874/// to introduce parameters into function prototype scope. 1875Sema::DeclTy * 1876Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 1877 // FIXME: disallow CXXScopeSpec for param declarators. 1878 const DeclSpec &DS = D.getDeclSpec(); 1879 1880 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 1881 VarDecl::StorageClass StorageClass = VarDecl::None; 1882 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 1883 StorageClass = VarDecl::Register; 1884 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 1885 Diag(DS.getStorageClassSpecLoc(), 1886 diag::err_invalid_storage_class_in_func_decl); 1887 D.getMutableDeclSpec().ClearStorageClassSpecs(); 1888 } 1889 if (DS.isThreadSpecified()) { 1890 Diag(DS.getThreadSpecLoc(), 1891 diag::err_invalid_storage_class_in_func_decl); 1892 D.getMutableDeclSpec().ClearStorageClassSpecs(); 1893 } 1894 1895 // Check that there are no default arguments inside the type of this 1896 // parameter (C++ only). 1897 if (getLangOptions().CPlusPlus) 1898 CheckExtraCXXDefaultArguments(D); 1899 1900 // In this context, we *do not* check D.getInvalidType(). If the declarator 1901 // type was invalid, GetTypeForDeclarator() still returns a "valid" type, 1902 // though it will not reflect the user specified type. 1903 QualType parmDeclType = GetTypeForDeclarator(D, S); 1904 1905 assert(!parmDeclType.isNull() && "GetTypeForDeclarator() returned null type"); 1906 1907 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope. 1908 // Can this happen for params? We already checked that they don't conflict 1909 // among each other. Here they can only shadow globals, which is ok. 1910 IdentifierInfo *II = D.getIdentifier(); 1911 if (Decl *PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S)) { 1912 if (S->isDeclScope(PrevDecl)) { 1913 Diag(D.getIdentifierLoc(), diag::err_param_redefinition, 1914 dyn_cast<NamedDecl>(PrevDecl)->getName()); 1915 1916 // Recover by removing the name 1917 II = 0; 1918 D.SetIdentifier(0, D.getIdentifierLoc()); 1919 } 1920 } 1921 1922 // Perform the default function/array conversion (C99 6.7.5.3p[7,8]). 1923 // Doing the promotion here has a win and a loss. The win is the type for 1924 // both Decl's and DeclRefExpr's will match (a convenient invariant for the 1925 // code generator). The loss is the orginal type isn't preserved. For example: 1926 // 1927 // void func(int parmvardecl[5]) { // convert "int [5]" to "int *" 1928 // int blockvardecl[5]; 1929 // sizeof(parmvardecl); // size == 4 1930 // sizeof(blockvardecl); // size == 20 1931 // } 1932 // 1933 // For expressions, all implicit conversions are captured using the 1934 // ImplicitCastExpr AST node (we have no such mechanism for Decl's). 1935 // 1936 // FIXME: If a source translation tool needs to see the original type, then 1937 // we need to consider storing both types (in ParmVarDecl)... 1938 // 1939 if (parmDeclType->isArrayType()) { 1940 // int x[restrict 4] -> int *restrict 1941 parmDeclType = Context.getArrayDecayedType(parmDeclType); 1942 } else if (parmDeclType->isFunctionType()) 1943 parmDeclType = Context.getPointerType(parmDeclType); 1944 1945 ParmVarDecl *New = ParmVarDecl::Create(Context, CurContext, 1946 D.getIdentifierLoc(), II, 1947 parmDeclType, StorageClass, 1948 0, 0); 1949 1950 if (D.getInvalidType()) 1951 New->setInvalidDecl(); 1952 1953 if (II) 1954 PushOnScopeChains(New, S); 1955 1956 ProcessDeclAttributes(New, D); 1957 return New; 1958 1959} 1960 1961Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) { 1962 assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 1963 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function && 1964 "Not a function declarator!"); 1965 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun; 1966 1967 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 1968 // for a K&R function. 1969 if (!FTI.hasPrototype) { 1970 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) { 1971 if (FTI.ArgInfo[i].Param == 0) { 1972 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared, 1973 FTI.ArgInfo[i].Ident->getName()); 1974 // Implicitly declare the argument as type 'int' for lack of a better 1975 // type. 1976 DeclSpec DS; 1977 const char* PrevSpec; // unused 1978 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc, 1979 PrevSpec); 1980 Declarator ParamD(DS, Declarator::KNRTypeListContext); 1981 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc); 1982 FTI.ArgInfo[i].Param = ActOnParamDeclarator(FnBodyScope, ParamD); 1983 } 1984 } 1985 } else { 1986 // FIXME: Diagnose arguments without names in C. 1987 } 1988 1989 Scope *GlobalScope = FnBodyScope->getParent(); 1990 1991 return ActOnStartOfFunctionDef(FnBodyScope, 1992 ActOnDeclarator(GlobalScope, D, 0)); 1993} 1994 1995Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclTy *D) { 1996 Decl *decl = static_cast<Decl*>(D); 1997 FunctionDecl *FD = cast<FunctionDecl>(decl); 1998 1999 // See if this is a redefinition. 2000 const FunctionDecl *Definition; 2001 if (FD->getBody(Definition)) { 2002 Diag(FD->getLocation(), diag::err_redefinition, 2003 FD->getName()); 2004 Diag(Definition->getLocation(), diag::err_previous_definition); 2005 } 2006 2007 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 2008 if (isa<CXXRecordDecl>(CurContext)) 2009 MD->setInlineDefinition(true); 2010 2011 PushDeclContext(FD); 2012 2013 // Check the validity of our function parameters 2014 CheckParmsForFunctionDef(FD); 2015 2016 // Introduce our parameters into the function scope 2017 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 2018 ParmVarDecl *Param = FD->getParamDecl(p); 2019 // If this has an identifier, add it to the scope stack. 2020 if (Param->getIdentifier()) 2021 PushOnScopeChains(Param, FnBodyScope); 2022 } 2023 2024 return FD; 2025} 2026 2027Sema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtTy *Body) { 2028 Decl *dcl = static_cast<Decl *>(D); 2029 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(dcl)) { 2030 FD->setBody((Stmt*)Body); 2031 assert(FD == getCurFunctionDecl() && "Function parsing confused"); 2032 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 2033 MD->setBody((Stmt*)Body); 2034 } else 2035 return 0; 2036 PopDeclContext(); 2037 // Verify and clean out per-function state. 2038 2039 // Check goto/label use. 2040 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator 2041 I = LabelMap.begin(), E = LabelMap.end(); I != E; ++I) { 2042 // Verify that we have no forward references left. If so, there was a goto 2043 // or address of a label taken, but no definition of it. Label fwd 2044 // definitions are indicated with a null substmt. 2045 if (I->second->getSubStmt() == 0) { 2046 LabelStmt *L = I->second; 2047 // Emit error. 2048 Diag(L->getIdentLoc(), diag::err_undeclared_label_use, L->getName()); 2049 2050 // At this point, we have gotos that use the bogus label. Stitch it into 2051 // the function body so that they aren't leaked and that the AST is well 2052 // formed. 2053 if (Body) { 2054 L->setSubStmt(new NullStmt(L->getIdentLoc())); 2055 cast<CompoundStmt>((Stmt*)Body)->push_back(L); 2056 } else { 2057 // The whole function wasn't parsed correctly, just delete this. 2058 delete L; 2059 } 2060 } 2061 } 2062 LabelMap.clear(); 2063 2064 return D; 2065} 2066 2067/// ImplicitlyDefineFunction - An undeclared identifier was used in a function 2068/// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 2069ScopedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 2070 IdentifierInfo &II, Scope *S) { 2071 // Extension in C99. Legal in C90, but warn about it. 2072 if (getLangOptions().C99) 2073 Diag(Loc, diag::ext_implicit_function_decl, II.getName()); 2074 else 2075 Diag(Loc, diag::warn_implicit_function_decl, II.getName()); 2076 2077 // FIXME: handle stuff like: 2078 // void foo() { extern float X(); } 2079 // void bar() { X(); } <-- implicit decl for X in another scope. 2080 2081 // Set a Declarator for the implicit definition: int foo(); 2082 const char *Dummy; 2083 DeclSpec DS; 2084 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy); 2085 Error = Error; // Silence warning. 2086 assert(!Error && "Error setting up implicit decl!"); 2087 Declarator D(DS, Declarator::BlockContext); 2088 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, 0, 0, 0, Loc)); 2089 D.SetIdentifier(&II, Loc); 2090 2091 // Insert this function into translation-unit scope. 2092 2093 DeclContext *PrevDC = CurContext; 2094 CurContext = Context.getTranslationUnitDecl(); 2095 2096 FunctionDecl *FD = 2097 dyn_cast<FunctionDecl>(static_cast<Decl*>(ActOnDeclarator(TUScope, D, 0))); 2098 FD->setImplicit(); 2099 2100 CurContext = PrevDC; 2101 2102 return FD; 2103} 2104 2105 2106TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 2107 ScopedDecl *LastDeclarator) { 2108 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 2109 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 2110 2111 // Scope manipulation handled by caller. 2112 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 2113 D.getIdentifierLoc(), 2114 D.getIdentifier(), 2115 T, LastDeclarator); 2116 if (D.getInvalidType()) 2117 NewTD->setInvalidDecl(); 2118 return NewTD; 2119} 2120 2121/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the 2122/// former case, Name will be non-null. In the later case, Name will be null. 2123/// TagType indicates what kind of tag this is. TK indicates whether this is a 2124/// reference/declaration/definition of a tag. 2125Sema::DeclTy *Sema::ActOnTag(Scope *S, unsigned TagType, TagKind TK, 2126 SourceLocation KWLoc, const CXXScopeSpec &SS, 2127 IdentifierInfo *Name, SourceLocation NameLoc, 2128 AttributeList *Attr) { 2129 // If this is a use of an existing tag, it must have a name. 2130 assert((Name != 0 || TK == TK_Definition) && 2131 "Nameless record must be a definition!"); 2132 2133 TagDecl::TagKind Kind; 2134 switch (TagType) { 2135 default: assert(0 && "Unknown tag type!"); 2136 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 2137 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 2138 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 2139 case DeclSpec::TST_enum: Kind = TagDecl::TK_enum; break; 2140 } 2141 2142 // Two code paths: a new one for structs/unions/classes where we create 2143 // separate decls for forward declarations, and an old (eventually to 2144 // be removed) code path for enums. 2145 if (Kind != TagDecl::TK_enum) 2146 return ActOnTagStruct(S, Kind, TK, KWLoc, SS, Name, NameLoc, Attr); 2147 2148 DeclContext *DC = CurContext; 2149 ScopedDecl *PrevDecl = 0; 2150 2151 if (Name && SS.isNotEmpty()) { 2152 // We have a nested-name tag ('struct foo::bar'). 2153 2154 // Check for invalid 'foo::'. 2155 if (SS.isInvalid()) { 2156 Name = 0; 2157 goto CreateNewDecl; 2158 } 2159 2160 DC = static_cast<DeclContext*>(SS.getScopeRep()); 2161 // Look-up name inside 'foo::'. 2162 PrevDecl = dyn_cast_or_null<TagDecl>(LookupDecl(Name, Decl::IDNS_Tag,S,DC)); 2163 2164 // A tag 'foo::bar' must already exist. 2165 if (PrevDecl == 0) { 2166 Diag(NameLoc, diag::err_not_tag_in_scope, Name->getName(), 2167 SS.getRange()); 2168 Name = 0; 2169 goto CreateNewDecl; 2170 } 2171 } else { 2172 // If this is a named struct, check to see if there was a previous forward 2173 // declaration or definition. 2174 // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up. 2175 PrevDecl = dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag,S)); 2176 } 2177 2178 if (PrevDecl) { 2179 assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) && 2180 "unexpected Decl type"); 2181 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 2182 // If this is a use of a previous tag, or if the tag is already declared 2183 // in the same scope (so that the definition/declaration completes or 2184 // rementions the tag), reuse the decl. 2185 if (TK == TK_Reference || isDeclInScope(PrevDecl, DC, S)) { 2186 // Make sure that this wasn't declared as an enum and now used as a 2187 // struct or something similar. 2188 if (PrevTagDecl->getTagKind() != Kind) { 2189 Diag(KWLoc, diag::err_use_with_wrong_tag, Name->getName()); 2190 Diag(PrevDecl->getLocation(), diag::err_previous_use); 2191 // Recover by making this an anonymous redefinition. 2192 Name = 0; 2193 PrevDecl = 0; 2194 } else { 2195 // If this is a use or a forward declaration, we're good. 2196 if (TK != TK_Definition) 2197 return PrevDecl; 2198 2199 // Diagnose attempts to redefine a tag. 2200 if (PrevTagDecl->isDefinition()) { 2201 Diag(NameLoc, diag::err_redefinition, Name->getName()); 2202 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 2203 // If this is a redefinition, recover by making this struct be 2204 // anonymous, which will make any later references get the previous 2205 // definition. 2206 Name = 0; 2207 } else { 2208 // Okay, this is definition of a previously declared or referenced 2209 // tag. Move the location of the decl to be the definition site. 2210 PrevDecl->setLocation(NameLoc); 2211 return PrevDecl; 2212 } 2213 } 2214 } 2215 // If we get here, this is a definition of a new struct type in a nested 2216 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a new 2217 // type. 2218 } else { 2219 // PrevDecl is a namespace. 2220 if (isDeclInScope(PrevDecl, DC, S)) { 2221 // The tag name clashes with a namespace name, issue an error and 2222 // recover by making this tag be anonymous. 2223 Diag(NameLoc, diag::err_redefinition_different_kind, Name->getName()); 2224 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 2225 Name = 0; 2226 } 2227 } 2228 } 2229 2230 CreateNewDecl: 2231 2232 // If there is an identifier, use the location of the identifier as the 2233 // location of the decl, otherwise use the location of the struct/union 2234 // keyword. 2235 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 2236 2237 // Otherwise, if this is the first time we've seen this tag, create the decl. 2238 TagDecl *New; 2239 if (Kind == TagDecl::TK_enum) { 2240 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 2241 // enum X { A, B, C } D; D should chain to X. 2242 New = EnumDecl::Create(Context, DC, Loc, Name, 0); 2243 // If this is an undefined enum, warn. 2244 if (TK != TK_Definition) Diag(Loc, diag::ext_forward_ref_enum); 2245 } else { 2246 // struct/union/class 2247 2248 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 2249 // struct X { int A; } D; D should chain to X. 2250 if (getLangOptions().CPlusPlus) 2251 // FIXME: Look for a way to use RecordDecl for simple structs. 2252 New = CXXRecordDecl::Create(Context, Kind, DC, Loc, Name); 2253 else 2254 New = RecordDecl::Create(Context, Kind, DC, Loc, Name); 2255 } 2256 2257 // If this has an identifier, add it to the scope stack. 2258 if (Name) { 2259 // The scope passed in may not be a decl scope. Zip up the scope tree until 2260 // we find one that is. 2261 while ((S->getFlags() & Scope::DeclScope) == 0) 2262 S = S->getParent(); 2263 2264 // Add it to the decl chain. 2265 PushOnScopeChains(New, S); 2266 } 2267 2268 if (Attr) 2269 ProcessDeclAttributeList(New, Attr); 2270 return New; 2271} 2272 2273/// ActOnTagStruct - New "ActOnTag" logic for structs/unions/classes. Unlike 2274/// the logic for enums, we create separate decls for forward declarations. 2275/// This is called by ActOnTag, but eventually will replace its logic. 2276Sema::DeclTy *Sema::ActOnTagStruct(Scope *S, TagDecl::TagKind Kind, TagKind TK, 2277 SourceLocation KWLoc, const CXXScopeSpec &SS, 2278 IdentifierInfo *Name, SourceLocation NameLoc, 2279 AttributeList *Attr) { 2280 DeclContext *DC = CurContext; 2281 ScopedDecl *PrevDecl = 0; 2282 2283 if (Name && SS.isNotEmpty()) { 2284 // We have a nested-name tag ('struct foo::bar'). 2285 2286 // Check for invalid 'foo::'. 2287 if (SS.isInvalid()) { 2288 Name = 0; 2289 goto CreateNewDecl; 2290 } 2291 2292 DC = static_cast<DeclContext*>(SS.getScopeRep()); 2293 // Look-up name inside 'foo::'. 2294 PrevDecl = dyn_cast_or_null<TagDecl>(LookupDecl(Name, Decl::IDNS_Tag,S,DC)); 2295 2296 // A tag 'foo::bar' must already exist. 2297 if (PrevDecl == 0) { 2298 Diag(NameLoc, diag::err_not_tag_in_scope, Name->getName(), 2299 SS.getRange()); 2300 Name = 0; 2301 goto CreateNewDecl; 2302 } 2303 } else { 2304 // If this is a named struct, check to see if there was a previous forward 2305 // declaration or definition. 2306 // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up. 2307 PrevDecl = dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag,S)); 2308 } 2309 2310 if (PrevDecl) { 2311 assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) && 2312 "unexpected Decl type"); 2313 2314 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 2315 // If this is a use of a previous tag, or if the tag is already declared 2316 // in the same scope (so that the definition/declaration completes or 2317 // rementions the tag), reuse the decl. 2318 if (TK == TK_Reference || isDeclInScope(PrevDecl, DC, S)) { 2319 // Make sure that this wasn't declared as an enum and now used as a 2320 // struct or something similar. 2321 if (PrevTagDecl->getTagKind() != Kind) { 2322 Diag(KWLoc, diag::err_use_with_wrong_tag, Name->getName()); 2323 Diag(PrevDecl->getLocation(), diag::err_previous_use); 2324 // Recover by making this an anonymous redefinition. 2325 Name = 0; 2326 PrevDecl = 0; 2327 } else { 2328 // If this is a use, return the original decl. 2329 2330 // FIXME: In the future, return a variant or some other clue 2331 // for the consumer of this Decl to know it doesn't own it. 2332 // For our current ASTs this shouldn't be a problem, but will 2333 // need to be changed with DeclGroups. 2334 if (TK == TK_Reference) 2335 return PrevDecl; 2336 2337 // The new decl is a definition? 2338 if (TK == TK_Definition) { 2339 // Diagnose attempts to redefine a tag. 2340 if (RecordDecl* DefRecord = 2341 cast<RecordDecl>(PrevTagDecl)->getDefinition(Context)) { 2342 Diag(NameLoc, diag::err_redefinition, Name->getName()); 2343 Diag(DefRecord->getLocation(), diag::err_previous_definition); 2344 // If this is a redefinition, recover by making this struct be 2345 // anonymous, which will make any later references get the previous 2346 // definition. 2347 Name = 0; 2348 PrevDecl = 0; 2349 } 2350 // Okay, this is definition of a previously declared or referenced 2351 // tag. We're going to create a new Decl. 2352 } 2353 } 2354 // If we get here we have (another) forward declaration. Just create 2355 // a new decl. 2356 } 2357 else { 2358 // If we get here, this is a definition of a new struct type in a nested 2359 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 2360 // new decl/type. We set PrevDecl to NULL so that the Records 2361 // have distinct types. 2362 PrevDecl = 0; 2363 } 2364 } else { 2365 // PrevDecl is a namespace. 2366 if (isDeclInScope(PrevDecl, DC, S)) { 2367 // The tag name clashes with a namespace name, issue an error and 2368 // recover by making this tag be anonymous. 2369 Diag(NameLoc, diag::err_redefinition_different_kind, Name->getName()); 2370 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 2371 Name = 0; 2372 } 2373 } 2374 } 2375 2376 CreateNewDecl: 2377 2378 // If there is an identifier, use the location of the identifier as the 2379 // location of the decl, otherwise use the location of the struct/union 2380 // keyword. 2381 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 2382 2383 // Otherwise, if this is the first time we've seen this tag, create the decl. 2384 TagDecl *New; 2385 2386 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 2387 // struct X { int A; } D; D should chain to X. 2388 if (getLangOptions().CPlusPlus) 2389 // FIXME: Look for a way to use RecordDecl for simple structs. 2390 New = CXXRecordDecl::Create(Context, Kind, DC, Loc, Name, 2391 dyn_cast_or_null<CXXRecordDecl>(PrevDecl)); 2392 else 2393 New = RecordDecl::Create(Context, Kind, DC, Loc, Name, 2394 dyn_cast_or_null<RecordDecl>(PrevDecl)); 2395 2396 // If this has an identifier, add it to the scope stack. 2397 if ((TK == TK_Definition || !PrevDecl) && Name) { 2398 // The scope passed in may not be a decl scope. Zip up the scope tree until 2399 // we find one that is. 2400 while ((S->getFlags() & Scope::DeclScope) == 0) 2401 S = S->getParent(); 2402 2403 // Add it to the decl chain. 2404 PushOnScopeChains(New, S); 2405 } 2406 2407 // Handle #pragma pack: if the #pragma pack stack has non-default 2408 // alignment, make up a packed attribute for this decl. These 2409 // attributes are checked when the ASTContext lays out the 2410 // structure. 2411 // 2412 // It is important for implementing the correct semantics that this 2413 // happen here (in act on tag decl). The #pragma pack stack is 2414 // maintained as a result of parser callbacks which can occur at 2415 // many points during the parsing of a struct declaration (because 2416 // the #pragma tokens are effectively skipped over during the 2417 // parsing of the struct). 2418 if (unsigned Alignment = PackContext.getAlignment()) 2419 New->addAttr(new PackedAttr(Alignment * 8)); 2420 2421 if (Attr) 2422 ProcessDeclAttributeList(New, Attr); 2423 2424 return New; 2425} 2426 2427 2428/// Collect the instance variables declared in an Objective-C object. Used in 2429/// the creation of structures from objects using the @defs directive. 2430static void CollectIvars(ObjCInterfaceDecl *Class, ASTContext& Ctx, 2431 llvm::SmallVectorImpl<Sema::DeclTy*> &ivars) { 2432 if (Class->getSuperClass()) 2433 CollectIvars(Class->getSuperClass(), Ctx, ivars); 2434 2435 // For each ivar, create a fresh ObjCAtDefsFieldDecl. 2436 for (ObjCInterfaceDecl::ivar_iterator 2437 I=Class->ivar_begin(), E=Class->ivar_end(); I!=E; ++I) { 2438 2439 ObjCIvarDecl* ID = *I; 2440 ivars.push_back(ObjCAtDefsFieldDecl::Create(Ctx, ID->getLocation(), 2441 ID->getIdentifier(), 2442 ID->getType(), 2443 ID->getBitWidth())); 2444 } 2445} 2446 2447/// Called whenever @defs(ClassName) is encountered in the source. Inserts the 2448/// instance variables of ClassName into Decls. 2449void Sema::ActOnDefs(Scope *S, SourceLocation DeclStart, 2450 IdentifierInfo *ClassName, 2451 llvm::SmallVectorImpl<DeclTy*> &Decls) { 2452 // Check that ClassName is a valid class 2453 ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName); 2454 if (!Class) { 2455 Diag(DeclStart, diag::err_undef_interface, ClassName->getName()); 2456 return; 2457 } 2458 // Collect the instance variables 2459 CollectIvars(Class, Context, Decls); 2460} 2461 2462QualType Sema::TryFixInvalidVariablyModifiedType(QualType T) { 2463 // This method tries to turn a variable array into a constant 2464 // array even when the size isn't an ICE. This is necessary 2465 // for compatibility with code that depends on gcc's buggy 2466 // constant expression folding, like struct {char x[(int)(char*)2];} 2467 if (const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T)) { 2468 APValue Result; 2469 if (VLATy->getSizeExpr() && 2470 VLATy->getSizeExpr()->tryEvaluate(Result, Context) && Result.isInt()) { 2471 llvm::APSInt &Res = Result.getInt(); 2472 if (Res > llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) 2473 return Context.getConstantArrayType(VLATy->getElementType(), 2474 Res, ArrayType::Normal, 0); 2475 } 2476 } 2477 return QualType(); 2478} 2479 2480/// ActOnField - Each field of a struct/union/class is passed into this in order 2481/// to create a FieldDecl object for it. 2482Sema::DeclTy *Sema::ActOnField(Scope *S, 2483 SourceLocation DeclStart, 2484 Declarator &D, ExprTy *BitfieldWidth) { 2485 IdentifierInfo *II = D.getIdentifier(); 2486 Expr *BitWidth = (Expr*)BitfieldWidth; 2487 SourceLocation Loc = DeclStart; 2488 if (II) Loc = D.getIdentifierLoc(); 2489 2490 // FIXME: Unnamed fields can be handled in various different ways, for 2491 // example, unnamed unions inject all members into the struct namespace! 2492 2493 if (BitWidth) { 2494 // TODO: Validate. 2495 //printf("WARNING: BITFIELDS IGNORED!\n"); 2496 2497 // 6.7.2.1p3 2498 // 6.7.2.1p4 2499 2500 } else { 2501 // Not a bitfield. 2502 2503 // validate II. 2504 2505 } 2506 2507 QualType T = GetTypeForDeclarator(D, S); 2508 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 2509 bool InvalidDecl = false; 2510 2511 // C99 6.7.2.1p8: A member of a structure or union may have any type other 2512 // than a variably modified type. 2513 if (T->isVariablyModifiedType()) { 2514 QualType FixedTy = TryFixInvalidVariablyModifiedType(T); 2515 if (!FixedTy.isNull()) { 2516 Diag(Loc, diag::warn_illegal_constant_array_size, Loc); 2517 T = FixedTy; 2518 } else { 2519 // FIXME: This diagnostic needs work 2520 Diag(Loc, diag::err_typecheck_illegal_vla, Loc); 2521 InvalidDecl = true; 2522 } 2523 } 2524 // FIXME: Chain fielddecls together. 2525 FieldDecl *NewFD; 2526 2527 if (getLangOptions().CPlusPlus) { 2528 // FIXME: Replace CXXFieldDecls with FieldDecls for simple structs. 2529 NewFD = CXXFieldDecl::Create(Context, cast<CXXRecordDecl>(CurContext), 2530 Loc, II, T, BitWidth); 2531 if (II) 2532 PushOnScopeChains(NewFD, S); 2533 } 2534 else 2535 NewFD = FieldDecl::Create(Context, Loc, II, T, BitWidth); 2536 2537 ProcessDeclAttributes(NewFD, D); 2538 2539 if (D.getInvalidType() || InvalidDecl) 2540 NewFD->setInvalidDecl(); 2541 return NewFD; 2542} 2543 2544/// TranslateIvarVisibility - Translate visibility from a token ID to an 2545/// AST enum value. 2546static ObjCIvarDecl::AccessControl 2547TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 2548 switch (ivarVisibility) { 2549 default: assert(0 && "Unknown visitibility kind"); 2550 case tok::objc_private: return ObjCIvarDecl::Private; 2551 case tok::objc_public: return ObjCIvarDecl::Public; 2552 case tok::objc_protected: return ObjCIvarDecl::Protected; 2553 case tok::objc_package: return ObjCIvarDecl::Package; 2554 } 2555} 2556 2557/// ActOnIvar - Each ivar field of an objective-c class is passed into this 2558/// in order to create an IvarDecl object for it. 2559Sema::DeclTy *Sema::ActOnIvar(Scope *S, 2560 SourceLocation DeclStart, 2561 Declarator &D, ExprTy *BitfieldWidth, 2562 tok::ObjCKeywordKind Visibility) { 2563 IdentifierInfo *II = D.getIdentifier(); 2564 Expr *BitWidth = (Expr*)BitfieldWidth; 2565 SourceLocation Loc = DeclStart; 2566 if (II) Loc = D.getIdentifierLoc(); 2567 2568 // FIXME: Unnamed fields can be handled in various different ways, for 2569 // example, unnamed unions inject all members into the struct namespace! 2570 2571 2572 if (BitWidth) { 2573 // TODO: Validate. 2574 //printf("WARNING: BITFIELDS IGNORED!\n"); 2575 2576 // 6.7.2.1p3 2577 // 6.7.2.1p4 2578 2579 } else { 2580 // Not a bitfield. 2581 2582 // validate II. 2583 2584 } 2585 2586 QualType T = GetTypeForDeclarator(D, S); 2587 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 2588 bool InvalidDecl = false; 2589 2590 // C99 6.7.2.1p8: A member of a structure or union may have any type other 2591 // than a variably modified type. 2592 if (T->isVariablyModifiedType()) { 2593 // FIXME: This diagnostic needs work 2594 Diag(Loc, diag::err_typecheck_illegal_vla, Loc); 2595 InvalidDecl = true; 2596 } 2597 2598 // Get the visibility (access control) for this ivar. 2599 ObjCIvarDecl::AccessControl ac = 2600 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 2601 : ObjCIvarDecl::None; 2602 2603 // Construct the decl. 2604 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, Loc, II, T, ac, 2605 (Expr *)BitfieldWidth); 2606 2607 // Process attributes attached to the ivar. 2608 ProcessDeclAttributes(NewID, D); 2609 2610 if (D.getInvalidType() || InvalidDecl) 2611 NewID->setInvalidDecl(); 2612 2613 return NewID; 2614} 2615 2616void Sema::ActOnFields(Scope* S, 2617 SourceLocation RecLoc, DeclTy *RecDecl, 2618 DeclTy **Fields, unsigned NumFields, 2619 SourceLocation LBrac, SourceLocation RBrac, 2620 AttributeList *Attr) { 2621 Decl *EnclosingDecl = static_cast<Decl*>(RecDecl); 2622 assert(EnclosingDecl && "missing record or interface decl"); 2623 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 2624 2625 if (Record) 2626 if (RecordDecl* DefRecord = Record->getDefinition(Context)) { 2627 // Diagnose code like: 2628 // struct S { struct S {} X; }; 2629 // We discover this when we complete the outer S. Reject and ignore the 2630 // outer S. 2631 Diag(DefRecord->getLocation(), diag::err_nested_redefinition, 2632 DefRecord->getKindName()); 2633 Diag(RecLoc, diag::err_previous_definition); 2634 Record->setInvalidDecl(); 2635 return; 2636 } 2637 2638 // Verify that all the fields are okay. 2639 unsigned NumNamedMembers = 0; 2640 llvm::SmallVector<FieldDecl*, 32> RecFields; 2641 llvm::SmallSet<const IdentifierInfo*, 32> FieldIDs; 2642 2643 for (unsigned i = 0; i != NumFields; ++i) { 2644 2645 FieldDecl *FD = cast_or_null<FieldDecl>(static_cast<Decl*>(Fields[i])); 2646 assert(FD && "missing field decl"); 2647 2648 // Remember all fields. 2649 RecFields.push_back(FD); 2650 2651 // Get the type for the field. 2652 Type *FDTy = FD->getType().getTypePtr(); 2653 2654 // C99 6.7.2.1p2 - A field may not be a function type. 2655 if (FDTy->isFunctionType()) { 2656 Diag(FD->getLocation(), diag::err_field_declared_as_function, 2657 FD->getName()); 2658 FD->setInvalidDecl(); 2659 EnclosingDecl->setInvalidDecl(); 2660 continue; 2661 } 2662 // C99 6.7.2.1p2 - A field may not be an incomplete type except... 2663 if (FDTy->isIncompleteType()) { 2664 if (!Record) { // Incomplete ivar type is always an error. 2665 Diag(FD->getLocation(), diag::err_field_incomplete, FD->getName()); 2666 FD->setInvalidDecl(); 2667 EnclosingDecl->setInvalidDecl(); 2668 continue; 2669 } 2670 if (i != NumFields-1 || // ... that the last member ... 2671 !Record->isStruct() || // ... of a structure ... 2672 !FDTy->isArrayType()) { //... may have incomplete array type. 2673 Diag(FD->getLocation(), diag::err_field_incomplete, FD->getName()); 2674 FD->setInvalidDecl(); 2675 EnclosingDecl->setInvalidDecl(); 2676 continue; 2677 } 2678 if (NumNamedMembers < 1) { //... must have more than named member ... 2679 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct, 2680 FD->getName()); 2681 FD->setInvalidDecl(); 2682 EnclosingDecl->setInvalidDecl(); 2683 continue; 2684 } 2685 // Okay, we have a legal flexible array member at the end of the struct. 2686 if (Record) 2687 Record->setHasFlexibleArrayMember(true); 2688 } 2689 /// C99 6.7.2.1p2 - a struct ending in a flexible array member cannot be the 2690 /// field of another structure or the element of an array. 2691 if (const RecordType *FDTTy = FDTy->getAsRecordType()) { 2692 if (FDTTy->getDecl()->hasFlexibleArrayMember()) { 2693 // If this is a member of a union, then entire union becomes "flexible". 2694 if (Record && Record->isUnion()) { 2695 Record->setHasFlexibleArrayMember(true); 2696 } else { 2697 // If this is a struct/class and this is not the last element, reject 2698 // it. Note that GCC supports variable sized arrays in the middle of 2699 // structures. 2700 if (i != NumFields-1) { 2701 Diag(FD->getLocation(), diag::err_variable_sized_type_in_struct, 2702 FD->getName()); 2703 FD->setInvalidDecl(); 2704 EnclosingDecl->setInvalidDecl(); 2705 continue; 2706 } 2707 // We support flexible arrays at the end of structs in other structs 2708 // as an extension. 2709 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct, 2710 FD->getName()); 2711 if (Record) 2712 Record->setHasFlexibleArrayMember(true); 2713 } 2714 } 2715 } 2716 /// A field cannot be an Objective-c object 2717 if (FDTy->isObjCInterfaceType()) { 2718 Diag(FD->getLocation(), diag::err_statically_allocated_object, 2719 FD->getName()); 2720 FD->setInvalidDecl(); 2721 EnclosingDecl->setInvalidDecl(); 2722 continue; 2723 } 2724 // Keep track of the number of named members. 2725 if (IdentifierInfo *II = FD->getIdentifier()) { 2726 // Detect duplicate member names. 2727 if (!FieldIDs.insert(II)) { 2728 Diag(FD->getLocation(), diag::err_duplicate_member, II->getName()); 2729 // Find the previous decl. 2730 SourceLocation PrevLoc; 2731 for (unsigned i = 0; ; ++i) { 2732 assert(i != RecFields.size() && "Didn't find previous def!"); 2733 if (RecFields[i]->getIdentifier() == II) { 2734 PrevLoc = RecFields[i]->getLocation(); 2735 break; 2736 } 2737 } 2738 Diag(PrevLoc, diag::err_previous_definition); 2739 FD->setInvalidDecl(); 2740 EnclosingDecl->setInvalidDecl(); 2741 continue; 2742 } 2743 ++NumNamedMembers; 2744 } 2745 } 2746 2747 // Okay, we successfully defined 'Record'. 2748 if (Record) { 2749 Record->defineBody(Context, &RecFields[0], RecFields.size()); 2750 // If this is a C++ record, HandleTagDeclDefinition will be invoked in 2751 // Sema::ActOnFinishCXXClassDef. 2752 if (!isa<CXXRecordDecl>(Record)) 2753 Consumer.HandleTagDeclDefinition(Record); 2754 } else { 2755 ObjCIvarDecl **ClsFields = reinterpret_cast<ObjCIvarDecl**>(&RecFields[0]); 2756 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) 2757 ID->addInstanceVariablesToClass(ClsFields, RecFields.size(), RBrac); 2758 else if (ObjCImplementationDecl *IMPDecl = 2759 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 2760 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 2761 IMPDecl->ObjCAddInstanceVariablesToClassImpl(ClsFields, RecFields.size()); 2762 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 2763 } 2764 } 2765 2766 if (Attr) 2767 ProcessDeclAttributeList(Record, Attr); 2768} 2769 2770Sema::DeclTy *Sema::ActOnEnumConstant(Scope *S, DeclTy *theEnumDecl, 2771 DeclTy *lastEnumConst, 2772 SourceLocation IdLoc, IdentifierInfo *Id, 2773 SourceLocation EqualLoc, ExprTy *val) { 2774 EnumDecl *TheEnumDecl = cast<EnumDecl>(static_cast<Decl*>(theEnumDecl)); 2775 EnumConstantDecl *LastEnumConst = 2776 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(lastEnumConst)); 2777 Expr *Val = static_cast<Expr*>(val); 2778 2779 // The scope passed in may not be a decl scope. Zip up the scope tree until 2780 // we find one that is. 2781 while ((S->getFlags() & Scope::DeclScope) == 0) 2782 S = S->getParent(); 2783 2784 // Verify that there isn't already something declared with this name in this 2785 // scope. 2786 if (Decl *PrevDecl = LookupDecl(Id, Decl::IDNS_Ordinary, S)) { 2787 // When in C++, we may get a TagDecl with the same name; in this case the 2788 // enum constant will 'hide' the tag. 2789 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 2790 "Received TagDecl when not in C++!"); 2791 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 2792 if (isa<EnumConstantDecl>(PrevDecl)) 2793 Diag(IdLoc, diag::err_redefinition_of_enumerator, Id->getName()); 2794 else 2795 Diag(IdLoc, diag::err_redefinition, Id->getName()); 2796 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 2797 delete Val; 2798 return 0; 2799 } 2800 } 2801 2802 llvm::APSInt EnumVal(32); 2803 QualType EltTy; 2804 if (Val) { 2805 // Make sure to promote the operand type to int. 2806 UsualUnaryConversions(Val); 2807 2808 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 2809 SourceLocation ExpLoc; 2810 if (!Val->isIntegerConstantExpr(EnumVal, Context, &ExpLoc)) { 2811 Diag(ExpLoc, diag::err_enum_value_not_integer_constant_expr, 2812 Id->getName()); 2813 delete Val; 2814 Val = 0; // Just forget about it. 2815 } else { 2816 EltTy = Val->getType(); 2817 } 2818 } 2819 2820 if (!Val) { 2821 if (LastEnumConst) { 2822 // Assign the last value + 1. 2823 EnumVal = LastEnumConst->getInitVal(); 2824 ++EnumVal; 2825 2826 // Check for overflow on increment. 2827 if (EnumVal < LastEnumConst->getInitVal()) 2828 Diag(IdLoc, diag::warn_enum_value_overflow); 2829 2830 EltTy = LastEnumConst->getType(); 2831 } else { 2832 // First value, set to zero. 2833 EltTy = Context.IntTy; 2834 EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy))); 2835 } 2836 } 2837 2838 EnumConstantDecl *New = 2839 EnumConstantDecl::Create(Context, TheEnumDecl, IdLoc, Id, EltTy, 2840 Val, EnumVal, 2841 LastEnumConst); 2842 2843 // Register this decl in the current scope stack. 2844 PushOnScopeChains(New, S); 2845 return New; 2846} 2847 2848// FIXME: For consistency with ActOnFields(), we should have the parser 2849// pass in the source location for the left/right braces. 2850void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX, 2851 DeclTy **Elements, unsigned NumElements) { 2852 EnumDecl *Enum = cast<EnumDecl>(static_cast<Decl*>(EnumDeclX)); 2853 2854 if (Enum && Enum->isDefinition()) { 2855 // Diagnose code like: 2856 // enum e0 { 2857 // E0 = sizeof(enum e0 { E1 }) 2858 // }; 2859 Diag(Enum->getLocation(), diag::err_nested_redefinition, 2860 Enum->getName()); 2861 Diag(EnumLoc, diag::err_previous_definition); 2862 Enum->setInvalidDecl(); 2863 return; 2864 } 2865 // TODO: If the result value doesn't fit in an int, it must be a long or long 2866 // long value. ISO C does not support this, but GCC does as an extension, 2867 // emit a warning. 2868 unsigned IntWidth = Context.Target.getIntWidth(); 2869 2870 // Verify that all the values are okay, compute the size of the values, and 2871 // reverse the list. 2872 unsigned NumNegativeBits = 0; 2873 unsigned NumPositiveBits = 0; 2874 2875 // Keep track of whether all elements have type int. 2876 bool AllElementsInt = true; 2877 2878 EnumConstantDecl *EltList = 0; 2879 for (unsigned i = 0; i != NumElements; ++i) { 2880 EnumConstantDecl *ECD = 2881 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i])); 2882 if (!ECD) continue; // Already issued a diagnostic. 2883 2884 // If the enum value doesn't fit in an int, emit an extension warning. 2885 const llvm::APSInt &InitVal = ECD->getInitVal(); 2886 assert(InitVal.getBitWidth() >= IntWidth && 2887 "Should have promoted value to int"); 2888 if (InitVal.getBitWidth() > IntWidth) { 2889 llvm::APSInt V(InitVal); 2890 V.trunc(IntWidth); 2891 V.extend(InitVal.getBitWidth()); 2892 if (V != InitVal) 2893 Diag(ECD->getLocation(), diag::ext_enum_value_not_int, 2894 InitVal.toString(10)); 2895 } 2896 2897 // Keep track of the size of positive and negative values. 2898 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 2899 NumPositiveBits = std::max(NumPositiveBits, 2900 (unsigned)InitVal.getActiveBits()); 2901 else 2902 NumNegativeBits = std::max(NumNegativeBits, 2903 (unsigned)InitVal.getMinSignedBits()); 2904 2905 // Keep track of whether every enum element has type int (very commmon). 2906 if (AllElementsInt) 2907 AllElementsInt = ECD->getType() == Context.IntTy; 2908 2909 ECD->setNextDeclarator(EltList); 2910 EltList = ECD; 2911 } 2912 2913 // Figure out the type that should be used for this enum. 2914 // FIXME: Support attribute(packed) on enums and -fshort-enums. 2915 QualType BestType; 2916 unsigned BestWidth; 2917 2918 if (NumNegativeBits) { 2919 // If there is a negative value, figure out the smallest integer type (of 2920 // int/long/longlong) that fits. 2921 if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 2922 BestType = Context.IntTy; 2923 BestWidth = IntWidth; 2924 } else { 2925 BestWidth = Context.Target.getLongWidth(); 2926 2927 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) 2928 BestType = Context.LongTy; 2929 else { 2930 BestWidth = Context.Target.getLongLongWidth(); 2931 2932 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 2933 Diag(Enum->getLocation(), diag::warn_enum_too_large); 2934 BestType = Context.LongLongTy; 2935 } 2936 } 2937 } else { 2938 // If there is no negative value, figure out which of uint, ulong, ulonglong 2939 // fits. 2940 if (NumPositiveBits <= IntWidth) { 2941 BestType = Context.UnsignedIntTy; 2942 BestWidth = IntWidth; 2943 } else if (NumPositiveBits <= 2944 (BestWidth = Context.Target.getLongWidth())) { 2945 BestType = Context.UnsignedLongTy; 2946 } else { 2947 BestWidth = Context.Target.getLongLongWidth(); 2948 assert(NumPositiveBits <= BestWidth && 2949 "How could an initializer get larger than ULL?"); 2950 BestType = Context.UnsignedLongLongTy; 2951 } 2952 } 2953 2954 // Loop over all of the enumerator constants, changing their types to match 2955 // the type of the enum if needed. 2956 for (unsigned i = 0; i != NumElements; ++i) { 2957 EnumConstantDecl *ECD = 2958 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i])); 2959 if (!ECD) continue; // Already issued a diagnostic. 2960 2961 // Standard C says the enumerators have int type, but we allow, as an 2962 // extension, the enumerators to be larger than int size. If each 2963 // enumerator value fits in an int, type it as an int, otherwise type it the 2964 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 2965 // that X has type 'int', not 'unsigned'. 2966 if (ECD->getType() == Context.IntTy) { 2967 // Make sure the init value is signed. 2968 llvm::APSInt IV = ECD->getInitVal(); 2969 IV.setIsSigned(true); 2970 ECD->setInitVal(IV); 2971 continue; // Already int type. 2972 } 2973 2974 // Determine whether the value fits into an int. 2975 llvm::APSInt InitVal = ECD->getInitVal(); 2976 bool FitsInInt; 2977 if (InitVal.isUnsigned() || !InitVal.isNegative()) 2978 FitsInInt = InitVal.getActiveBits() < IntWidth; 2979 else 2980 FitsInInt = InitVal.getMinSignedBits() <= IntWidth; 2981 2982 // If it fits into an integer type, force it. Otherwise force it to match 2983 // the enum decl type. 2984 QualType NewTy; 2985 unsigned NewWidth; 2986 bool NewSign; 2987 if (FitsInInt) { 2988 NewTy = Context.IntTy; 2989 NewWidth = IntWidth; 2990 NewSign = true; 2991 } else if (ECD->getType() == BestType) { 2992 // Already the right type! 2993 continue; 2994 } else { 2995 NewTy = BestType; 2996 NewWidth = BestWidth; 2997 NewSign = BestType->isSignedIntegerType(); 2998 } 2999 3000 // Adjust the APSInt value. 3001 InitVal.extOrTrunc(NewWidth); 3002 InitVal.setIsSigned(NewSign); 3003 ECD->setInitVal(InitVal); 3004 3005 // Adjust the Expr initializer and type. 3006 ECD->setInitExpr(new ImplicitCastExpr(NewTy, ECD->getInitExpr())); 3007 ECD->setType(NewTy); 3008 } 3009 3010 Enum->defineElements(EltList, BestType); 3011 Consumer.HandleTagDeclDefinition(Enum); 3012} 3013 3014Sema::DeclTy *Sema::ActOnFileScopeAsmDecl(SourceLocation Loc, 3015 ExprTy *expr) { 3016 StringLiteral *AsmString = cast<StringLiteral>((Expr*)expr); 3017 3018 return FileScopeAsmDecl::Create(Context, Loc, AsmString); 3019} 3020 3021Sema::DeclTy* Sema::ActOnLinkageSpec(SourceLocation Loc, 3022 SourceLocation LBrace, 3023 SourceLocation RBrace, 3024 const char *Lang, 3025 unsigned StrSize, 3026 DeclTy *D) { 3027 LinkageSpecDecl::LanguageIDs Language; 3028 Decl *dcl = static_cast<Decl *>(D); 3029 if (strncmp(Lang, "\"C\"", StrSize) == 0) 3030 Language = LinkageSpecDecl::lang_c; 3031 else if (strncmp(Lang, "\"C++\"", StrSize) == 0) 3032 Language = LinkageSpecDecl::lang_cxx; 3033 else { 3034 Diag(Loc, diag::err_bad_language); 3035 return 0; 3036 } 3037 3038 // FIXME: Add all the various semantics of linkage specifications 3039 return LinkageSpecDecl::Create(Context, Loc, Language, dcl); 3040} 3041 3042void Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name, 3043 ExprTy *alignment, SourceLocation PragmaLoc, 3044 SourceLocation LParenLoc, SourceLocation RParenLoc) { 3045 Expr *Alignment = static_cast<Expr *>(alignment); 3046 3047 // If specified then alignment must be a "small" power of two. 3048 unsigned AlignmentVal = 0; 3049 if (Alignment) { 3050 llvm::APSInt Val; 3051 if (!Alignment->isIntegerConstantExpr(Val, Context) || 3052 !Val.isPowerOf2() || 3053 Val.getZExtValue() > 16) { 3054 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment); 3055 delete Alignment; 3056 return; // Ignore 3057 } 3058 3059 AlignmentVal = (unsigned) Val.getZExtValue(); 3060 } 3061 3062 switch (Kind) { 3063 case Action::PPK_Default: // pack([n]) 3064 PackContext.setAlignment(AlignmentVal); 3065 break; 3066 3067 case Action::PPK_Show: // pack(show) 3068 // Show the current alignment, making sure to show the right value 3069 // for the default. 3070 AlignmentVal = PackContext.getAlignment(); 3071 // FIXME: This should come from the target. 3072 if (AlignmentVal == 0) 3073 AlignmentVal = 8; 3074 Diag(PragmaLoc, diag::warn_pragma_pack_show, llvm::utostr(AlignmentVal)); 3075 break; 3076 3077 case Action::PPK_Push: // pack(push [, id] [, [n]) 3078 PackContext.push(Name); 3079 // Set the new alignment if specified. 3080 if (Alignment) 3081 PackContext.setAlignment(AlignmentVal); 3082 break; 3083 3084 case Action::PPK_Pop: // pack(pop [, id] [, n]) 3085 // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: 3086 // "#pragma pack(pop, identifier, n) is undefined" 3087 if (Alignment && Name) 3088 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment); 3089 3090 // Do the pop. 3091 if (!PackContext.pop(Name)) { 3092 // If a name was specified then failure indicates the name 3093 // wasn't found. Otherwise failure indicates the stack was 3094 // empty. 3095 Diag(PragmaLoc, diag::warn_pragma_pack_pop_failed, 3096 Name ? "no record matching name" : "stack empty"); 3097 3098 // FIXME: Warn about popping named records as MSVC does. 3099 } else { 3100 // Pop succeeded, set the new alignment if specified. 3101 if (Alignment) 3102 PackContext.setAlignment(AlignmentVal); 3103 } 3104 break; 3105 3106 default: 3107 assert(0 && "Invalid #pragma pack kind."); 3108 } 3109} 3110 3111bool PragmaPackStack::pop(IdentifierInfo *Name) { 3112 if (Stack.empty()) 3113 return false; 3114 3115 // If name is empty just pop top. 3116 if (!Name) { 3117 Alignment = Stack.back().first; 3118 Stack.pop_back(); 3119 return true; 3120 } 3121 3122 // Otherwise, find the named record. 3123 for (unsigned i = Stack.size(); i != 0; ) { 3124 --i; 3125 if (strcmp(Stack[i].second.c_str(), Name->getName()) == 0) { 3126 // Found it, pop up to and including this record. 3127 Alignment = Stack[i].first; 3128 Stack.erase(Stack.begin() + i, Stack.end()); 3129 return true; 3130 } 3131 } 3132 3133 return false; 3134} 3135