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