SemaDecl.cpp revision 49badde06e066d058d6c7fcf4e628a72999b65a9
1ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby//===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===// 2ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// 3ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// The LLVM Compiler Infrastructure 4ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// 5ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// This file is distributed under the University of Illinois Open Source 6ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// License. See LICENSE.TXT for details. 7ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// 8ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby//===----------------------------------------------------------------------===// 9ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// 10ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby// This file implements semantic analysis for declarations. 113483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar// 12c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner//===----------------------------------------------------------------------===// 13c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner 14c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "Sema.h" 15ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "clang/AST/APValue.h" 16ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "clang/AST/ASTConsumer.h" 17ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "clang/AST/ASTContext.h" 18ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "clang/AST/DeclObjC.h" 19ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "clang/AST/ExprCXX.h" 20c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "clang/Parse/DeclSpec.h" 21c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "clang/Basic/Diagnostic.h" 22fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar#include "clang/Basic/TargetInfo.h" 23762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan#include "clang/Basic/SourceManager.h" 24c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's) 25345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar#include "clang/Lex/Preprocessor.h" 26c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "clang/Lex/HeaderSearch.h" 27ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/ADT/SmallSet.h" 28ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "llvm/ADT/StringExtras.h" 29ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyusing namespace clang; 30ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 31ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin EnderbySema::TypeTy *Sema::isTypeName(const IdentifierInfo &II, Scope *S) { 32a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Decl *IIDecl = LookupDecl(&II, Decl::IDNS_Ordinary, S, false); 33a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 34a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (IIDecl && (isa<TypedefDecl>(IIDecl) || 35a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby isa<ObjCInterfaceDecl>(IIDecl) || 36a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby isa<TagDecl>(IIDecl))) 37a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return IIDecl; 38a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return 0; 39a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 40a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 41ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin EnderbyDeclContext *Sema::getDCParent(DeclContext *DC) { 42ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // If CurContext is a ObjC method, getParent() will return NULL. 43d73ada7d24832bc2a4c3965b8f00ffd951341acfDaniel Dunbar if (isa<ObjCMethodDecl>(DC)) 44ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return Context.getTranslationUnitDecl(); 45ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 46ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // A C++ inline method is parsed *after* the topmost class it was declared in 47ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // is fully parsed (it's "complete"). 48ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // The parsing of a C++ inline method happens at the declaration context of 49ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // the topmost (non-nested) class it is declared in. 50ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) { 51ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby assert(isa<CXXRecordDecl>(MD->getParent()) && "C++ method not in Record."); 52ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby DC = MD->getParent(); 53ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getParent())) 54762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan DC = RD; 55a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 56762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // Return the declaration context of the topmost class the inline method is 57d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // declared in. 58762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return DC; 59a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 609c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 619c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return DC->getParent(); 629c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby} 639c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 649c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderbyvoid Sema::PushDeclContext(DeclContext *DC) { 659c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby assert(getDCParent(DC) == CurContext && 66762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan "The next DeclContext should be directly contained in the current one."); 67762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan CurContext = DC; 689c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby} 69762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 70a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderbyvoid Sema::PopDeclContext() { 71762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan assert(CurContext && "DeclContext imbalance!"); 72a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby CurContext = getDCParent(CurContext); 73ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 74ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 75515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby/// Add this decl to the scope shadowed decl chains. 76515d509360d81946247fd0f937034cdf1f237c72Kevin Enderbyvoid Sema::PushOnScopeChains(NamedDecl *D, Scope *S) { 77515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby S->AddDecl(D); 78515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 79515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // C++ [basic.scope]p4: 80515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // -- exactly one declaration shall declare a class name or 81515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // enumeration name that is not a typedef name and the other 82515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // declarations shall all refer to the same object or 83a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // enumerator, or all refer to functions and function templates; 84a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // in this case the class name or enumeration name is hidden. 853483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 863483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar // We are pushing the name of a tag (enum or class). 873483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar IdentifierResolver::iterator 889898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner I = IdResolver.begin(TD->getIdentifier(), 89a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby TD->getDeclContext(), false/*LookInParentCtx*/); 90a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (I != IdResolver.end() && isDeclInScope(*I, TD->getDeclContext(), S)) { 91a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // There is already a declaration with the same name in the same 92a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // scope. It must be found before we find the new declaration, 93a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // so swap the order on the shadowed declaration chain. 94ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 95d73ada7d24832bc2a4c3965b8f00ffd951341acfDaniel Dunbar IdResolver.AddShadowedDecl(TD, *I); 96d73ada7d24832bc2a4c3965b8f00ffd951341acfDaniel Dunbar return; 97ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 9838e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer } else if (getLangOptions().CPlusPlus && isa<FunctionDecl>(D)) { 999898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner FunctionDecl *FD = cast<FunctionDecl>(D); 100ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // We are pushing the name of a function, which might be an 101ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // overloaded name. 102ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby IdentifierResolver::iterator 103ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby I = IdResolver.begin(FD->getIdentifier(), 104a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby FD->getDeclContext(), false/*LookInParentCtx*/); 105a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (I != IdResolver.end() && 1067659389d0d4d315d30877592221da6a6f663114aChris Lattner IdResolver.isDeclInScope(*I, FD->getDeclContext(), S) && 107762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan (isa<OverloadedFunctionDecl>(*I) || isa<FunctionDecl>(*I))) { 108762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // There is already a declaration with the same name in the same 109762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // scope. It must be a function or an overloaded function. 110762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan OverloadedFunctionDecl* Ovl = dyn_cast<OverloadedFunctionDecl>(*I); 1118462b30548fb5969250858036638c73c16b65b43Daniel Dunbar if (!Ovl) { 112cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby // We haven't yet overloaded this function. Take the existing 1138462b30548fb5969250858036638c73c16b65b43Daniel Dunbar // FunctionDecl and put it into an OverloadedFunctionDecl. 1148462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Ovl = OverloadedFunctionDecl::Create(Context, 1158462b30548fb5969250858036638c73c16b65b43Daniel Dunbar FD->getDeclContext(), 116a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby FD->getIdentifier()); 117a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Ovl->addOverload(dyn_cast<FunctionDecl>(*I)); 118762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 119a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Remove the name binding to the existing FunctionDecl... 120a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby IdResolver.RemoveDecl(*I); 121a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1228462b30548fb5969250858036638c73c16b65b43Daniel Dunbar // ... and put the OverloadedFunctionDecl in its place. 1238462b30548fb5969250858036638c73c16b65b43Daniel Dunbar IdResolver.AddDecl(Ovl); 1248462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } 1258462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 126a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // We have an OverloadedFunctionDecl. Add the new FunctionDecl 127a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // to its list of overloads. 128a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Ovl->addOverload(FD); 129a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 130a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return; 131a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 13299e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby } 133a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 134a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby IdResolver.AddDecl(D); 135cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby} 136cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby 137cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderbyvoid Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 138762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (S->decl_empty()) return; 139a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert((S->getFlags() & Scope::DeclScope) &&"Scope shouldn't contain decls!"); 140a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 141a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end(); 142a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby I != E; ++I) { 1439c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Decl *TmpD = static_cast<Decl*>(*I); 144a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby assert(TmpD && "This decl didn't get pushed??"); 1459c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 1469c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (isa<CXXFieldDecl>(TmpD)) continue; 1479c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 1489c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby assert(isa<ScopedDecl>(TmpD) && "Decl isn't ScopedDecl?"); 1499c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby ScopedDecl *D = cast<ScopedDecl>(TmpD); 1509c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 1519c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby IdentifierInfo *II = D->getIdentifier(); 1529c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (!II) continue; 153a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 154a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // We only want to remove the decls from the identifier decl chains for 155a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // local scopes, when inside a function/method. 156762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (S->getFnParent() != 0) 157762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan IdResolver.RemoveDecl(D); 158762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 159762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // Chain this decl to the containing DeclContext. 160762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan D->setNext(CurContext->getDeclChain()); 161762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan CurContext->setDeclChain(D); 162762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 163762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan} 164762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 1658462b30548fb5969250858036638c73c16b65b43Daniel Dunbar/// getObjCInterfaceDecl - Look up a for a class declaration in the scope. 1668462b30548fb5969250858036638c73c16b65b43Daniel Dunbar/// return 0 if one not found. 1678462b30548fb5969250858036638c73c16b65b43Daniel DunbarObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *Id) { 168762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // The third "scope" argument is 0 since we aren't enabling lazy built-in 1698462b30548fb5969250858036638c73c16b65b43Daniel Dunbar // creation from this context. 170762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Decl *IDecl = LookupDecl(Id, Decl::IDNS_Ordinary, 0, false); 171762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 172762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 173762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan} 174762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 175762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// LookupDecl - Look up the inner-most declaration in the specified 176762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// namespace. 177762647673379dbcff6bbba6167b0b1b0d658ba9dSean CallananDecl *Sema::LookupDecl(const IdentifierInfo *II, unsigned NSI, 178762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Scope *S, bool enableLazyBuiltinCreation) { 179762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (II == 0) return 0; 180762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan unsigned NS = NSI; 181762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (getLangOptions().CPlusPlus && (NS & Decl::IDNS_Ordinary)) 182762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan NS |= Decl::IDNS_Tag; 183762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 184762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // Scan up the scope chain looking for a decl that matches this identifier 185762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // that is in the appropriate namespace. This search should not take long, as 186762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // shadowing of names is uncommon, and deep shadowing is extremely uncommon. 187a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby for (IdentifierResolver::iterator 1888462b30548fb5969250858036638c73c16b65b43Daniel Dunbar I = IdResolver.begin(II, CurContext), E = IdResolver.end(); I != E; ++I) 1898462b30548fb5969250858036638c73c16b65b43Daniel Dunbar if ((*I)->getIdentifierNamespace() & NS) 1908462b30548fb5969250858036638c73c16b65b43Daniel Dunbar return *I; 1918462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 1928462b30548fb5969250858036638c73c16b65b43Daniel Dunbar // If we didn't find a use of this identifier, and if the identifier 193a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // corresponds to a compiler builtin, create the decl object for the builtin 194a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // now, injecting it into translation unit scope, and return it. 195a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (NS & Decl::IDNS_Ordinary) { 196a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (enableLazyBuiltinCreation) { 197a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // If this is a builtin on this (or all) targets, create the decl. 198a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (unsigned BuiltinID = II->getBuiltinID()) 199a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, S); 200a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 201a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (getLangOptions().ObjC1) { 202a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // @interface and @compatibility_alias introduce typedef-like names. 203cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby // Unlike typedef's, they can only be introduced at file-scope (and are 204cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby // therefore not scoped decls). They can, however, be shadowed by 205cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby // other names in IDNS_Ordinary. 206cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby ObjCInterfaceDeclsTy::iterator IDI = ObjCInterfaceDecls.find(II); 207cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby if (IDI != ObjCInterfaceDecls.end()) 2088462b30548fb5969250858036638c73c16b65b43Daniel Dunbar return IDI->second; 2098462b30548fb5969250858036638c73c16b65b43Daniel Dunbar ObjCAliasTy::iterator I = ObjCAliasDecls.find(II); 2103483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar if (I != ObjCAliasDecls.end()) 211a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return I->second->getClassInterface(); 212a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 213a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 2143483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar return 0; 2153483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar} 2163483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 2173483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbarvoid Sema::InitBuiltinVaListType() { 2183483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar if (!Context.getBuiltinVaListType().isNull()) 2193483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar return; 2203483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 2213483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list"); 2223483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Decl *VaDecl = LookupDecl(VaIdent, Decl::IDNS_Ordinary, TUScope); 2233483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl); 2248462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef)); 225345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar} 2268462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 227345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar/// LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope. 228345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar/// lazily create a decl for it. 2298462b30548fb5969250858036638c73c16b65b43Daniel DunbarScopedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, 2308462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Scope *S) { 231a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Builtin::ID BID = (Builtin::ID)bid; 232a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 233a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (Context.BuiltinInfo.hasVAListUse(BID)) 234a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby InitBuiltinVaListType(); 235a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 2363483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar QualType R = Context.BuiltinInfo.GetBuiltinType(BID, Context); 2373483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar FunctionDecl *New = FunctionDecl::Create(Context, 2383483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Context.getTranslationUnitDecl(), 2393483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar SourceLocation(), II, R, 2403483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar FunctionDecl::Extern, false, 0); 241fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar 242b3cb6967949493a2e1b10d015ac08b746736764eDaniel Dunbar // Create Decl objects for each parameter, adding them to the 243345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // FunctionDecl. 244345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar if (FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(R)) { 245345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar llvm::SmallVector<ParmVarDecl*, 16> Params; 246345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) 247345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0, 248345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar FT->getArgType(i), VarDecl::None, 0, 249345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 0)); 250345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar New->setParams(&Params[0], Params.size()); 251345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar } 252762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 253762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 254762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 255762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // TUScope is the translation-unit scope to insert this function into. 256762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan PushOnScopeChains(New, TUScope); 257762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return New; 258762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan} 259762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 260a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// MergeTypeDefDecl - We just parsed a typedef 'New' which has the same name 261a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// and scope as a previous declaration 'Old'. Figure out how to resolve this 262762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// situation, merging decls or emitting diagnostics as appropriate. 263762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// 264762647673379dbcff6bbba6167b0b1b0d658ba9dSean CallananTypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) { 265762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // Allow multiple definitions for ObjC built-in typedefs. 266762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // FIXME: Verify the underlying types are equivalent! 267762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (getLangOptions().ObjC1) { 268762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan const IdentifierInfo *typeIdent = New->getIdentifier(); 269762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (typeIdent == Ident_id) { 270762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Context.setObjCIdType(New); 271a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return New; 272a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } else if (typeIdent == Ident_Class) { 273762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Context.setObjCClassType(New); 274762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return New; 275762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } else if (typeIdent == Ident_SEL) { 276762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Context.setObjCSelType(New); 277762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return New; 278762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } else if (typeIdent == Ident_Protocol) { 279762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Context.setObjCProtoType(New->getUnderlyingType()); 280762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return New; 281cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby } 282cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby // Fall through - the typedef name was not a builtin type. 283762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 284762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // Verify the old decl was also a typedef. 285762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan TypedefDecl *Old = dyn_cast<TypedefDecl>(OldD); 286762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (!Old) { 287762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(New->getLocation(), diag::err_redefinition_different_kind, 288762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan New->getName()); 289762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(OldD->getLocation(), diag::err_previous_definition); 290762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return New; 291762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 292762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 293762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // If the typedef types are not identical, reject them in all languages and 294762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // with any extensions enabled. 295762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (Old->getUnderlyingType() != New->getUnderlyingType() && 296762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Context.getCanonicalType(Old->getUnderlyingType()) != 297762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Context.getCanonicalType(New->getUnderlyingType())) { 298762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(New->getLocation(), diag::err_redefinition_different_typedef, 299762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan New->getUnderlyingType().getAsString(), 300762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Old->getUnderlyingType().getAsString()); 301762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(Old->getLocation(), diag::err_previous_definition); 302762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return Old; 303762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 304762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 305762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (getLangOptions().Microsoft) return New; 306a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 307a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Redeclaration of a type is a constraint violation (6.7.2.3p1). 308a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Apparently GCC, Intel, and Sun all silently ignore the redeclaration if 309a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // *either* declaration is in a system header. The code below implements 310a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // this adhoc compatibility rule. FIXME: The following code will not 311fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar // work properly when compiling ".i" files (containing preprocessed output). 312fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar if (PP.getDiagnostics().getSuppressSystemWarnings()) { 313fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar SourceManager &SrcMgr = Context.getSourceManager(); 314fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar if (SrcMgr.isInSystemHeader(Old->getLocation())) 315fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar return New; 316fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar if (SrcMgr.isInSystemHeader(New->getLocation())) 317fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar return New; 318fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar } 319fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar 320fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar Diag(New->getLocation(), diag::err_redefinition, New->getName()); 321fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar Diag(Old->getLocation(), diag::err_previous_definition); 322fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar return New; 323fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar} 324fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar 325fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar/// DeclhasAttr - returns true if decl Declaration already has the target 326fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar/// attribute. 327fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbarstatic bool DeclHasAttr(const Decl *decl, const Attr *target) { 328fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext()) 329fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar if (attr->getKind() == target->getKind()) 3303483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar return true; 3313483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 3323483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar return false; 3333483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar} 3343483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 3353483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar/// MergeAttributes - append attributes from the Old decl to the New one. 3363483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbarstatic void MergeAttributes(Decl *New, Decl *Old) { 3373483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar Attr *attr = const_cast<Attr*>(Old->getAttrs()), *tmp; 3389c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 3399c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby while (attr) { 3409c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby tmp = attr; 3419c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby attr = attr->getNext(); 3429c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 343762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (!DeclHasAttr(New, tmp)) { 344762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan New->addAttr(tmp); 345762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } else { 34618b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan tmp->setNext(0); 347a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby delete(tmp); 348a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 349a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 350a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 351d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby Old->invalidateAttrs(); 352a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 353a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 354d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby/// MergeFunctionDecl - We just parsed a function 'New' from 355a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// declarator D which has the same name and scope as a previous 356762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// declaration 'Old'. Figure out how to resolve this situation, 357762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// merging decls or emitting diagnostics as appropriate. 358762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// Redeclaration will be set true if this New is a redeclaration OldD. 359b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan/// 360762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// In C++, New and Old must be declarations that are not 361762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// overloaded. Use IsOverload to determine whether New and Old are 362a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// overloaded, and to select the Old declaration that New should be 36399e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby/// merged with. 3649c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin EnderbyFunctionDecl * 36518b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean CallananSema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, bool &Redeclaration) { 3669c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby assert(!isa<OverloadedFunctionDecl>(OldD) && 367762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan "Cannot merge with an overloaded function declaration"); 3689c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 369b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Redeclaration = false; 3709c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Verify the old decl was also a function. 37199e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby FunctionDecl *Old = dyn_cast<FunctionDecl>(OldD); 37299e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby if (!Old) { 373762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(New->getLocation(), diag::err_redefinition_different_kind, 37499e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby New->getName()); 375a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(OldD->getLocation(), diag::err_previous_definition); 376a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return New; 377a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 3789c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 3799c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Determine whether the previous declaration was a definition, 380762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // implicit declaration, or a declaration. 381762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan diag::kind PrevDiag; 38218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan if (Old->isThisDeclarationADefinition()) 383cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby PrevDiag = diag::err_previous_definition; 384762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan else if (Old->isImplicit()) 385b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan PrevDiag = diag::err_previous_implicit_declaration; 386d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby else 38718b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan PrevDiag = diag::err_previous_declaration; 388d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 389d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby QualType OldQType = Context.getCanonicalType(Old->getType()); 390d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby QualType NewQType = Context.getCanonicalType(New->getType()); 391d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 392d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby if (getLangOptions().CPlusPlus) { 393d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // (C++98 13.1p2): 394b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // Certain function declarations cannot be overloaded: 395d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // -- Function declarations that differ only in the return type 396d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // cannot be overloaded. 397d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby QualType OldReturnType 398d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby = cast<FunctionType>(OldQType.getTypePtr())->getResultType(); 39918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan QualType NewReturnType 400b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan = cast<FunctionType>(NewQType.getTypePtr())->getResultType(); 401d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby if (OldReturnType != NewReturnType) { 40218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan Diag(New->getLocation(), diag::err_ovl_diff_return_type); 403d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby Diag(Old->getLocation(), PrevDiag); 404d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby return New; 405d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby } 406d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 407d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old); 408d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New); 409d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby if (OldMethod && NewMethod) { 410d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // -- Member function declarations with the same name and the 411d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // same parameter types cannot be overloaded if any of them 412d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // is a static member function declaration. 413d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby if (OldMethod->isStatic() || NewMethod->isStatic()) { 414d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 415d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby Diag(Old->getLocation(), PrevDiag); 416d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby return New; 417b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan } 418d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby } 41918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan 420d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // (C++98 8.3.5p3): 421d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // All declarations for a function shall agree exactly in both the 422762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // return type and the parameter-type-list. 423b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan if (OldQType == NewQType) { 424d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // We have a redeclaration. 425d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby MergeAttributes(New, Old); 426d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby Redeclaration = true; 427d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby return MergeCXXFunctionDecl(New, Old); 4289c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 4299c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 4309c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Fall through for conflicting redeclarations and redefinitions. 4319c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 432762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 433762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // C: Function types need to be compatible, not identical. This handles 43418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan // duplicate function decls like "void f(int); void f(enum X);" properly. 4356bd266e56799703cd2773cadc4da8bc3c5107fdfKevin Enderby if (!getLangOptions().CPlusPlus && 436762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Context.typesAreCompatible(OldQType, NewQType)) { 437b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan MergeAttributes(New, Old); 438a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Redeclaration = true; 43918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan return New; 440a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 441a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 4429c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // A function that has already been declared has been redeclared or defined 443a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // with a different type- show appropriate diagnostic 444762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 445a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope. 446a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // TODO: This is totally simplistic. It should handle merging functions 447a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // together etc, merging extern int X; int X; ... 448a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(New->getLocation(), diag::err_conflicting_types, New->getName()); 449a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(Old->getLocation(), PrevDiag); 450a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return New; 451a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 4529c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 4539c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// Predicate for C "tentative" external object definitions (C99 6.9.2). 45418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callananstatic bool isTentativeDefinition(VarDecl *VD) { 455a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (VD->isFileVarDecl()) 456a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return (!VD->getInit() && 457b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan (VD->getStorageClass() == VarDecl::None || 4589c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby VD->getStorageClass() == VarDecl::Static)); 4599c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return false; 460a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 461a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 462a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// CheckForFileScopedRedefinitions - Make sure we forgo redefinition errors 4639c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// when dealing with C "tentative" external object definitions (C99 6.9.2). 464762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callananvoid Sema::CheckForFileScopedRedefinitions(Scope *S, VarDecl *VD) { 4659c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool VDIsTentative = isTentativeDefinition(VD); 46618b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan bool VDIsIncompleteArray = VD->getType()->isIncompleteArrayType(); 467a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 468a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby for (IdentifierResolver::iterator 469762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan I = IdResolver.begin(VD->getIdentifier(), 470b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan VD->getDeclContext(), false/*LookInParentCtx*/), 471a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby E = IdResolver.end(); I != E; ++I) { 47218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan if (*I != VD && isDeclInScope(*I, VD->getDeclContext(), S)) { 473a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby VarDecl *OldDecl = dyn_cast<VarDecl>(*I); 474762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 475a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Handle the following case: 476b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // int a[10]; 477a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // int a[]; - the code below makes sure we set the correct type. 478762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // int a[11]; - this is an error, size isn't 10. 479762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (OldDecl && VDIsTentative && VDIsIncompleteArray && 480762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan OldDecl->getType()->isConstantArrayType()) 481a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby VD->setType(OldDecl->getType()); 482a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 483a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Check for "tentative" definitions. We can't accomplish this in 484a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // MergeVarDecl since the initializer hasn't been attached. 4859c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (!OldDecl || isTentativeDefinition(OldDecl) || VDIsTentative) 4869c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby continue; 487a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 488a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Handle __private_extern__ just like extern. 489762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (OldDecl->getStorageClass() != VarDecl::Extern && 490b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan OldDecl->getStorageClass() != VarDecl::PrivateExtern && 491a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby VD->getStorageClass() != VarDecl::Extern && 492e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby VD->getStorageClass() != VarDecl::PrivateExtern) { 493a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(VD->getLocation(), diag::err_redefinition, VD->getName()); 494a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(OldDecl->getLocation(), diag::err_previous_definition); 495a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 496a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 497a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 49818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan} 499e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby 500e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin Enderby/// MergeVarDecl - We just parsed a variable 'New' which has the same name 5013472766f9eb7d66f234c390ce1b3a8b76f0ee9ceDuncan Sands/// and scope as a previous declaration 'Old'. Figure out how to resolve this 502b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan/// situation, merging decls or emitting diagnostics as appropriate. 5039c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// 504762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// Tentative definition rules (C99 6.9.2p2) are checked by 505762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 5069c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// definitions here, since the initializer hasn't been attached. 507a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// 508e2a98dd2a4f007d5d9d3c71460cfbe0a825b8993Kevin EnderbyVarDecl *Sema::MergeVarDecl(VarDecl *New, Decl *OldD) { 509762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // Verify the old decl was also a variable. 510762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan VarDecl *Old = dyn_cast<VarDecl>(OldD); 511762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (!Old) { 512a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(New->getLocation(), diag::err_redefinition_different_kind, 513a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby New->getName()); 514a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(OldD->getLocation(), diag::err_previous_definition); 515a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return New; 516a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 517a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 5189c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby MergeAttributes(New, Old); 5199c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 5209c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Verify the types match. 5219c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby QualType OldCType = Context.getCanonicalType(Old->getType()); 5229c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby QualType NewCType = Context.getCanonicalType(New->getType()); 5239c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (OldCType != NewCType && !Context.typesAreCompatible(OldCType, NewCType)) { 5249c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Diag(New->getLocation(), diag::err_redefinition, New->getName()); 5259c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Diag(Old->getLocation(), diag::err_previous_definition); 526762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return New; 5279c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 5289c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // C99 6.2.2p4: Check if we have a static decl followed by a non-static. 5299c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (New->getStorageClass() == VarDecl::Static && 5309c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby (Old->getStorageClass() == VarDecl::None || 531762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Old->getStorageClass() == VarDecl::Extern)) { 532762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(New->getLocation(), diag::err_static_non_static, New->getName()); 533762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(Old->getLocation(), diag::err_previous_definition); 5349c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return New; 5359c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 5369c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // C99 6.2.2p4: Check if we have a non-static decl followed by a static. 5379c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (New->getStorageClass() != VarDecl::Static && 53818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan Old->getStorageClass() == VarDecl::Static) { 539762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(New->getLocation(), diag::err_non_static_static, New->getName()); 5409c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Diag(Old->getLocation(), diag::err_previous_definition); 541b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan return New; 5429c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 5439c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 544b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan if (New->getStorageClass() != VarDecl::Extern && !New->isFileVarDecl()) { 5459c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Diag(New->getLocation(), diag::err_redefinition, New->getName()); 5469c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Diag(Old->getLocation(), diag::err_previous_definition); 54718b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan } 5489c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return New; 5499c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby} 550762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 551762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// CheckParmsForFunctionDef - Check that the parameters of the given 552762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// function are appropriate for the definition of a function. This 553762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// takes care of any checks that cannot be performed on the 5549c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// declaration itself, e.g., that the types of each of the function 5559c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// parameters are complete. 5569c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderbybool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) { 5579c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby bool HasInvalidParm = false; 55818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 5599c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby ParmVarDecl *Param = FD->getParamDecl(p); 560b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan 5619c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // C99 6.7.5.3p4: the parameters in a parameter type list in a 56218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan // function declarator that is part of a function definition of 563762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // that function shall not have incomplete type. 5643472766f9eb7d66f234c390ce1b3a8b76f0ee9ceDuncan Sands if (Param->getType()->isIncompleteType() && 5659c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby !Param->isInvalidDecl()) { 5669c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Diag(Param->getLocation(), diag::err_typecheck_decl_incomplete_type, 5679c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Param->getType().getAsString()); 5689c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Param->setInvalidDecl(); 5699c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby HasInvalidParm = true; 57018b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan } 5719c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 5729c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 573762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return HasInvalidParm; 574b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan} 5759c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 5769c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 5779c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby/// no declarator (e.g. "struct foo;") is parsed. 578762647673379dbcff6bbba6167b0b1b0d658ba9dSean CallananSema::DeclTy *Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) { 5799c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // TODO: emit error on 'int;' or 'const enum foo;'. 5809c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // TODO: emit error on 'typedef int;' 5819c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // if (!DS.isMissingDeclaratorOk()) Diag(...); 5829c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 583a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return dyn_cast_or_null<TagDecl>(static_cast<Decl *>(DS.getTypeRep())); 584a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 585a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 586a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderbybool Sema::CheckSingleInitializer(Expr *&Init, QualType DeclType) { 587762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // Get the type before calling CheckSingleAssignmentConstraints(), since 588762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // it can promote the expression. 589762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan QualType InitType = Init->getType(); 59018b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan 591a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby AssignConvertType ConvTy = CheckSingleAssignmentConstraints(DeclType, Init); 592a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return DiagnoseAssignmentResult(ConvTy, Init->getLocStart(), DeclType, 59338e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer InitType, Init, "initializing"); 594a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 5959c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby 596a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderbybool Sema::CheckStringLiteralInit(StringLiteral *strLiteral, QualType &DeclT) { 5979c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const ArrayType *AT = Context.getAsArrayType(DeclT); 598a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 5999c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 600a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // C99 6.7.8p14. We have an array of character type with unknown size 6019c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // being initialized to a string literal. 602a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby llvm::APSInt ConstVal(32); 6039c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby ConstVal = strLiteral->getByteLength() + 1; 604a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Return a new array type (C99 6.7.8p22). 605a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby DeclT = Context.getConstantArrayType(IAT->getElementType(), ConstVal, 606b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan ArrayType::Normal, 0); 607a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } else { 6089c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby const ConstantArrayType *CAT = cast<ConstantArrayType>(AT); 6099c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // C99 6.7.8p14. We have an array of character type with known size. 6109c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // FIXME: Avoid truncation for 64-bit length strings. 611a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (strLiteral->getByteLength() > (unsigned)CAT->getSize().getZExtValue()) 6129c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby Diag(strLiteral->getSourceRange().getBegin(), 61318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan diag::warn_initializer_string_for_char_array_too_long, 6149c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby strLiteral->getSourceRange()); 6159c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby } 616b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // Set type from "char *" to "constant array of char". 6179c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby strLiteral->setType(DeclT); 6189c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // For now, we always return false (meaning success). 6199c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return false; 620a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 621a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 622a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin EnderbyStringLiteral *Sema::IsStringLiteralInit(Expr *Init, QualType DeclType) { 623a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby const ArrayType *AT = Context.getAsArrayType(DeclType); 6249c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby if (AT && AT->getElementType()->isCharType()) { 6259c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby return dyn_cast<StringLiteral>(Init); 626762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 627762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return 0; 628762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan} 629a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 630a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderbybool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType) { 6319c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // C99 6.7.8p3: The type of the entity to be initialized shall be an array 632a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // of unknown size ("[]") or an object type that is not a variable array type. 633515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (const VariableArrayType *VAT = Context.getAsVariableArrayType(DeclType)) 634515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby return Diag(VAT->getSizeExpr()->getLocStart(), 635515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby diag::err_variable_object_no_init, 636762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan VAT->getSizeExpr()->getSourceRange()); 637515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 638515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby InitListExpr *InitList = dyn_cast<InitListExpr>(Init); 639762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (!InitList) { 640762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // FIXME: Handle wide strings 641515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (StringLiteral *strLiteral = IsStringLiteralInit(Init, DeclType)) 642a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return CheckStringLiteralInit(strLiteral, DeclType); 643515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 644d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby // C99 6.7.8p16. 645515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (DeclType->isArrayType()) 646d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby return Diag(Init->getLocStart(), 647079469f649d8da3923b9f747d7062c84e01cc4aeKevin Enderby diag::err_array_init_list_required, 648079469f649d8da3923b9f747d7062c84e01cc4aeKevin Enderby Init->getSourceRange()); 649762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 650b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan return CheckSingleInitializer(Init, DeclType); 651515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby } 652515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 653cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby InitListChecker CheckInitList(this, InitList, DeclType); 654762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return CheckInitList.HadError(); 655762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan} 656cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby 657a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin EnderbySema::DeclTy * 65818b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean CallananSema::ActOnDeclarator(Scope *S, Declarator &D, DeclTy *lastDecl) { 659a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby ScopedDecl *LastDeclarator = dyn_cast_or_null<ScopedDecl>((Decl *)lastDecl); 660a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby IdentifierInfo *II = D.getIdentifier(); 661a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 6629c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // All of these full declarators require an identifier. If it doesn't have 66338e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer // one, the ParsedFreeStandingDeclSpec action should be used. 6649898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner if (II == 0) { 665762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(D.getDeclSpec().getSourceRange().getBegin(), 6665747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar diag::err_declarator_need_ident, 6675747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar D.getDeclSpec().getSourceRange(), D.getSourceRange()); 6685747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar return 0; 6695747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar } 6705747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar 671345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // The scope passed in may not be a decl scope. Zip up the scope tree until 672345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // we find one that is. 673345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar while ((S->getFlags() & Scope::DeclScope) == 0) 674345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar S = S->getParent(); 675345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 676345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // See if this is a redefinition of a variable in the same scope. 677345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Decl *PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S); 678345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar ScopedDecl *New; 679345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar bool InvalidDecl = false; 680345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 681345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // In C++, the previous declaration we find might be a tag type 682345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // (class or enum). In this case, the new declaration will hide the 683345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // tag type. 684345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 685345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar PrevDecl = 0; 686345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 687345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar QualType R = GetTypeForDeclarator(D, S); 688345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar assert(!R.isNull() && "GetTypeForDeclarator() returned null type"); 689345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 690345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 691345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // Check that there are no default arguments (C++ only). 692345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar if (getLangOptions().CPlusPlus) 693345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar CheckExtraCXXDefaultArguments(D); 694345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 695345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, LastDeclarator); 696345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar if (!NewTD) return 0; 697345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 6985747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar // Handle attributes prior to checking for duplicates in MergeVarDecl 699762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan ProcessDeclAttributes(NewTD, D); 700a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Merge the decl with the existing one if appropriate. If the decl is 701345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar // in an outer scope, it isn't the same thing. 702345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar if (PrevDecl && isDeclInScope(PrevDecl, CurContext, S)) { 703345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar NewTD = MergeTypeDefDecl(NewTD, PrevDecl); 704345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar if (NewTD == 0) return 0; 7055747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar } 7065747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar New = NewTD; 7075747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar if (S->getFnParent() == 0) { 7085747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar // C99 6.7.7p2: If a typedef name specifies a variably modified type 709a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // then it shall have block scope. 7105747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar if (NewTD->getUnderlyingType()->isVariablyModifiedType()) { 7115747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar // FIXME: Diagnostic needs to be fixed. 7125747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar Diag(D.getIdentifierLoc(), diag::err_typecheck_illegal_vla); 7135747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar InvalidDecl = true; 7145747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar } 7155747b13af801d5af7cd5827c07c6a59e981bdb1aDaniel Dunbar } 716a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } else if (R.getTypePtr()->isFunctionType()) { 717762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan FunctionDecl::StorageClass SC = FunctionDecl::None; 7189898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner switch (D.getDeclSpec().getStorageClassSpec()) { 719762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan default: assert(0 && "Unknown storage class!"); 720a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case DeclSpec::SCS_auto: 721a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case DeclSpec::SCS_register: 722b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_func, 723a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby R.getAsString()); 724a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby InvalidDecl = true; 7259898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner break; 726762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break; 727a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break; 728a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case DeclSpec::SCS_static: SC = FunctionDecl::Static; break; 7299898671a74d3fc924347e679c45edaa685b3fe6eChris Lattner case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break; 730ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 731ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 732515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool isInline = D.getDeclSpec().isInlineSpecified(); 733ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby FunctionDecl *NewFD; 734ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (D.getContext() == Declarator::MemberContext) { 735ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // This is a C++ method declaration. 736ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(CurContext), 737515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby D.getIdentifierLoc(), II, R, 738515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby (SC == FunctionDecl::Static), isInline, 739515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby LastDeclarator); 740515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby } else { 741515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby NewFD = FunctionDecl::Create(Context, CurContext, 742515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby D.getIdentifierLoc(), 743515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby II, R, SC, isInline, LastDeclarator, 744515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // FIXME: Move to DeclGroup... 745ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby D.getDeclSpec().getSourceRange().getBegin()); 746ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 747ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // Handle attributes. 748ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby ProcessDeclAttributes(NewFD, D); 749ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 750ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // Handle GNU asm-label extension (encoded as an attribute). 751ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (Expr *E = (Expr*) D.getAsmLabel()) { 752ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // The parser guarantees this is a string. 753ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby StringLiteral *SE = cast<StringLiteral>(E); 754ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby NewFD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(), 755ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby SE->getByteLength()))); 756ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby } 757aaec205b87637cd0d59d4f11630db603686eb73dChris Lattner 758ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // Copy the parameter declarations from the declarator D to 759ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // the function declaration NewFD, if they are available. 760ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (D.getNumTypeObjects() > 0) { 761ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun; 762ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 763ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // Create Decl objects for each parameter, adding them to the 764ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // FunctionDecl. 765b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan llvm::SmallVector<ParmVarDecl*, 16> Params; 766ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 767ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 768ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // function that takes no arguments, not a function that takes a 769b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // single void argument. 770ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // We let through "const void" here because Sema::GetTypeForDeclarator 771ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // already checks for that case. 772ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 773515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby FTI.ArgInfo[0].Param && 774515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby ((ParmVarDecl*)FTI.ArgInfo[0].Param)->getType()->isVoidType()) { 775515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // empty arg list, don't push any params. 776515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby ParmVarDecl *Param = (ParmVarDecl*)FTI.ArgInfo[0].Param; 777515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 778b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // In C++, the empty parameter-type-list must be spelled "void"; a 779515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // typedef of void is not permitted. 780515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (getLangOptions().CPlusPlus && 781515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby Param->getType().getUnqualifiedType() != Context.VoidTy) { 782515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby Diag(Param->getLocation(), diag::ext_param_typedef_of_void); 783515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby } 784515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) { 785515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) 786515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby Params.push_back((ParmVarDecl *)FTI.ArgInfo[i].Param); 787515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby } 788515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 78918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan NewFD->setParams(&Params[0], Params.size()); 790515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby } else if (R->getAsTypedefType()) { 791515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // When we're declaring a function with a typedef, as in the 79218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan // following example, we'll need to synthesize (unnamed) 793b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // parameters for use in the declaration. 794515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // 795515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // @code 796515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // typedef void fn(int); 797b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // fn f; 798515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // @endcode 799515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby const FunctionTypeProto *FT = R->getAsFunctionTypeProto(); 800515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (!FT) { 801515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // This is a typedef of a function with no prototype, so we 802515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // don't need to do anything. 803515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby } else if ((FT->getNumArgs() == 0) || 804515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby (FT->getNumArgs() == 1 && !FT->isVariadic() && 805515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby FT->getArgType(0)->isVoidType())) { 806515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // This is a zero-argument function. We don't need to do anything. 80718b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan } else { 808515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // Synthesize a parameter for each argument type. 809515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby llvm::SmallVector<ParmVarDecl*, 16> Params; 81038e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramer for (FunctionTypeProto::arg_type_iterator ArgType = FT->arg_type_begin(); 81158c86910b31c569a5709466c82e2fabae2014a56Duncan Sands ArgType != FT->arg_type_end(); ++ArgType) { 812b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Params.push_back(ParmVarDecl::Create(Context, CurContext, 81358c86910b31c569a5709466c82e2fabae2014a56Duncan Sands SourceLocation(), 0, 814b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan *ArgType, VarDecl::None, 815515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 0, 0)); 816515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby } 817515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 818515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby NewFD->setParams(&Params[0], Params.size()); 81918b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan } 820b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan } 821515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 822515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // Merge the decl with the existing one if appropriate. Since C functions 823515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // are in a flat namespace, make sure we consider decls in outer scopes. 824515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (PrevDecl && 825515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby (!getLangOptions().CPlusPlus||isDeclInScope(PrevDecl, CurContext, S))) { 826515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby bool Redeclaration = false; 827515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 828515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // If C++, determine whether NewFD is an overload of PrevDecl or 829515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // a declaration that requires merging. If it's an overload, 83018b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan // there's no more work to do here; we'll just add the new 831515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // function to the scope. 832515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby OverloadedFunctionDecl::function_iterator MatchedDecl; 83318b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan if (!getLangOptions().CPlusPlus || 83458c86910b31c569a5709466c82e2fabae2014a56Duncan Sands !IsOverload(NewFD, PrevDecl, MatchedDecl)) { 835b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan Decl *OldDecl = PrevDecl; 83658c86910b31c569a5709466c82e2fabae2014a56Duncan Sands 837b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // If PrevDecl was an overloaded function, extract the 838515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby // FunctionDecl that matched. 839515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (isa<OverloadedFunctionDecl>(PrevDecl)) 840515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby OldDecl = *MatchedDecl; 841515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 84218b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan // NewFD and PrevDecl represent declarations that need to be 843b9a25b7744ed12b80031426978decce3d4cebbd7Sean Callanan // merged. 844515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby NewFD = MergeFunctionDecl(NewFD, OldDecl, Redeclaration); 845515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 846515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (NewFD == 0) return 0; 847515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (Redeclaration) { 848515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl)); 849515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby 85090b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan if (OldDecl == PrevDecl) { 85190b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan // Remove the name binding for the previous 8529c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby // declaration. We'll add the binding back later, but then 853ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // it will refer to the new declaration (which will 854ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // contain more information). 855ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby IdResolver.RemoveDecl(cast<NamedDecl>(PrevDecl)); 85690b7097f92f6b4f6b27cd88c7c88a21b777f5795Sean Callanan } else { 857ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby // We need to update the OverloadedFunctionDecl with the 8583483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar // latest declaration of this function, so that name 8593483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar // lookup will always refer to the latest declaration of 860 // this function. 861 *MatchedDecl = NewFD; 862 863 // Add the redeclaration to the current scope, since we'll 864 // be skipping PushOnScopeChains. 865 S->AddDecl(NewFD); 866 867 return NewFD; 868 } 869 } 870 } 871 } 872 New = NewFD; 873 874 // In C++, check default arguments now that we have merged decls. 875 if (getLangOptions().CPlusPlus) 876 CheckCXXDefaultArguments(NewFD); 877 } else { 878 // Check that there are no default arguments (C++ only). 879 if (getLangOptions().CPlusPlus) 880 CheckExtraCXXDefaultArguments(D); 881 882 if (R.getTypePtr()->isObjCInterfaceType()) { 883 Diag(D.getIdentifierLoc(), diag::err_statically_allocated_object, 884 D.getIdentifier()->getName()); 885 InvalidDecl = true; 886 } 887 888 VarDecl *NewVD; 889 VarDecl::StorageClass SC; 890 switch (D.getDeclSpec().getStorageClassSpec()) { 891 default: assert(0 && "Unknown storage class!"); 892 case DeclSpec::SCS_unspecified: SC = VarDecl::None; break; 893 case DeclSpec::SCS_extern: SC = VarDecl::Extern; break; 894 case DeclSpec::SCS_static: SC = VarDecl::Static; break; 895 case DeclSpec::SCS_auto: SC = VarDecl::Auto; break; 896 case DeclSpec::SCS_register: SC = VarDecl::Register; break; 897 case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break; 898 } 899 if (D.getContext() == Declarator::MemberContext) { 900 assert(SC == VarDecl::Static && "Invalid storage class for member!"); 901 // This is a static data member for a C++ class. 902 NewVD = CXXClassVarDecl::Create(Context, cast<CXXRecordDecl>(CurContext), 903 D.getIdentifierLoc(), II, 904 R, LastDeclarator); 905 } else { 906 bool ThreadSpecified = D.getDeclSpec().isThreadSpecified(); 907 if (S->getFnParent() == 0) { 908 // C99 6.9p2: The storage-class specifiers auto and register shall not 909 // appear in the declaration specifiers in an external declaration. 910 if (SC == VarDecl::Auto || SC == VarDecl::Register) { 911 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope, 912 R.getAsString()); 913 InvalidDecl = true; 914 } 915 } 916 NewVD = VarDecl::Create(Context, CurContext, D.getIdentifierLoc(), 917 II, R, SC, LastDeclarator, 918 // FIXME: Move to DeclGroup... 919 D.getDeclSpec().getSourceRange().getBegin()); 920 NewVD->setThreadSpecified(ThreadSpecified); 921 } 922 // Handle attributes prior to checking for duplicates in MergeVarDecl 923 ProcessDeclAttributes(NewVD, D); 924 925 // Handle GNU asm-label extension (encoded as an attribute). 926 if (Expr *E = (Expr*) D.getAsmLabel()) { 927 // The parser guarantees this is a string. 928 StringLiteral *SE = cast<StringLiteral>(E); 929 NewVD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(), 930 SE->getByteLength()))); 931 } 932 933 // Emit an error if an address space was applied to decl with local storage. 934 // This includes arrays of objects with address space qualifiers, but not 935 // automatic variables that point to other address spaces. 936 // ISO/IEC TR 18037 S5.1.2 937 if (NewVD->hasLocalStorage() && (NewVD->getType().getAddressSpace() != 0)) { 938 Diag(D.getIdentifierLoc(), diag::err_as_qualified_auto_decl); 939 InvalidDecl = true; 940 } 941 // Merge the decl with the existing one if appropriate. If the decl is 942 // in an outer scope, it isn't the same thing. 943 if (PrevDecl && isDeclInScope(PrevDecl, CurContext, S)) { 944 NewVD = MergeVarDecl(NewVD, PrevDecl); 945 if (NewVD == 0) return 0; 946 } 947 New = NewVD; 948 } 949 950 // If this has an identifier, add it to the scope stack. 951 if (II) 952 PushOnScopeChains(New, S); 953 // If any semantic error occurred, mark the decl as invalid. 954 if (D.getInvalidType() || InvalidDecl) 955 New->setInvalidDecl(); 956 957 return New; 958} 959 960void Sema::InitializerElementNotConstant(const Expr *Init) { 961 Diag(Init->getExprLoc(), 962 diag::err_init_element_not_constant, Init->getSourceRange()); 963} 964 965bool Sema::CheckAddressConstantExpressionLValue(const Expr* Init) { 966 switch (Init->getStmtClass()) { 967 default: 968 InitializerElementNotConstant(Init); 969 return true; 970 case Expr::ParenExprClass: { 971 const ParenExpr* PE = cast<ParenExpr>(Init); 972 return CheckAddressConstantExpressionLValue(PE->getSubExpr()); 973 } 974 case Expr::CompoundLiteralExprClass: 975 return cast<CompoundLiteralExpr>(Init)->isFileScope(); 976 case Expr::DeclRefExprClass: { 977 const Decl *D = cast<DeclRefExpr>(Init)->getDecl(); 978 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 979 if (VD->hasGlobalStorage()) 980 return false; 981 InitializerElementNotConstant(Init); 982 return true; 983 } 984 if (isa<FunctionDecl>(D)) 985 return false; 986 InitializerElementNotConstant(Init); 987 return true; 988 } 989 case Expr::MemberExprClass: { 990 const MemberExpr *M = cast<MemberExpr>(Init); 991 if (M->isArrow()) 992 return CheckAddressConstantExpression(M->getBase()); 993 return CheckAddressConstantExpressionLValue(M->getBase()); 994 } 995 case Expr::ArraySubscriptExprClass: { 996 // FIXME: Should we pedwarn for "x[0+0]" (where x is a pointer)? 997 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(Init); 998 return CheckAddressConstantExpression(ASE->getBase()) || 999 CheckArithmeticConstantExpression(ASE->getIdx()); 1000 } 1001 case Expr::StringLiteralClass: 1002 case Expr::PredefinedExprClass: 1003 return false; 1004 case Expr::UnaryOperatorClass: { 1005 const UnaryOperator *Exp = cast<UnaryOperator>(Init); 1006 1007 // C99 6.6p9 1008 if (Exp->getOpcode() == UnaryOperator::Deref) 1009 return CheckAddressConstantExpression(Exp->getSubExpr()); 1010 1011 InitializerElementNotConstant(Init); 1012 return true; 1013 } 1014 } 1015} 1016 1017bool Sema::CheckAddressConstantExpression(const Expr* Init) { 1018 switch (Init->getStmtClass()) { 1019 default: 1020 InitializerElementNotConstant(Init); 1021 return true; 1022 case Expr::ParenExprClass: 1023 return CheckAddressConstantExpression(cast<ParenExpr>(Init)->getSubExpr()); 1024 case Expr::StringLiteralClass: 1025 case Expr::ObjCStringLiteralClass: 1026 return false; 1027 case Expr::CallExprClass: 1028 // __builtin___CFStringMakeConstantString is a valid constant l-value. 1029 if (cast<CallExpr>(Init)->isBuiltinCall() == 1030 Builtin::BI__builtin___CFStringMakeConstantString) 1031 return false; 1032 1033 InitializerElementNotConstant(Init); 1034 return true; 1035 1036 case Expr::UnaryOperatorClass: { 1037 const UnaryOperator *Exp = cast<UnaryOperator>(Init); 1038 1039 // C99 6.6p9 1040 if (Exp->getOpcode() == UnaryOperator::AddrOf) 1041 return CheckAddressConstantExpressionLValue(Exp->getSubExpr()); 1042 1043 if (Exp->getOpcode() == UnaryOperator::Extension) 1044 return CheckAddressConstantExpression(Exp->getSubExpr()); 1045 1046 InitializerElementNotConstant(Init); 1047 return true; 1048 } 1049 case Expr::BinaryOperatorClass: { 1050 // FIXME: Should we pedwarn for expressions like "a + 1 + 2"? 1051 const BinaryOperator *Exp = cast<BinaryOperator>(Init); 1052 1053 Expr *PExp = Exp->getLHS(); 1054 Expr *IExp = Exp->getRHS(); 1055 if (IExp->getType()->isPointerType()) 1056 std::swap(PExp, IExp); 1057 1058 // FIXME: Should we pedwarn if IExp isn't an integer constant expression? 1059 return CheckAddressConstantExpression(PExp) || 1060 CheckArithmeticConstantExpression(IExp); 1061 } 1062 case Expr::ImplicitCastExprClass: 1063 case Expr::ExplicitCCastExprClass: { 1064 const Expr* SubExpr = cast<CastExpr>(Init)->getSubExpr(); 1065 if (Init->getStmtClass() == Expr::ImplicitCastExprClass) { 1066 // Check for implicit promotion 1067 if (SubExpr->getType()->isFunctionType() || 1068 SubExpr->getType()->isArrayType()) 1069 return CheckAddressConstantExpressionLValue(SubExpr); 1070 } 1071 1072 // Check for pointer->pointer cast 1073 if (SubExpr->getType()->isPointerType()) 1074 return CheckAddressConstantExpression(SubExpr); 1075 1076 if (SubExpr->getType()->isIntegralType()) { 1077 // Check for the special-case of a pointer->int->pointer cast; 1078 // this isn't standard, but some code requires it. See 1079 // PR2720 for an example. 1080 if (const CastExpr* SubCast = dyn_cast<CastExpr>(SubExpr)) { 1081 if (SubCast->getSubExpr()->getType()->isPointerType()) { 1082 unsigned IntWidth = Context.getIntWidth(SubCast->getType()); 1083 unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy); 1084 if (IntWidth >= PointerWidth) { 1085 return CheckAddressConstantExpression(SubCast->getSubExpr()); 1086 } 1087 } 1088 } 1089 } 1090 if (SubExpr->getType()->isArithmeticType()) { 1091 return CheckArithmeticConstantExpression(SubExpr); 1092 } 1093 1094 InitializerElementNotConstant(Init); 1095 return true; 1096 } 1097 case Expr::ConditionalOperatorClass: { 1098 // FIXME: Should we pedwarn here? 1099 const ConditionalOperator *Exp = cast<ConditionalOperator>(Init); 1100 if (!Exp->getCond()->getType()->isArithmeticType()) { 1101 InitializerElementNotConstant(Init); 1102 return true; 1103 } 1104 if (CheckArithmeticConstantExpression(Exp->getCond())) 1105 return true; 1106 if (Exp->getLHS() && 1107 CheckAddressConstantExpression(Exp->getLHS())) 1108 return true; 1109 return CheckAddressConstantExpression(Exp->getRHS()); 1110 } 1111 case Expr::AddrLabelExprClass: 1112 return false; 1113 } 1114} 1115 1116static const Expr* FindExpressionBaseAddress(const Expr* E); 1117 1118static const Expr* FindExpressionBaseAddressLValue(const Expr* E) { 1119 switch (E->getStmtClass()) { 1120 default: 1121 return E; 1122 case Expr::ParenExprClass: { 1123 const ParenExpr* PE = cast<ParenExpr>(E); 1124 return FindExpressionBaseAddressLValue(PE->getSubExpr()); 1125 } 1126 case Expr::MemberExprClass: { 1127 const MemberExpr *M = cast<MemberExpr>(E); 1128 if (M->isArrow()) 1129 return FindExpressionBaseAddress(M->getBase()); 1130 return FindExpressionBaseAddressLValue(M->getBase()); 1131 } 1132 case Expr::ArraySubscriptExprClass: { 1133 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(E); 1134 return FindExpressionBaseAddress(ASE->getBase()); 1135 } 1136 case Expr::UnaryOperatorClass: { 1137 const UnaryOperator *Exp = cast<UnaryOperator>(E); 1138 1139 if (Exp->getOpcode() == UnaryOperator::Deref) 1140 return FindExpressionBaseAddress(Exp->getSubExpr()); 1141 1142 return E; 1143 } 1144 } 1145} 1146 1147static const Expr* FindExpressionBaseAddress(const Expr* E) { 1148 switch (E->getStmtClass()) { 1149 default: 1150 return E; 1151 case Expr::ParenExprClass: { 1152 const ParenExpr* PE = cast<ParenExpr>(E); 1153 return FindExpressionBaseAddress(PE->getSubExpr()); 1154 } 1155 case Expr::UnaryOperatorClass: { 1156 const UnaryOperator *Exp = cast<UnaryOperator>(E); 1157 1158 // C99 6.6p9 1159 if (Exp->getOpcode() == UnaryOperator::AddrOf) 1160 return FindExpressionBaseAddressLValue(Exp->getSubExpr()); 1161 1162 if (Exp->getOpcode() == UnaryOperator::Extension) 1163 return FindExpressionBaseAddress(Exp->getSubExpr()); 1164 1165 return E; 1166 } 1167 case Expr::BinaryOperatorClass: { 1168 const BinaryOperator *Exp = cast<BinaryOperator>(E); 1169 1170 Expr *PExp = Exp->getLHS(); 1171 Expr *IExp = Exp->getRHS(); 1172 if (IExp->getType()->isPointerType()) 1173 std::swap(PExp, IExp); 1174 1175 return FindExpressionBaseAddress(PExp); 1176 } 1177 case Expr::ImplicitCastExprClass: { 1178 const Expr* SubExpr = cast<ImplicitCastExpr>(E)->getSubExpr(); 1179 1180 // Check for implicit promotion 1181 if (SubExpr->getType()->isFunctionType() || 1182 SubExpr->getType()->isArrayType()) 1183 return FindExpressionBaseAddressLValue(SubExpr); 1184 1185 // Check for pointer->pointer cast 1186 if (SubExpr->getType()->isPointerType()) 1187 return FindExpressionBaseAddress(SubExpr); 1188 1189 // We assume that we have an arithmetic expression here; 1190 // if we don't, we'll figure it out later 1191 return 0; 1192 } 1193 case Expr::ExplicitCCastExprClass: { 1194 const Expr* SubExpr = cast<CastExpr>(E)->getSubExpr(); 1195 1196 // Check for pointer->pointer cast 1197 if (SubExpr->getType()->isPointerType()) 1198 return FindExpressionBaseAddress(SubExpr); 1199 1200 // We assume that we have an arithmetic expression here; 1201 // if we don't, we'll figure it out later 1202 return 0; 1203 } 1204 } 1205} 1206 1207bool Sema::CheckArithmeticConstantExpression(const Expr* Init) { 1208 switch (Init->getStmtClass()) { 1209 default: 1210 InitializerElementNotConstant(Init); 1211 return true; 1212 case Expr::ParenExprClass: { 1213 const ParenExpr* PE = cast<ParenExpr>(Init); 1214 return CheckArithmeticConstantExpression(PE->getSubExpr()); 1215 } 1216 case Expr::FloatingLiteralClass: 1217 case Expr::IntegerLiteralClass: 1218 case Expr::CharacterLiteralClass: 1219 case Expr::ImaginaryLiteralClass: 1220 case Expr::TypesCompatibleExprClass: 1221 case Expr::CXXBoolLiteralExprClass: 1222 return false; 1223 case Expr::CallExprClass: { 1224 const CallExpr *CE = cast<CallExpr>(Init); 1225 1226 // Allow any constant foldable calls to builtins. 1227 if (CE->isBuiltinCall() && CE->isEvaluatable(Context)) 1228 return false; 1229 1230 InitializerElementNotConstant(Init); 1231 return true; 1232 } 1233 case Expr::DeclRefExprClass: { 1234 const Decl *D = cast<DeclRefExpr>(Init)->getDecl(); 1235 if (isa<EnumConstantDecl>(D)) 1236 return false; 1237 InitializerElementNotConstant(Init); 1238 return true; 1239 } 1240 case Expr::CompoundLiteralExprClass: 1241 // Allow "(vector type){2,4}"; normal C constraints don't allow this, 1242 // but vectors are allowed to be magic. 1243 if (Init->getType()->isVectorType()) 1244 return false; 1245 InitializerElementNotConstant(Init); 1246 return true; 1247 case Expr::UnaryOperatorClass: { 1248 const UnaryOperator *Exp = cast<UnaryOperator>(Init); 1249 1250 switch (Exp->getOpcode()) { 1251 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 1252 // See C99 6.6p3. 1253 default: 1254 InitializerElementNotConstant(Init); 1255 return true; 1256 case UnaryOperator::SizeOf: 1257 case UnaryOperator::AlignOf: 1258 case UnaryOperator::OffsetOf: 1259 // sizeof(E) is a constantexpr if and only if E is not evaluted. 1260 // See C99 6.5.3.4p2 and 6.6p3. 1261 if (Exp->getSubExpr()->getType()->isConstantSizeType()) 1262 return false; 1263 InitializerElementNotConstant(Init); 1264 return true; 1265 case UnaryOperator::Extension: 1266 case UnaryOperator::LNot: 1267 case UnaryOperator::Plus: 1268 case UnaryOperator::Minus: 1269 case UnaryOperator::Not: 1270 return CheckArithmeticConstantExpression(Exp->getSubExpr()); 1271 } 1272 } 1273 case Expr::SizeOfAlignOfTypeExprClass: { 1274 const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(Init); 1275 // Special check for void types, which are allowed as an extension 1276 if (Exp->getArgumentType()->isVoidType()) 1277 return false; 1278 // alignof always evaluates to a constant. 1279 // FIXME: is sizeof(int[3.0]) a constant expression? 1280 if (Exp->isSizeOf() && !Exp->getArgumentType()->isConstantSizeType()) { 1281 InitializerElementNotConstant(Init); 1282 return true; 1283 } 1284 return false; 1285 } 1286 case Expr::BinaryOperatorClass: { 1287 const BinaryOperator *Exp = cast<BinaryOperator>(Init); 1288 1289 if (Exp->getLHS()->getType()->isArithmeticType() && 1290 Exp->getRHS()->getType()->isArithmeticType()) { 1291 return CheckArithmeticConstantExpression(Exp->getLHS()) || 1292 CheckArithmeticConstantExpression(Exp->getRHS()); 1293 } 1294 1295 if (Exp->getLHS()->getType()->isPointerType() && 1296 Exp->getRHS()->getType()->isPointerType()) { 1297 const Expr* LHSBase = FindExpressionBaseAddress(Exp->getLHS()); 1298 const Expr* RHSBase = FindExpressionBaseAddress(Exp->getRHS()); 1299 1300 // Only allow a null (constant integer) base; we could 1301 // allow some additional cases if necessary, but this 1302 // is sufficient to cover offsetof-like constructs. 1303 if (!LHSBase && !RHSBase) { 1304 return CheckAddressConstantExpression(Exp->getLHS()) || 1305 CheckAddressConstantExpression(Exp->getRHS()); 1306 } 1307 } 1308 1309 InitializerElementNotConstant(Init); 1310 return true; 1311 } 1312 case Expr::ImplicitCastExprClass: 1313 case Expr::ExplicitCCastExprClass: { 1314 const Expr *SubExpr = cast<CastExpr>(Init)->getSubExpr(); 1315 if (SubExpr->getType()->isArithmeticType()) 1316 return CheckArithmeticConstantExpression(SubExpr); 1317 1318 if (SubExpr->getType()->isPointerType()) { 1319 const Expr* Base = FindExpressionBaseAddress(SubExpr); 1320 // If the pointer has a null base, this is an offsetof-like construct 1321 if (!Base) 1322 return CheckAddressConstantExpression(SubExpr); 1323 } 1324 1325 InitializerElementNotConstant(Init); 1326 return true; 1327 } 1328 case Expr::ConditionalOperatorClass: { 1329 const ConditionalOperator *Exp = cast<ConditionalOperator>(Init); 1330 1331 // If GNU extensions are disabled, we require all operands to be arithmetic 1332 // constant expressions. 1333 if (getLangOptions().NoExtensions) { 1334 return CheckArithmeticConstantExpression(Exp->getCond()) || 1335 (Exp->getLHS() && CheckArithmeticConstantExpression(Exp->getLHS())) || 1336 CheckArithmeticConstantExpression(Exp->getRHS()); 1337 } 1338 1339 // Otherwise, we have to emulate some of the behavior of fold here. 1340 // Basically GCC treats things like "4 ? 1 : somefunc()" as a constant 1341 // because it can constant fold things away. To retain compatibility with 1342 // GCC code, we see if we can fold the condition to a constant (which we 1343 // should always be able to do in theory). If so, we only require the 1344 // specified arm of the conditional to be a constant. This is a horrible 1345 // hack, but is require by real world code that uses __builtin_constant_p. 1346 APValue Val; 1347 if (!Exp->getCond()->tryEvaluate(Val, Context)) { 1348 // If the tryEvaluate couldn't fold it, CheckArithmeticConstantExpression 1349 // won't be able to either. Use it to emit the diagnostic though. 1350 bool Res = CheckArithmeticConstantExpression(Exp->getCond()); 1351 assert(Res && "tryEvaluate couldn't evaluate this constant?"); 1352 return Res; 1353 } 1354 1355 // Verify that the side following the condition is also a constant. 1356 const Expr *TrueSide = Exp->getLHS(), *FalseSide = Exp->getRHS(); 1357 if (Val.getInt() == 0) 1358 std::swap(TrueSide, FalseSide); 1359 1360 if (TrueSide && CheckArithmeticConstantExpression(TrueSide)) 1361 return true; 1362 1363 // Okay, the evaluated side evaluates to a constant, so we accept this. 1364 // Check to see if the other side is obviously not a constant. If so, 1365 // emit a warning that this is a GNU extension. 1366 if (FalseSide && !FalseSide->isEvaluatable(Context)) 1367 Diag(Init->getExprLoc(), 1368 diag::ext_typecheck_expression_not_constant_but_accepted, 1369 FalseSide->getSourceRange()); 1370 return false; 1371 } 1372 } 1373} 1374 1375bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 1376 Init = Init->IgnoreParens(); 1377 1378 // Look through CXXDefaultArgExprs; they have no meaning in this context. 1379 if (CXXDefaultArgExpr* DAE = dyn_cast<CXXDefaultArgExpr>(Init)) 1380 return CheckForConstantInitializer(DAE->getExpr(), DclT); 1381 1382 if (CompoundLiteralExpr *e = dyn_cast<CompoundLiteralExpr>(Init)) 1383 return CheckForConstantInitializer(e->getInitializer(), DclT); 1384 1385 if (Init->getType()->isReferenceType()) { 1386 // FIXME: Work out how the heck references work. 1387 return false; 1388 } 1389 1390 if (InitListExpr *Exp = dyn_cast<InitListExpr>(Init)) { 1391 unsigned numInits = Exp->getNumInits(); 1392 for (unsigned i = 0; i < numInits; i++) { 1393 // FIXME: Need to get the type of the declaration for C++, 1394 // because it could be a reference? 1395 if (CheckForConstantInitializer(Exp->getInit(i), 1396 Exp->getInit(i)->getType())) 1397 return true; 1398 } 1399 return false; 1400 } 1401 1402 if (Init->isNullPointerConstant(Context)) 1403 return false; 1404 if (Init->getType()->isArithmeticType()) { 1405 QualType InitTy = Context.getCanonicalType(Init->getType()) 1406 .getUnqualifiedType(); 1407 if (InitTy == Context.BoolTy) { 1408 // Special handling for pointers implicitly cast to bool; 1409 // (e.g. "_Bool rr = &rr;"). This is only legal at the top level. 1410 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Init)) { 1411 Expr* SubE = ICE->getSubExpr(); 1412 if (SubE->getType()->isPointerType() || 1413 SubE->getType()->isArrayType() || 1414 SubE->getType()->isFunctionType()) { 1415 return CheckAddressConstantExpression(Init); 1416 } 1417 } 1418 } else if (InitTy->isIntegralType()) { 1419 Expr* SubE = 0; 1420 if (CastExpr* CE = dyn_cast<CastExpr>(Init)) 1421 SubE = CE->getSubExpr(); 1422 // Special check for pointer cast to int; we allow as an extension 1423 // an address constant cast to an integer if the integer 1424 // is of an appropriate width (this sort of code is apparently used 1425 // in some places). 1426 // FIXME: Add pedwarn? 1427 // FIXME: Don't allow bitfields here! Need the FieldDecl for that. 1428 if (SubE && (SubE->getType()->isPointerType() || 1429 SubE->getType()->isArrayType() || 1430 SubE->getType()->isFunctionType())) { 1431 unsigned IntWidth = Context.getTypeSize(Init->getType()); 1432 unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy); 1433 if (IntWidth >= PointerWidth) 1434 return CheckAddressConstantExpression(Init); 1435 } 1436 } 1437 1438 return CheckArithmeticConstantExpression(Init); 1439 } 1440 1441 if (Init->getType()->isPointerType()) 1442 return CheckAddressConstantExpression(Init); 1443 1444 // An array type at the top level that isn't an init-list must 1445 // be a string literal 1446 if (Init->getType()->isArrayType()) 1447 return false; 1448 1449 if (Init->getType()->isFunctionType()) 1450 return false; 1451 1452 // Allow block exprs at top level. 1453 if (Init->getType()->isBlockPointerType()) 1454 return false; 1455 1456 InitializerElementNotConstant(Init); 1457 return true; 1458} 1459 1460void Sema::AddInitializerToDecl(DeclTy *dcl, ExprTy *init) { 1461 Decl *RealDecl = static_cast<Decl *>(dcl); 1462 Expr *Init = static_cast<Expr *>(init); 1463 assert(Init && "missing initializer"); 1464 1465 // If there is no declaration, there was an error parsing it. Just ignore 1466 // the initializer. 1467 if (RealDecl == 0) { 1468 delete Init; 1469 return; 1470 } 1471 1472 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 1473 if (!VDecl) { 1474 Diag(dyn_cast<ScopedDecl>(RealDecl)->getLocation(), 1475 diag::err_illegal_initializer); 1476 RealDecl->setInvalidDecl(); 1477 return; 1478 } 1479 // Get the decls type and save a reference for later, since 1480 // CheckInitializerTypes may change it. 1481 QualType DclT = VDecl->getType(), SavT = DclT; 1482 if (VDecl->isBlockVarDecl()) { 1483 VarDecl::StorageClass SC = VDecl->getStorageClass(); 1484 if (SC == VarDecl::Extern) { // C99 6.7.8p5 1485 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 1486 VDecl->setInvalidDecl(); 1487 } else if (!VDecl->isInvalidDecl()) { 1488 if (CheckInitializerTypes(Init, DclT)) 1489 VDecl->setInvalidDecl(); 1490 1491 // C++ 3.6.2p2, allow dynamic initialization of static initializers. 1492 if (!getLangOptions().CPlusPlus) { 1493 if (SC == VarDecl::Static) // C99 6.7.8p4. 1494 CheckForConstantInitializer(Init, DclT); 1495 } 1496 } 1497 } else if (VDecl->isFileVarDecl()) { 1498 if (VDecl->getStorageClass() == VarDecl::Extern) 1499 Diag(VDecl->getLocation(), diag::warn_extern_init); 1500 if (!VDecl->isInvalidDecl()) 1501 if (CheckInitializerTypes(Init, DclT)) 1502 VDecl->setInvalidDecl(); 1503 1504 // C++ 3.6.2p2, allow dynamic initialization of static initializers. 1505 if (!getLangOptions().CPlusPlus) { 1506 // C99 6.7.8p4. All file scoped initializers need to be constant. 1507 CheckForConstantInitializer(Init, DclT); 1508 } 1509 } 1510 // If the type changed, it means we had an incomplete type that was 1511 // completed by the initializer. For example: 1512 // int ary[] = { 1, 3, 5 }; 1513 // "ary" transitions from a VariableArrayType to a ConstantArrayType. 1514 if (!VDecl->isInvalidDecl() && (DclT != SavT)) { 1515 VDecl->setType(DclT); 1516 Init->setType(DclT); 1517 } 1518 1519 // Attach the initializer to the decl. 1520 VDecl->setInit(Init); 1521 return; 1522} 1523 1524/// The declarators are chained together backwards, reverse the list. 1525Sema::DeclTy *Sema::FinalizeDeclaratorGroup(Scope *S, DeclTy *group) { 1526 // Often we have single declarators, handle them quickly. 1527 Decl *GroupDecl = static_cast<Decl*>(group); 1528 if (GroupDecl == 0) 1529 return 0; 1530 1531 ScopedDecl *Group = dyn_cast<ScopedDecl>(GroupDecl); 1532 ScopedDecl *NewGroup = 0; 1533 if (Group->getNextDeclarator() == 0) 1534 NewGroup = Group; 1535 else { // reverse the list. 1536 while (Group) { 1537 ScopedDecl *Next = Group->getNextDeclarator(); 1538 Group->setNextDeclarator(NewGroup); 1539 NewGroup = Group; 1540 Group = Next; 1541 } 1542 } 1543 // Perform semantic analysis that depends on having fully processed both 1544 // the declarator and initializer. 1545 for (ScopedDecl *ID = NewGroup; ID; ID = ID->getNextDeclarator()) { 1546 VarDecl *IDecl = dyn_cast<VarDecl>(ID); 1547 if (!IDecl) 1548 continue; 1549 QualType T = IDecl->getType(); 1550 1551 // C99 6.7.5.2p2: If an identifier is declared to be an object with 1552 // static storage duration, it shall not have a variable length array. 1553 if ((IDecl->isFileVarDecl() || IDecl->isBlockVarDecl()) && 1554 IDecl->getStorageClass() == VarDecl::Static) { 1555 if (T->isVariableArrayType()) { 1556 Diag(IDecl->getLocation(), diag::err_typecheck_illegal_vla); 1557 IDecl->setInvalidDecl(); 1558 } 1559 } 1560 // Block scope. C99 6.7p7: If an identifier for an object is declared with 1561 // no linkage (C99 6.2.2p6), the type for the object shall be complete... 1562 if (IDecl->isBlockVarDecl() && 1563 IDecl->getStorageClass() != VarDecl::Extern) { 1564 if (T->isIncompleteType() && !IDecl->isInvalidDecl()) { 1565 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type, 1566 T.getAsString()); 1567 IDecl->setInvalidDecl(); 1568 } 1569 } 1570 // File scope. C99 6.9.2p2: A declaration of an identifier for and 1571 // object that has file scope without an initializer, and without a 1572 // storage-class specifier or with the storage-class specifier "static", 1573 // constitutes a tentative definition. Note: A tentative definition with 1574 // external linkage is valid (C99 6.2.2p5). 1575 if (isTentativeDefinition(IDecl)) { 1576 if (T->isIncompleteArrayType()) { 1577 // C99 6.9.2 (p2, p5): Implicit initialization causes an incomplete 1578 // array to be completed. Don't issue a diagnostic. 1579 } else if (T->isIncompleteType() && !IDecl->isInvalidDecl()) { 1580 // C99 6.9.2p3: If the declaration of an identifier for an object is 1581 // a tentative definition and has internal linkage (C99 6.2.2p3), the 1582 // declared type shall not be an incomplete type. 1583 Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type, 1584 T.getAsString()); 1585 IDecl->setInvalidDecl(); 1586 } 1587 } 1588 if (IDecl->isFileVarDecl()) 1589 CheckForFileScopedRedefinitions(S, IDecl); 1590 } 1591 return NewGroup; 1592} 1593 1594/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 1595/// to introduce parameters into function prototype scope. 1596Sema::DeclTy * 1597Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 1598 const DeclSpec &DS = D.getDeclSpec(); 1599 1600 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 1601 VarDecl::StorageClass StorageClass = VarDecl::None; 1602 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 1603 StorageClass = VarDecl::Register; 1604 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 1605 Diag(DS.getStorageClassSpecLoc(), 1606 diag::err_invalid_storage_class_in_func_decl); 1607 D.getMutableDeclSpec().ClearStorageClassSpecs(); 1608 } 1609 if (DS.isThreadSpecified()) { 1610 Diag(DS.getThreadSpecLoc(), 1611 diag::err_invalid_storage_class_in_func_decl); 1612 D.getMutableDeclSpec().ClearStorageClassSpecs(); 1613 } 1614 1615 // Check that there are no default arguments inside the type of this 1616 // parameter (C++ only). 1617 if (getLangOptions().CPlusPlus) 1618 CheckExtraCXXDefaultArguments(D); 1619 1620 // In this context, we *do not* check D.getInvalidType(). If the declarator 1621 // type was invalid, GetTypeForDeclarator() still returns a "valid" type, 1622 // though it will not reflect the user specified type. 1623 QualType parmDeclType = GetTypeForDeclarator(D, S); 1624 1625 assert(!parmDeclType.isNull() && "GetTypeForDeclarator() returned null type"); 1626 1627 // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope. 1628 // Can this happen for params? We already checked that they don't conflict 1629 // among each other. Here they can only shadow globals, which is ok. 1630 IdentifierInfo *II = D.getIdentifier(); 1631 if (Decl *PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S)) { 1632 if (S->isDeclScope(PrevDecl)) { 1633 Diag(D.getIdentifierLoc(), diag::err_param_redefinition, 1634 dyn_cast<NamedDecl>(PrevDecl)->getName()); 1635 1636 // Recover by removing the name 1637 II = 0; 1638 D.SetIdentifier(0, D.getIdentifierLoc()); 1639 } 1640 } 1641 1642 // Perform the default function/array conversion (C99 6.7.5.3p[7,8]). 1643 // Doing the promotion here has a win and a loss. The win is the type for 1644 // both Decl's and DeclRefExpr's will match (a convenient invariant for the 1645 // code generator). The loss is the orginal type isn't preserved. For example: 1646 // 1647 // void func(int parmvardecl[5]) { // convert "int [5]" to "int *" 1648 // int blockvardecl[5]; 1649 // sizeof(parmvardecl); // size == 4 1650 // sizeof(blockvardecl); // size == 20 1651 // } 1652 // 1653 // For expressions, all implicit conversions are captured using the 1654 // ImplicitCastExpr AST node (we have no such mechanism for Decl's). 1655 // 1656 // FIXME: If a source translation tool needs to see the original type, then 1657 // we need to consider storing both types (in ParmVarDecl)... 1658 // 1659 if (parmDeclType->isArrayType()) { 1660 // int x[restrict 4] -> int *restrict 1661 parmDeclType = Context.getArrayDecayedType(parmDeclType); 1662 } else if (parmDeclType->isFunctionType()) 1663 parmDeclType = Context.getPointerType(parmDeclType); 1664 1665 ParmVarDecl *New = ParmVarDecl::Create(Context, CurContext, 1666 D.getIdentifierLoc(), II, 1667 parmDeclType, StorageClass, 1668 0, 0); 1669 1670 if (D.getInvalidType()) 1671 New->setInvalidDecl(); 1672 1673 if (II) 1674 PushOnScopeChains(New, S); 1675 1676 ProcessDeclAttributes(New, D); 1677 return New; 1678 1679} 1680 1681Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) { 1682 assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 1683 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function && 1684 "Not a function declarator!"); 1685 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun; 1686 1687 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 1688 // for a K&R function. 1689 if (!FTI.hasPrototype) { 1690 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) { 1691 if (FTI.ArgInfo[i].Param == 0) { 1692 Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared, 1693 FTI.ArgInfo[i].Ident->getName()); 1694 // Implicitly declare the argument as type 'int' for lack of a better 1695 // type. 1696 DeclSpec DS; 1697 const char* PrevSpec; // unused 1698 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc, 1699 PrevSpec); 1700 Declarator ParamD(DS, Declarator::KNRTypeListContext); 1701 ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc); 1702 FTI.ArgInfo[i].Param = ActOnParamDeclarator(FnBodyScope, ParamD); 1703 } 1704 } 1705 } else { 1706 // FIXME: Diagnose arguments without names in C. 1707 } 1708 1709 Scope *GlobalScope = FnBodyScope->getParent(); 1710 1711 // See if this is a redefinition. 1712 Decl *PrevDcl = LookupDecl(D.getIdentifier(), Decl::IDNS_Ordinary, 1713 GlobalScope); 1714 if (PrevDcl && isDeclInScope(PrevDcl, CurContext)) { 1715 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PrevDcl)) { 1716 const FunctionDecl *Definition; 1717 if (FD->getBody(Definition)) { 1718 Diag(D.getIdentifierLoc(), diag::err_redefinition, 1719 D.getIdentifier()->getName()); 1720 Diag(Definition->getLocation(), diag::err_previous_definition); 1721 } 1722 } 1723 } 1724 1725 return ActOnStartOfFunctionDef(FnBodyScope, 1726 ActOnDeclarator(GlobalScope, D, 0)); 1727} 1728 1729Sema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclTy *D) { 1730 Decl *decl = static_cast<Decl*>(D); 1731 FunctionDecl *FD = cast<FunctionDecl>(decl); 1732 PushDeclContext(FD); 1733 1734 // Check the validity of our function parameters 1735 CheckParmsForFunctionDef(FD); 1736 1737 // Introduce our parameters into the function scope 1738 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 1739 ParmVarDecl *Param = FD->getParamDecl(p); 1740 // If this has an identifier, add it to the scope stack. 1741 if (Param->getIdentifier()) 1742 PushOnScopeChains(Param, FnBodyScope); 1743 } 1744 1745 return FD; 1746} 1747 1748Sema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtTy *Body) { 1749 Decl *dcl = static_cast<Decl *>(D); 1750 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(dcl)) { 1751 FD->setBody((Stmt*)Body); 1752 assert(FD == getCurFunctionDecl() && "Function parsing confused"); 1753 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 1754 MD->setBody((Stmt*)Body); 1755 } else 1756 return 0; 1757 PopDeclContext(); 1758 // Verify and clean out per-function state. 1759 1760 // Check goto/label use. 1761 for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator 1762 I = LabelMap.begin(), E = LabelMap.end(); I != E; ++I) { 1763 // Verify that we have no forward references left. If so, there was a goto 1764 // or address of a label taken, but no definition of it. Label fwd 1765 // definitions are indicated with a null substmt. 1766 if (I->second->getSubStmt() == 0) { 1767 LabelStmt *L = I->second; 1768 // Emit error. 1769 Diag(L->getIdentLoc(), diag::err_undeclared_label_use, L->getName()); 1770 1771 // At this point, we have gotos that use the bogus label. Stitch it into 1772 // the function body so that they aren't leaked and that the AST is well 1773 // formed. 1774 if (Body) { 1775 L->setSubStmt(new NullStmt(L->getIdentLoc())); 1776 cast<CompoundStmt>((Stmt*)Body)->push_back(L); 1777 } else { 1778 // The whole function wasn't parsed correctly, just delete this. 1779 delete L; 1780 } 1781 } 1782 } 1783 LabelMap.clear(); 1784 1785 return D; 1786} 1787 1788/// ImplicitlyDefineFunction - An undeclared identifier was used in a function 1789/// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 1790ScopedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 1791 IdentifierInfo &II, Scope *S) { 1792 // Extension in C99. Legal in C90, but warn about it. 1793 if (getLangOptions().C99) 1794 Diag(Loc, diag::ext_implicit_function_decl, II.getName()); 1795 else 1796 Diag(Loc, diag::warn_implicit_function_decl, II.getName()); 1797 1798 // FIXME: handle stuff like: 1799 // void foo() { extern float X(); } 1800 // void bar() { X(); } <-- implicit decl for X in another scope. 1801 1802 // Set a Declarator for the implicit definition: int foo(); 1803 const char *Dummy; 1804 DeclSpec DS; 1805 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy); 1806 Error = Error; // Silence warning. 1807 assert(!Error && "Error setting up implicit decl!"); 1808 Declarator D(DS, Declarator::BlockContext); 1809 D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, 0, 0, 0, Loc)); 1810 D.SetIdentifier(&II, Loc); 1811 1812 // Insert this function into translation-unit scope. 1813 1814 DeclContext *PrevDC = CurContext; 1815 CurContext = Context.getTranslationUnitDecl(); 1816 1817 FunctionDecl *FD = 1818 dyn_cast<FunctionDecl>(static_cast<Decl*>(ActOnDeclarator(TUScope, D, 0))); 1819 FD->setImplicit(); 1820 1821 CurContext = PrevDC; 1822 1823 return FD; 1824} 1825 1826 1827TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 1828 ScopedDecl *LastDeclarator) { 1829 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 1830 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 1831 1832 // Scope manipulation handled by caller. 1833 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 1834 D.getIdentifierLoc(), 1835 D.getIdentifier(), 1836 T, LastDeclarator); 1837 if (D.getInvalidType()) 1838 NewTD->setInvalidDecl(); 1839 return NewTD; 1840} 1841 1842/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the 1843/// former case, Name will be non-null. In the later case, Name will be null. 1844/// TagType indicates what kind of tag this is. TK indicates whether this is a 1845/// reference/declaration/definition of a tag. 1846Sema::DeclTy *Sema::ActOnTag(Scope *S, unsigned TagType, TagKind TK, 1847 SourceLocation KWLoc, IdentifierInfo *Name, 1848 SourceLocation NameLoc, AttributeList *Attr) { 1849 // If this is a use of an existing tag, it must have a name. 1850 assert((Name != 0 || TK == TK_Definition) && 1851 "Nameless record must be a definition!"); 1852 1853 TagDecl::TagKind Kind; 1854 switch (TagType) { 1855 default: assert(0 && "Unknown tag type!"); 1856 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 1857 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 1858 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 1859 case DeclSpec::TST_enum: Kind = TagDecl::TK_enum; break; 1860 } 1861 1862 // Two code paths: a new one for structs/unions/classes where we create 1863 // separate decls for forward declarations, and an old (eventually to 1864 // be removed) code path for enums. 1865 if (Kind != TagDecl::TK_enum) 1866 return ActOnTagStruct(S, Kind, TK, KWLoc, Name, NameLoc, Attr); 1867 1868 // If this is a named struct, check to see if there was a previous forward 1869 // declaration or definition. 1870 // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up. 1871 ScopedDecl *PrevDecl = 1872 dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag, S)); 1873 1874 if (PrevDecl) { 1875 assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) && 1876 "unexpected Decl type"); 1877 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 1878 // If this is a use of a previous tag, or if the tag is already declared 1879 // in the same scope (so that the definition/declaration completes or 1880 // rementions the tag), reuse the decl. 1881 if (TK == TK_Reference || isDeclInScope(PrevDecl, CurContext, S)) { 1882 // Make sure that this wasn't declared as an enum and now used as a 1883 // struct or something similar. 1884 if (PrevTagDecl->getTagKind() != Kind) { 1885 Diag(KWLoc, diag::err_use_with_wrong_tag, Name->getName()); 1886 Diag(PrevDecl->getLocation(), diag::err_previous_use); 1887 // Recover by making this an anonymous redefinition. 1888 Name = 0; 1889 PrevDecl = 0; 1890 } else { 1891 // If this is a use or a forward declaration, we're good. 1892 if (TK != TK_Definition) 1893 return PrevDecl; 1894 1895 // Diagnose attempts to redefine a tag. 1896 if (PrevTagDecl->isDefinition()) { 1897 Diag(NameLoc, diag::err_redefinition, Name->getName()); 1898 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 1899 // If this is a redefinition, recover by making this struct be 1900 // anonymous, which will make any later references get the previous 1901 // definition. 1902 Name = 0; 1903 } else { 1904 // Okay, this is definition of a previously declared or referenced 1905 // tag. Move the location of the decl to be the definition site. 1906 PrevDecl->setLocation(NameLoc); 1907 return PrevDecl; 1908 } 1909 } 1910 } 1911 // If we get here, this is a definition of a new struct type in a nested 1912 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a new 1913 // type. 1914 } else { 1915 // PrevDecl is a namespace. 1916 if (isDeclInScope(PrevDecl, CurContext, S)) { 1917 // The tag name clashes with a namespace name, issue an error and 1918 // recover by making this tag be anonymous. 1919 Diag(NameLoc, diag::err_redefinition_different_kind, Name->getName()); 1920 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 1921 Name = 0; 1922 } 1923 } 1924 } 1925 1926 // If there is an identifier, use the location of the identifier as the 1927 // location of the decl, otherwise use the location of the struct/union 1928 // keyword. 1929 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 1930 1931 // Otherwise, if this is the first time we've seen this tag, create the decl. 1932 TagDecl *New; 1933 if (Kind == TagDecl::TK_enum) { 1934 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 1935 // enum X { A, B, C } D; D should chain to X. 1936 New = EnumDecl::Create(Context, CurContext, Loc, Name, 0); 1937 // If this is an undefined enum, warn. 1938 if (TK != TK_Definition) Diag(Loc, diag::ext_forward_ref_enum); 1939 } else { 1940 // struct/union/class 1941 1942 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 1943 // struct X { int A; } D; D should chain to X. 1944 if (getLangOptions().CPlusPlus) 1945 // FIXME: Look for a way to use RecordDecl for simple structs. 1946 New = CXXRecordDecl::Create(Context, Kind, CurContext, Loc, Name); 1947 else 1948 New = RecordDecl::Create(Context, Kind, CurContext, Loc, Name); 1949 } 1950 1951 // If this has an identifier, add it to the scope stack. 1952 if (Name) { 1953 // The scope passed in may not be a decl scope. Zip up the scope tree until 1954 // we find one that is. 1955 while ((S->getFlags() & Scope::DeclScope) == 0) 1956 S = S->getParent(); 1957 1958 // Add it to the decl chain. 1959 PushOnScopeChains(New, S); 1960 } 1961 1962 if (Attr) 1963 ProcessDeclAttributeList(New, Attr); 1964 return New; 1965} 1966 1967/// ActOnTagStruct - New "ActOnTag" logic for structs/unions/classes. Unlike 1968/// the logic for enums, we create separate decls for forward declarations. 1969/// This is called by ActOnTag, but eventually will replace its logic. 1970Sema::DeclTy *Sema::ActOnTagStruct(Scope *S, TagDecl::TagKind Kind, TagKind TK, 1971 SourceLocation KWLoc, IdentifierInfo *Name, 1972 SourceLocation NameLoc, AttributeList *Attr) { 1973 1974 // If this is a named struct, check to see if there was a previous forward 1975 // declaration or definition. 1976 // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up. 1977 ScopedDecl *PrevDecl = 1978 dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag, S)); 1979 1980 if (PrevDecl) { 1981 assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) && 1982 "unexpected Decl type"); 1983 1984 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 1985 // If this is a use of a previous tag, or if the tag is already declared 1986 // in the same scope (so that the definition/declaration completes or 1987 // rementions the tag), reuse the decl. 1988 if (TK == TK_Reference || isDeclInScope(PrevDecl, CurContext, S)) { 1989 // Make sure that this wasn't declared as an enum and now used as a 1990 // struct or something similar. 1991 if (PrevTagDecl->getTagKind() != Kind) { 1992 Diag(KWLoc, diag::err_use_with_wrong_tag, Name->getName()); 1993 Diag(PrevDecl->getLocation(), diag::err_previous_use); 1994 // Recover by making this an anonymous redefinition. 1995 Name = 0; 1996 PrevDecl = 0; 1997 } else { 1998 // If this is a use, return the original decl. 1999 2000 // FIXME: In the future, return a variant or some other clue 2001 // for the consumer of this Decl to know it doesn't own it. 2002 // For our current ASTs this shouldn't be a problem, but will 2003 // need to be changed with DeclGroups. 2004 if (TK == TK_Reference) 2005 return PrevDecl; 2006 2007 // The new decl is a definition? 2008 if (TK == TK_Definition) { 2009 // Diagnose attempts to redefine a tag. 2010 if (RecordDecl* DefRecord = 2011 cast<RecordDecl>(PrevTagDecl)->getDefinition(Context)) { 2012 Diag(NameLoc, diag::err_redefinition, Name->getName()); 2013 Diag(DefRecord->getLocation(), diag::err_previous_definition); 2014 // If this is a redefinition, recover by making this struct be 2015 // anonymous, which will make any later references get the previous 2016 // definition. 2017 Name = 0; 2018 PrevDecl = 0; 2019 } 2020 // Okay, this is definition of a previously declared or referenced 2021 // tag. We're going to create a new Decl. 2022 } 2023 } 2024 // If we get here we have (another) forward declaration. Just create 2025 // a new decl. 2026 } 2027 else { 2028 // If we get here, this is a definition of a new struct type in a nested 2029 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 2030 // new decl/type. We set PrevDecl to NULL so that the Records 2031 // have distinct types. 2032 PrevDecl = 0; 2033 } 2034 } else { 2035 // PrevDecl is a namespace. 2036 if (isDeclInScope(PrevDecl, CurContext, S)) { 2037 // The tag name clashes with a namespace name, issue an error and 2038 // recover by making this tag be anonymous. 2039 Diag(NameLoc, diag::err_redefinition_different_kind, Name->getName()); 2040 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 2041 Name = 0; 2042 } 2043 } 2044 } 2045 2046 // If there is an identifier, use the location of the identifier as the 2047 // location of the decl, otherwise use the location of the struct/union 2048 // keyword. 2049 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 2050 2051 // Otherwise, if this is the first time we've seen this tag, create the decl. 2052 TagDecl *New; 2053 2054 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 2055 // struct X { int A; } D; D should chain to X. 2056 if (getLangOptions().CPlusPlus) 2057 // FIXME: Look for a way to use RecordDecl for simple structs. 2058 New = CXXRecordDecl::Create(Context, Kind, CurContext, Loc, Name, 2059 dyn_cast_or_null<CXXRecordDecl>(PrevDecl)); 2060 else 2061 New = RecordDecl::Create(Context, Kind, CurContext, Loc, Name, 2062 dyn_cast_or_null<RecordDecl>(PrevDecl)); 2063 2064 // If this has an identifier, add it to the scope stack. 2065 if ((TK == TK_Definition || !PrevDecl) && Name) { 2066 // The scope passed in may not be a decl scope. Zip up the scope tree until 2067 // we find one that is. 2068 while ((S->getFlags() & Scope::DeclScope) == 0) 2069 S = S->getParent(); 2070 2071 // Add it to the decl chain. 2072 PushOnScopeChains(New, S); 2073 } 2074 2075 // Handle #pragma pack: if the #pragma pack stack has non-default 2076 // alignment, make up a packed attribute for this decl. These 2077 // attributes are checked when the ASTContext lays out the 2078 // structure. 2079 // 2080 // It is important for implementing the correct semantics that this 2081 // happen here (in act on tag decl). The #pragma pack stack is 2082 // maintained as a result of parser callbacks which can occur at 2083 // many points during the parsing of a struct declaration (because 2084 // the #pragma tokens are effectively skipped over during the 2085 // parsing of the struct). 2086 if (unsigned Alignment = PackContext.getAlignment()) 2087 New->addAttr(new PackedAttr(Alignment * 8)); 2088 2089 if (Attr) 2090 ProcessDeclAttributeList(New, Attr); 2091 2092 return New; 2093} 2094 2095 2096/// Collect the instance variables declared in an Objective-C object. Used in 2097/// the creation of structures from objects using the @defs directive. 2098static void CollectIvars(ObjCInterfaceDecl *Class, ASTContext& Ctx, 2099 llvm::SmallVectorImpl<Sema::DeclTy*> &ivars) { 2100 if (Class->getSuperClass()) 2101 CollectIvars(Class->getSuperClass(), Ctx, ivars); 2102 2103 // For each ivar, create a fresh ObjCAtDefsFieldDecl. 2104 for (ObjCInterfaceDecl::ivar_iterator 2105 I=Class->ivar_begin(), E=Class->ivar_end(); I!=E; ++I) { 2106 2107 ObjCIvarDecl* ID = *I; 2108 ivars.push_back(ObjCAtDefsFieldDecl::Create(Ctx, ID->getLocation(), 2109 ID->getIdentifier(), 2110 ID->getType(), 2111 ID->getBitWidth())); 2112 } 2113} 2114 2115/// Called whenever @defs(ClassName) is encountered in the source. Inserts the 2116/// instance variables of ClassName into Decls. 2117void Sema::ActOnDefs(Scope *S, SourceLocation DeclStart, 2118 IdentifierInfo *ClassName, 2119 llvm::SmallVectorImpl<DeclTy*> &Decls) { 2120 // Check that ClassName is a valid class 2121 ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName); 2122 if (!Class) { 2123 Diag(DeclStart, diag::err_undef_interface, ClassName->getName()); 2124 return; 2125 } 2126 // Collect the instance variables 2127 CollectIvars(Class, Context, Decls); 2128} 2129 2130QualType Sema::TryFixInvalidVariablyModifiedType(QualType T) { 2131 // This method tries to turn a variable array into a constant 2132 // array even when the size isn't an ICE. This is necessary 2133 // for compatibility with code that depends on gcc's buggy 2134 // constant expression folding, like struct {char x[(int)(char*)2];} 2135 if (const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T)) { 2136 APValue Result; 2137 if (VLATy->getSizeExpr() && 2138 VLATy->getSizeExpr()->tryEvaluate(Result, Context) && Result.isInt()) { 2139 llvm::APSInt &Res = Result.getInt(); 2140 if (Res > llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) 2141 return Context.getConstantArrayType(VLATy->getElementType(), 2142 Res, ArrayType::Normal, 0); 2143 } 2144 } 2145 return QualType(); 2146} 2147 2148/// ActOnField - Each field of a struct/union/class is passed into this in order 2149/// to create a FieldDecl object for it. 2150Sema::DeclTy *Sema::ActOnField(Scope *S, 2151 SourceLocation DeclStart, 2152 Declarator &D, ExprTy *BitfieldWidth) { 2153 IdentifierInfo *II = D.getIdentifier(); 2154 Expr *BitWidth = (Expr*)BitfieldWidth; 2155 SourceLocation Loc = DeclStart; 2156 if (II) Loc = D.getIdentifierLoc(); 2157 2158 // FIXME: Unnamed fields can be handled in various different ways, for 2159 // example, unnamed unions inject all members into the struct namespace! 2160 2161 if (BitWidth) { 2162 // TODO: Validate. 2163 //printf("WARNING: BITFIELDS IGNORED!\n"); 2164 2165 // 6.7.2.1p3 2166 // 6.7.2.1p4 2167 2168 } else { 2169 // Not a bitfield. 2170 2171 // validate II. 2172 2173 } 2174 2175 QualType T = GetTypeForDeclarator(D, S); 2176 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 2177 bool InvalidDecl = false; 2178 2179 // C99 6.7.2.1p8: A member of a structure or union may have any type other 2180 // than a variably modified type. 2181 if (T->isVariablyModifiedType()) { 2182 QualType FixedTy = TryFixInvalidVariablyModifiedType(T); 2183 if (!FixedTy.isNull()) { 2184 Diag(Loc, diag::warn_illegal_constant_array_size, Loc); 2185 T = FixedTy; 2186 } else { 2187 // FIXME: This diagnostic needs work 2188 Diag(Loc, diag::err_typecheck_illegal_vla, Loc); 2189 InvalidDecl = true; 2190 } 2191 } 2192 // FIXME: Chain fielddecls together. 2193 FieldDecl *NewFD; 2194 2195 if (getLangOptions().CPlusPlus) { 2196 // FIXME: Replace CXXFieldDecls with FieldDecls for simple structs. 2197 NewFD = CXXFieldDecl::Create(Context, cast<CXXRecordDecl>(CurContext), 2198 Loc, II, T, BitWidth); 2199 if (II) 2200 PushOnScopeChains(NewFD, S); 2201 } 2202 else 2203 NewFD = FieldDecl::Create(Context, Loc, II, T, BitWidth); 2204 2205 ProcessDeclAttributes(NewFD, D); 2206 2207 if (D.getInvalidType() || InvalidDecl) 2208 NewFD->setInvalidDecl(); 2209 return NewFD; 2210} 2211 2212/// TranslateIvarVisibility - Translate visibility from a token ID to an 2213/// AST enum value. 2214static ObjCIvarDecl::AccessControl 2215TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 2216 switch (ivarVisibility) { 2217 default: assert(0 && "Unknown visitibility kind"); 2218 case tok::objc_private: return ObjCIvarDecl::Private; 2219 case tok::objc_public: return ObjCIvarDecl::Public; 2220 case tok::objc_protected: return ObjCIvarDecl::Protected; 2221 case tok::objc_package: return ObjCIvarDecl::Package; 2222 } 2223} 2224 2225/// ActOnIvar - Each ivar field of an objective-c class is passed into this 2226/// in order to create an IvarDecl object for it. 2227Sema::DeclTy *Sema::ActOnIvar(Scope *S, 2228 SourceLocation DeclStart, 2229 Declarator &D, ExprTy *BitfieldWidth, 2230 tok::ObjCKeywordKind Visibility) { 2231 IdentifierInfo *II = D.getIdentifier(); 2232 Expr *BitWidth = (Expr*)BitfieldWidth; 2233 SourceLocation Loc = DeclStart; 2234 if (II) Loc = D.getIdentifierLoc(); 2235 2236 // FIXME: Unnamed fields can be handled in various different ways, for 2237 // example, unnamed unions inject all members into the struct namespace! 2238 2239 2240 if (BitWidth) { 2241 // TODO: Validate. 2242 //printf("WARNING: BITFIELDS IGNORED!\n"); 2243 2244 // 6.7.2.1p3 2245 // 6.7.2.1p4 2246 2247 } else { 2248 // Not a bitfield. 2249 2250 // validate II. 2251 2252 } 2253 2254 QualType T = GetTypeForDeclarator(D, S); 2255 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 2256 bool InvalidDecl = false; 2257 2258 // C99 6.7.2.1p8: A member of a structure or union may have any type other 2259 // than a variably modified type. 2260 if (T->isVariablyModifiedType()) { 2261 // FIXME: This diagnostic needs work 2262 Diag(Loc, diag::err_typecheck_illegal_vla, Loc); 2263 InvalidDecl = true; 2264 } 2265 2266 // Get the visibility (access control) for this ivar. 2267 ObjCIvarDecl::AccessControl ac = 2268 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 2269 : ObjCIvarDecl::None; 2270 2271 // Construct the decl. 2272 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, Loc, II, T, ac, 2273 (Expr *)BitfieldWidth); 2274 2275 // Process attributes attached to the ivar. 2276 ProcessDeclAttributes(NewID, D); 2277 2278 if (D.getInvalidType() || InvalidDecl) 2279 NewID->setInvalidDecl(); 2280 2281 return NewID; 2282} 2283 2284void Sema::ActOnFields(Scope* S, 2285 SourceLocation RecLoc, DeclTy *RecDecl, 2286 DeclTy **Fields, unsigned NumFields, 2287 SourceLocation LBrac, SourceLocation RBrac, 2288 AttributeList *Attr) { 2289 Decl *EnclosingDecl = static_cast<Decl*>(RecDecl); 2290 assert(EnclosingDecl && "missing record or interface decl"); 2291 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 2292 2293 if (Record) 2294 if (RecordDecl* DefRecord = Record->getDefinition(Context)) { 2295 // Diagnose code like: 2296 // struct S { struct S {} X; }; 2297 // We discover this when we complete the outer S. Reject and ignore the 2298 // outer S. 2299 Diag(DefRecord->getLocation(), diag::err_nested_redefinition, 2300 DefRecord->getKindName()); 2301 Diag(RecLoc, diag::err_previous_definition); 2302 Record->setInvalidDecl(); 2303 return; 2304 } 2305 2306 // Verify that all the fields are okay. 2307 unsigned NumNamedMembers = 0; 2308 llvm::SmallVector<FieldDecl*, 32> RecFields; 2309 llvm::SmallSet<const IdentifierInfo*, 32> FieldIDs; 2310 2311 for (unsigned i = 0; i != NumFields; ++i) { 2312 2313 FieldDecl *FD = cast_or_null<FieldDecl>(static_cast<Decl*>(Fields[i])); 2314 assert(FD && "missing field decl"); 2315 2316 // Remember all fields. 2317 RecFields.push_back(FD); 2318 2319 // Get the type for the field. 2320 Type *FDTy = FD->getType().getTypePtr(); 2321 2322 // C99 6.7.2.1p2 - A field may not be a function type. 2323 if (FDTy->isFunctionType()) { 2324 Diag(FD->getLocation(), diag::err_field_declared_as_function, 2325 FD->getName()); 2326 FD->setInvalidDecl(); 2327 EnclosingDecl->setInvalidDecl(); 2328 continue; 2329 } 2330 // C99 6.7.2.1p2 - A field may not be an incomplete type except... 2331 if (FDTy->isIncompleteType()) { 2332 if (!Record) { // Incomplete ivar type is always an error. 2333 Diag(FD->getLocation(), diag::err_field_incomplete, FD->getName()); 2334 FD->setInvalidDecl(); 2335 EnclosingDecl->setInvalidDecl(); 2336 continue; 2337 } 2338 if (i != NumFields-1 || // ... that the last member ... 2339 !Record->isStruct() || // ... of a structure ... 2340 !FDTy->isArrayType()) { //... may have incomplete array type. 2341 Diag(FD->getLocation(), diag::err_field_incomplete, FD->getName()); 2342 FD->setInvalidDecl(); 2343 EnclosingDecl->setInvalidDecl(); 2344 continue; 2345 } 2346 if (NumNamedMembers < 1) { //... must have more than named member ... 2347 Diag(FD->getLocation(), diag::err_flexible_array_empty_struct, 2348 FD->getName()); 2349 FD->setInvalidDecl(); 2350 EnclosingDecl->setInvalidDecl(); 2351 continue; 2352 } 2353 // Okay, we have a legal flexible array member at the end of the struct. 2354 if (Record) 2355 Record->setHasFlexibleArrayMember(true); 2356 } 2357 /// C99 6.7.2.1p2 - a struct ending in a flexible array member cannot be the 2358 /// field of another structure or the element of an array. 2359 if (const RecordType *FDTTy = FDTy->getAsRecordType()) { 2360 if (FDTTy->getDecl()->hasFlexibleArrayMember()) { 2361 // If this is a member of a union, then entire union becomes "flexible". 2362 if (Record && Record->isUnion()) { 2363 Record->setHasFlexibleArrayMember(true); 2364 } else { 2365 // If this is a struct/class and this is not the last element, reject 2366 // it. Note that GCC supports variable sized arrays in the middle of 2367 // structures. 2368 if (i != NumFields-1) { 2369 Diag(FD->getLocation(), diag::err_variable_sized_type_in_struct, 2370 FD->getName()); 2371 FD->setInvalidDecl(); 2372 EnclosingDecl->setInvalidDecl(); 2373 continue; 2374 } 2375 // We support flexible arrays at the end of structs in other structs 2376 // as an extension. 2377 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct, 2378 FD->getName()); 2379 if (Record) 2380 Record->setHasFlexibleArrayMember(true); 2381 } 2382 } 2383 } 2384 /// A field cannot be an Objective-c object 2385 if (FDTy->isObjCInterfaceType()) { 2386 Diag(FD->getLocation(), diag::err_statically_allocated_object, 2387 FD->getName()); 2388 FD->setInvalidDecl(); 2389 EnclosingDecl->setInvalidDecl(); 2390 continue; 2391 } 2392 // Keep track of the number of named members. 2393 if (IdentifierInfo *II = FD->getIdentifier()) { 2394 // Detect duplicate member names. 2395 if (!FieldIDs.insert(II)) { 2396 Diag(FD->getLocation(), diag::err_duplicate_member, II->getName()); 2397 // Find the previous decl. 2398 SourceLocation PrevLoc; 2399 for (unsigned i = 0; ; ++i) { 2400 assert(i != RecFields.size() && "Didn't find previous def!"); 2401 if (RecFields[i]->getIdentifier() == II) { 2402 PrevLoc = RecFields[i]->getLocation(); 2403 break; 2404 } 2405 } 2406 Diag(PrevLoc, diag::err_previous_definition); 2407 FD->setInvalidDecl(); 2408 EnclosingDecl->setInvalidDecl(); 2409 continue; 2410 } 2411 ++NumNamedMembers; 2412 } 2413 } 2414 2415 // Okay, we successfully defined 'Record'. 2416 if (Record) { 2417 Record->defineBody(Context, &RecFields[0], RecFields.size()); 2418 // If this is a C++ record, HandleTagDeclDefinition will be invoked in 2419 // Sema::ActOnFinishCXXClassDef. 2420 if (!isa<CXXRecordDecl>(Record)) 2421 Consumer.HandleTagDeclDefinition(Record); 2422 } else { 2423 ObjCIvarDecl **ClsFields = reinterpret_cast<ObjCIvarDecl**>(&RecFields[0]); 2424 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) 2425 ID->addInstanceVariablesToClass(ClsFields, RecFields.size(), RBrac); 2426 else if (ObjCImplementationDecl *IMPDecl = 2427 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 2428 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 2429 IMPDecl->ObjCAddInstanceVariablesToClassImpl(ClsFields, RecFields.size()); 2430 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 2431 } 2432 } 2433 2434 if (Attr) 2435 ProcessDeclAttributeList(Record, Attr); 2436} 2437 2438Sema::DeclTy *Sema::ActOnEnumConstant(Scope *S, DeclTy *theEnumDecl, 2439 DeclTy *lastEnumConst, 2440 SourceLocation IdLoc, IdentifierInfo *Id, 2441 SourceLocation EqualLoc, ExprTy *val) { 2442 EnumDecl *TheEnumDecl = cast<EnumDecl>(static_cast<Decl*>(theEnumDecl)); 2443 EnumConstantDecl *LastEnumConst = 2444 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(lastEnumConst)); 2445 Expr *Val = static_cast<Expr*>(val); 2446 2447 // The scope passed in may not be a decl scope. Zip up the scope tree until 2448 // we find one that is. 2449 while ((S->getFlags() & Scope::DeclScope) == 0) 2450 S = S->getParent(); 2451 2452 // Verify that there isn't already something declared with this name in this 2453 // scope. 2454 if (Decl *PrevDecl = LookupDecl(Id, Decl::IDNS_Ordinary, S)) { 2455 // When in C++, we may get a TagDecl with the same name; in this case the 2456 // enum constant will 'hide' the tag. 2457 assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 2458 "Received TagDecl when not in C++!"); 2459 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 2460 if (isa<EnumConstantDecl>(PrevDecl)) 2461 Diag(IdLoc, diag::err_redefinition_of_enumerator, Id->getName()); 2462 else 2463 Diag(IdLoc, diag::err_redefinition, Id->getName()); 2464 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 2465 delete Val; 2466 return 0; 2467 } 2468 } 2469 2470 llvm::APSInt EnumVal(32); 2471 QualType EltTy; 2472 if (Val) { 2473 // Make sure to promote the operand type to int. 2474 UsualUnaryConversions(Val); 2475 2476 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 2477 SourceLocation ExpLoc; 2478 if (!Val->isIntegerConstantExpr(EnumVal, Context, &ExpLoc)) { 2479 Diag(ExpLoc, diag::err_enum_value_not_integer_constant_expr, 2480 Id->getName()); 2481 delete Val; 2482 Val = 0; // Just forget about it. 2483 } else { 2484 EltTy = Val->getType(); 2485 } 2486 } 2487 2488 if (!Val) { 2489 if (LastEnumConst) { 2490 // Assign the last value + 1. 2491 EnumVal = LastEnumConst->getInitVal(); 2492 ++EnumVal; 2493 2494 // Check for overflow on increment. 2495 if (EnumVal < LastEnumConst->getInitVal()) 2496 Diag(IdLoc, diag::warn_enum_value_overflow); 2497 2498 EltTy = LastEnumConst->getType(); 2499 } else { 2500 // First value, set to zero. 2501 EltTy = Context.IntTy; 2502 EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy))); 2503 } 2504 } 2505 2506 EnumConstantDecl *New = 2507 EnumConstantDecl::Create(Context, TheEnumDecl, IdLoc, Id, EltTy, 2508 Val, EnumVal, 2509 LastEnumConst); 2510 2511 // Register this decl in the current scope stack. 2512 PushOnScopeChains(New, S); 2513 return New; 2514} 2515 2516// FIXME: For consistency with ActOnFields(), we should have the parser 2517// pass in the source location for the left/right braces. 2518void Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX, 2519 DeclTy **Elements, unsigned NumElements) { 2520 EnumDecl *Enum = cast<EnumDecl>(static_cast<Decl*>(EnumDeclX)); 2521 2522 if (Enum && Enum->isDefinition()) { 2523 // Diagnose code like: 2524 // enum e0 { 2525 // E0 = sizeof(enum e0 { E1 }) 2526 // }; 2527 Diag(Enum->getLocation(), diag::err_nested_redefinition, 2528 Enum->getName()); 2529 Diag(EnumLoc, diag::err_previous_definition); 2530 Enum->setInvalidDecl(); 2531 return; 2532 } 2533 // TODO: If the result value doesn't fit in an int, it must be a long or long 2534 // long value. ISO C does not support this, but GCC does as an extension, 2535 // emit a warning. 2536 unsigned IntWidth = Context.Target.getIntWidth(); 2537 2538 // Verify that all the values are okay, compute the size of the values, and 2539 // reverse the list. 2540 unsigned NumNegativeBits = 0; 2541 unsigned NumPositiveBits = 0; 2542 2543 // Keep track of whether all elements have type int. 2544 bool AllElementsInt = true; 2545 2546 EnumConstantDecl *EltList = 0; 2547 for (unsigned i = 0; i != NumElements; ++i) { 2548 EnumConstantDecl *ECD = 2549 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i])); 2550 if (!ECD) continue; // Already issued a diagnostic. 2551 2552 // If the enum value doesn't fit in an int, emit an extension warning. 2553 const llvm::APSInt &InitVal = ECD->getInitVal(); 2554 assert(InitVal.getBitWidth() >= IntWidth && 2555 "Should have promoted value to int"); 2556 if (InitVal.getBitWidth() > IntWidth) { 2557 llvm::APSInt V(InitVal); 2558 V.trunc(IntWidth); 2559 V.extend(InitVal.getBitWidth()); 2560 if (V != InitVal) 2561 Diag(ECD->getLocation(), diag::ext_enum_value_not_int, 2562 InitVal.toString(10)); 2563 } 2564 2565 // Keep track of the size of positive and negative values. 2566 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 2567 NumPositiveBits = std::max(NumPositiveBits, 2568 (unsigned)InitVal.getActiveBits()); 2569 else 2570 NumNegativeBits = std::max(NumNegativeBits, 2571 (unsigned)InitVal.getMinSignedBits()); 2572 2573 // Keep track of whether every enum element has type int (very commmon). 2574 if (AllElementsInt) 2575 AllElementsInt = ECD->getType() == Context.IntTy; 2576 2577 ECD->setNextDeclarator(EltList); 2578 EltList = ECD; 2579 } 2580 2581 // Figure out the type that should be used for this enum. 2582 // FIXME: Support attribute(packed) on enums and -fshort-enums. 2583 QualType BestType; 2584 unsigned BestWidth; 2585 2586 if (NumNegativeBits) { 2587 // If there is a negative value, figure out the smallest integer type (of 2588 // int/long/longlong) that fits. 2589 if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 2590 BestType = Context.IntTy; 2591 BestWidth = IntWidth; 2592 } else { 2593 BestWidth = Context.Target.getLongWidth(); 2594 2595 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) 2596 BestType = Context.LongTy; 2597 else { 2598 BestWidth = Context.Target.getLongLongWidth(); 2599 2600 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 2601 Diag(Enum->getLocation(), diag::warn_enum_too_large); 2602 BestType = Context.LongLongTy; 2603 } 2604 } 2605 } else { 2606 // If there is no negative value, figure out which of uint, ulong, ulonglong 2607 // fits. 2608 if (NumPositiveBits <= IntWidth) { 2609 BestType = Context.UnsignedIntTy; 2610 BestWidth = IntWidth; 2611 } else if (NumPositiveBits <= 2612 (BestWidth = Context.Target.getLongWidth())) { 2613 BestType = Context.UnsignedLongTy; 2614 } else { 2615 BestWidth = Context.Target.getLongLongWidth(); 2616 assert(NumPositiveBits <= BestWidth && 2617 "How could an initializer get larger than ULL?"); 2618 BestType = Context.UnsignedLongLongTy; 2619 } 2620 } 2621 2622 // Loop over all of the enumerator constants, changing their types to match 2623 // the type of the enum if needed. 2624 for (unsigned i = 0; i != NumElements; ++i) { 2625 EnumConstantDecl *ECD = 2626 cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i])); 2627 if (!ECD) continue; // Already issued a diagnostic. 2628 2629 // Standard C says the enumerators have int type, but we allow, as an 2630 // extension, the enumerators to be larger than int size. If each 2631 // enumerator value fits in an int, type it as an int, otherwise type it the 2632 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 2633 // that X has type 'int', not 'unsigned'. 2634 if (ECD->getType() == Context.IntTy) { 2635 // Make sure the init value is signed. 2636 llvm::APSInt IV = ECD->getInitVal(); 2637 IV.setIsSigned(true); 2638 ECD->setInitVal(IV); 2639 continue; // Already int type. 2640 } 2641 2642 // Determine whether the value fits into an int. 2643 llvm::APSInt InitVal = ECD->getInitVal(); 2644 bool FitsInInt; 2645 if (InitVal.isUnsigned() || !InitVal.isNegative()) 2646 FitsInInt = InitVal.getActiveBits() < IntWidth; 2647 else 2648 FitsInInt = InitVal.getMinSignedBits() <= IntWidth; 2649 2650 // If it fits into an integer type, force it. Otherwise force it to match 2651 // the enum decl type. 2652 QualType NewTy; 2653 unsigned NewWidth; 2654 bool NewSign; 2655 if (FitsInInt) { 2656 NewTy = Context.IntTy; 2657 NewWidth = IntWidth; 2658 NewSign = true; 2659 } else if (ECD->getType() == BestType) { 2660 // Already the right type! 2661 continue; 2662 } else { 2663 NewTy = BestType; 2664 NewWidth = BestWidth; 2665 NewSign = BestType->isSignedIntegerType(); 2666 } 2667 2668 // Adjust the APSInt value. 2669 InitVal.extOrTrunc(NewWidth); 2670 InitVal.setIsSigned(NewSign); 2671 ECD->setInitVal(InitVal); 2672 2673 // Adjust the Expr initializer and type. 2674 ECD->setInitExpr(new ImplicitCastExpr(NewTy, ECD->getInitExpr())); 2675 ECD->setType(NewTy); 2676 } 2677 2678 Enum->defineElements(EltList, BestType); 2679 Consumer.HandleTagDeclDefinition(Enum); 2680} 2681 2682Sema::DeclTy *Sema::ActOnFileScopeAsmDecl(SourceLocation Loc, 2683 ExprTy *expr) { 2684 StringLiteral *AsmString = cast<StringLiteral>((Expr*)expr); 2685 2686 return FileScopeAsmDecl::Create(Context, Loc, AsmString); 2687} 2688 2689Sema::DeclTy* Sema::ActOnLinkageSpec(SourceLocation Loc, 2690 SourceLocation LBrace, 2691 SourceLocation RBrace, 2692 const char *Lang, 2693 unsigned StrSize, 2694 DeclTy *D) { 2695 LinkageSpecDecl::LanguageIDs Language; 2696 Decl *dcl = static_cast<Decl *>(D); 2697 if (strncmp(Lang, "\"C\"", StrSize) == 0) 2698 Language = LinkageSpecDecl::lang_c; 2699 else if (strncmp(Lang, "\"C++\"", StrSize) == 0) 2700 Language = LinkageSpecDecl::lang_cxx; 2701 else { 2702 Diag(Loc, diag::err_bad_language); 2703 return 0; 2704 } 2705 2706 // FIXME: Add all the various semantics of linkage specifications 2707 return LinkageSpecDecl::Create(Context, Loc, Language, dcl); 2708} 2709 2710void Sema::ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name, 2711 ExprTy *alignment, SourceLocation PragmaLoc, 2712 SourceLocation LParenLoc, SourceLocation RParenLoc) { 2713 Expr *Alignment = static_cast<Expr *>(alignment); 2714 2715 // If specified then alignment must be a "small" power of two. 2716 unsigned AlignmentVal = 0; 2717 if (Alignment) { 2718 llvm::APSInt Val; 2719 if (!Alignment->isIntegerConstantExpr(Val, Context) || 2720 !Val.isPowerOf2() || 2721 Val.getZExtValue() > 16) { 2722 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment); 2723 delete Alignment; 2724 return; // Ignore 2725 } 2726 2727 AlignmentVal = (unsigned) Val.getZExtValue(); 2728 } 2729 2730 switch (Kind) { 2731 case Action::PPK_Default: // pack([n]) 2732 PackContext.setAlignment(AlignmentVal); 2733 break; 2734 2735 case Action::PPK_Show: // pack(show) 2736 // Show the current alignment, making sure to show the right value 2737 // for the default. 2738 AlignmentVal = PackContext.getAlignment(); 2739 // FIXME: This should come from the target. 2740 if (AlignmentVal == 0) 2741 AlignmentVal = 8; 2742 Diag(PragmaLoc, diag::warn_pragma_pack_show, llvm::utostr(AlignmentVal)); 2743 break; 2744 2745 case Action::PPK_Push: // pack(push [, id] [, [n]) 2746 PackContext.push(Name); 2747 // Set the new alignment if specified. 2748 if (Alignment) 2749 PackContext.setAlignment(AlignmentVal); 2750 break; 2751 2752 case Action::PPK_Pop: // pack(pop [, id] [, n]) 2753 // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: 2754 // "#pragma pack(pop, identifier, n) is undefined" 2755 if (Alignment && Name) 2756 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment); 2757 2758 // Do the pop. 2759 if (!PackContext.pop(Name)) { 2760 // If a name was specified then failure indicates the name 2761 // wasn't found. Otherwise failure indicates the stack was 2762 // empty. 2763 Diag(PragmaLoc, diag::warn_pragma_pack_pop_failed, 2764 Name ? "no record matching name" : "stack empty"); 2765 2766 // FIXME: Warn about popping named records as MSVC does. 2767 } else { 2768 // Pop succeeded, set the new alignment if specified. 2769 if (Alignment) 2770 PackContext.setAlignment(AlignmentVal); 2771 } 2772 break; 2773 2774 default: 2775 assert(0 && "Invalid #pragma pack kind."); 2776 } 2777} 2778 2779bool PragmaPackStack::pop(IdentifierInfo *Name) { 2780 if (Stack.empty()) 2781 return false; 2782 2783 // If name is empty just pop top. 2784 if (!Name) { 2785 Alignment = Stack.back().first; 2786 Stack.pop_back(); 2787 return true; 2788 } 2789 2790 // Otherwise, find the named record. 2791 for (unsigned i = Stack.size(); i != 0; ) { 2792 --i; 2793 if (strcmp(Stack[i].second.c_str(), Name->getName()) == 0) { 2794 // Found it, pop up to and including this record. 2795 Alignment = Stack[i].first; 2796 Stack.erase(Stack.begin() + i, Stack.end()); 2797 return true; 2798 } 2799 } 2800 2801 return false; 2802} 2803