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