SemaDecl.cpp revision ff9eb1fe0a16a34c355db0d1bc4a9d0f7a276c73
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// 1094b9550a32d189704a8eae55505edf62662c0534Evan Cheng// This file implements semantic analysis for declarations. 11ee04a6d3a40c3017124e3fd89a0db473a2824498Evan Cheng// 12ee04a6d3a40c3017124e3fd89a0db473a2824498Evan Cheng//===----------------------------------------------------------------------===// 13c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner 14c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "Sema.h" 15c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "clang/AST/APValue.h" 166469540adf63d94a876c2b623cb4ca70479647f7Rafael Espindola#include "clang/AST/ASTConsumer.h" 17642fc9c24ba7c43a4a962c6c05cfffce713d7de7Jim Grosbach#include "clang/AST/ASTContext.h" 18ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "clang/AST/Attr.h" 19ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "clang/AST/Builtins.h" 20ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby#include "clang/AST/Decl.h" 217801136b95d1fbe515b9655b73ada39b05a33559Evan Cheng#include "clang/AST/DeclCXX.h" 2294b9550a32d189704a8eae55505edf62662c0534Evan Cheng#include "clang/AST/Expr.h" 23ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng#include "clang/AST/ExprCXX.h" 2494b9550a32d189704a8eae55505edf62662c0534Evan Cheng#include "clang/AST/Type.h" 2589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach#include "clang/Parse/DeclSpec.h" 26c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "clang/Parse/Scope.h" 273e74d6fdd248e20a280f1dff3da9a6c689c2c4c3Evan Cheng#include "clang/Basic/LangOptions.h" 28fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar#include "clang/Basic/TargetInfo.h" 2911e03e7c2d0c163e54b911ad1e665616dc0bcc8cJim Grosbach#include "clang/Basic/SourceManager.h" 3075ca4b94bd9dcd3952fdc237429342a2154ba142Benjamin Kramer// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's) 3194b9550a32d189704a8eae55505edf62662c0534Evan Cheng#include "clang/Lex/Preprocessor.h" 32c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "clang/Lex/HeaderSearch.h" 330c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson#include "llvm/ADT/SmallString.h" 34345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar#include "llvm/ADT/SmallSet.h" 35c6ef277a0b8f43af22d86aea9d5053749cacfbbbChris Lattner#include "llvm/ADT/DenseSet.h" 36ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Chengusing namespace clang; 37ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 38ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin EnderbySema::TypeTy *Sema::isTypeName(const IdentifierInfo &II, Scope *S) { 393a69756e392942bc522193f38d7f33958ed3b131Chris Lattner Decl *IIDecl = LookupDecl(&II, Decl::IDNS_Ordinary, S, false); 40146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling 41146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling if (IIDecl && (isa<TypedefDecl>(IIDecl) || 4216c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach isa<ObjCInterfaceDecl>(IIDecl) || 4394b9550a32d189704a8eae55505edf62662c0534Evan Cheng isa<TagDecl>(IIDecl))) 44ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng return IIDecl; 45ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby return 0; 46ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 47f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach 48f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim GrosbachDeclContext *Sema::getDCParent(DeclContext *DC) { 49f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach // If CurContext is a ObjC method, getParent() will return NULL. 50f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach if (isa<ObjCMethodDecl>(DC)) 51f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach return Context.getTranslationUnitDecl(); 52f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach 53f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach // A C++ inline method is parsed *after* the topmost class it was declared in 54f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach // is fully parsed (it's "complete"). 55f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach // The parsing of a C++ inline method happens at the declaration context of 56f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach // the topmost (non-nested) class it is declared in. 57f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) { 58f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach assert(isa<CXXRecordDecl>(MD->getParent()) && "C++ method not in Record."); 59f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach DC = MD->getParent(); 60f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getParent())) 61f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach DC = RD; 62f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach 63f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach // Return the declaration context of the topmost class the inline method is 64f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach // declared in. 65f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach return DC; 66f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach } 67a110988b391652e3f4f85cb709a3eeb81c8cdd84Jim Grosbach 68a110988b391652e3f4f85cb709a3eeb81c8cdd84Jim Grosbach return DC->getParent(); 69a110988b391652e3f4f85cb709a3eeb81c8cdd84Jim Grosbach} 70a110988b391652e3f4f85cb709a3eeb81c8cdd84Jim Grosbach 71a110988b391652e3f4f85cb709a3eeb81c8cdd84Jim Grosbachvoid Sema::PushDeclContext(DeclContext *DC) { 72a110988b391652e3f4f85cb709a3eeb81c8cdd84Jim Grosbach assert(getDCParent(DC) == CurContext && 73a110988b391652e3f4f85cb709a3eeb81c8cdd84Jim Grosbach "The next DeclContext should be directly contained in the current one."); 74a110988b391652e3f4f85cb709a3eeb81c8cdd84Jim Grosbach CurContext = DC; 75f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach} 76f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach 77ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderbyvoid Sema::PopDeclContext() { 78ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby assert(CurContext && "DeclContext imbalance!"); 79ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby CurContext = getDCParent(CurContext); 80ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby} 81ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 82ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby/// Add this decl to the scope shadowed decl chains. 831355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbachvoid Sema::PushOnScopeChains(NamedDecl *D, Scope *S) { 841355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach S->AddDecl(D); 850d87ec21d79c8622733b8367aa41067169602480Jim Grosbach 861355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // C++ [basic.scope]p4: 877ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // -- exactly one declaration shall declare a class name or 881355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // enumeration name that is not a typedef name and the other 891355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // declarations shall all refer to the same object or 907ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // enumerator, or all refer to functions and function templates; 917ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // in this case the class name or enumeration name is hidden. 921355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 931355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // We are pushing the name of a tag (enum or class). 941355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach IdentifierResolver::iterator 951355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach I = IdResolver.begin(TD->getIdentifier(), 961355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach TD->getDeclContext(), false/*LookInParentCtx*/); 97515d509360d81946247fd0f937034cdf1f237c72Kevin Enderby if (I != IdResolver.end() && 981355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach IdResolver.isDeclInScope(*I, TD->getDeclContext(), S)) { 9989df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // There is already a declaration with the same name in the same 10089df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // scope. It must be found before we find the new declaration, 1011355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // so swap the order on the shadowed declaration chain. 102fdcee77887372dbf6589d47cc33094965b679f24Bruno Cardoso Lopes 10316c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach IdResolver.AddShadowedDecl(TD, *I); 104ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng return; 105ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng } 106ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng } 107ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng IdResolver.AddDecl(D); 108ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng} 109ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng 110ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Chengvoid Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 11147a0d52b69056250a1edaca8b28f705993094542Jim Grosbach if (S->decl_empty()) return; 11247a0d52b69056250a1edaca8b28f705993094542Jim Grosbach assert((S->getFlags() & Scope::DeclScope) &&"Scope shouldn't contain decls!"); 11347a0d52b69056250a1edaca8b28f705993094542Jim Grosbach 114194bd8982936c819a4b14335a4d08f28af8f3d42Jim Grosbach for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end(); 115194bd8982936c819a4b14335a4d08f28af8f3d42Jim Grosbach I != E; ++I) { 116194bd8982936c819a4b14335a4d08f28af8f3d42Jim Grosbach Decl *TmpD = static_cast<Decl*>(*I); 11732869205052430f45d598fba25ab878d8b29da2dEvan Cheng assert(TmpD && "This decl didn't get pushed??"); 118ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng 119ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng if (isa<CXXFieldDecl>(TmpD)) continue; 12032869205052430f45d598fba25ab878d8b29da2dEvan Cheng 121ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng assert(isa<ScopedDecl>(TmpD) && "Decl isn't ScopedDecl?"); 122a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby ScopedDecl *D = cast<ScopedDecl>(TmpD); 123a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1243483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar IdentifierInfo *II = D->getIdentifier(); 1250692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner if (!II) continue; 1260692ee676f8cdad25ad09a868bf597af4115c9d9Chris Lattner 127a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // We only want to remove the decls from the identifier decl chains for local 128a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // scopes, when inside a function/method. 129a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (S->getFnParent() != 0) 13089df996ab20609676ecc8823f58414d598b09b46Jim Grosbach IdResolver.RemoveDecl(D); 13143904299b05bdf579415749041f77c4490fe5f5bJim Grosbach 132f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // Chain this decl to the containing DeclContext. 13343904299b05bdf579415749041f77c4490fe5f5bJim Grosbach D->setNext(CurContext->getDeclChain()); 134f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach CurContext->setDeclChain(D); 13543904299b05bdf579415749041f77c4490fe5f5bJim Grosbach } 1368bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes} 13743904299b05bdf579415749041f77c4490fe5f5bJim Grosbach 1388bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso Lopes/// getObjCInterfaceDecl - Look up a for a class declaration in the scope. 13943904299b05bdf579415749041f77c4490fe5f5bJim Grosbach/// return 0 if one not found. 1408bba1a5ef0f8a71de2e58c7f05b8714a73464ca8Bruno Cardoso LopesObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *Id) { 141f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // The third "scope" argument is 0 since we aren't enabling lazy built-in 142f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // creation from this context. 143f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Decl *IDecl = LookupDecl(Id, Decl::IDNS_Ordinary, 0, false); 144f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 145f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 146f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach} 147f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 148f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach/// LookupDecl - Look up the inner-most declaration in the specified 149c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach/// namespace. 150580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim GrosbachDecl *Sema::LookupDecl(const IdentifierInfo *II, unsigned NSI, 1517e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Scope *S, bool enableLazyBuiltinCreation) { 152293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (II == 0) return 0; 1537ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach unsigned NS = NSI; 154251bf25e7ee9702fed2a66deeb404ce473f7bac1Jim Grosbach if (getLangOptions().CPlusPlus && (NS & Decl::IDNS_Ordinary)) 155ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes NS |= Decl::IDNS_Tag; 156ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes 157a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach // Scan up the scope chain looking for a decl that matches this identifier 158a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach // that is in the appropriate namespace. This search should not take long, as 159a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach // shadowing of names is uncommon, and deep shadowing is extremely uncommon. 160a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach for (IdentifierResolver::iterator 161eeec025cf5a2236ee9527a3312496a6ea42100c6Jim Grosbach I = IdResolver.begin(II, CurContext), E = IdResolver.end(); I != E; ++I) 162eeec025cf5a2236ee9527a3312496a6ea42100c6Jim Grosbach if ((*I)->getIdentifierNamespace() & NS) 163ee2c2a4f98c4a6fa575dcdd1bcc3effd1432a7c7Jim Grosbach return *I; 164ee2c2a4f98c4a6fa575dcdd1bcc3effd1432a7c7Jim Grosbach 1651355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // If we didn't find a use of this identifier, and if the identifier 166ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // corresponds to a compiler builtin, create the decl object for the builtin 1679ab0f25fc194b4315db1b87d38d4024054120bf6Owen Anderson // now, injecting it into translation unit scope, and return it. 1689ab0f25fc194b4315db1b87d38d4024054120bf6Owen Anderson if (NS & Decl::IDNS_Ordinary) { 169548340c4bfa596b602f286dfd3a8782817859d95Jim Grosbach if (enableLazyBuiltinCreation) { 170548340c4bfa596b602f286dfd3a8782817859d95Jim Grosbach // If this is a builtin on this (or all) targets, create the decl. 1711355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (unsigned BuiltinID = II->getBuiltinID()) 172ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, S); 1737b8f46cf9e31d730acc25be771462e2a6a1a1dfbJim Grosbach } 1747b8f46cf9e31d730acc25be771462e2a6a1a1dfbJim Grosbach if (getLangOptions().ObjC1) { 1757ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // @interface and @compatibility_alias introduce typedef-like names. 1767ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // Unlike typedef's, they can only be introduced at file-scope (and are 1777ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // therefore not scoped decls). They can, however, be shadowed by 1787ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // other names in IDNS_Ordinary. 1797ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach ObjCInterfaceDeclsTy::iterator IDI = ObjCInterfaceDecls.find(II); 1807ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (IDI != ObjCInterfaceDecls.end()) 1817ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return IDI->second; 1827ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach ObjCAliasTy::iterator I = ObjCAliasDecls.find(II); 1832fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (I != ObjCAliasDecls.end()) 1842fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return I->second->getClassInterface(); 18514605d1a679d55ff25875656e100ff455194ee17Jim Grosbach } 18614605d1a679d55ff25875656e100ff455194ee17Jim Grosbach } 187623a454b0f5c300e69a19984d7855a1e976c3d09Jim Grosbach return 0; 188623a454b0f5c300e69a19984d7855a1e976c3d09Jim Grosbach} 18988ae2bc6d53bbf58422ff74729da18a53e155b4aJim Grosbach 19088ae2bc6d53bbf58422ff74729da18a53e155b4aJim Grosbachvoid Sema::InitBuiltinVaListType() { 191189610f9466686a91fb7d847b572e1645c785323Jim Grosbach if (!Context.getBuiltinVaListType().isNull()) 192189610f9466686a91fb7d847b572e1645c785323Jim Grosbach return; 193189610f9466686a91fb7d847b572e1645c785323Jim Grosbach 194f8fce711e8b756adca63044f7d122648c960ab96Jim Grosbach IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list"); 195f8fce711e8b756adca63044f7d122648c960ab96Jim Grosbach Decl *VaDecl = LookupDecl(VaIdent, Decl::IDNS_Ordinary, TUScope); 196d54b4e612aa5d2d76a62f4409f82bd409f9af297Jim Grosbach TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl); 197d54b4e612aa5d2d76a62f4409f82bd409f9af297Jim Grosbach Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef)); 198189610f9466686a91fb7d847b572e1645c785323Jim Grosbach} 199ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 20047a0d52b69056250a1edaca8b28f705993094542Jim Grosbach/// LazilyCreateBuiltin - The specified Builtin-ID was first used at file scope. 201194bd8982936c819a4b14335a4d08f28af8f3d42Jim Grosbach/// lazily create a decl for it. 202f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim GrosbachScopedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid, 203194bd8982936c819a4b14335a4d08f28af8f3d42Jim Grosbach Scope *S) { 204194bd8982936c819a4b14335a4d08f28af8f3d42Jim Grosbach Builtin::ID BID = (Builtin::ID)bid; 20547a0d52b69056250a1edaca8b28f705993094542Jim Grosbach 20647a0d52b69056250a1edaca8b28f705993094542Jim Grosbach if (BID == Builtin::BI__builtin_va_start || 207ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng BID == Builtin::BI__builtin_va_copy || 20894b9550a32d189704a8eae55505edf62662c0534Evan Cheng BID == Builtin::BI__builtin_va_end || 209ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng BID == Builtin::BI__builtin_stdarg_start) 21032869205052430f45d598fba25ab878d8b29da2dEvan Cheng InitBuiltinVaListType(); 211ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng 212ffc0e73046f737d75e0a62b3a83ef19bcef111e3Evan Cheng QualType R = Context.BuiltinInfo.GetBuiltinType(BID, Context); 213f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach FunctionDecl *New = FunctionDecl::Create(Context, 214f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach Context.getTranslationUnitDecl(), 215f8e1e3e729473b8b2b7ee6134b6417976af84d05Jim Grosbach SourceLocation(), II, R, 216ebdeeab812beec0385b445f3d4c41a114e0d972fEvan Cheng FunctionDecl::Extern, false, 0); 217ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 2181355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // Create Decl objects for each parameter, adding them to the 2191355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // FunctionDecl. 2201355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach if (FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(R)) { 221189610f9466686a91fb7d847b572e1645c785323Jim Grosbach llvm::SmallVector<ParmVarDecl*, 16> Params; 2221355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) 2231355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0, 22447a0d52b69056250a1edaca8b28f705993094542Jim Grosbach FT->getArgType(i), VarDecl::None, 0, 22547a0d52b69056250a1edaca8b28f705993094542Jim Grosbach 0)); 2261355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach New->setParams(&Params[0], Params.size()); 2271355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach } 2281355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach 229ca9c42c4daa8f4ffd9411e11c05fb53ee1bfaf70Kevin Enderby 23016c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 23116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach // TUScope is the translation-unit scope to insert this function into. 2323a69756e392942bc522193f38d7f33958ed3b131Chris Lattner PushOnScopeChains(New, TUScope); 2333a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return New; 234a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 235a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 236146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling/// MergeTypeDefDecl - We just parsed a typedef 'New' which has the same name 237762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// and scope as a previous declaration 'Old'. Figure out how to resolve this 2388462b30548fb5969250858036638c73c16b65b43Daniel Dunbar/// situation, merging decls or emitting diagnostics as appropriate. 239d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach/// 24089df996ab20609676ecc8823f58414d598b09b46Jim GrosbachTypedefDecl *Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) { 241fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // Verify the old decl was also a typedef. 242fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes TypedefDecl *Old = dyn_cast<TypedefDecl>(OldD); 243cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby if (!Old) { 244706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Diag(New->getLocation(), diag::err_redefinition_different_kind, 2458462b30548fb5969250858036638c73c16b65b43Daniel Dunbar New->getName()); 2467ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Diag(OldD->getLocation(), diag::err_previous_definition); 247584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return New; 248a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2498462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 2508d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling // If the typedef types are not identical, reject them in all languages and 2510f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling // with any extensions enabled. 2520f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling if (Old->getUnderlyingType() != New->getUnderlyingType() && 253e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Context.getCanonicalType(Old->getUnderlyingType()) != 25492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Context.getCanonicalType(New->getUnderlyingType())) { 255580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Diag(New->getLocation(), diag::err_redefinition_different_typedef, 2567e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach New->getUnderlyingType().getAsString(), 257293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach Old->getUnderlyingType().getAsString()); 2588462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Diag(Old->getLocation(), diag::err_previous_definition); 259a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return Old; 260a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 261762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 26224d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling // Allow multiple definitions for ObjC built-in typedefs. 263a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // FIXME: Verify the underlying types are equivalent! 264a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (getLangOptions().ObjC1 && isBuiltinObjCType(New)) 265a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return Old; 2668462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 2678462b30548fb5969250858036638c73c16b65b43Daniel Dunbar if (getLangOptions().Microsoft) return New; 2688462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 2698462b30548fb5969250858036638c73c16b65b43Daniel Dunbar // Redeclaration of a type is a constraint violation (6.7.2.3p1). 270fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // Apparently GCC, Intel, and Sun all silently ignore the redeclaration if 271fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // *either* declaration is in a system header. The code below implements 272fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // this adhoc compatibility rule. FIXME: The following code will not 273fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // work properly when compiling ".i" files (containing preprocessed output). 27489df996ab20609676ecc8823f58414d598b09b46Jim Grosbach SourceManager &SrcMgr = Context.getSourceManager(); 27589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach HeaderSearch &HdrInfo = PP.getHeaderSearchInfo(); 27689df996ab20609676ecc8823f58414d598b09b46Jim Grosbach const FileEntry *OldDeclFile = SrcMgr.getFileEntryForLoc(Old->getLocation()); 27789df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (OldDeclFile) { 27889df996ab20609676ecc8823f58414d598b09b46Jim Grosbach DirectoryLookup::DirType OldDirType = HdrInfo.getFileDirFlavor(OldDeclFile); 27989df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // Allow reclarations in both SystemHeaderDir and ExternCSystemHeaderDir. 28089df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (OldDirType != DirectoryLookup::NormalHeaderDir) 28189df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return New; 282a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 283a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes const FileEntry *NewDeclFile = SrcMgr.getFileEntryForLoc(New->getLocation()); 284a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (NewDeclFile) { 285a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes DirectoryLookup::DirType NewDirType = HdrInfo.getFileDirFlavor(NewDeclFile); 286584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Allow reclarations in both SystemHeaderDir and ExternCSystemHeaderDir. 287584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (NewDirType != DirectoryLookup::NormalHeaderDir) 288584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return New; 289584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 290a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 291a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(New->getLocation(), diag::err_redefinition, New->getName()); 292a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby Diag(Old->getLocation(), diag::err_previous_definition); 293a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return New; 294a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 295a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 296a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// DeclhasAttr - returns true if decl Declaration already has the target 297a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby/// attribute. 2988155e5b753aca42973cf317727f3805faddcaf90Bill Wendlingstatic bool DeclHasAttr(const Decl *decl, const Attr *target) { 299cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext()) 300cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby if (attr->getKind() == target->getKind()) 30116c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach return true; 3026a5c22ed89c8bb73034a70105340acf6539dc58bDaniel Dunbar 303a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return false; 304a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby} 3057ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 3067ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach/// MergeAttributes - append attributes from the Old decl to the New one. 3077ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbachstatic void MergeAttributes(Decl *New, Decl *Old) { 3087ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Attr *attr = const_cast<Attr*>(Old->getAttrs()), *tmp; 3097ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 3100d6fac36eda6b65f0e396b24c5bce582f89f7992Jim Grosbach while (attr) { 3117ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach tmp = attr; 312a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby attr = attr->getNext(); 3130082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 3140082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson if (!DeclHasAttr(New, tmp)) { 3157ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach New->addAttr(tmp); 316f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach } else { 317f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach tmp->setNext(0); 318f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach delete(tmp); 3197ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 3207ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 3217ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 322580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Old->invalidateAttrs(); 323e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach} 324580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 325e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach/// MergeFunctionDecl - We just parsed a function 'New' from 326e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach/// declarator D which has the same name and scope as a previous 327e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach/// declaration 'Old'. Figure out how to resolve this situation, 328e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach/// merging decls or emitting diagnostics as appropriate. 329e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach/// Redeclaration will be set true if thisNew is a redeclaration OldD. 330af6981f2f59f0d825ad973e0bed8fff5d302196fJim GrosbachFunctionDecl * 33192a202213bb4c20301abf6ab64e46df3695e60bfOwen AndersonSema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, bool &Redeclaration) { 33292a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Redeclaration = false; 33392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson // Verify the old decl was also a function. 33492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson FunctionDecl *Old = dyn_cast<FunctionDecl>(OldD); 335af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach if (!Old) { 3367e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Diag(New->getLocation(), diag::err_redefinition_different_kind, 3377e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach New->getName()); 3387e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Diag(OldD->getLocation(), diag::err_previous_definition); 339293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach return New; 340293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 341293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 342293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach QualType OldQType = Context.getCanonicalType(Old->getType()); 343a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby QualType NewQType = Context.getCanonicalType(New->getType()); 34416c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 345146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling // C++ [dcl.fct]p3: 346146018fc6414eb2a1e67b2d8798a42a2f55ec96cBill Wendling // All declarations for a function shall agree exactly in both the 347762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // return type and the parameter-type-list. 348762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (getLangOptions().CPlusPlus && OldQType == NewQType) { 349762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan MergeAttributes(New, Old); 350762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Redeclaration = true; 351762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return MergeCXXFunctionDecl(New, Old); 3528462b30548fb5969250858036638c73c16b65b43Daniel Dunbar } 3538462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 3548462b30548fb5969250858036638c73c16b65b43Daniel Dunbar // C: Function types need to be compatible, not identical. This handles 35589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // duplicate function decls like "void f(int); void f(enum X);" properly. 35689df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (!getLangOptions().CPlusPlus && 35789df996ab20609676ecc8823f58414d598b09b46Jim Grosbach Context.functionTypesAreCompatible(OldQType, NewQType)) { 358762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan MergeAttributes(New, Old); 3598462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Redeclaration = true; 360762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return New; 361d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach } 362762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 363762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // A function that has already been declared has been redeclared or defined 364762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // with a different type- show appropriate diagnostic 3658d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling diag::kind PrevDiag; 3660f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling if (Old->isThisDeclarationADefinition()) 3670f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling PrevDiag = diag::err_previous_definition; 36824d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling else if (Old->isImplicit()) 3698d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling PrevDiag = diag::err_previous_implicit_declaration; 370fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes else 371fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes PrevDiag = diag::err_previous_declaration; 372fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 373fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope. 374762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // TODO: This is totally simplistic. It should handle merging functions 375762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan // together etc, merging extern int X; int X; ... 376762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(New->getLocation(), diag::err_conflicting_types, New->getName()); 377706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Diag(Old->getLocation(), PrevDiag); 378706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes return New; 379706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes} 380762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 381762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// equivalentArrayTypes - Used to determine whether two array types are 382762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// equivalent. 3837ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach/// We need to check this explicitly as an incomplete array definition is 3847ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach/// considered a VariableArrayType, so will not match a complete array 3857ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach/// definition that would be otherwise equivalent. 386584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopesstatic bool areEquivalentArrayTypes(QualType NewQType, QualType OldQType, 387584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes ASTContext &Context) { 388584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes const ArrayType *NewAT = Context.getAsArrayType(NewQType); 389a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes const ArrayType *OldAT = Context.getAsArrayType(OldQType); 390a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 3910082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson if (!NewAT || !OldAT) 392580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return false; 393580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 3940082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // If either (or both) array types in incomplete we need to strip off the 395e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // outer VariableArrayType. Once the outer VAT is removed the remaining 396af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach // types must be identical if the array types are to be considered 397e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // equivalent. 39892a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson // eg. int[][1] and int[1][1] become 399af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach // VAT(null, CAT(1, int)) and CAT(1, CAT(1, int)) 40092a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson // removing the outermost VAT gives 4017e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // CAT(1, int) and CAT(1, int) 4027e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // which are equal, therefore the array types are equivalent. 4037e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (NewAT->isIncompleteArrayType() || OldAT->isIncompleteArrayType()) { 404293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (NewAT->getIndexTypeQualifier() != OldAT->getIndexTypeQualifier()) 405293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach return false; 406293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach NewQType = Context.getCanonicalType(NewAT->getElementType()); 407762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan OldQType = Context.getCanonicalType(OldAT->getElementType()); 408762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 40916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach 410762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan return NewQType == OldQType; 411762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan} 412762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 413762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan/// Predicate for C "tentative" external object definitions (C99 6.9.2). 414a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderbybool Sema::isTentativeDefinition(VarDecl *VD) { 4158462b30548fb5969250858036638c73c16b65b43Daniel Dunbar if (VD->isFileVarDecl()) 4168462b30548fb5969250858036638c73c16b65b43Daniel Dunbar return (!VD->getInit() && 4178462b30548fb5969250858036638c73c16b65b43Daniel Dunbar (VD->getStorageClass() == VarDecl::None || 4188462b30548fb5969250858036638c73c16b65b43Daniel Dunbar VD->getStorageClass() == VarDecl::Static)); 4198462b30548fb5969250858036638c73c16b65b43Daniel Dunbar return false; 420fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes} 421fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 422fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// CheckForFileScopedRedefinitions - Make sure we forgo redefinition errors 423fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// when dealing with C "tentative" external object definitions (C99 6.9.2). 424fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopesvoid Sema::CheckForFileScopedRedefinitions(Scope *S, VarDecl *VD) { 425a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby bool VDIsTentative = isTentativeDefinition(VD); 426a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 427a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby for (IdentifierResolver::iterator 428a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby I = IdResolver.begin(VD->getIdentifier(), 429a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby VD->getDeclContext(), false/*LookInParentCtx*/), 430a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby E = IdResolver.end(); I != E; ++I) { 4316aa49435994c33257b7588cac24671785d17fa6eBenjamin Kramer if (*I != VD && IdResolver.isDeclInScope(*I, VD->getDeclContext(), S)) { 4327729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling VarDecl *OldDecl = dyn_cast<VarDecl>(*I); 433a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 434a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // Check for "tentative" definitions. We can't accomplish this in 4355fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling // MergeVarDecl since the initializer hasn't been attached. 4360f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling if (!OldDecl || isTentativeDefinition(OldDecl) || VDIsTentative) 4370f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling continue; 43824d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling 4398d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling // Handle __private_extern__ just like extern. 4408d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling if (OldDecl->getStorageClass() != VarDecl::Extern && 441cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby OldDecl->getStorageClass() != VarDecl::PrivateExtern && 442cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby VD->getStorageClass() != VarDecl::Extern && 443cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby VD->getStorageClass() != VarDecl::PrivateExtern) { 444cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby Diag(VD->getLocation(), diag::err_redefinition, VD->getName()); 445cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby Diag(OldDecl->getLocation(), diag::err_previous_definition); 446706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 447706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 448706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 449706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes} 450706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 451a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes/// MergeVarDecl - We just parsed a variable 'New' which has the same name 452a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes/// and scope as a previous declaration 'Old'. Figure out how to resolve this 453a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes/// situation, merging decls or emitting diagnostics as appropriate. 454a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes/// 455a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes/// Tentative definition rules (C99 6.9.2p2) are checked by 456584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 457584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes/// definitions here, since the initializer hasn't been attached. 458584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes/// 459584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso LopesVarDecl *Sema::MergeVarDecl(VarDecl *New, Decl *OldD) { 460584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Verify the old decl was also a variable. 461fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes VarDecl *Old = dyn_cast<VarDecl>(OldD); 462fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (!Old) { 4638462b30548fb5969250858036638c73c16b65b43Daniel Dunbar Diag(New->getLocation(), diag::err_redefinition_different_kind, 464d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach New->getName()); 46589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach Diag(OldD->getLocation(), diag::err_previous_definition); 46689df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return New; 4673483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 468a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach 469a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach MergeAttributes(New, Old); 470a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach 471a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach // Verify the types match. 472a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach QualType OldCType = Context.getCanonicalType(Old->getType()); 473a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach QualType NewCType = Context.getCanonicalType(New->getType()); 474a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach if (OldCType != NewCType && 475a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach !areEquivalentArrayTypes(NewCType, OldCType, Context)) { 47672f39f8436848885176943b0ba985a7171145423Jim Grosbach Diag(New->getLocation(), diag::err_redefinition, New->getName()); 47772f39f8436848885176943b0ba985a7171145423Jim Grosbach Diag(Old->getLocation(), diag::err_previous_definition); 47872f39f8436848885176943b0ba985a7171145423Jim Grosbach return New; 47972f39f8436848885176943b0ba985a7171145423Jim Grosbach } 48072f39f8436848885176943b0ba985a7171145423Jim Grosbach // C99 6.2.2p4: Check if we have a static decl followed by a non-static. 48172f39f8436848885176943b0ba985a7171145423Jim Grosbach if (New->getStorageClass() == VarDecl::Static && 48272f39f8436848885176943b0ba985a7171145423Jim Grosbach (Old->getStorageClass() == VarDecl::None || 48372f39f8436848885176943b0ba985a7171145423Jim Grosbach Old->getStorageClass() == VarDecl::Extern)) { 48472f39f8436848885176943b0ba985a7171145423Jim Grosbach Diag(New->getLocation(), diag::err_static_non_static, New->getName()); 48572f39f8436848885176943b0ba985a7171145423Jim Grosbach Diag(Old->getLocation(), diag::err_previous_definition); 48672f39f8436848885176943b0ba985a7171145423Jim Grosbach return New; 48772f39f8436848885176943b0ba985a7171145423Jim Grosbach } 48872f39f8436848885176943b0ba985a7171145423Jim Grosbach // C99 6.2.2p4: Check if we have a non-static decl followed by a static. 48972f39f8436848885176943b0ba985a7171145423Jim Grosbach if (New->getStorageClass() != VarDecl::Static && 49072f39f8436848885176943b0ba985a7171145423Jim Grosbach Old->getStorageClass() == VarDecl::Static) { 49172f39f8436848885176943b0ba985a7171145423Jim Grosbach Diag(New->getLocation(), diag::err_non_static_static, New->getName()); 4926b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach Diag(Old->getLocation(), diag::err_previous_definition); 4936b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return New; 4946b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 4956b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach // File scoped variables are analyzed in FinalizeDeclaratorGroup. 4966b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (!New->isFileVarDecl()) { 4976b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach Diag(New->getLocation(), diag::err_redefinition, New->getName()); 4986b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach Diag(Old->getLocation(), diag::err_previous_definition); 4996b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 50083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return New; 50183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach} 50283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach 50383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach/// CheckParmsForFunctionDef - Check that the parameters of the given 50483ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach/// function are appropriate for the definition of a function. This 50583ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach/// takes care of any checks that cannot be performed on the 50683ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach/// declaration itself, e.g., that the types of each of the function 50783ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach/// parameters are complete. 50883ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbachbool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) { 50983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach bool HasInvalidParm = false; 51083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 51183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach ParmVarDecl *Param = FD->getParamDecl(p); 51283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach 51383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach // C99 6.7.5.3p4: the parameters in a parameter type list in a 51483ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach // function declarator that is part of a function definition of 51583ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach // that function shall not have incomplete type. 5167c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach if (Param->getType()->isIncompleteType() && 5177c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach !Param->isInvalidDecl()) { 5187c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach Diag(Param->getLocation(), diag::err_typecheck_decl_incomplete_type, 5197c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach Param->getType().getAsString()); 5207c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach Param->setInvalidDecl(); 5217c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach HasInvalidParm = true; 5227c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach } 5237c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach } 524f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach 525f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach return HasInvalidParm; 526f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach} 527f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach 528f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach/// CreateImplicitParameter - Creates an implicit function parameter 529f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach/// in the scope S and with the given type. This routine is used, for 530f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach/// example, to create the implicit "self" parameter in an Objective-C 531f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach/// method. 5324a5ffb399f841783c201c599b88d576757f1922eJim GrosbachImplicitParamDecl * 5334a5ffb399f841783c201c599b88d576757f1922eJim GrosbachSema::CreateImplicitParameter(Scope *S, IdentifierInfo *Id, 5344a5ffb399f841783c201c599b88d576757f1922eJim Grosbach SourceLocation IdLoc, QualType Type) { 5354a5ffb399f841783c201c599b88d576757f1922eJim Grosbach ImplicitParamDecl *New = ImplicitParamDecl::Create(Context, CurContext, 5364a5ffb399f841783c201c599b88d576757f1922eJim Grosbach IdLoc, Id, Type, 0); 5374a5ffb399f841783c201c599b88d576757f1922eJim Grosbach if (Id) 5384a5ffb399f841783c201c599b88d576757f1922eJim Grosbach PushOnScopeChains(New, S); 5394a5ffb399f841783c201c599b88d576757f1922eJim Grosbach 540fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach return New; 541fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach} 542fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach 543fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 544fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach/// no declarator (e.g. "struct foo;") is parsed. 545fff76ee7ef007b2bb74804f165fee475e30ead0dJim GrosbachSema::DeclTy *Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) { 546fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach // TODO: emit error on 'int;' or 'const enum foo;'. 547fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach // TODO: emit error on 'typedef int;' 548ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // if (!DS.isMissingDeclaratorOk()) Diag(...); 549ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 550ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach return dyn_cast_or_null<TagDecl>(static_cast<Decl *>(DS.getTypeRep())); 551ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach} 552ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 553ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbachbool Sema::CheckSingleInitializer(Expr *&Init, QualType DeclType) { 554ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // Get the type before calling CheckSingleAssignmentConstraints(), since 555ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach // it can promote the expression. 556ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach QualType InitType = Init->getType(); 557ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 558ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach AssignConvertType ConvTy = CheckSingleAssignmentConstraints(DeclType, Init); 559ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach return DiagnoseAssignmentResult(ConvTy, Init->getLocStart(), DeclType, 560ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach InitType, Init, "initializing"); 561ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach} 562ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach 563ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbachbool Sema::CheckStringLiteralInit(StringLiteral *strLiteral, QualType &DeclT) { 564ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach const ArrayType *AT = Context.getAsArrayType(DeclT); 565ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach 56670939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 56770939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach // C99 6.7.8p14. We have an array of character type with unknown size 56870939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach // being initialized to a string literal. 56970939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach llvm::APSInt ConstVal(32); 57070939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach ConstVal = strLiteral->getByteLength() + 1; 57170939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach // Return a new array type (C99 6.7.8p22). 57270939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach DeclT = Context.getConstantArrayType(IAT->getElementType(), ConstVal, 57370939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach ArrayType::Normal, 0); 574f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } else { 575f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const ConstantArrayType *CAT = cast<ConstantArrayType>(AT); 576f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // C99 6.7.8p14. We have an array of character type with known size. 577f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // FIXME: Avoid truncation for 64-bit length strings. 578f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (strLiteral->getByteLength() > (unsigned)CAT->getSize().getZExtValue()) 579f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Diag(strLiteral->getSourceRange().getBegin(), 580f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach diag::warn_initializer_string_for_char_array_too_long, 581f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach strLiteral->getSourceRange()); 582f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 583f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // Set type from "char *" to "constant array of char". 584f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach strLiteral->setType(DeclT); 585f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // For now, we always return false (meaning success). 586f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return false; 587f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach} 588f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 589f6c0525d421cb48119423a96e23289b473eddbd7Jim GrosbachStringLiteral *Sema::IsStringLiteralInit(Expr *Init, QualType DeclType) { 5906bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach const ArrayType *AT = Context.getAsArrayType(DeclType); 5916bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach if (AT && AT->getElementType()->isCharType()) { 5926bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach return dyn_cast<StringLiteral>(Init); 5936bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach } 5946bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach return 0; 5956bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach} 5966bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach 5976bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbachbool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType) { 5986b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach // C99 6.7.8p3: The type of the entity to be initialized shall be an array 5996b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach // of unknown size ("[]") or an object type that is not a variable array type. 6006b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (const VariableArrayType *VAT = Context.getAsVariableArrayType(DeclType)) 6016b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return Diag(VAT->getSizeExpr()->getLocStart(), 6026b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach diag::err_variable_object_no_init, 6036b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach VAT->getSizeExpr()->getSourceRange()); 6046b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach 6056b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach InitListExpr *InitList = dyn_cast<InitListExpr>(Init); 606c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (!InitList) { 607c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach // FIXME: Handle wide strings 608c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (StringLiteral *strLiteral = IsStringLiteralInit(Init, DeclType)) 609c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return CheckStringLiteralInit(strLiteral, DeclType); 610c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach 611c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (DeclType->isArrayType()) 612c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return Diag(Init->getLocStart(), 613c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach diag::err_array_init_list_required, 614b32e7844e9f79d2bd4ff34a1d19aba347f999abcBill Wendling Init->getSourceRange()); 6158d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 6160f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling return CheckSingleInitializer(Init, DeclType); 6170f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling } 61814b93851cc7611ae6c2000f1c162592ead954420Chris Lattner 619706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes InitListChecker CheckInitList(this, InitList, DeclType); 62014b93851cc7611ae6c2000f1c162592ead954420Chris Lattner return CheckInitList.HadError(); 621580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach} 622af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach 623af6981f2f59f0d825ad973e0bed8fff5d302196fJim GrosbachSema::DeclTy * 6247e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim GrosbachSema::ActOnDeclarator(Scope *S, Declarator &D, DeclTy *lastDecl) { 625293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach ScopedDecl *LastDeclarator = dyn_cast_or_null<ScopedDecl>((Decl *)lastDecl); 626f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach IdentifierInfo *II = D.getIdentifier(); 627f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach 628f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // All of these full declarators require an identifier. If it doesn't have 629f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // one, the ParsedFreeStandingDeclSpec action should be used. 6307ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (II == 0) { 6317ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Diag(D.getDeclSpec().getSourceRange().getBegin(), 632ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes diag::err_declarator_need_ident, 6337ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach D.getDeclSpec().getSourceRange(), D.getSourceRange()); 6347ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return 0; 635ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes } 6367ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 6377ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // The scope passed in may not be a decl scope. Zip up the scope tree until 638ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // we find one that is. 6397ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach while ((S->getFlags() & Scope::DeclScope) == 0) 6407ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach S = S->getParent(); 6417ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 6427ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // See if this is a redefinition of a variable in the same scope. 6437ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Decl *PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S); 6447ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach ScopedDecl *New; 6457ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach bool InvalidDecl = false; 646039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach 647039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach // In C++, the previous declaration we find might be a tag type 648039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach // (class or enum). In this case, the new declaration will hide the 649039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach // tag type. 650039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 651039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach PrevDecl = 0; 652039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach 653039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach QualType R = GetTypeForDeclarator(D, S); 654039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach assert(!R.isNull() && "GetTypeForDeclarator() returned null type"); 6552fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach 6562fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 6572fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach // Check that there are no default arguments (C++ only). 6582fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (getLangOptions().CPlusPlus) 6592fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach CheckExtraCXXDefaultArguments(D); 6602fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach 6612fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach TypedefDecl *NewTD = ParseTypedefDecl(S, D, R, LastDeclarator); 6622fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (!NewTD) return 0; 6632fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach 6642fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach // Handle attributes prior to checking for duplicates in MergeVarDecl 6652fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach ProcessDeclAttributes(NewTD, D); 6662fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach // Merge the decl with the existing one if appropriate. If the decl is 6672fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach // in an outer scope, it isn't the same thing. 6682fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (PrevDecl && IdResolver.isDeclInScope(PrevDecl, CurContext, S)) { 6692fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach NewTD = MergeTypeDefDecl(NewTD, PrevDecl); 6702fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (NewTD == 0) return 0; 6712fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach } 6722fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach New = NewTD; 6732fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (S->getFnParent() == 0) { 6742fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach // C99 6.7.7p2: If a typedef name specifies a variably modified type 6752fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach // then it shall have block scope. 676251bf25e7ee9702fed2a66deeb404ce473f7bac1Jim Grosbach if (NewTD->getUnderlyingType()->isVariablyModifiedType()) { 677251bf25e7ee9702fed2a66deeb404ce473f7bac1Jim Grosbach // FIXME: Diagnostic needs to be fixed. 6782fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach Diag(D.getIdentifierLoc(), diag::err_typecheck_illegal_vla); 6797ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach InvalidDecl = true; 6807ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 681ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } 6827ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } else if (R.getTypePtr()->isFunctionType()) { 6837ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach FunctionDecl::StorageClass SC = FunctionDecl::None; 6847ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach switch (D.getDeclSpec().getStorageClassSpec()) { 6857ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach default: assert(0 && "Unknown storage class!"); 6867ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case DeclSpec::SCS_auto: 6870da10cf44d0f22111dae728bb535ade2283d976bOwen Anderson case DeclSpec::SCS_register: 6880da10cf44d0f22111dae728bb535ade2283d976bOwen Anderson Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_func, 6897ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach R.getAsString()); 6907f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach InvalidDecl = true; 6917f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach break; 6927f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break; 6937f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach case DeclSpec::SCS_extern: SC = FunctionDecl::Extern; break; 6947f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach case DeclSpec::SCS_static: SC = FunctionDecl::Static; break; 6957f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break; 6967f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach } 6977f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach 6987f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach bool isInline = D.getDeclSpec().isInlineSpecified(); 6997f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach FunctionDecl *NewFD; 7007f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach if (D.getContext() == Declarator::MemberContext) { 7017f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach // This is a C++ method declaration. 7027ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(CurContext), 7037ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach D.getIdentifierLoc(), II, R, 704ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes (SC == FunctionDecl::Static), isInline, 705ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes LastDeclarator); 706ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes } else { 707ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach NewFD = FunctionDecl::Create(Context, CurContext, 708ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach D.getIdentifierLoc(), 709ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach II, R, SC, isInline, 710ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach LastDeclarator); 711ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach } 712ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach // Handle attributes. 713ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach ProcessDeclAttributes(NewFD, D); 714ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach 715ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach // Handle GNU asm-label extension (encoded as an attribute). 716ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach if (Expr *E = (Expr*) D.getAsmLabel()) { 7177ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // The parser guarantees this is a string. 7187ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach StringLiteral *SE = cast<StringLiteral>(E); 7197ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach NewFD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(), 7207ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach SE->getByteLength()))); 7217ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 72287f4f9a946549ad93046990a364ac5190333a7ebBill Wendling 72360f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach // Copy the parameter declarations from the declarator D to 72460f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach // the function declaration NewFD, if they are available. 72560f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach if (D.getNumTypeObjects() > 0 && 72660f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach D.getTypeObject(0).Fun.hasPrototype) { 72760f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun; 72860f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach 72960f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach // Create Decl objects for each parameter, adding them to the 73060f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach // FunctionDecl. 73160f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach llvm::SmallVector<ParmVarDecl*, 16> Params; 73260f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach 733ecd858968384be029574d845eb098d357049e02eJim Grosbach // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 734ecd858968384be029574d845eb098d357049e02eJim Grosbach // function that takes no arguments, not a function that takes a 73538466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach // single void argument. 73638466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach // We let through "const void" here because Sema::GetTypeForDeclarator 73738466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach // already checks for that case. 73838466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 73938466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach FTI.ArgInfo[0].Param && 74038466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach ((ParmVarDecl*)FTI.ArgInfo[0].Param)->getType()->isVoidType()) { 74138466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach // empty arg list, don't push any params. 74238466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach ParmVarDecl *Param = (ParmVarDecl*)FTI.ArgInfo[0].Param; 74338466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach 74448ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach // In C++, the empty parameter-type-list must be spelled "void"; a 74548ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach // typedef of void is not permitted. 74648ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach if (getLangOptions().CPlusPlus && 74748ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach Param->getType().getUnqualifiedType() != Context.VoidTy) { 74848ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach Diag(Param->getLocation(), diag::ext_param_typedef_of_void); 74948ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach } 75048ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach 75148ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach } else { 75248ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) 753ecd858968384be029574d845eb098d357049e02eJim Grosbach Params.push_back((ParmVarDecl *)FTI.ArgInfo[i].Param); 754ecd858968384be029574d845eb098d357049e02eJim Grosbach } 755ecd858968384be029574d845eb098d357049e02eJim Grosbach 756ecd858968384be029574d845eb098d357049e02eJim Grosbach NewFD->setParams(&Params[0], Params.size()); 757ecd858968384be029574d845eb098d357049e02eJim Grosbach } 758ecd858968384be029574d845eb098d357049e02eJim Grosbach 759ecd858968384be029574d845eb098d357049e02eJim Grosbach // Merge the decl with the existing one if appropriate. Since C functions 760505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes // are in a flat namespace, make sure we consider decls in outer scopes. 761a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach if (PrevDecl && 762a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach (!getLangOptions().CPlusPlus || 763a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach IdResolver.isDeclInScope(PrevDecl, CurContext, S)) ) { 764a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach bool Redeclaration = false; 765a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach NewFD = MergeFunctionDecl(NewFD, PrevDecl, Redeclaration); 766a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach if (NewFD == 0) return 0; 767a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach if (Redeclaration) { 768a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach NewFD->setPreviousDeclaration(cast<FunctionDecl>(PrevDecl)); 769b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach } 770b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach } 771b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach New = NewFD; 772b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach 773b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach // In C++, check default arguments now that we have merged decls. 774b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach if (getLangOptions().CPlusPlus) 775b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach CheckCXXDefaultArguments(NewFD); 776b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach } else { 7777ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // Check that there are no default arguments (C++ only). 7787ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (getLangOptions().CPlusPlus) 779f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling CheckExtraCXXDefaultArguments(D); 7807ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 7817ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (R.getTypePtr()->isObjCInterfaceType()) { 7827ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Diag(D.getIdentifierLoc(), diag::err_statically_allocated_object, 7834d2a00147d19b17d382644de0d6a1f0d3230e0e4Owen Anderson D.getIdentifier()->getName()); 784f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling InvalidDecl = true; 785f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach } 786f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach 787f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach VarDecl *NewVD; 788f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach VarDecl::StorageClass SC; 789f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach switch (D.getDeclSpec().getStorageClassSpec()) { 790f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach default: assert(0 && "Unknown storage class!"); 791f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach case DeclSpec::SCS_unspecified: SC = VarDecl::None; break; 792f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach case DeclSpec::SCS_extern: SC = VarDecl::Extern; break; 793a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach case DeclSpec::SCS_static: SC = VarDecl::Static; break; 794a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach case DeclSpec::SCS_auto: SC = VarDecl::Auto; break; 795a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach case DeclSpec::SCS_register: SC = VarDecl::Register; break; 796a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break; 797a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach } 798a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach if (D.getContext() == Declarator::MemberContext) { 799a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach assert(SC == VarDecl::Static && "Invalid storage class for member!"); 800a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach // This is a static data member for a C++ class. 801a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach NewVD = CXXClassVarDecl::Create(Context, cast<CXXRecordDecl>(CurContext), 802a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach D.getIdentifierLoc(), II, 803a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach R, LastDeclarator); 804a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach } else { 805a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach if (S->getFnParent() == 0) { 806a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach // C99 6.9p2: The storage-class specifiers auto and register shall not 807a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach // appear in the declaration specifiers in an external declaration. 808a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach if (SC == VarDecl::Auto || SC == VarDecl::Register) { 809a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope, 810a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach R.getAsString()); 811a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach InvalidDecl = true; 812a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach } 813a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach NewVD = VarDecl::Create(Context, CurContext, D.getIdentifierLoc(), 814a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach II, R, SC, LastDeclarator); 8157ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } else { 81609176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach NewVD = VarDecl::Create(Context, CurContext, D.getIdentifierLoc(), 81709176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach II, R, SC, LastDeclarator); 81809176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach } 81909176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach } 82009176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach // Handle attributes prior to checking for duplicates in MergeVarDecl 82109176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach ProcessDeclAttributes(NewVD, D); 8227ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 823ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling // Handle GNU asm-label extension (encoded as an attribute). 8247ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (Expr *E = (Expr*) D.getAsmLabel()) { 8257ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // The parser guarantees this is a string. 8267ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach StringLiteral *SE = cast<StringLiteral>(E); 8270da10cf44d0f22111dae728bb535ade2283d976bOwen Anderson NewVD->addAttr(new AsmLabelAttr(std::string(SE->getStrData(), 8287ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach SE->getByteLength()))); 8297ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 8307ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 8317ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // Emit an error if an address space was applied to decl with local storage. 8327ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // This includes arrays of objects with address space qualifiers, but not 833ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling // automatic variables that point to other address spaces. 8347ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // ISO/IEC TR 18037 S5.1.2 83563553c77cd1cf3b204d955fb65350db087aaff1dOwen Anderson if (NewVD->hasLocalStorage() && (NewVD->getType().getAddressSpace() != 0)) { 836ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling Diag(D.getIdentifierLoc(), diag::err_as_qualified_auto_decl); 8377ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach InvalidDecl = true; 838584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 839a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Merge the decl with the existing one if appropriate. If the decl is 8403483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar // in an outer scope, it isn't the same thing. 8413483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar if (PrevDecl && IdResolver.isDeclInScope(PrevDecl, CurContext, S)) { 84214b93851cc7611ae6c2000f1c162592ead954420Chris Lattner NewVD = MergeVarDecl(NewVD, PrevDecl); 84314b93851cc7611ae6c2000f1c162592ead954420Chris Lattner if (NewVD == 0) return 0; 84414b93851cc7611ae6c2000f1c162592ead954420Chris Lattner } 84514b93851cc7611ae6c2000f1c162592ead954420Chris Lattner New = NewVD; 8463483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 8473483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 8483483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar // If this has an identifier, add it to the scope stack. 8493483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar if (II) 8503483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar PushOnScopeChains(New, S); 8518462b30548fb5969250858036638c73c16b65b43Daniel Dunbar // If any semantic error occurred, mark the decl as invalid. 852345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar if (D.getInvalidType() || InvalidDecl) 8538462b30548fb5969250858036638c73c16b65b43Daniel Dunbar New->setInvalidDecl(); 85404f74942f2994a7c1d8e62c207c4005ed4652b6aJim Grosbach 85504f74942f2994a7c1d8e62c207c4005ed4652b6aJim Grosbach return New; 8568462b30548fb5969250858036638c73c16b65b43Daniel Dunbar} 8578462b30548fb5969250858036638c73c16b65b43Daniel Dunbar 858fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopesbool Sema::CheckAddressConstantExpressionLValue(const Expr* Init) { 859fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes switch (Init->getStmtClass()) { 860fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes default: 861fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Diag(Init->getExprLoc(), 862fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes diag::err_init_element_not_constant, Init->getSourceRange()); 86389df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return true; 86489df996ab20609676ecc8823f58414d598b09b46Jim Grosbach case Expr::ParenExprClass: { 86589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach const ParenExpr* PE = cast<ParenExpr>(Init); 86689df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return CheckAddressConstantExpressionLValue(PE->getSubExpr()); 86789df996ab20609676ecc8823f58414d598b09b46Jim Grosbach } 86889df996ab20609676ecc8823f58414d598b09b46Jim Grosbach case Expr::CompoundLiteralExprClass: 86989df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return cast<CompoundLiteralExpr>(Init)->isFileScope(); 87089df996ab20609676ecc8823f58414d598b09b46Jim Grosbach case Expr::DeclRefExprClass: { 87189df996ab20609676ecc8823f58414d598b09b46Jim Grosbach const Decl *D = cast<DeclRefExpr>(Init)->getDecl(); 87289df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 873fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (VD->hasGlobalStorage()) 874fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return false; 875fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Diag(Init->getExprLoc(), 876fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes diag::err_init_element_not_constant, Init->getSourceRange()); 877fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return true; 878d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach } 879d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach if (isa<FunctionDecl>(D)) 880d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach return false; 881d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach Diag(Init->getExprLoc(), 882d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 883a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby return true; 884a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 885a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby case Expr::MemberExprClass: { 886a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby const MemberExpr *M = cast<MemberExpr>(Init); 887a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (M->isArrow()) 888af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach return CheckAddressConstantExpression(M->getBase()); 889e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach return CheckAddressConstantExpressionLValue(M->getBase()); 890af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach } 891af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach case Expr::ArraySubscriptExprClass: { 892af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach // FIXME: Should we pedwarn for "x[0+0]" (where x is a pointer)? 893e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(Init); 894af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach return CheckAddressConstantExpression(ASE->getBase()) || 895e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach CheckArithmeticConstantExpression(ASE->getIdx()); 896e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 897af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach case Expr::StringLiteralClass: 898152d4a4bb6b75de740b4b8a9f48abb9069d50c17Owen Anderson case Expr::PreDefinedExprClass: 899af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach return false; 900af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach case Expr::UnaryOperatorClass: { 90192a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson const UnaryOperator *Exp = cast<UnaryOperator>(Init); 902af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach 90392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson // C99 6.6p9 90492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson if (Exp->getOpcode() == UnaryOperator::Deref) 905580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return CheckAddressConstantExpression(Exp->getSubExpr()); 9060082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 907580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Diag(Init->getExprLoc(), 908580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 9090082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson return true; 9100082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } 91187f4f9a946549ad93046990a364ac5190333a7ebBill Wendling } 9127729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling} 9135fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling 9145fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendlingbool Sema::CheckAddressConstantExpression(const Expr* Init) { 9157729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling switch (Init->getStmtClass()) { 9167729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling default: 91787f4f9a946549ad93046990a364ac5190333a7ebBill Wendling Diag(Init->getExprLoc(), 91887f4f9a946549ad93046990a364ac5190333a7ebBill Wendling diag::err_init_element_not_constant, Init->getSourceRange()); 9190f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling return true; 9200f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case Expr::ParenExprClass: { 9210f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling const ParenExpr* PE = cast<ParenExpr>(Init); 9220f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling return CheckAddressConstantExpression(PE->getSubExpr()); 9230f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling } 9240f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case Expr::StringLiteralClass: 9250f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling case Expr::ObjCStringLiteralClass: 9260f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling return false; 9277e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach case Expr::CallExprClass: { 9287e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach const CallExpr *CE = cast<CallExpr>(Init); 9297e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (CE->isBuiltinConstantExpr()) 9307e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return false; 9317e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Diag(Init->getExprLoc(), 9327e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 933293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach return true; 934293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 935293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach case Expr::UnaryOperatorClass: { 936293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach const UnaryOperator *Exp = cast<UnaryOperator>(Init); 937293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 938293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // C99 6.6p9 939293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (Exp->getOpcode() == UnaryOperator::AddrOf) 940293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach return CheckAddressConstantExpressionLValue(Exp->getSubExpr()); 941293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 942293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (Exp->getOpcode() == UnaryOperator::Extension) 943293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach return CheckAddressConstantExpression(Exp->getSubExpr()); 9443483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 9456b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach Diag(Init->getExprLoc(), 9466b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 9476b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return true; 9486b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach } 949a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach case Expr::BinaryOperatorClass: { 950a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach // FIXME: Should we pedwarn for expressions like "a + 1 + 2"? 951a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach const BinaryOperator *Exp = cast<BinaryOperator>(Init); 952a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach 953a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach Expr *PExp = Exp->getLHS(); 954a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach Expr *IExp = Exp->getRHS(); 955a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach if (IExp->getType()->isPointerType()) 956a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach std::swap(PExp, IExp); 95772f39f8436848885176943b0ba985a7171145423Jim Grosbach 95872f39f8436848885176943b0ba985a7171145423Jim Grosbach // FIXME: Should we pedwarn if IExp isn't an integer constant expression? 95972f39f8436848885176943b0ba985a7171145423Jim Grosbach return CheckAddressConstantExpression(PExp) || 96072f39f8436848885176943b0ba985a7171145423Jim Grosbach CheckArithmeticConstantExpression(IExp); 96172f39f8436848885176943b0ba985a7171145423Jim Grosbach } 96272f39f8436848885176943b0ba985a7171145423Jim Grosbach case Expr::ImplicitCastExprClass: { 96372f39f8436848885176943b0ba985a7171145423Jim Grosbach const Expr* SubExpr = cast<ImplicitCastExpr>(Init)->getSubExpr(); 96472f39f8436848885176943b0ba985a7171145423Jim Grosbach 96572f39f8436848885176943b0ba985a7171145423Jim Grosbach // Check for implicit promotion 96672f39f8436848885176943b0ba985a7171145423Jim Grosbach if (SubExpr->getType()->isFunctionType() || 96772f39f8436848885176943b0ba985a7171145423Jim Grosbach SubExpr->getType()->isArrayType()) 96872f39f8436848885176943b0ba985a7171145423Jim Grosbach return CheckAddressConstantExpressionLValue(SubExpr); 96972f39f8436848885176943b0ba985a7171145423Jim Grosbach 97072f39f8436848885176943b0ba985a7171145423Jim Grosbach // Check for pointer->pointer cast 97172f39f8436848885176943b0ba985a7171145423Jim Grosbach if (SubExpr->getType()->isPointerType()) 97272f39f8436848885176943b0ba985a7171145423Jim Grosbach return CheckAddressConstantExpression(SubExpr); 9736b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach 9746b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach if (SubExpr->getType()->isArithmeticType()) 9756b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach return CheckArithmeticConstantExpression(SubExpr); 9766b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach 9776b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach Diag(Init->getExprLoc(), 97883ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 97983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return true; 98083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach } 98183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach case Expr::CastExprClass: { 98283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach const Expr* SubExpr = cast<CastExpr>(Init)->getSubExpr(); 98383ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach 9847c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach // Check for pointer->pointer cast 9857c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach if (SubExpr->getType()->isPointerType()) 9867c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach return CheckAddressConstantExpression(SubExpr); 9877c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach 9887c6e42e9273168ba9b1273a1580d569e1bac0e91Jim Grosbach // FIXME: Should we pedwarn for (int*)(0+0)? 98983ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach if (SubExpr->getType()->isArithmeticType()) 99083ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach return CheckArithmeticConstantExpression(SubExpr); 99183ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach 99283ab070fc1fbb02ca77b0a37e6ae0eacf58001e1Jim Grosbach Diag(Init->getExprLoc(), 993f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 994f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach return true; 995f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach } 996f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach case Expr::ConditionalOperatorClass: { 997f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach // FIXME: Should we pedwarn here? 998f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach const ConditionalOperator *Exp = cast<ConditionalOperator>(Init); 999f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach if (!Exp->getCond()->getType()->isArithmeticType()) { 1000f49433523e8a39db6d83503e312ae55160eed90aJim Grosbach Diag(Init->getExprLoc(), 10014a5ffb399f841783c201c599b88d576757f1922eJim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 10024a5ffb399f841783c201c599b88d576757f1922eJim Grosbach return true; 10034a5ffb399f841783c201c599b88d576757f1922eJim Grosbach } 10044a5ffb399f841783c201c599b88d576757f1922eJim Grosbach if (CheckArithmeticConstantExpression(Exp->getCond())) 10054a5ffb399f841783c201c599b88d576757f1922eJim Grosbach return true; 10064a5ffb399f841783c201c599b88d576757f1922eJim Grosbach if (Exp->getLHS() && 10074a5ffb399f841783c201c599b88d576757f1922eJim Grosbach CheckAddressConstantExpression(Exp->getLHS())) 10084a5ffb399f841783c201c599b88d576757f1922eJim Grosbach return true; 1009fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach return CheckAddressConstantExpression(Exp->getRHS()); 1010fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach } 1011fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach case Expr::AddrLabelExprClass: 1012fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach return false; 1013fff76ee7ef007b2bb74804f165fee475e30ead0dJim Grosbach } 1014ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach} 1015ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach 1016ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbachstatic const Expr* FindExpressionBaseAddress(const Expr* E); 1017ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach 1018ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbachstatic const Expr* FindExpressionBaseAddressLValue(const Expr* E) { 1019ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach switch (E->getStmtClass()) { 1020ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach default: 1021ed8384806e56952c44f8a717c1ef54a8468d2c8dJim Grosbach return E; 102270939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach case Expr::ParenExprClass: { 102370939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach const ParenExpr* PE = cast<ParenExpr>(E); 102470939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach return FindExpressionBaseAddressLValue(PE->getSubExpr()); 102570939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach } 102670939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach case Expr::MemberExprClass: { 102770939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach const MemberExpr *M = cast<MemberExpr>(E); 102870939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach if (M->isArrow()) 102970939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach return FindExpressionBaseAddress(M->getBase()); 103070939ee1415722d7f39f13faf9b3644b96007996Jim Grosbach return FindExpressionBaseAddressLValue(M->getBase()); 1031ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach } 1032ffa3225e26cc1977d20f0d9649fcd6f38a3c4815Jim Grosbach case Expr::ArraySubscriptExprClass: { 1033f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(E); 1034f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return FindExpressionBaseAddress(ASE->getBase()); 1035f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1036f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach case Expr::UnaryOperatorClass: { 1037f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach const UnaryOperator *Exp = cast<UnaryOperator>(E); 1038f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 1039f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (Exp->getOpcode() == UnaryOperator::Deref) 1040f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return FindExpressionBaseAddress(Exp->getSubExpr()); 1041f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 1042f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach return E; 1043f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1044f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 1045f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach} 1046f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 10476bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbachstatic const Expr* FindExpressionBaseAddress(const Expr* E) { 10486bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach switch (E->getStmtClass()) { 10496bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach default: 10506bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach return E; 10516bc1dbc37695bcfc5ae23a1a9e17550ee50fe02fJim Grosbach case Expr::ParenExprClass: { 10526b8f1e35eacba34a11e2a7d5f614efc47b43d2e3Jim Grosbach const ParenExpr* PE = cast<ParenExpr>(E); 10533483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar return FindExpressionBaseAddress(PE->getSubExpr()); 10543483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } 10553483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar case Expr::UnaryOperatorClass: { 105616c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach const UnaryOperator *Exp = cast<UnaryOperator>(E); 1057c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach 1058c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach // C99 6.6p9 1059c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (Exp->getOpcode() == UnaryOperator::AddrOf) 1060c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return FindExpressionBaseAddressLValue(Exp->getSubExpr()); 1061c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach 1062706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes if (Exp->getOpcode() == UnaryOperator::Extension) 1063706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes return FindExpressionBaseAddress(Exp->getSubExpr()); 1064706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 1065706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes return E; 1066706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 10677ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case Expr::BinaryOperatorClass: { 10687ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach const BinaryOperator *Exp = cast<BinaryOperator>(E); 10697ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 1070505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes Expr *PExp = Exp->getLHS(); 1071505f3cd2965e65b6b7ad023eaba0e3dc89b67409Bruno Cardoso Lopes Expr *IExp = Exp->getRHS(); 10727ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (IExp->getType()->isPointerType()) 10737ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach std::swap(PExp, IExp); 10747ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 10757ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return FindExpressionBaseAddress(PExp); 10767ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 10777ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case Expr::ImplicitCastExprClass: { 10787ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach const Expr* SubExpr = cast<ImplicitCastExpr>(E)->getSubExpr(); 10797ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 10807ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // Check for implicit promotion 10817ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (SubExpr->getType()->isFunctionType() || 10827ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach SubExpr->getType()->isArrayType()) 10837ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return FindExpressionBaseAddressLValue(SubExpr); 10847ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 1085dd32ba337aab88c215108ca8bf4a0267fce1e773Jim Grosbach // Check for pointer->pointer cast 1086ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes if (SubExpr->getType()->isPointerType()) 10877ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return FindExpressionBaseAddress(SubExpr); 10887ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 10897ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // We assume that we have an arithmetic expression here; 1090ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes // if we don't, we'll figure it out later 1091ae0855401b8c80f96904b6808b0bc4c89216aecdBruno Cardoso Lopes return 0; 1092039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach } 1093039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach case Expr::CastExprClass: { 1094039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach const Expr* SubExpr = cast<CastExpr>(E)->getSubExpr(); 1095039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach 1096039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach // Check for pointer->pointer cast 1097039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach if (SubExpr->getType()->isPointerType()) 1098039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach return FindExpressionBaseAddress(SubExpr); 1099039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach 1100039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach // We assume that we have an arithmetic expression here; 1101039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach // if we don't, we'll figure it out later 1102039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach return 0; 1103039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach } 1104039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach } 1105039c2e19c4237fb484315a62e95222ac28640bb7Jim Grosbach} 11062fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach 11072fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbachbool Sema::CheckArithmeticConstantExpression(const Expr* Init) { 11082fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach switch (Init->getStmtClass()) { 11092fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach default: 11102fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach Diag(Init->getExprLoc(), 11112fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 11122fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return true; 11132fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::ParenExprClass: { 11142fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach const ParenExpr* PE = cast<ParenExpr>(Init); 11152fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return CheckArithmeticConstantExpression(PE->getSubExpr()); 11162fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach } 11172fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::FloatingLiteralClass: 11182fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::IntegerLiteralClass: 11192fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::CharacterLiteralClass: 11202fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::ImaginaryLiteralClass: 11212fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::TypesCompatibleExprClass: 11222fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::CXXBoolLiteralExprClass: 11232fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return false; 11242fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::CallExprClass: { 11252fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach const CallExpr *CE = cast<CallExpr>(Init); 11262fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (CE->isBuiltinConstantExpr()) 11272fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return false; 11282fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach Diag(Init->getExprLoc(), 11292fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 11302fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return true; 11312fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach } 1132251bf25e7ee9702fed2a66deeb404ce473f7bac1Jim Grosbach case Expr::DeclRefExprClass: { 11332fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach const Decl *D = cast<DeclRefExpr>(Init)->getDecl(); 11342fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (isa<EnumConstantDecl>(D)) 11352fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return false; 11362fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach Diag(Init->getExprLoc(), 11372fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 11382fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return true; 11392fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach } 11402fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach case Expr::CompoundLiteralExprClass: 11412fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach // Allow "(vector type){2,4}"; normal C constraints don't allow this, 1142251bf25e7ee9702fed2a66deeb404ce473f7bac1Jim Grosbach // but vectors are allowed to be magic. 11432fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach if (Init->getType()->isVectorType()) 11442fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach return false; 11452fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach Diag(Init->getExprLoc(), 11462fd2b87ded53f6b87eb240c17d62a23fb4964ba0Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 11477ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return true; 11487ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case Expr::UnaryOperatorClass: { 11497ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach const UnaryOperator *Exp = cast<UnaryOperator>(Init); 11507ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 11517ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach switch (Exp->getOpcode()) { 11527ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 11537ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // See C99 6.6p3. 11547ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach default: 11557ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Diag(Init->getExprLoc(), 11567ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 11577ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return true; 11587ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case UnaryOperator::SizeOf: 11597ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case UnaryOperator::AlignOf: 1160a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach case UnaryOperator::OffsetOf: 1161a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach // sizeof(E) is a constantexpr if and only if E is not evaluted. 1162a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach // See C99 6.5.3.4p2 and 6.6p3. 1163a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach if (Exp->getSubExpr()->getType()->isConstantSizeType()) 1164a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach return false; 1165a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach Diag(Init->getExprLoc(), 1166a77295db19527503d6b290e4f34f273d0a789365Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 1167b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach return true; 1168b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach case UnaryOperator::Extension: 1169b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach case UnaryOperator::LNot: 1170b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach case UnaryOperator::Plus: 1171b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach case UnaryOperator::Minus: 1172b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach case UnaryOperator::Not: 1173b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach return CheckArithmeticConstantExpression(Exp->getSubExpr()); 1174b6aed508e310e31dcb080e761ca856127cec0773Jim Grosbach } 11757ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 11767ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case Expr::SizeOfAlignOfTypeExprClass: { 11777ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(Init); 11787ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // Special check for void types, which are allowed as an extension 11797ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (Exp->getArgumentType()->isVoidType()) 1180ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes return false; 1181ac79e4c82f201c30a06c2cd05baebd20f5b49888Bruno Cardoso Lopes // alignof always evaluates to a constant. 1182f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach // FIXME: is sizeof(int[3.0]) a constant expression? 1183f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach if (Exp->isSizeOf() && !Exp->getArgumentType()->isConstantSizeType()) { 1184f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach Diag(Init->getExprLoc(), 1185f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 1186a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach return true; 1187f0eee6eca8c39b11b6a41d9b04eba8985655df77Jim Grosbach } 1188a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach return false; 1189a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach } 1190a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach case Expr::BinaryOperatorClass: { 1191a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach const BinaryOperator *Exp = cast<BinaryOperator>(Init); 1192a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach 1193a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach if (Exp->getLHS()->getType()->isArithmeticType() && 1194a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach Exp->getRHS()->getType()->isArithmeticType()) { 1195a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach return CheckArithmeticConstantExpression(Exp->getLHS()) || 1196a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach CheckArithmeticConstantExpression(Exp->getRHS()); 1197a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach } 1198a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach 1199a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach if (Exp->getLHS()->getType()->isPointerType() && 1200a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach Exp->getRHS()->getType()->isPointerType()) { 1201a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach const Expr* LHSBase = FindExpressionBaseAddress(Exp->getLHS()); 1202a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach const Expr* RHSBase = FindExpressionBaseAddress(Exp->getRHS()); 1203a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach 1204a8307dd1c9279cbde1f3497e530d2ed9d014a0c5Jim Grosbach // Only allow a null (constant integer) base; we could 12057ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // allow some additional cases if necessary, but this 12067ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // is sufficient to cover offsetof-like constructs. 120709176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach if (!LHSBase && !RHSBase) { 120809176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach return CheckAddressConstantExpression(Exp->getLHS()) || 120909176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach CheckAddressConstantExpression(Exp->getRHS()); 121009176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach } 121109176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach } 121209176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach 121309176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach Diag(Init->getExprLoc(), 121409176e10dbe575b0f4c68803695c47ccb4b81f81Jim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 12157ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return true; 12167ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 12177ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case Expr::ImplicitCastExprClass: 12187ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case Expr::CastExprClass: { 121992b5a2eb1646b3c1173a5ff3c0073f24ed5ee6a4Bill Wendling const Expr *SubExpr; 12207f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach if (const CastExpr *C = dyn_cast<CastExpr>(Init)) { 12217f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach SubExpr = C->getSubExpr(); 12227f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach } else { 12237f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach SubExpr = cast<ImplicitCastExpr>(Init)->getSubExpr(); 12247f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach } 12257f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach 12267f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach if (SubExpr->getType()->isArithmeticType()) 12277f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach return CheckArithmeticConstantExpression(SubExpr); 12287f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach 12297f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach Diag(Init->getExprLoc(), 12307f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach diag::err_init_element_not_constant, Init->getSourceRange()); 12317f739bee261debdf56bd89ac922b57eca53e91dcJim Grosbach return true; 12327ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 12337ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach case Expr::ConditionalOperatorClass: { 12347ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach const ConditionalOperator *Exp = cast<ConditionalOperator>(Init); 12350d6fac36eda6b65f0e396b24c5bce582f89f7992Jim Grosbach if (CheckArithmeticConstantExpression(Exp->getCond())) 12367ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return true; 12377ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (Exp->getLHS() && 12387ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach CheckArithmeticConstantExpression(Exp->getLHS())) 12397ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return true; 1240d3df5f32c059b3ac111f1c08571d5493aa1d48c6Daniel Dunbar return CheckArithmeticConstantExpression(Exp->getRHS()); 1241ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach } 1242ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach } 1243ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach} 1244ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach 1245ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbachbool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 1246ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach Init = Init->IgnoreParens(); 1247ab899c1bcca7f1cc85342c3a686464ba4af035dfJim Grosbach 12487ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // Look through CXXDefaultArgExprs; they have no meaning in this context. 12497ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (CXXDefaultArgExpr* DAE = dyn_cast<CXXDefaultArgExpr>(Init)) 12507ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return CheckForConstantInitializer(DAE->getExpr(), DclT); 12517ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 125214b93851cc7611ae6c2000f1c162592ead954420Chris Lattner if (CompoundLiteralExpr *e = dyn_cast<CompoundLiteralExpr>(Init)) 12533483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar return CheckForConstantInitializer(e->getInitializer(), DclT); 125460f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach 125560f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach if (Init->getType()->isReferenceType()) { 125660f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach // FIXME: Work out how the heck reference types work 125760f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach return false; 125860f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach#if 0 125948ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach // A reference is constant if the address of the expression 126048ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach // is constant 126138466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach // We look through initlists here to simplify 126238466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach // CheckAddressConstantExpressionLValue. 126338466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach if (InitListExpr *Exp = dyn_cast<InitListExpr>(Init)) { 126438466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach assert(Exp->getNumInits() > 0 && 126538466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach "Refernce initializer cannot be empty"); 126638466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach Init = Exp->getInit(0); 126738466309d5c8ce408f05567fa47aeaa3b5826080Jim Grosbach } 126848ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach return CheckAddressConstantExpressionLValue(Init); 126948ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach#endif 127048ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach } 127148ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach 127248ff5ffe9e2a90f853ce3645b1b97ea7885eccf1Jim Grosbach if (InitListExpr *Exp = dyn_cast<InitListExpr>(Init)) { 127360f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach unsigned numInits = Exp->getNumInits(); 127460f91a3d9518617e29da18477ae433b8f0069304Jim Grosbach for (unsigned i = 0; i < numInits; i++) { 1275ecd858968384be029574d845eb098d357049e02eJim Grosbach // FIXME: Need to get the type of the declaration for C++, 1276ecd858968384be029574d845eb098d357049e02eJim Grosbach // because it could be a reference? 1277ecd858968384be029574d845eb098d357049e02eJim Grosbach if (CheckForConstantInitializer(Exp->getInit(i), 1278ecd858968384be029574d845eb098d357049e02eJim Grosbach Exp->getInit(i)->getType())) 1279ecd858968384be029574d845eb098d357049e02eJim Grosbach return true; 1280ecd858968384be029574d845eb098d357049e02eJim Grosbach } 1281ecd858968384be029574d845eb098d357049e02eJim Grosbach return false; 12827ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 12837ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 12847ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (Init->isNullPointerConstant(Context)) 12857ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return false; 12867ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (Init->getType()->isArithmeticType()) { 12877ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach QualType InitTy = Context.getCanonicalType(Init->getType()) 128863553c77cd1cf3b204d955fb65350db087aaff1dOwen Anderson .getUnqualifiedType(); 12897ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (InitTy == Context.BoolTy) { 12907ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // Special handling for pointers implicitly cast to bool; 1291f4caf69720d807573c50d41aa06bcec1c99bdbbdBill Wendling // (e.g. "_Bool rr = &rr;"). This is only legal at the top level. 1292ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Init)) { 12937ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Expr* SubE = ICE->getSubExpr(); 12947ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (SubE->getType()->isPointerType() || 12957ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach SubE->getType()->isArrayType() || 1296f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach SubE->getType()->isFunctionType()) { 1297f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach return CheckAddressConstantExpression(Init); 1298f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach } 1299f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach } 1300f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach } else if (InitTy->isIntegralType()) { 1301f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach Expr* SubE = 0; 1302f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Init)) 1303f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach SubE = ICE->getSubExpr(); 1304f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach else if (CastExpr* CE = dyn_cast<CastExpr>(Init)) 1305f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach SubE = CE->getSubExpr(); 1306f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // Special check for pointer cast to int; we allow as an extension 1307f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // an address constant cast to an integer if the integer 1308ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling // is of an appropriate width (this sort of code is apparently used 1309ef4a68badbde372faac9ca47efb9001def57a43dBill Wendling // in some places). 1310584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // FIXME: Add pedwarn? 1311584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // FIXME: Don't allow bitfields here! Need the FieldDecl for that. 1312584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (SubE && (SubE->getType()->isPointerType() || 1313584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes SubE->getType()->isArrayType() || 1314584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes SubE->getType()->isFunctionType())) { 1315a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned IntWidth = Context.getTypeSize(Init->getType()); 1316a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes unsigned PointerWidth = Context.getTypeSize(Context.VoidPtrTy); 1317a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (IntWidth >= PointerWidth) 1318a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes return CheckAddressConstantExpression(Init); 1319a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1320b7f689bab98777236a2bf600f299d232d246bb61Jim Grosbach } 1321b3cb6967949493a2e1b10d015ac08b746736764eDaniel Dunbar 132289df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return CheckArithmeticConstantExpression(Init); 132389df996ab20609676ecc8823f58414d598b09b46Jim Grosbach } 132489df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 132589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (Init->getType()->isPointerType()) 132689df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return CheckAddressConstantExpression(Init); 132789df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 132889df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // An array type at the top level that isn't an init-list must 132989df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // be a string literal 13303a69756e392942bc522193f38d7f33958ed3b131Chris Lattner if (Init->getType()->isArrayType()) 13313a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return false; 1332345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 1333345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Diag(Init->getExprLoc(), diag::err_init_element_not_constant, 1334345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar Init->getSourceRange()); 13353a69756e392942bc522193f38d7f33958ed3b131Chris Lattner return true; 1336345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar} 1337345a9a6269318c96f333c0492b23733e29d952dfDaniel Dunbar 1338fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopesvoid Sema::AddInitializerToDecl(DeclTy *dcl, ExprTy *init) { 1339fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Decl *RealDecl = static_cast<Decl *>(dcl); 1340fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Expr *Init = static_cast<Expr *>(init); 1341fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes assert(Init && "missing initializer"); 1342fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1343fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // If there is no declaration, there was an error parsing it. Just ignore 1344fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // the initializer. 1345fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (RealDecl == 0) { 1346fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes delete Init; 1347fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes return; 1348fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 1349fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1350fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 1351fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (!VDecl) { 1352fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Diag(dyn_cast<ScopedDecl>(RealDecl)->getLocation(), 1353fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes diag::err_illegal_initializer); 1354d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach RealDecl->setInvalidDecl(); 1355d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach return; 1356d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach } 1357d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach // Get the decls type and save a reference for later, since 1358d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach // CheckInitializerTypes may change it. 1359d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach QualType DclT = VDecl->getType(), SavT = DclT; 1360d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach if (VDecl->isBlockVarDecl()) { 1361d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach VarDecl::StorageClass SC = VDecl->getStorageClass(); 13623a69756e392942bc522193f38d7f33958ed3b131Chris Lattner if (SC == VarDecl::Extern) { // C99 6.7.8p5 13633a69756e392942bc522193f38d7f33958ed3b131Chris Lattner Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 1364762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan VDecl->setInvalidDecl(); 1365762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } else if (!VDecl->isInvalidDecl()) { 1366762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (CheckInitializerTypes(Init, DclT)) 1367762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan VDecl->setInvalidDecl(); 13683a69756e392942bc522193f38d7f33958ed3b131Chris Lattner if (SC == VarDecl::Static) // C99 6.7.8p4. 1369a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby CheckForConstantInitializer(Init, DclT); 1370a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby } 137150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling } else if (VDecl->isFileVarDecl()) { 13723a69756e392942bc522193f38d7f33958ed3b131Chris Lattner if (VDecl->getStorageClass() == VarDecl::Extern) 1373762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan Diag(VDecl->getLocation(), diag::warn_extern_init); 1374762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (!VDecl->isInvalidDecl()) 1375762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (CheckInitializerTypes(Init, DclT)) 13763a69756e392942bc522193f38d7f33958ed3b131Chris Lattner VDecl->setInvalidDecl(); 1377a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1378a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // C99 6.7.8p4. All file scoped initializers need to be constant. 1379e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach CheckForConstantInitializer(Init, DclT); 1380e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 1381e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // If the type changed, it means we had an incomplete type that was 1382e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // completed by the initializer. For example: 1383e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // int ary[] = { 1, 3, 5 }; 1384e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // "ary" transitions from a VariableArrayType to a ConstantArrayType. 1385af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach if (!VDecl->isInvalidDecl() && (DclT != SavT)) { 1386af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach VDecl->setType(DclT); 1387af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Init->setType(DclT); 1388af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach } 1389e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1390e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // Attach the initializer to the decl. 1391e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach VDecl->setInit(Init); 1392e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach return; 1393e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach} 139492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson 139592a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson/// The declarators are chained together backwards, reverse the list. 139692a202213bb4c20301abf6ab64e46df3695e60bfOwen AndersonSema::DeclTy *Sema::FinalizeDeclaratorGroup(Scope *S, DeclTy *group) { 139792a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson // Often we have single declarators, handle them quickly. 139892a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Decl *GroupDecl = static_cast<Decl*>(group); 1399af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach if (GroupDecl == 0) 1400af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach return 0; 1401af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach 140292a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson ScopedDecl *Group = dyn_cast<ScopedDecl>(GroupDecl); 140392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson ScopedDecl *NewGroup = 0; 140492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson if (Group->getNextDeclarator() == 0) 140592a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson NewGroup = Group; 140692a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson else { // reverse the list. 1407580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach while (Group) { 14080082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson ScopedDecl *Next = Group->getNextDeclarator(); 1409580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Group->setNextDeclarator(NewGroup); 1410580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach NewGroup = Group; 1411580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Group = Next; 14120082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } 14130082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } 14140082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // Perform semantic analysis that depends on having fully processed both 14150082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // the declarator and initializer. 14160082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson for (ScopedDecl *ID = NewGroup; ID; ID = ID->getNextDeclarator()) { 14177e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach VarDecl *IDecl = dyn_cast<VarDecl>(ID); 14187e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (!IDecl) 14197e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach continue; 14207e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach QualType T = IDecl->getType(); 14217e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 14227e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // C99 6.7.5.2p2: If an identifier is declared to be an object with 14237e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // static storage duration, it shall not have a variable length array. 14247e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if ((IDecl->isFileVarDecl() || IDecl->isBlockVarDecl()) && 1425293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach IDecl->getStorageClass() == VarDecl::Static) { 1426293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (T->isVariableArrayType()) { 1427293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach Diag(IDecl->getLocation(), diag::err_typecheck_illegal_vla); 1428293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach IDecl->setInvalidDecl(); 1429293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 1430293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 1431293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // Block scope. C99 6.7p7: If an identifier for an object is declared with 1432293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // no linkage (C99 6.2.2p6), the type for the object shall be complete... 1433293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (IDecl->isBlockVarDecl() && 1434293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach IDecl->getStorageClass() != VarDecl::Extern) { 14357729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling if (T->isIncompleteType() && !IDecl->isInvalidDecl()) { 14365fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type, 1437cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay T.getAsString()); 14380f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling IDecl->setInvalidDecl(); 14390f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling } 1440d300b94e51cf8c91928a66478c387c1c3d76faabJim Grosbach } 14410f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling // File scope. C99 6.9.2p2: A declaration of an identifier for and 1442d300b94e51cf8c91928a66478c387c1c3d76faabJim Grosbach // object that has file scope without an initializer, and without a 1443275944afb55086d0b4b20d4d831de7c1c7507925Evan Cheng // storage-class specifier or with the storage-class specifier "static", 14440f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling // constitutes a tentative definition. Note: A tentative definition with 14450f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling // external linkage is valid (C99 6.2.2p5). 14460f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling if (isTentativeDefinition(IDecl)) { 14475fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling if (T->isIncompleteArrayType()) { 14487729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling // C99 6.9.2 (p2, p5): Implicit initialization causes an incomplete 144924d22d27640e9de954a5ac26f51a45cc96bb9135Bill Wendling // array to be completed. Don't issue a diagnostic. 1450cb21d1c9fd1cf53f063183f7eb28af7fa4052ef0Bill Wendling } else if (T->isIncompleteType() && !IDecl->isInvalidDecl()) { 1451cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay // C99 6.9.2p3: If the declaration of an identifier for an object is 1452cc8d10e1a8a8555fa63f33e36e3c1ed2fb24389dMatt Beaumont-Gay // a tentative definition and has internal linkage (C99 6.2.2p3), the 14538d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling // declared type shall not be an incomplete type. 14548d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type, 14558d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling T.getAsString()); 14563a69756e392942bc522193f38d7f33958ed3b131Chris Lattner IDecl->setInvalidDecl(); 14573a69756e392942bc522193f38d7f33958ed3b131Chris Lattner } 1458762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan } 1459762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (IDecl->isFileVarDecl()) 1460762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan CheckForFileScopedRedefinitions(S, IDecl); 14613a69756e392942bc522193f38d7f33958ed3b131Chris Lattner } 1462cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby return NewGroup; 1463cfe072401658bbe9336b200b79526b65c5213b74Kevin Enderby} 14647ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 14657ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 14667ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach/// to introduce parameters into function prototype scope. 14677ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim GrosbachSema::DeclTy * 14680d6fac36eda6b65f0e396b24c5bce582f89f7992Jim GrosbachSema::ActOnParamDeclarator(Scope *S, Declarator &D) { 14697ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach const DeclSpec &DS = D.getDeclSpec(); 14703a69756e392942bc522193f38d7f33958ed3b131Chris Lattner 14713a69756e392942bc522193f38d7f33958ed3b131Chris Lattner // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 1472762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 14737ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach DS.getStorageClassSpec() != DeclSpec::SCS_register) { 14747ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Diag(DS.getStorageClassSpecLoc(), 1475762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan diag::err_invalid_storage_class_in_func_decl); 14760d6fac36eda6b65f0e396b24c5bce582f89f7992Jim Grosbach D.getMutableDeclSpec().ClearStorageClassSpecs(); 14777ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 14787ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (DS.isThreadSpecified()) { 14797ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Diag(DS.getThreadSpecLoc(), 14807ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach diag::err_invalid_storage_class_in_func_decl); 14817ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach D.getMutableDeclSpec().ClearStorageClassSpecs(); 148216c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach } 1483f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach 1484f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // Check that there are no default arguments inside the type of this 1485f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // parameter (C++ only). 14867ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (getLangOptions().CPlusPlus) 14877ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach CheckExtraCXXDefaultArguments(D); 14887ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 1489f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // In this context, we *do not* check D.getInvalidType(). If the declarator 1490f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // type was invalid, GetTypeForDeclarator() still returns a "valid" type, 1491f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // though it will not reflect the user specified type. 1492762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan QualType parmDeclType = GetTypeForDeclarator(D, S); 1493762647673379dbcff6bbba6167b0b1b0d658ba9dSean Callanan 14943a69756e392942bc522193f38d7f33958ed3b131Chris Lattner assert(!parmDeclType.isNull() && "GetTypeForDeclarator() returned null type"); 1495a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby 1496706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope. 1497706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes // Can this happen for params? We already checked that they don't conflict 1498706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes // among each other. Here they can only shadow globals, which is ok. 1499706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes IdentifierInfo *II = D.getIdentifier(); 1500706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes if (Decl *PrevDecl = LookupDecl(II, Decl::IDNS_Ordinary, S)) { 1501706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes if (S->isDeclScope(PrevDecl)) { 1502706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Diag(D.getIdentifierLoc(), diag::err_param_redefinition, 1503706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes dyn_cast<NamedDecl>(PrevDecl)->getName()); 1504a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1505a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Recover by removing the name 1506a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes II = 0; 1507a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes D.SetIdentifier(0, D.getIdentifierLoc()); 1508a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1509a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1510a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1511a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Perform the default function/array conversion (C99 6.7.5.3p[7,8]). 1512584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Doing the promotion here has a win and a loss. The win is the type for 1513584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // both Decl's and DeclRefExpr's will match (a convenient invariant for the 1514584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // code generator). The loss is the orginal type isn't preserved. For example: 1515584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // 1516584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // void func(int parmvardecl[5]) { // convert "int [5]" to "int *" 1517584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // int blockvardecl[5]; 1518584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // sizeof(parmvardecl); // size == 4 1519584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // sizeof(blockvardecl); // size == 20 1520a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // } 1521a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // 1522a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // For expressions, all implicit conversions are captured using the 1523a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // ImplicitCastExpr AST node (we have no such mechanism for Decl's). 1524b7f689bab98777236a2bf600f299d232d246bb61Jim Grosbach // 1525fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar // FIXME: If a source translation tool needs to see the original type, then 1526fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar // we need to consider storing both types (in ParmVarDecl)... 15276a5c22ed89c8bb73034a70105340acf6539dc58bDaniel Dunbar // 1528fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar if (parmDeclType->isArrayType()) { 1529d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach // int x[restrict 4] -> int *restrict 1530d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach parmDeclType = Context.getArrayDecayedType(parmDeclType); 1531d67641b6f804110505a69aaed5479f446bbbb34eJim Grosbach } else if (parmDeclType->isFunctionType()) 153289df996ab20609676ecc8823f58414d598b09b46Jim Grosbach parmDeclType = Context.getPointerType(parmDeclType); 153389df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 153489df996ab20609676ecc8823f58414d598b09b46Jim Grosbach ParmVarDecl *New = ParmVarDecl::Create(Context, CurContext, 153589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach D.getIdentifierLoc(), II, 153689df996ab20609676ecc8823f58414d598b09b46Jim Grosbach parmDeclType, VarDecl::None, 153789df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 0, 0); 153889df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 153989df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (D.getInvalidType()) 1540fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes New->setInvalidDecl(); 1541fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1542fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (II) 1543fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes PushOnScopeChains(New, S); 1544fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1545fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes ProcessDeclAttributes(New, D); 1546584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes return New; 1547584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes 1548584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes} 1549fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar 1550fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel DunbarSema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) { 1551fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 1552706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function && 1553706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes "Not a function declarator!"); 1554706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun; 1555fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar 15566ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 15577ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // for a K&R function. 15586ec56204f372df73e4a27085b188a72548b867acDaniel Dunbar if (!FTI.hasPrototype) { 1559fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) { 15607ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (FTI.ArgInfo[i].Param == 0) { 1561f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared, 1562f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach FTI.ArgInfo[i].Ident->getName()); 1563f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // Implicitly declare the argument as type 'int' for lack of a better 1564f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // type. 1565f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach DeclSpec DS; 1566f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach const char* PrevSpec; // unused 15677ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc, 1568a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes PrevSpec); 1569a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Declarator ParamD(DS, Declarator::KNRTypeListContext); 1570a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc); 1571a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes FTI.ArgInfo[i].Param = ActOnParamDeclarator(FnBodyScope, ParamD); 1572a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1573a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 1574a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 1575a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Since this is a function definition, act as though we have information 1576a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // about the arguments. 1577fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar if (FTI.NumArgs) 157850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling FTI.hasPrototype = true; 1579fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar } else { 1580580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // FIXME: Diagnose arguments without names in C. 1581580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 1582580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 1583e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach Scope *GlobalScope = FnBodyScope->getParent(); 1584e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 158592a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson // See if this is a redefinition. 1586af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Decl *PrevDcl = LookupDecl(D.getIdentifier(), Decl::IDNS_Ordinary, 1587af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach GlobalScope); 1588af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach if (PrevDcl && IdResolver.isDeclInScope(PrevDcl, CurContext)) { 1589af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PrevDcl)) { 1590e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach const FunctionDecl *Definition; 15910082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson if (FD->getBody(Definition)) { 159292a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Diag(D.getIdentifierLoc(), diag::err_redefinition, 159392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson D.getIdentifier()->getName()); 1594af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach Diag(Definition->getLocation(), diag::err_previous_definition); 1595af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach } 1596af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach } 159792a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson } 159892a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson 15997e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach return ActOnStartOfFunctionDef(FnBodyScope, 16007e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach ActOnDeclarator(GlobalScope, D, 0)); 16017e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach} 1602293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 1603293a2ee3063953bb6f5bc828831f985f054782a3Jim GrosbachSema::DeclTy *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclTy *D) { 1604293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach Decl *decl = static_cast<Decl*>(D); 1605293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach FunctionDecl *FD = cast<FunctionDecl>(decl); 16060f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling PushDeclContext(FD); 16070f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling 16080f6307561359fac4425a0b9e512931cf96c1ec5bBill Wendling // Check the validity of our function parameters 16098d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling CheckParmsForFunctionDef(FD); 16108d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 16115fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling // Introduce our parameters into the function scope 16125fa22a19750c082ff161db1702ebe96dd2a787e7Bill Wendling for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 16137729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling ParmVarDecl *Param = FD->getParamDecl(p); 16147729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling // If this has an identifier, add it to the scope stack. 16157729e06c128be01fc564870d5ea3d22d236dddb5Bill Wendling if (Param->getIdentifier()) 16168d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling PushOnScopeChains(Param, FnBodyScope); 16178d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling } 16188d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling 16198d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling return FD; 16208d5acb7007decaf0c30bf4a3d4c55e5cc2cce0a7Bill Wendling} 1621fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar 1622fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel DunbarSema::DeclTy *Sema::ActOnFinishFunctionBody(DeclTy *D, StmtTy *Body) { 1623fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar Decl *dcl = static_cast<Decl *>(D); 1624fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(dcl)) { 1625fa315de8f44ddb318a7c6ff913e80d71d7c68859Daniel Dunbar FD->setBody((Stmt*)Body); 16263483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar assert(FD == getCurFunctionDecl() && "Function parsing confused"); 16273483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 16283483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar MD->setBody((Stmt*)Body); 16293483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar } else 16303483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar return 0; 16313483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar PopDeclContext(); 16323483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar // Verify and clean out per-function state. 16333483acabf012b847b13b969ebd9ce5c4d16d9eb7Daniel Dunbar 163469df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilson // Check goto/label use. 163569df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilson for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator 16361355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach I = LabelMap.begin(), E = LabelMap.end(); I != E; ++I) { 1637bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky // Verify that we have no forward references left. If so, there was a goto 1638bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky // or address of a label taken, but no definition of it. Label fwd 1639bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky // definitions are indicated with a null substmt. 1640bf7553210ae44f05e7460edeae1ee499d8a22dcbRoman Divacky if (I->second->getSubStmt() == 0) { 16419c41fa87eac369d84f8bfc2245084cd39f281ee4Kevin Enderby LabelStmt *L = I->second; 1642e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner // Emit error. 1643e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner Diag(L->getIdentLoc(), diag::err_undeclared_label_use, L->getName()); 16443a69756e392942bc522193f38d7f33958ed3b131Chris Lattner 16451355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // At this point, we have gotos that use the bogus label. Stitch it into 164618b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan // the function body so that they aren't leaked and that the AST is well 16477ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach // formed. 1648d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach if (Body) { 1649a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby L->setSubStmt(new NullStmt(L->getIdentLoc())); 1650a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby cast<CompoundStmt>((Stmt*)Body)->push_back(L); 16510c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson } else { 16520c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson // The whole function wasn't parsed correctly, just delete this. 16530c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson delete L; 16540c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson } 16550c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson } 16560c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson } 16570c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson LabelMap.clear(); 16580c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson 16590c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson return D; 16600c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson} 16610c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson 16620c9f250d54ed59108fffe5ce2f7df7bc8448915cOwen Anderson/// ImplicitlyDefineFunction - An undeclared identifier was used in a function 166369df72367f45c0414541196efaf7c13b1ccd3f08Bob Wilson/// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 1664b9a25b7744ed12b80031426978decce3d4cebbd7Sean CallananScopedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 1665e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner IdentifierInfo &II, Scope *S) { 1666e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner // Extension in C99. Legal in C90, but warn about it. 1667d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach if (getLangOptions().C99) 166819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Diag(Loc, diag::ext_implicit_function_decl, II.getName()); 166919906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach else 167019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Diag(Loc, diag::warn_implicit_function_decl, II.getName()); 167119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach 167219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach // FIXME: handle stuff like: 16730d87ec21d79c8622733b8367aa41067169602480Jim Grosbach // void foo() { extern float X(); } 16740082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // void bar() { X(); } <-- implicit decl for X in another scope. 16750082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 16760082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // Set a Declarator for the implicit definition: int foo(); 16770082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson const char *Dummy; 16780082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson DeclSpec DS; 16790082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy); 16800082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Error = Error; // Silence warning. 16810082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson assert(!Error && "Error setting up implicit decl!"); 16820082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson Declarator D(DS, Declarator::BlockContext); 16830082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, 0, 0, Loc)); 16840082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson D.SetIdentifier(&II, Loc); 16850082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 16860082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // Insert this function into translation-unit scope. 16870082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson 16880082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson DeclContext *PrevDC = CurContext; 16890082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson CurContext = Context.getTranslationUnitDecl(); 169019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach 16910082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson FunctionDecl *FD = 1692e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach dyn_cast<FunctionDecl>(static_cast<Decl*>(ActOnDeclarator(TUScope, D, 0))); 1693e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach FD->setImplicit(); 1694e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1695e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach CurContext = PrevDC; 1696e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1697eac0796542d098caa371856d545faa6cdab5aad3Benjamin Kramer return FD; 1698e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach} 1699e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1700e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1701e8606dc7c878d4562da5e3e5609b9d7d734d498cJim GrosbachTypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 1702e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach ScopedDecl *LastDeclarator) { 1703e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 1704e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 1705e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1706e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // Scope manipulation handled by caller. 1707e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 1708e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach D.getIdentifierLoc(), 1709e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach D.getIdentifier(), 1710e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach T, LastDeclarator); 1711e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach if (D.getInvalidType()) 1712e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach NewTD->setInvalidDecl(); 1713e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach return NewTD; 171419906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach} 171519906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach 171619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the 171719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach/// former case, Name will be non-null. In the later case, Name will be null. 1718e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach/// TagType indicates what kind of tag this is. TK indicates whether this is a 1719e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach/// reference/declaration/definition of a tag. 172019906729a490744ce3071d20e3d514cadc12e6c5Jim GrosbachSema::DeclTy *Sema::ActOnTag(Scope *S, unsigned TagType, TagKind TK, 172119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach SourceLocation KWLoc, IdentifierInfo *Name, 172219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach SourceLocation NameLoc, AttributeList *Attr) { 172319906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach // If this is a use of an existing tag, it must have a name. 1724e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach assert((Name != 0 || TK == TK_Definition) && 1725e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach "Nameless record must be a definition!"); 1726e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach 1727e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach TagDecl::TagKind Kind; 1728e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach switch (TagType) { 1729e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach default: assert(0 && "Unknown tag type!"); 1730e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 173119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 173219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 1733e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach case DeclSpec::TST_enum: Kind = TagDecl::TK_enum; break; 1734e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach } 17351355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach 1736e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // If this is a named struct, check to see if there was a previous forward 173719906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach // declaration or definition. 173819906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach // Use ScopedDecl instead of TagDecl, because a NamespaceDecl may come up. 173919906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (ScopedDecl *PrevDecl = 174019906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach dyn_cast_or_null<ScopedDecl>(LookupDecl(Name, Decl::IDNS_Tag, S))) { 174119906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach 174219906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach assert((isa<TagDecl>(PrevDecl) || isa<NamespaceDecl>(PrevDecl)) && 1743e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach "unexpected Decl type"); 174419906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 174519906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach // If this is a use of a previous tag, or if the tag is already declared 1746e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // in the same scope (so that the definition/declaration completes or 1747e8606dc7c878d4562da5e3e5609b9d7d734d498cJim Grosbach // rementions the tag), reuse the decl. 174892a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson if (TK == TK_Reference || 174992a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson IdResolver.isDeclInScope(PrevDecl, CurContext, S)) { 1750af6981f2f59f0d825ad973e0bed8fff5d302196fJim Grosbach // Make sure that this wasn't declared as an enum and now used as a 17510082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // struct or something similar. 175292a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson if (PrevTagDecl->getTagKind() != Kind) { 175392a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Diag(KWLoc, diag::err_use_with_wrong_tag, Name->getName()); 175492a202213bb4c20301abf6ab64e46df3695e60bfOwen Anderson Diag(PrevDecl->getLocation(), diag::err_previous_use); 17550082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // Recover by making this an anonymous redefinition. 175619906729a490744ce3071d20e3d514cadc12e6c5Jim Grosbach Name = 0; 17570082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson PrevDecl = 0; 17580082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson } else { 17590082830cb26248178fe5cc9bbdbd00881556c33dOwen Anderson // If this is a use or a forward declaration, we're good. 176050d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling if (TK != TK_Definition) 176150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling return PrevDecl; 176250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling 1763e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner // Diagnose attempts to redefine a tag. 1764e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner if (PrevTagDecl->isDefinition()) { 1765e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner Diag(NameLoc, diag::err_redefinition, Name->getName()); 176650d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling Diag(PrevDecl->getLocation(), diag::err_previous_definition); 17671355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // If this is a redefinition, recover by making this struct be 1768e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner // anonymous, which will make any later references get the previous 17691355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach // definition. 1770e717610f53e0465cde198536561a3c00ce29d59fBill Wendling Name = 0; 177150d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling } else { 1772d4462a5a4feae0293ca14376ff25d8bb72dd12a9Jim Grosbach // Okay, this is definition of a previously declared or referenced 177350d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling // tag. Move the location of the decl to be the definition site. 1774a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby PrevDecl->setLocation(NameLoc); 1775e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner return PrevDecl; 1776e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner } 177750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling } 177850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling } 1779e5658fa15ebb733e0786a96c1852c7cf590d5b24Chris Lattner // If we get here, this is a definition of a new struct type in a nested 178099e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby // scope, e.g. "struct foo; void bar() { struct foo; }", just create a new 178199e6d4e8392497d950d48b03f45c79b7dd131327Kevin Enderby // type. 178250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling } else { 1783a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby // PrevDecl is a namespace. 1784a7ba3a81c008142a91d799e2ec3152cfd6bbb15fKevin Enderby if (IdResolver.isDeclInScope(PrevDecl, CurContext, S)) { 1785fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // The tag name clashes with a namespace name, issue an error and recover 1786fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // by making this tag be anonymous. 1787fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Diag(NameLoc, diag::err_redefinition_different_kind, Name->getName()); 1788fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Diag(PrevDecl->getLocation(), diag::err_previous_definition); 1789e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson Name = 0; 1790e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1791e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1792e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1793e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1794fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // If there is an identifier, use the location of the identifier as the 1795e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // location of the decl, otherwise use the location of the struct/union 1796e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // keyword. 1797e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 1798e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1799e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // Otherwise, if this is the first time we've seen this tag, create the decl. 1800e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson TagDecl *New; 1801e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson if (Kind == TagDecl::TK_enum) { 1802e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 1803e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // enum X { A, B, C } D; D should chain to X. 1804e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson New = EnumDecl::Create(Context, CurContext, Loc, Name, 0); 1805e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // If this is an undefined enum, warn. 1806e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson if (TK != TK_Definition) Diag(Loc, diag::ext_forward_ref_enum); 1807e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } else { 1808e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // struct/union/class 1809e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1810e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 1811fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // struct X { int A; } D; D should chain to X. 1812e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson if (getLangOptions().CPlusPlus) 1813e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // FIXME: Look for a way to use RecordDecl for simple structs. 1814e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson New = CXXRecordDecl::Create(Context, Kind, CurContext, Loc, Name, 0); 1815e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson else 1816e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson New = RecordDecl::Create(Context, Kind, CurContext, Loc, Name, 0); 1817e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1818e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1819e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // If this has an identifier, add it to the scope stack. 1820e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson if (Name) { 1821e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // The scope passed in may not be a decl scope. Zip up the scope tree until 1822e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // we find one that is. 1823e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson while ((S->getFlags() & Scope::DeclScope) == 0) 1824e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson S = S->getParent(); 1825e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1826e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson // Add it to the decl chain. 1827e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson PushOnScopeChains(New, S); 182889df996ab20609676ecc8823f58414d598b09b46Jim Grosbach } 182989df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 183089df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (Attr) 183189df996ab20609676ecc8823f58414d598b09b46Jim Grosbach ProcessDeclAttributeList(New, Attr); 183289df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return New; 183389df996ab20609676ecc8823f58414d598b09b46Jim Grosbach} 183489df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 183589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach/// Collect the instance variables declared in an Objective-C object. Used in 183689df996ab20609676ecc8823f58414d598b09b46Jim Grosbach/// the creation of structures from objects using the @defs directive. 183789df996ab20609676ecc8823f58414d598b09b46Jim Grosbachstatic void CollectIvars(ObjCInterfaceDecl *Class, 183889df996ab20609676ecc8823f58414d598b09b46Jim Grosbach llvm::SmallVectorImpl<Sema::DeclTy*> &ivars) { 183989df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (Class->getSuperClass()) 184089df996ab20609676ecc8823f58414d598b09b46Jim Grosbach CollectIvars(Class->getSuperClass(), ivars); 184189df996ab20609676ecc8823f58414d598b09b46Jim Grosbach ivars.append(Class->ivar_begin(), Class->ivar_end()); 184289df996ab20609676ecc8823f58414d598b09b46Jim Grosbach} 184389df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 184489df996ab20609676ecc8823f58414d598b09b46Jim Grosbach/// Called whenever @defs(ClassName) is encountered in the source. Inserts the 184589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach/// instance variables of ClassName into Decls. 184689df996ab20609676ecc8823f58414d598b09b46Jim Grosbachvoid Sema::ActOnDefs(Scope *S, SourceLocation DeclStart, 184789df996ab20609676ecc8823f58414d598b09b46Jim Grosbach IdentifierInfo *ClassName, 184889df996ab20609676ecc8823f58414d598b09b46Jim Grosbach llvm::SmallVectorImpl<DeclTy*> &Decls) { 184989df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // Check that ClassName is a valid class 185089df996ab20609676ecc8823f58414d598b09b46Jim Grosbach ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName); 185189df996ab20609676ecc8823f58414d598b09b46Jim Grosbach if (!Class) { 185289df996ab20609676ecc8823f58414d598b09b46Jim Grosbach Diag(DeclStart, diag::err_undef_interface, ClassName->getName()); 185389df996ab20609676ecc8823f58414d598b09b46Jim Grosbach return; 185489df996ab20609676ecc8823f58414d598b09b46Jim Grosbach } 185589df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // Collect the instance variables 185689df996ab20609676ecc8823f58414d598b09b46Jim Grosbach CollectIvars(Class, Decls); 185789df996ab20609676ecc8823f58414d598b09b46Jim Grosbach} 185889df996ab20609676ecc8823f58414d598b09b46Jim Grosbach 185989df996ab20609676ecc8823f58414d598b09b46Jim GrosbachQualType Sema::TryFixInvalidVariablyModifiedType(QualType T) { 186089df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // This method tries to turn a variable array into a constant 186189df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // array even when the size isn't an ICE. This is necessary 186289df996ab20609676ecc8823f58414d598b09b46Jim Grosbach // for compatibility with code that depends on gcc's buggy 186343904299b05bdf579415749041f77c4490fe5f5bJim Grosbach // constant expression folding, like struct {char x[(int)(char*)2];} 1864fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T)) { 1865fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes APValue Result; 1866f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach if (VLATy->getSizeExpr() && 186743904299b05bdf579415749041f77c4490fe5f5bJim Grosbach VLATy->getSizeExpr()->tryEvaluate(Result, Context) && Result.isInt()) { 1868e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson llvm::APSInt &Res = Result.getInt(); 1869e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson if (Res > llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) 1870e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson return Context.getConstantArrayType(VLATy->getElementType(), 1871e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson Res, ArrayType::Normal, 0); 1872fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes } 1873e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } 1874f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach return QualType(); 1875e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson} 1876e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1877fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes/// ActOnField - Each field of a struct/union/class is passed into this in order 1878f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach/// to create a FieldDecl object for it. 1879fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso LopesSema::DeclTy *Sema::ActOnField(Scope *S, 1880fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes SourceLocation DeclStart, 188143904299b05bdf579415749041f77c4490fe5f5bJim Grosbach Declarator &D, ExprTy *BitfieldWidth) { 1882fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes IdentifierInfo *II = D.getIdentifier(); 1883fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes Expr *BitWidth = (Expr*)BitfieldWidth; 1884f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach SourceLocation Loc = DeclStart; 188543904299b05bdf579415749041f77c4490fe5f5bJim Grosbach if (II) Loc = D.getIdentifierLoc(); 1886fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1887fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // FIXME: Unnamed fields can be handled in various different ways, for 1888fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // example, unnamed unions inject all members into the struct namespace! 1889fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1890fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1891fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes if (BitWidth) { 1892f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // TODO: Validate. 1893fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes //printf("WARNING: BITFIELDS IGNORED!\n"); 1894fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes 1895fafde7f0b7c70e08de719d9e33ce9f6fdaefc984Bruno Cardoso Lopes // 6.7.2.1p3 1896f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach // 6.7.2.1p4 1897e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson 1898e4e5e2aae7e1e0e84877061432e7b981a360a77dOwen Anderson } else { 1899d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // Not a bitfield. 1900d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1901d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // validate II. 1902d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1903d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } 1904d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1905d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach QualType T = GetTypeForDeclarator(D, S); 1906d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 1907d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach bool InvalidDecl = false; 1908d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1909d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // C99 6.7.2.1p8: A member of a structure or union may have any type other 1910d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // than a variably modified type. 1911d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach if (T->isVariablyModifiedType()) { 1912d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach QualType FixedTy = TryFixInvalidVariablyModifiedType(T); 1913d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach if (!FixedTy.isNull()) { 1914d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach Diag(Loc, diag::warn_illegal_constant_array_size, Loc); 1915d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach T = FixedTy; 1916d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } else { 1917d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // FIXME: This diagnostic needs work 1918d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach Diag(Loc, diag::err_typecheck_illegal_vla, Loc); 1919d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach InvalidDecl = true; 1920d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } 1921d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } 192250d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling // FIXME: Chain fielddecls together. 19231355cf1f76abe9699cd1c2838da132ff8b25b76bJim Grosbach FieldDecl *NewFD; 192418b8323de70e3461b5d035e3f9e4f6dfaf5e674bSean Callanan 1925a60f157b7c6fb60b33598fa5143ed8cb91aa5107Bill Wendling if (getLangOptions().CPlusPlus) { 1926e717610f53e0465cde198536561a3c00ce29d59fBill Wendling // FIXME: Replace CXXFieldDecls with FieldDecls for simple structs. 1927d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach NewFD = CXXFieldDecl::Create(Context, cast<CXXRecordDecl>(CurContext), 1928d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach Loc, II, T, BitWidth); 192916c7425cff6ac3d0a4a9c56779bdfa91b2e8e863Jim Grosbach if (II) 1930d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach PushOnScopeChains(NewFD, S); 1931d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } 1932d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach else 1933d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach NewFD = FieldDecl::Create(Context, Loc, II, T, BitWidth); 1934d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1935d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach ProcessDeclAttributes(NewFD, D); 1936d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1937d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach if (D.getInvalidType() || InvalidDecl) 1938d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach NewFD->setInvalidDecl(); 1939d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach return NewFD; 1940d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach} 1941d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1942d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach/// TranslateIvarVisibility - Translate visibility from a token ID to an 1943d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach/// AST enum value. 1944d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbachstatic ObjCIvarDecl::AccessControl 1945e717610f53e0465cde198536561a3c00ce29d59fBill WendlingTranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 1946d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach switch (ivarVisibility) { 1947d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach case tok::objc_private: return ObjCIvarDecl::Private; 1948d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach case tok::objc_public: return ObjCIvarDecl::Public; 1949d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach case tok::objc_protected: return ObjCIvarDecl::Protected; 1950d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach case tok::objc_package: return ObjCIvarDecl::Package; 1951d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach default: assert(false && "Unknown visitibility kind"); 1952d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } 1953d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach} 1954d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1955d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach/// ActOnIvar - Each ivar field of an objective-c class is passed into this 1956d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach/// in order to create an IvarDecl object for it. 1957d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim GrosbachSema::DeclTy *Sema::ActOnIvar(Scope *S, 1958d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach SourceLocation DeclStart, 1959d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach Declarator &D, ExprTy *BitfieldWidth, 1960d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach tok::ObjCKeywordKind Visibility) { 1961d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach IdentifierInfo *II = D.getIdentifier(); 1962d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach Expr *BitWidth = (Expr*)BitfieldWidth; 1963d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach SourceLocation Loc = DeclStart; 1964d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach if (II) Loc = D.getIdentifierLoc(); 1965d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1966d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // FIXME: Unnamed fields can be handled in various different ways, for 1967d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // example, unnamed unions inject all members into the struct namespace! 1968d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1969d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1970d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach if (BitWidth) { 1971d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // TODO: Validate. 1972d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach //printf("WARNING: BITFIELDS IGNORED!\n"); 1973d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1974d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // 6.7.2.1p3 1975d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // 6.7.2.1p4 1976d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1977d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } else { 1978d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // Not a bitfield. 1979d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1980d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // validate II. 1981d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1982d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } 1983d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1984d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach QualType T = GetTypeForDeclarator(D, S); 1985d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 19862d539691a1e4b9d61853aa99d1a5580dc88595dbJim Grosbach bool InvalidDecl = false; 1987d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1988d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // C99 6.7.2.1p8: A member of a structure or union may have any type other 1989d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // than a variably modified type. 1990d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach if (T->isVariablyModifiedType()) { 1991d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // FIXME: This diagnostic needs work 1992d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach Diag(Loc, diag::err_typecheck_illegal_vla, Loc); 1993d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach InvalidDecl = true; 1994d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach } 1995d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 1996d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // Get the visibility (access control) for this ivar. 1997d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach ObjCIvarDecl::AccessControl ac = 1998d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 1999d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach : ObjCIvarDecl::None; 2000d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 2001d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // Construct the decl. 2002d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, Loc, II, T, ac, 2003d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach (Expr *)BitfieldWidth); 2004d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach 2005d0588e2a2ed1f7570f13b78c2042855dc4afae10Jim Grosbach // Process attributes attached to the ivar. 2006e717610f53e0465cde198536561a3c00ce29d59fBill Wendling ProcessDeclAttributes(NewID, D); 200750d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling 200850d0f5894448aff6eb02ad63da55ecf26b54aeb8Bill Wendling if (D.getInvalidType() || InvalidDecl) 2009d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby NewID->setInvalidDecl(); 2010d7894f105a3c397a3d7f5c5136eee39f5865e64bKevin Enderby 201143904299b05bdf579415749041f77c4490fe5f5bJim Grosbach return NewID; 2012f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach} 201343904299b05bdf579415749041f77c4490fe5f5bJim Grosbach 2014706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopesvoid Sema::ActOnFields(Scope* S, 2015706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes SourceLocation RecLoc, DeclTy *RecDecl, 2016706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes DeclTy **Fields, unsigned NumFields, 2017706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes SourceLocation LBrac, SourceLocation RBrac) { 2018706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Decl *EnclosingDecl = static_cast<Decl*>(RecDecl); 2019706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(EnclosingDecl && "missing record or interface decl"); 2020706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 2021706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 2022032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach if (Record && Record->isDefinition()) { 2023706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes // Diagnose code like: 2024032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach // struct S { struct S {} X; }; 2025706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes // We discover this when we complete the outer S. Reject and ignore the 2026706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes // outer S. 2027032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach Diag(Record->getLocation(), diag::err_nested_redefinition, 2028706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Record->getKindName()); 2029032434d622b6cd030a60bb9045a520c93b0d7d68Jim Grosbach Diag(RecLoc, diag::err_previous_definition); 2030706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes Record->setInvalidDecl(); 2031706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes return; 2032706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes } 2033706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes // Verify that all the fields are okay. 2034706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes unsigned NumNamedMembers = 0; 2035f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach llvm::SmallVector<FieldDecl*, 32> RecFields; 2036706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes llvm::SmallSet<const IdentifierInfo*, 32> FieldIDs; 2037706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes 2038706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes for (unsigned i = 0; i != NumFields; ++i) { 2039f922c47143d247cbae14b294a0bada139bcd35f6Jim Grosbach 2040706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes FieldDecl *FD = cast_or_null<FieldDecl>(static_cast<Decl*>(Fields[i])); 2041706d946cfe44fa93f482c3a56ed42d52ca81b257Bruno Cardoso Lopes assert(FD && "missing field decl"); 204243904299b05bdf579415749041f77c4490fe5f5bJim Grosbach 2043a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Remember all fields. 204443904299b05bdf579415749041f77c4490fe5f5bJim Grosbach RecFields.push_back(FD); 2045a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 2046a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // Get the type for the field. 2047a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Type *FDTy = FD->getType().getTypePtr(); 2048a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes 2049a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // C99 6.7.2.1p2 - A field may not be a function type. 2050a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (FDTy->isFunctionType()) { 2051a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Diag(FD->getLocation(), diag::err_field_declared_as_function, 2052a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes FD->getName()); 2053a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes FD->setInvalidDecl(); 2054a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes EnclosingDecl->setInvalidDecl(); 2055a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes continue; 2056a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2057a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes // C99 6.7.2.1p2 - A field may not be an incomplete type except... 2058a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (FDTy->isIncompleteType()) { 2059a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (!Record) { // Incomplete ivar type is always an error. 2060a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Diag(FD->getLocation(), diag::err_field_incomplete, FD->getName()); 2061a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes FD->setInvalidDecl(); 2062a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes EnclosingDecl->setInvalidDecl(); 2063a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes continue; 2064a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes } 2065a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes if (i != NumFields-1 || // ... that the last member ... 2066a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes !Record->isStruct() || // ... of a structure ... 2067a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes !FDTy->isArrayType()) { //... may have incomplete array type. 2068a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes Diag(FD->getLocation(), diag::err_field_incomplete, FD->getName()); 2069584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FD->setInvalidDecl(); 2070584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes EnclosingDecl->setInvalidDecl(); 207143904299b05bdf579415749041f77c4490fe5f5bJim Grosbach continue; 2072584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 207343904299b05bdf579415749041f77c4490fe5f5bJim Grosbach if (NumNamedMembers < 1) { //... must have more than named member ... 2074584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Diag(FD->getLocation(), diag::err_flexible_array_empty_struct, 2075584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FD->getName()); 2076584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FD->setInvalidDecl(); 2077584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes EnclosingDecl->setInvalidDecl(); 2078584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes continue; 2079584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2080584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Okay, we have a legal flexible array member at the end of the struct. 2081584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (Record) 2082b29b4dd988c50d5c4a15cd196e7910bf46f30b83Jim Grosbach Record->setHasFlexibleArrayMember(true); 2083584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2084584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes /// C99 6.7.2.1p2 - a struct ending in a flexible array member cannot be the 2085584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes /// field of another structure or the element of an array. 2086584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (const RecordType *FDTTy = FDTy->getAsRecordType()) { 2087584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (FDTTy->getDecl()->hasFlexibleArrayMember()) { 2088584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // If this is a member of a union, then entire union becomes "flexible". 2089584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (Record && Record->isUnion()) { 2090584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Record->setHasFlexibleArrayMember(true); 2091584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } else { 2092584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // If this is a struct/class and this is not the last element, reject 2093b29b4dd988c50d5c4a15cd196e7910bf46f30b83Jim Grosbach // it. Note that GCC supports variable sized arrays in the middle of 2094584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // structures. 2095584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (i != NumFields-1) { 2096584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Diag(FD->getLocation(), diag::err_variable_sized_type_in_struct, 2097584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FD->getName()); 20984b19c9865ee94367d7b3594c36e59e4c15ba82ccJoerg Sonnenberger FD->setInvalidDecl(); 2099584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes EnclosingDecl->setInvalidDecl(); 2100584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes continue; 2101584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2102bf841cf3360558d2939c9f1a244a7a7296f846dfJim Grosbach // We support flexible arrays at the end of structs in other structs 21034b19c9865ee94367d7b3594c36e59e4c15ba82ccJoerg Sonnenberger // as an extension. 2104584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Diag(FD->getLocation(), diag::ext_flexible_array_in_struct, 210556926a39619bd644c83c4128f0b55189e52707d7Bruno Cardoso Lopes FD->getName()); 210656926a39619bd644c83c4128f0b55189e52707d7Bruno Cardoso Lopes if (Record) 2107584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Record->setHasFlexibleArrayMember(true); 2108584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2109584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2110584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2111584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes /// A field cannot be an Objective-c object 2112584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (FDTy->isObjCInterfaceType()) { 2113584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Diag(FD->getLocation(), diag::err_statically_allocated_object, 2114584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FD->getName()); 2115584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FD->setInvalidDecl(); 2116584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes EnclosingDecl->setInvalidDecl(); 2117584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes continue; 2118584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2119584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Keep track of the number of named members. 2120584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (IdentifierInfo *II = FD->getIdentifier()) { 2121584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Detect duplicate member names. 2122584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (!FieldIDs.insert(II)) { 2123584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Diag(FD->getLocation(), diag::err_duplicate_member, II->getName()); 2124584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes // Find the previous decl. 2125584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes SourceLocation PrevLoc; 2126584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes for (unsigned i = 0, e = RecFields.size(); ; ++i) { 2127584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes assert(i != e && "Didn't find previous def!"); 2128584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes if (RecFields[i]->getIdentifier() == II) { 2129584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes PrevLoc = RecFields[i]->getLocation(); 2130584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes break; 2131584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2132584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes } 2133584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes Diag(PrevLoc, diag::err_previous_definition); 2134584bf7bb03e4cf1475b26851edcc1ddb66b85028Bruno Cardoso Lopes FD->setInvalidDecl(); 2135a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes EnclosingDecl->setInvalidDecl(); 2136a2b6e4151b75248f9dbf8067186cba673520f8f4Bruno Cardoso Lopes continue; 2137f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 2138f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach ++NumNamedMembers; 2139f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 2140f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 2141f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 2142f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // Okay, we successfully defined 'Record'. 2143f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (Record) { 2144f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Record->defineBody(&RecFields[0], RecFields.size()); 2145f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Consumer.HandleTagDeclDefinition(Record); 2146f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } else { 2147f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach ObjCIvarDecl **ClsFields = reinterpret_cast<ObjCIvarDecl**>(&RecFields[0]); 2148f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) 2149f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach ID->addInstanceVariablesToClass(ClsFields, RecFields.size(), RBrac); 2150f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach else if (ObjCImplementationDecl *IMPDecl = 2151f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 2152f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 2153f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach IMPDecl->ObjCAddInstanceVariablesToClassImpl(ClsFields, RecFields.size()); 2154f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 2155f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 2156f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach } 2157f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach} 2158f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 2159f6c0525d421cb48119423a96e23289b473eddbd7Jim GrosbachSema::DeclTy *Sema::ActOnEnumConstant(Scope *S, DeclTy *theEnumDecl, 2160f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach DeclTy *lastEnumConst, 2161f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach SourceLocation IdLoc, IdentifierInfo *Id, 2162f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach SourceLocation EqualLoc, ExprTy *val) { 2163f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach EnumDecl *TheEnumDecl = cast<EnumDecl>(static_cast<Decl*>(theEnumDecl)); 2164f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach EnumConstantDecl *LastEnumConst = 2165f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach cast_or_null<EnumConstantDecl>(static_cast<Decl*>(lastEnumConst)); 2166f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach Expr *Val = static_cast<Expr*>(val); 2167f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 2168f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // The scope passed in may not be a decl scope. Zip up the scope tree until 2169f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // we find one that is. 2170f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach while ((S->getFlags() & Scope::DeclScope) == 0) 2171f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach S = S->getParent(); 2172f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach 2173f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // Verify that there isn't already something declared with this name in this 2174f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // scope. 2175f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (Decl *PrevDecl = LookupDecl(Id, Decl::IDNS_Ordinary, S)) { 2176f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // When in C++, we may get a TagDecl with the same name; in this case the 2177f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach // enum constant will 'hide' the tag. 2178f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 2179f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach "Received TagDecl when not in C++!"); 2180f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (!isa<TagDecl>(PrevDecl) && 2181f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach IdResolver.isDeclInScope(PrevDecl, CurContext, S)) { 2182f6c0525d421cb48119423a96e23289b473eddbd7Jim Grosbach if (isa<EnumConstantDecl>(PrevDecl)) 2183c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Diag(IdLoc, diag::err_redefinition_of_enumerator, Id->getName()); 2184c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach else 2185c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Diag(IdLoc, diag::err_redefinition, Id->getName()); 2186c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Diag(PrevDecl->getLocation(), diag::err_previous_definition); 2187c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach delete Val; 2188c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach return 0; 2189c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach } 2190c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach } 2191c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach 2192c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach llvm::APSInt EnumVal(32); 2193c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach QualType EltTy; 2194c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (Val) { 2195c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach // Make sure to promote the operand type to int. 2196c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach UsualUnaryConversions(Val); 2197c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach 2198c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach // C99 6.7.2.2p2: Make sure we have an integer constant expression. 2199c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach SourceLocation ExpLoc; 2200c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach if (!Val->isIntegerConstantExpr(EnumVal, Context, &ExpLoc)) { 2201c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Diag(ExpLoc, diag::err_enum_value_not_integer_constant_expr, 2202c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Id->getName()); 2203c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach delete Val; 2204c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach Val = 0; // Just forget about it. 2205c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach } else { 2206c27d4f9ea0cb9064d3e2cadb384d73e95e9de449Jim Grosbach EltTy = Val->getType(); 2207580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 2208580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 2209580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2210580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (!Val) { 2211580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (LastEnumConst) { 2212580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // Assign the last value + 1. 2213580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EnumVal = LastEnumConst->getInitVal(); 2214580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach ++EnumVal; 2215580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2216580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // Check for overflow on increment. 2217580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (EnumVal < LastEnumConst->getInitVal()) 2218580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Diag(IdLoc, diag::warn_enum_value_overflow); 2219580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2220580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EltTy = LastEnumConst->getType(); 2221580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } else { 2222580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // First value, set to zero. 2223580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EltTy = Context.IntTy; 2224580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy))); 2225580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 2226580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 2227580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2228580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EnumConstantDecl *New = 2229580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EnumConstantDecl::Create(Context, TheEnumDecl, IdLoc, Id, EltTy, 2230580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Val, EnumVal, 2231580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach LastEnumConst); 2232580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2233580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // Register this decl in the current scope stack. 2234580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach PushOnScopeChains(New, S); 2235580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return New; 2236580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach} 2237580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2238580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach// FIXME: For consistency with ActOnFields(), we should have the parser 2239580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach// pass in the source location for the left/right braces. 2240580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbachvoid Sema::ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDeclX, 2241580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach DeclTy **Elements, unsigned NumElements) { 2242580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EnumDecl *Enum = cast<EnumDecl>(static_cast<Decl*>(EnumDeclX)); 2243580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2244580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (Enum && Enum->isDefinition()) { 2245580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // Diagnose code like: 2246580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // enum e0 { 2247580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // E0 = sizeof(enum e0 { E1 }) 2248580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // }; 2249580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Diag(Enum->getLocation(), diag::err_nested_redefinition, 2250580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Enum->getName()); 2251580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Diag(EnumLoc, diag::err_previous_definition); 2252580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach Enum->setInvalidDecl(); 2253580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach return; 2254580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach } 2255580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // TODO: If the result value doesn't fit in an int, it must be a long or long 2256580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // long value. ISO C does not support this, but GCC does as an extension, 2257580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // emit a warning. 22580afa0094afdfe589f407feb76948f273b414b278Owen Anderson unsigned IntWidth = Context.Target.getIntWidth(); 22590afa0094afdfe589f407feb76948f273b414b278Owen Anderson 22600afa0094afdfe589f407feb76948f273b414b278Owen Anderson // Verify that all the values are okay, compute the size of the values, and 22610afa0094afdfe589f407feb76948f273b414b278Owen Anderson // reverse the list. 22620afa0094afdfe589f407feb76948f273b414b278Owen Anderson unsigned NumNegativeBits = 0; 2263580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach unsigned NumPositiveBits = 0; 2264580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2265580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // Keep track of whether all elements have type int. 2266580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach bool AllElementsInt = true; 2267580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2268580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EnumConstantDecl *EltList = 0; 2269580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach for (unsigned i = 0; i != NumElements; ++i) { 2270580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach EnumConstantDecl *ECD = 2271580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i])); 2272580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach if (!ECD) continue; // Already issued a diagnostic. 2273580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach 2274580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach // If the enum value doesn't fit in an int, emit an extension warning. 2275580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach const llvm::APSInt &InitVal = ECD->getInitVal(); 2276580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach assert(InitVal.getBitWidth() >= IntWidth && 2277580f4a9c1c2fcbb8877463f873c6e9ca2a5ccf9fJim Grosbach "Should have promoted value to int"); 22787e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (InitVal.getBitWidth() > IntWidth) { 22797e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach llvm::APSInt V(InitVal); 22807e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach V.trunc(IntWidth); 22817e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach V.extend(InitVal.getBitWidth()); 22827e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (V != InitVal) 22837e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Diag(ECD->getLocation(), diag::ext_enum_value_not_int, 22847e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach InitVal.toString()); 2285326efe58918d3f0a431d07938054870fcd0e240fJim Grosbach } 2286326efe58918d3f0a431d07938054870fcd0e240fJim Grosbach 22877e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // Keep track of the size of positive and negative values. 2288326efe58918d3f0a431d07938054870fcd0e240fJim Grosbach if (InitVal.isUnsigned() || InitVal.isNonNegative()) 2289326efe58918d3f0a431d07938054870fcd0e240fJim Grosbach NumPositiveBits = std::max(NumPositiveBits, 22907e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach (unsigned)InitVal.getActiveBits()); 22917e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach else 22927e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach NumNegativeBits = std::max(NumNegativeBits, 22937e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach (unsigned)InitVal.getMinSignedBits()); 22947e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 22957e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // Keep track of whether every enum element has type int (very commmon). 22967e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (AllElementsInt) 22977e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach AllElementsInt = ECD->getType() == Context.IntTy; 22987e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 22997e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach ECD->setNextDeclarator(EltList); 23007e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach EltList = ECD; 23017e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 23027e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 23037e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // Figure out the type that should be used for this enum. 23047e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // FIXME: Support attribute(packed) on enums and -fshort-enums. 23057e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach QualType BestType; 23067e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach unsigned BestWidth; 23077e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 23087e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (NumNegativeBits) { 23097e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // If there is a negative value, figure out the smallest integer type (of 23107e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach // int/long/longlong) that fits. 23117e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 23127e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach BestType = Context.IntTy; 23137e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach BestWidth = IntWidth; 23147e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } else { 23157e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach BestWidth = Context.Target.getLongWidth(); 23167e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 23177e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) 23187e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach BestType = Context.LongTy; 23197e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach else { 23207e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach BestWidth = Context.Target.getLongLongWidth(); 23217e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach 23227e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 23237e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach Diag(Enum->getLocation(), diag::warn_enum_too_large); 23247e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach BestType = Context.LongLongTy; 23257e1547ebf726a40e7ed3dbe89a77e1b946a8e2d0Jim Grosbach } 2326293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 2327293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } else { 2328293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // If there is no negative value, figure out which of uint, ulong, ulonglong 2329293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // fits. 2330293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (NumPositiveBits <= IntWidth) { 2331293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach BestType = Context.UnsignedIntTy; 2332293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach BestWidth = IntWidth; 2333293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } else if (NumPositiveBits <= 2334293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach (BestWidth = Context.Target.getLongWidth())) { 2335293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach BestType = Context.UnsignedLongTy; 2336293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } else { 2337293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach BestWidth = Context.Target.getLongLongWidth(); 2338293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach assert(NumPositiveBits <= BestWidth && 2339293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach "How could an initializer get larger than ULL?"); 2340293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach BestType = Context.UnsignedLongLongTy; 2341293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 2342293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 2343293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 2344293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // Loop over all of the enumerator constants, changing their types to match 2345293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // the type of the enum if needed. 2346293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach for (unsigned i = 0; i != NumElements; ++i) { 2347293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach EnumConstantDecl *ECD = 2348293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach cast_or_null<EnumConstantDecl>(static_cast<Decl*>(Elements[i])); 2349293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (!ECD) continue; // Already issued a diagnostic. 2350293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 2351293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // Standard C says the enumerators have int type, but we allow, as an 2352293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // extension, the enumerators to be larger than int size. If each 2353293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // enumerator value fits in an int, type it as an int, otherwise type it the 2354293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // same as the enumerator decl itself. This means that in "enum { X = 1U }" 2355293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // that X has type 'int', not 'unsigned'. 2356293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (ECD->getType() == Context.IntTy) { 2357293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // Make sure the init value is signed. 2358293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach llvm::APSInt IV = ECD->getInitVal(); 2359293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach IV.setIsSigned(true); 2360293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach ECD->setInitVal(IV); 2361293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach continue; // Already int type. 2362293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 2363293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 2364293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // Determine whether the value fits into an int. 2365293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach llvm::APSInt InitVal = ECD->getInitVal(); 2366293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach bool FitsInInt; 2367293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (InitVal.isUnsigned() || !InitVal.isNegative()) 2368293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach FitsInInt = InitVal.getActiveBits() < IntWidth; 2369293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach else 2370293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach FitsInInt = InitVal.getMinSignedBits() <= IntWidth; 2371293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 2372293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // If it fits into an integer type, force it. Otherwise force it to match 2373293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // the enum decl type. 2374293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach QualType NewTy; 2375293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach unsigned NewWidth; 2376293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach bool NewSign; 2377293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach if (FitsInInt) { 2378293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach NewTy = Context.IntTy; 2379293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach NewWidth = IntWidth; 2380293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach NewSign = true; 2381293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } else if (ECD->getType() == BestType) { 2382293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // Already the right type! 2383293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach continue; 2384293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } else { 2385293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach NewTy = BestType; 2386293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach NewWidth = BestWidth; 2387293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach NewSign = BestType->isSignedIntegerType(); 2388293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach } 2389293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach 2390293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach // Adjust the APSInt value. 2391293a2ee3063953bb6f5bc828831f985f054782a3Jim Grosbach InitVal.extOrTrunc(NewWidth); 23927ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach InitVal.setIsSigned(NewSign); 23937ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach ECD->setInitVal(InitVal); 23947ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 2395f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach // Adjust the Expr initializer and type. 2396f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach ECD->setInitExpr(new ImplicitCastExpr(NewTy, ECD->getInitExpr())); 2397f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach ECD->setType(NewTy); 23987ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach } 23997ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 24007ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Enum->defineElements(EltList, BestType); 24017ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Consumer.HandleTagDeclDefinition(Enum); 24027ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach} 24037ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 24047ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim GrosbachSema::DeclTy *Sema::ActOnFileScopeAsmDecl(SourceLocation Loc, 240516578b50889329eb62774148091ba0f38b681a09Jim Grosbach ExprTy *expr) { 24067ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach StringLiteral *AsmString = cast<StringLiteral>((Expr*)expr); 24077ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 24087ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach return FileScopeAsmDecl::Create(Context, Loc, AsmString); 24097ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach} 24107ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach 24117ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim GrosbachSema::DeclTy* Sema::ActOnLinkageSpec(SourceLocation Loc, 241216578b50889329eb62774148091ba0f38b681a09Jim Grosbach SourceLocation LBrace, 24137ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach SourceLocation RBrace, 24147ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach const char *Lang, 24157ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach unsigned StrSize, 24167ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach DeclTy *D) { 24177ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach LinkageSpecDecl::LanguageIDs Language; 24187ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Decl *dcl = static_cast<Decl *>(D); 24197ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach if (strncmp(Lang, "\"C\"", StrSize) == 0) 24207ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Language = LinkageSpecDecl::lang_c; 24217ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach else if (strncmp(Lang, "\"C++\"", StrSize) == 0) 24227ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Language = LinkageSpecDecl::lang_cxx; 24237ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach else { 24247ce057983ea7b8ad42d5cca1bb5d3f6941662269Jim Grosbach Diag(Loc, diag::err_bad_language); 2425f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach return 0; 2426f4fa3d6e463e88743983ccfa027a7555a8720917Jim Grosbach } 24270d6fac36eda6b65f0e396b24c5bce582f89f7992Jim Grosbach 24280d6fac36eda6b65f0e396b24c5bce582f89f7992Jim Grosbach // FIXME: Add all the various semantics of linkage specifications 24290d6fac36eda6b65f0e396b24c5bce582f89f7992Jim Grosbach return LinkageSpecDecl::Create(Context, Loc, Language, dcl); 24300d6fac36eda6b65f0e396b24c5bce582f89f7992Jim Grosbach} 24310d6fac36eda6b65f0e396b24c5bce582f89f7992Jim Grosbach