Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 1 | //===--- CGDecl.cpp - Emit LLVM Code for declarations ---------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 0bc735f | 2007-12-29 19:59:25 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This contains code to emit Decl nodes as LLVM code. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Sanjiv Gupta | cc9b163 | 2008-05-30 10:30:31 +0000 | [diff] [blame] | 14 | #include "CGDebugInfo.h" |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 15 | #include "CodeGenFunction.h" |
Anders Carlsson | 1a86b33 | 2007-10-17 00:52:43 +0000 | [diff] [blame] | 16 | #include "CodeGenModule.h" |
Daniel Dunbar | de7fb84 | 2008-08-11 05:00:27 +0000 | [diff] [blame] | 17 | #include "clang/AST/ASTContext.h" |
Ken Dyck | bdc601b | 2009-12-22 14:23:30 +0000 | [diff] [blame] | 18 | #include "clang/AST/CharUnits.h" |
Daniel Dunbar | c4a1dea | 2008-08-11 05:35:13 +0000 | [diff] [blame] | 19 | #include "clang/AST/Decl.h" |
Anders Carlsson | 19567ee | 2008-08-25 01:38:19 +0000 | [diff] [blame] | 20 | #include "clang/AST/DeclObjC.h" |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 21 | #include "clang/Basic/SourceManager.h" |
Chris Lattner | 2621fd1 | 2008-05-08 05:58:21 +0000 | [diff] [blame] | 22 | #include "clang/Basic/TargetInfo.h" |
Chandler Carruth | 2811ccf | 2009-11-12 17:24:48 +0000 | [diff] [blame] | 23 | #include "clang/CodeGen/CodeGenOptions.h" |
Anders Carlsson | 1a86b33 | 2007-10-17 00:52:43 +0000 | [diff] [blame] | 24 | #include "llvm/GlobalVariable.h" |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 25 | #include "llvm/Intrinsics.h" |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 26 | #include "llvm/Target/TargetData.h" |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 27 | #include "llvm/Type.h" |
| 28 | using namespace clang; |
| 29 | using namespace CodeGen; |
| 30 | |
| 31 | |
| 32 | void CodeGenFunction::EmitDecl(const Decl &D) { |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 33 | switch (D.getKind()) { |
Daniel Dunbar | fa133a1 | 2009-11-23 00:07:06 +0000 | [diff] [blame] | 34 | default: |
| 35 | CGM.ErrorUnsupported(&D, "decl"); |
| 36 | return; |
Chris Lattner | aa9fc46 | 2007-10-08 21:37:32 +0000 | [diff] [blame] | 37 | case Decl::ParmVar: |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 38 | assert(0 && "Parmdecls should not be in declstmts!"); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 39 | case Decl::Function: // void X(); |
Argyrios Kyrtzidis | 35bc082 | 2008-10-15 00:42:39 +0000 | [diff] [blame] | 40 | case Decl::Record: // struct/union/class X; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 41 | case Decl::Enum: // enum X; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 42 | case Decl::EnumConstant: // enum ? { X = ? } |
Argyrios Kyrtzidis | 35bc082 | 2008-10-15 00:42:39 +0000 | [diff] [blame] | 43 | case Decl::CXXRecord: // struct/union/class X; [C++] |
Daniel Dunbar | fa133a1 | 2009-11-23 00:07:06 +0000 | [diff] [blame] | 44 | case Decl::Using: // using X; [C++] |
| 45 | case Decl::UsingShadow: |
| 46 | case Decl::UsingDirective: // using namespace X; [C++] |
Anders Carlsson | 7b0ca3f | 2009-12-03 17:26:31 +0000 | [diff] [blame] | 47 | case Decl::StaticAssert: // static_assert(X, ""); [C++0x] |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 48 | // None of these decls require codegen support. |
| 49 | return; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 50 | |
Daniel Dunbar | 662174c8 | 2008-08-29 17:28:43 +0000 | [diff] [blame] | 51 | case Decl::Var: { |
| 52 | const VarDecl &VD = cast<VarDecl>(D); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 53 | assert(VD.isBlockVarDecl() && |
Daniel Dunbar | 662174c8 | 2008-08-29 17:28:43 +0000 | [diff] [blame] | 54 | "Should not see file-scope variables inside a function!"); |
| 55 | return EmitBlockVarDecl(VD); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 56 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 57 | |
Anders Carlsson | fcdbb93 | 2008-12-20 21:51:53 +0000 | [diff] [blame] | 58 | case Decl::Typedef: { // typedef int X; |
| 59 | const TypedefDecl &TD = cast<TypedefDecl>(D); |
| 60 | QualType Ty = TD.getUnderlyingType(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 61 | |
Anders Carlsson | fcdbb93 | 2008-12-20 21:51:53 +0000 | [diff] [blame] | 62 | if (Ty->isVariablyModifiedType()) |
| 63 | EmitVLASize(Ty); |
| 64 | } |
Daniel Dunbar | 662174c8 | 2008-08-29 17:28:43 +0000 | [diff] [blame] | 65 | } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | /// EmitBlockVarDecl - This method handles emission of any variable declaration |
| 69 | /// inside a function, including static vars etc. |
Steve Naroff | 248a753 | 2008-04-15 22:42:06 +0000 | [diff] [blame] | 70 | void CodeGenFunction::EmitBlockVarDecl(const VarDecl &D) { |
Argyrios Kyrtzidis | 40b598e | 2009-06-30 02:34:44 +0000 | [diff] [blame] | 71 | if (D.hasAttr<AsmLabelAttr>()) |
Fariborz Jahanian | ba8639d | 2009-03-30 20:32:06 +0000 | [diff] [blame] | 72 | CGM.ErrorUnsupported(&D, "__asm__"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 73 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 74 | switch (D.getStorageClass()) { |
Daniel Dunbar | 5466c7b | 2009-04-14 02:25:56 +0000 | [diff] [blame] | 75 | case VarDecl::None: |
| 76 | case VarDecl::Auto: |
| 77 | case VarDecl::Register: |
| 78 | return EmitLocalBlockVarDecl(D); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 79 | case VarDecl::Static: |
Anders Carlsson | 1a86b33 | 2007-10-17 00:52:43 +0000 | [diff] [blame] | 80 | return EmitStaticBlockVarDecl(D); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 81 | case VarDecl::Extern: |
Daniel Dunbar | 5466c7b | 2009-04-14 02:25:56 +0000 | [diff] [blame] | 82 | case VarDecl::PrivateExtern: |
Lauro Ramos Venancio | fea90b8 | 2008-02-16 22:30:38 +0000 | [diff] [blame] | 83 | // Don't emit it now, allow it to be emitted lazily on its first use. |
| 84 | return; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 85 | } |
Daniel Dunbar | 5466c7b | 2009-04-14 02:25:56 +0000 | [diff] [blame] | 86 | |
| 87 | assert(0 && "Unknown storage class"); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 88 | } |
| 89 | |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 90 | static std::string GetStaticDeclName(CodeGenFunction &CGF, const VarDecl &D, |
| 91 | const char *Separator) { |
| 92 | CodeGenModule &CGM = CGF.CGM; |
| 93 | if (CGF.getContext().getLangOptions().CPlusPlus) |
| 94 | return CGM.getMangledName(&D); |
| 95 | |
| 96 | std::string ContextName; |
| 97 | if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CGF.CurFuncDecl)) |
| 98 | ContextName = CGM.getMangledName(FD); |
| 99 | else if (isa<ObjCMethodDecl>(CGF.CurFuncDecl)) |
| 100 | ContextName = CGF.CurFn->getName(); |
| 101 | else |
| 102 | // FIXME: What about in a block?? |
| 103 | assert(0 && "Unknown context for block var decl"); |
| 104 | |
| 105 | return ContextName + Separator + D.getNameAsString(); |
| 106 | } |
| 107 | |
Daniel Dunbar | 0096acf | 2009-02-25 19:24:29 +0000 | [diff] [blame] | 108 | llvm::GlobalVariable * |
| 109 | CodeGenFunction::CreateStaticBlockVarDecl(const VarDecl &D, |
| 110 | const char *Separator, |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 111 | llvm::GlobalValue::LinkageTypes Linkage) { |
Chris Lattner | 8bcfc5b | 2008-04-06 23:10:54 +0000 | [diff] [blame] | 112 | QualType Ty = D.getType(); |
Eli Friedman | 3c2b317 | 2008-02-15 12:20:59 +0000 | [diff] [blame] | 113 | assert(Ty->isConstantSizeType() && "VLAs can't be static"); |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 114 | |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 115 | std::string Name = GetStaticDeclName(*this, D, Separator); |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 116 | |
Daniel Dunbar | 0096acf | 2009-02-25 19:24:29 +0000 | [diff] [blame] | 117 | const llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(Ty); |
Anders Carlsson | 41f8a13 | 2009-09-26 18:16:06 +0000 | [diff] [blame] | 118 | llvm::GlobalVariable *GV = |
| 119 | new llvm::GlobalVariable(CGM.getModule(), LTy, |
| 120 | Ty.isConstant(getContext()), Linkage, |
| 121 | CGM.EmitNullConstant(D.getType()), Name, 0, |
| 122 | D.isThreadSpecified(), Ty.getAddressSpace()); |
| 123 | GV->setAlignment(getContext().getDeclAlignInBytes(&D)); |
| 124 | return GV; |
Daniel Dunbar | 0096acf | 2009-02-25 19:24:29 +0000 | [diff] [blame] | 125 | } |
| 126 | |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 127 | /// AddInitializerToGlobalBlockVarDecl - Add the initializer for 'D' to the |
| 128 | /// global variable that has already been created for it. If the initializer |
| 129 | /// has a different type than GV does, this may free GV and return a different |
| 130 | /// one. Otherwise it just returns GV. |
| 131 | llvm::GlobalVariable * |
| 132 | CodeGenFunction::AddInitializerToGlobalBlockVarDecl(const VarDecl &D, |
| 133 | llvm::GlobalVariable *GV) { |
| 134 | llvm::Constant *Init = CGM.EmitConstantExpr(D.getInit(), D.getType(), this); |
| 135 | |
| 136 | // If constant emission failed, then this should be a C++ static |
| 137 | // initializer. |
| 138 | if (!Init) { |
| 139 | if (!getContext().getLangOptions().CPlusPlus) |
| 140 | CGM.ErrorUnsupported(D.getInit(), "constant l-value expression"); |
Anders Carlsson | 071c810 | 2010-01-26 04:02:23 +0000 | [diff] [blame^] | 141 | else { |
| 142 | // Since we have a static initializer, this global variable can't |
| 143 | // be constant. |
| 144 | GV->setConstant(false); |
| 145 | |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 146 | EmitStaticCXXBlockVarDeclInit(D, GV); |
Anders Carlsson | 071c810 | 2010-01-26 04:02:23 +0000 | [diff] [blame^] | 147 | } |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 148 | return GV; |
| 149 | } |
| 150 | |
| 151 | // The initializer may differ in type from the global. Rewrite |
| 152 | // the global to match the initializer. (We have to do this |
| 153 | // because some types, like unions, can't be completely represented |
| 154 | // in the LLVM type system.) |
| 155 | if (GV->getType() != Init->getType()) { |
| 156 | llvm::GlobalVariable *OldGV = GV; |
| 157 | |
| 158 | GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), |
| 159 | OldGV->isConstant(), |
| 160 | OldGV->getLinkage(), Init, "", |
| 161 | 0, D.isThreadSpecified(), |
| 162 | D.getType().getAddressSpace()); |
| 163 | |
| 164 | // Steal the name of the old global |
| 165 | GV->takeName(OldGV); |
| 166 | |
| 167 | // Replace all uses of the old global with the new global |
| 168 | llvm::Constant *NewPtrForOldDecl = |
| 169 | llvm::ConstantExpr::getBitCast(GV, OldGV->getType()); |
| 170 | OldGV->replaceAllUsesWith(NewPtrForOldDecl); |
| 171 | |
| 172 | // Erase the old global, since it is no longer used. |
| 173 | OldGV->eraseFromParent(); |
| 174 | } |
| 175 | |
| 176 | GV->setInitializer(Init); |
| 177 | return GV; |
| 178 | } |
| 179 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 180 | void CodeGenFunction::EmitStaticBlockVarDecl(const VarDecl &D) { |
Daniel Dunbar | a985b31 | 2009-02-25 19:45:19 +0000 | [diff] [blame] | 181 | llvm::Value *&DMEntry = LocalDeclMap[&D]; |
| 182 | assert(DMEntry == 0 && "Decl already exists in localdeclmap!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 183 | |
| 184 | llvm::GlobalVariable *GV = |
Daniel Dunbar | a985b31 | 2009-02-25 19:45:19 +0000 | [diff] [blame] | 185 | CreateStaticBlockVarDecl(D, ".", llvm::GlobalValue::InternalLinkage); |
| 186 | |
Daniel Dunbar | e5731f8 | 2009-02-25 20:08:33 +0000 | [diff] [blame] | 187 | // Store into LocalDeclMap before generating initializer to handle |
| 188 | // circular references. |
| 189 | DMEntry = GV; |
| 190 | |
Eli Friedman | c62aad8 | 2009-04-20 03:54:15 +0000 | [diff] [blame] | 191 | // Make sure to evaluate VLA bounds now so that we have them for later. |
Daniel Dunbar | d286f05 | 2009-07-19 06:58:07 +0000 | [diff] [blame] | 192 | // |
| 193 | // FIXME: Can this happen? |
Eli Friedman | c62aad8 | 2009-04-20 03:54:15 +0000 | [diff] [blame] | 194 | if (D.getType()->isVariablyModifiedType()) |
| 195 | EmitVLASize(D.getType()); |
| 196 | |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 197 | // If this value has an initializer, emit it. |
| 198 | if (D.getInit()) |
| 199 | GV = AddInitializerToGlobalBlockVarDecl(D, GV); |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 200 | |
Daniel Dunbar | 30510ab | 2009-02-12 23:32:54 +0000 | [diff] [blame] | 201 | // FIXME: Merge attribute handling. |
Argyrios Kyrtzidis | 40b598e | 2009-06-30 02:34:44 +0000 | [diff] [blame] | 202 | if (const AnnotateAttr *AA = D.getAttr<AnnotateAttr>()) { |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 203 | SourceManager &SM = CGM.getContext().getSourceManager(); |
| 204 | llvm::Constant *Ann = |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 205 | CGM.EmitAnnotateAttr(GV, AA, |
Chris Lattner | f7cf85b | 2009-01-16 07:36:28 +0000 | [diff] [blame] | 206 | SM.getInstantiationLineNumber(D.getLocation())); |
Nate Begeman | 8bd4afe | 2008-04-19 04:17:09 +0000 | [diff] [blame] | 207 | CGM.AddAnnotation(Ann); |
| 208 | } |
| 209 | |
Argyrios Kyrtzidis | 40b598e | 2009-06-30 02:34:44 +0000 | [diff] [blame] | 210 | if (const SectionAttr *SA = D.getAttr<SectionAttr>()) |
Daniel Dunbar | 30510ab | 2009-02-12 23:32:54 +0000 | [diff] [blame] | 211 | GV->setSection(SA->getName()); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 212 | |
Argyrios Kyrtzidis | 40b598e | 2009-06-30 02:34:44 +0000 | [diff] [blame] | 213 | if (D.hasAttr<UsedAttr>()) |
Daniel Dunbar | 5c61d97 | 2009-02-13 22:08:43 +0000 | [diff] [blame] | 214 | CGM.AddUsedGlobal(GV); |
| 215 | |
Daniel Dunbar | e5731f8 | 2009-02-25 20:08:33 +0000 | [diff] [blame] | 216 | // We may have to cast the constant because of the initializer |
| 217 | // mismatch above. |
| 218 | // |
| 219 | // FIXME: It is really dangerous to store this in the map; if anyone |
| 220 | // RAUW's the GV uses of this constant will be invalid. |
Eli Friedman | 2659052 | 2008-06-08 01:23:18 +0000 | [diff] [blame] | 221 | const llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(D.getType()); |
| 222 | const llvm::Type *LPtrTy = |
Owen Anderson | 96e0fc7 | 2009-07-29 22:16:19 +0000 | [diff] [blame] | 223 | llvm::PointerType::get(LTy, D.getType().getAddressSpace()); |
Owen Anderson | 3c4972d | 2009-07-29 18:54:39 +0000 | [diff] [blame] | 224 | DMEntry = llvm::ConstantExpr::getBitCast(GV, LPtrTy); |
Sanjiv Gupta | 686226b | 2008-06-05 08:59:10 +0000 | [diff] [blame] | 225 | |
| 226 | // Emit global variable debug descriptor for static vars. |
Anders Carlsson | e896d98 | 2009-02-13 08:11:52 +0000 | [diff] [blame] | 227 | CGDebugInfo *DI = getDebugInfo(); |
Mike Stump | 4451bd9 | 2009-02-20 00:19:45 +0000 | [diff] [blame] | 228 | if (DI) { |
Daniel Dunbar | 66031a5 | 2008-10-17 16:15:48 +0000 | [diff] [blame] | 229 | DI->setLocation(D.getLocation()); |
Sanjiv Gupta | 686226b | 2008-06-05 08:59:10 +0000 | [diff] [blame] | 230 | DI->EmitGlobalVariable(static_cast<llvm::GlobalVariable *>(GV), &D); |
| 231 | } |
Anders Carlsson | 1a86b33 | 2007-10-17 00:52:43 +0000 | [diff] [blame] | 232 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 233 | |
Anders Carlsson | 7dfa407 | 2009-09-12 02:14:24 +0000 | [diff] [blame] | 234 | unsigned CodeGenFunction::getByRefValueLLVMField(const ValueDecl *VD) const { |
| 235 | assert(ByRefValueInfo.count(VD) && "Did not find value!"); |
| 236 | |
| 237 | return ByRefValueInfo.find(VD)->second.second; |
| 238 | } |
| 239 | |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 240 | /// BuildByRefType - This routine changes a __block variable declared as T x |
| 241 | /// into: |
| 242 | /// |
| 243 | /// struct { |
| 244 | /// void *__isa; |
| 245 | /// void *__forwarding; |
| 246 | /// int32_t __flags; |
| 247 | /// int32_t __size; |
Mike Stump | 39605b4 | 2009-09-22 02:12:52 +0000 | [diff] [blame] | 248 | /// void *__copy_helper; // only if needed |
| 249 | /// void *__destroy_helper; // only if needed |
| 250 | /// char padding[X]; // only if needed |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 251 | /// T x; |
| 252 | /// } x |
| 253 | /// |
Anders Carlsson | 9ad5513 | 2009-09-09 02:51:03 +0000 | [diff] [blame] | 254 | const llvm::Type *CodeGenFunction::BuildByRefType(const ValueDecl *D) { |
Anders Carlsson | 7dfa407 | 2009-09-12 02:14:24 +0000 | [diff] [blame] | 255 | std::pair<const llvm::Type *, unsigned> &Info = ByRefValueInfo[D]; |
| 256 | if (Info.first) |
| 257 | return Info.first; |
| 258 | |
Anders Carlsson | 9ad5513 | 2009-09-09 02:51:03 +0000 | [diff] [blame] | 259 | QualType Ty = D->getType(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 260 | |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 261 | std::vector<const llvm::Type *> Types; |
Anders Carlsson | 3604386 | 2009-09-10 01:32:12 +0000 | [diff] [blame] | 262 | |
Benjamin Kramer | 3c0ef8c | 2009-10-13 10:07:13 +0000 | [diff] [blame] | 263 | const llvm::PointerType *Int8PtrTy = llvm::Type::getInt8PtrTy(VMContext); |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 264 | |
Anders Carlsson | 3604386 | 2009-09-10 01:32:12 +0000 | [diff] [blame] | 265 | llvm::PATypeHolder ByRefTypeHolder = llvm::OpaqueType::get(VMContext); |
| 266 | |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 267 | // void *__isa; |
| 268 | Types.push_back(Int8PtrTy); |
| 269 | |
| 270 | // void *__forwarding; |
| 271 | Types.push_back(llvm::PointerType::getUnqual(ByRefTypeHolder)); |
| 272 | |
| 273 | // int32_t __flags; |
| 274 | Types.push_back(llvm::Type::getInt32Ty(VMContext)); |
| 275 | |
| 276 | // int32_t __size; |
| 277 | Types.push_back(llvm::Type::getInt32Ty(VMContext)); |
| 278 | |
| 279 | bool HasCopyAndDispose = BlockRequiresCopying(Ty); |
| 280 | if (HasCopyAndDispose) { |
| 281 | /// void *__copy_helper; |
| 282 | Types.push_back(Int8PtrTy); |
| 283 | |
| 284 | /// void *__destroy_helper; |
| 285 | Types.push_back(Int8PtrTy); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 286 | } |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 287 | |
| 288 | bool Packed = false; |
| 289 | unsigned Align = getContext().getDeclAlignInBytes(D); |
| 290 | if (Align > Target.getPointerAlign(0) / 8) { |
| 291 | // We have to insert padding. |
| 292 | |
| 293 | // The struct above has 2 32-bit integers. |
| 294 | unsigned CurrentOffsetInBytes = 4 * 2; |
| 295 | |
| 296 | // And either 2 or 4 pointers. |
| 297 | CurrentOffsetInBytes += (HasCopyAndDispose ? 4 : 2) * |
| 298 | CGM.getTargetData().getTypeAllocSize(Int8PtrTy); |
| 299 | |
| 300 | // Align the offset. |
| 301 | unsigned AlignedOffsetInBytes = |
| 302 | llvm::RoundUpToAlignment(CurrentOffsetInBytes, Align); |
| 303 | |
| 304 | unsigned NumPaddingBytes = AlignedOffsetInBytes - CurrentOffsetInBytes; |
Anders Carlsson | e0c8822 | 2009-09-13 17:55:13 +0000 | [diff] [blame] | 305 | if (NumPaddingBytes > 0) { |
| 306 | const llvm::Type *Ty = llvm::Type::getInt8Ty(VMContext); |
Mike Stump | 04c688a | 2009-10-21 00:42:55 +0000 | [diff] [blame] | 307 | // FIXME: We need a sema error for alignment larger than the minimum of |
| 308 | // the maximal stack alignmint and the alignment of malloc on the system. |
Anders Carlsson | e0c8822 | 2009-09-13 17:55:13 +0000 | [diff] [blame] | 309 | if (NumPaddingBytes > 1) |
| 310 | Ty = llvm::ArrayType::get(Ty, NumPaddingBytes); |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 311 | |
Anders Carlsson | e0c8822 | 2009-09-13 17:55:13 +0000 | [diff] [blame] | 312 | Types.push_back(Ty); |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 313 | |
Anders Carlsson | e0c8822 | 2009-09-13 17:55:13 +0000 | [diff] [blame] | 314 | // We want a packed struct. |
| 315 | Packed = true; |
| 316 | } |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 317 | } |
| 318 | |
| 319 | // T x; |
| 320 | Types.push_back(ConvertType(Ty)); |
Anders Carlsson | 7dfa407 | 2009-09-12 02:14:24 +0000 | [diff] [blame] | 321 | |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 322 | const llvm::Type *T = llvm::StructType::get(VMContext, Types, Packed); |
Anders Carlsson | 3604386 | 2009-09-10 01:32:12 +0000 | [diff] [blame] | 323 | |
| 324 | cast<llvm::OpaqueType>(ByRefTypeHolder.get())->refineAbstractTypeTo(T); |
| 325 | CGM.getModule().addTypeName("struct.__block_byref_" + D->getNameAsString(), |
| 326 | ByRefTypeHolder.get()); |
| 327 | |
Anders Carlsson | 7dfa407 | 2009-09-12 02:14:24 +0000 | [diff] [blame] | 328 | Info.first = ByRefTypeHolder.get(); |
Anders Carlsson | 18be84c | 2009-09-12 02:44:18 +0000 | [diff] [blame] | 329 | |
| 330 | Info.second = Types.size() - 1; |
Anders Carlsson | 7dfa407 | 2009-09-12 02:14:24 +0000 | [diff] [blame] | 331 | |
| 332 | return Info.first; |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 333 | } |
| 334 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 335 | /// EmitLocalBlockVarDecl - Emit code and set up an entry in LocalDeclMap for a |
| 336 | /// variable declaration with auto, register, or no storage class specifier. |
Chris Lattner | 2621fd1 | 2008-05-08 05:58:21 +0000 | [diff] [blame] | 337 | /// These turn into simple stack objects, or GlobalValues depending on target. |
Steve Naroff | 248a753 | 2008-04-15 22:42:06 +0000 | [diff] [blame] | 338 | void CodeGenFunction::EmitLocalBlockVarDecl(const VarDecl &D) { |
Chris Lattner | 8bcfc5b | 2008-04-06 23:10:54 +0000 | [diff] [blame] | 339 | QualType Ty = D.getType(); |
Argyrios Kyrtzidis | 40b598e | 2009-06-30 02:34:44 +0000 | [diff] [blame] | 340 | bool isByRef = D.hasAttr<BlocksAttr>(); |
Mike Stump | 797b632 | 2009-03-05 01:23:13 +0000 | [diff] [blame] | 341 | bool needsDispose = false; |
Mike Stump | 3899a7f | 2009-06-05 23:26:36 +0000 | [diff] [blame] | 342 | unsigned Align = 0; |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 343 | bool IsSimpleConstantInitializer = false; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 344 | |
| 345 | llvm::Value *DeclPtr; |
Eli Friedman | 3c2b317 | 2008-02-15 12:20:59 +0000 | [diff] [blame] | 346 | if (Ty->isConstantSizeType()) { |
Chris Lattner | 2621fd1 | 2008-05-08 05:58:21 +0000 | [diff] [blame] | 347 | if (!Target.useGlobalsForAutomaticVariables()) { |
Tanya Lattner | 59876c2 | 2009-11-04 01:18:09 +0000 | [diff] [blame] | 348 | |
Chris Lattner | ff933b7 | 2009-12-05 06:49:57 +0000 | [diff] [blame] | 349 | // If this value is an array or struct, is POD, and if the initializer is |
| 350 | // a staticly determinable constant, try to optimize it. |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 351 | if (D.getInit() && !isByRef && |
Chris Lattner | ff933b7 | 2009-12-05 06:49:57 +0000 | [diff] [blame] | 352 | (Ty->isArrayType() || Ty->isRecordType()) && |
| 353 | Ty->isPODType() && |
| 354 | D.getInit()->isConstantInitializer(getContext())) { |
Chris Lattner | ff933b7 | 2009-12-05 06:49:57 +0000 | [diff] [blame] | 355 | // If this variable is marked 'const', emit the value as a global. |
| 356 | if (CGM.getCodeGenOpts().MergeAllConstants && |
| 357 | Ty.isConstant(getContext())) { |
Tanya Lattner | 59876c2 | 2009-11-04 01:18:09 +0000 | [diff] [blame] | 358 | EmitStaticBlockVarDecl(D); |
| 359 | return; |
| 360 | } |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 361 | |
| 362 | IsSimpleConstantInitializer = true; |
Tanya Lattner | 59876c2 | 2009-11-04 01:18:09 +0000 | [diff] [blame] | 363 | } |
| 364 | |
Chris Lattner | 2621fd1 | 2008-05-08 05:58:21 +0000 | [diff] [blame] | 365 | // A normal fixed sized variable becomes an alloca in the entry block. |
Eli Friedman | a3460ac | 2009-03-04 04:25:14 +0000 | [diff] [blame] | 366 | const llvm::Type *LTy = ConvertTypeForMem(Ty); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 367 | if (isByRef) |
Anders Carlsson | 9ad5513 | 2009-09-09 02:51:03 +0000 | [diff] [blame] | 368 | LTy = BuildByRefType(&D); |
Chris Lattner | f146684 | 2009-03-22 00:24:14 +0000 | [diff] [blame] | 369 | llvm::AllocaInst *Alloc = CreateTempAlloca(LTy); |
Benjamin Kramer | 155fd79 | 2009-12-08 14:04:35 +0000 | [diff] [blame] | 370 | Alloc->setName(D.getNameAsString()); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 371 | |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 372 | Align = getContext().getDeclAlignInBytes(&D); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 373 | if (isByRef) |
Mike Stump | 3899a7f | 2009-06-05 23:26:36 +0000 | [diff] [blame] | 374 | Align = std::max(Align, unsigned(Target.getPointerAlign(0) / 8)); |
| 375 | Alloc->setAlignment(Align); |
Eli Friedman | 77eedd6 | 2008-05-31 21:20:41 +0000 | [diff] [blame] | 376 | DeclPtr = Alloc; |
Chris Lattner | 2621fd1 | 2008-05-08 05:58:21 +0000 | [diff] [blame] | 377 | } else { |
| 378 | // Targets that don't support recursion emit locals as globals. |
| 379 | const char *Class = |
| 380 | D.getStorageClass() == VarDecl::Register ? ".reg." : ".auto."; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 381 | DeclPtr = CreateStaticBlockVarDecl(D, Class, |
Daniel Dunbar | a985b31 | 2009-02-25 19:45:19 +0000 | [diff] [blame] | 382 | llvm::GlobalValue |
| 383 | ::InternalLinkage); |
Chris Lattner | 2621fd1 | 2008-05-08 05:58:21 +0000 | [diff] [blame] | 384 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 385 | |
Daniel Dunbar | d286f05 | 2009-07-19 06:58:07 +0000 | [diff] [blame] | 386 | // FIXME: Can this happen? |
Anders Carlsson | 60d3541 | 2008-12-20 20:46:34 +0000 | [diff] [blame] | 387 | if (Ty->isVariablyModifiedType()) |
| 388 | EmitVLASize(Ty); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 389 | } else { |
Daniel Dunbar | d286f05 | 2009-07-19 06:58:07 +0000 | [diff] [blame] | 390 | EnsureInsertPoint(); |
| 391 | |
Anders Carlsson | 5ecb1b9 | 2009-02-09 20:41:50 +0000 | [diff] [blame] | 392 | if (!DidCallStackSave) { |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 393 | // Save the stack. |
Benjamin Kramer | 3c0ef8c | 2009-10-13 10:07:13 +0000 | [diff] [blame] | 394 | const llvm::Type *LTy = llvm::Type::getInt8PtrTy(VMContext); |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 395 | llvm::Value *Stack = CreateTempAlloca(LTy, "saved_stack"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 396 | |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 397 | llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave); |
| 398 | llvm::Value *V = Builder.CreateCall(F); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 399 | |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 400 | Builder.CreateStore(V, Stack); |
Anders Carlsson | 5ecb1b9 | 2009-02-09 20:41:50 +0000 | [diff] [blame] | 401 | |
| 402 | DidCallStackSave = true; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 403 | |
Anders Carlsson | 5ecb1b9 | 2009-02-09 20:41:50 +0000 | [diff] [blame] | 404 | { |
| 405 | // Push a cleanup block and restore the stack there. |
Douglas Gregor | d5782d5 | 2009-11-24 16:21:10 +0000 | [diff] [blame] | 406 | DelayedCleanupBlock scope(*this); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 407 | |
Anders Carlsson | 5ecb1b9 | 2009-02-09 20:41:50 +0000 | [diff] [blame] | 408 | V = Builder.CreateLoad(Stack, "tmp"); |
| 409 | llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stackrestore); |
| 410 | Builder.CreateCall(F, V); |
| 411 | } |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 412 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 413 | |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 414 | // Get the element type. |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 415 | const llvm::Type *LElemTy = ConvertTypeForMem(Ty); |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 416 | const llvm::Type *LElemPtrTy = |
Owen Anderson | 96e0fc7 | 2009-07-29 22:16:19 +0000 | [diff] [blame] | 417 | llvm::PointerType::get(LElemTy, D.getType().getAddressSpace()); |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 418 | |
Anders Carlsson | 60d3541 | 2008-12-20 20:46:34 +0000 | [diff] [blame] | 419 | llvm::Value *VLASize = EmitVLASize(Ty); |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 420 | |
Anders Carlsson | 96f2147 | 2009-02-05 19:43:10 +0000 | [diff] [blame] | 421 | // Downcast the VLA size expression |
Owen Anderson | 0032b27 | 2009-08-13 21:57:51 +0000 | [diff] [blame] | 422 | VLASize = Builder.CreateIntCast(VLASize, llvm::Type::getInt32Ty(VMContext), |
| 423 | false, "tmp"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 424 | |
Anders Carlsson | 5d46315 | 2008-12-12 07:38:43 +0000 | [diff] [blame] | 425 | // Allocate memory for the array. |
Anders Carlsson | 41f8a13 | 2009-09-26 18:16:06 +0000 | [diff] [blame] | 426 | llvm::AllocaInst *VLA = |
| 427 | Builder.CreateAlloca(llvm::Type::getInt8Ty(VMContext), VLASize, "vla"); |
| 428 | VLA->setAlignment(getContext().getDeclAlignInBytes(&D)); |
| 429 | |
Eli Friedman | 8f39f5e | 2008-12-20 23:11:59 +0000 | [diff] [blame] | 430 | DeclPtr = Builder.CreateBitCast(VLA, LElemPtrTy, "tmp"); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 431 | } |
Eli Friedman | 8f39f5e | 2008-12-20 23:11:59 +0000 | [diff] [blame] | 432 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 433 | llvm::Value *&DMEntry = LocalDeclMap[&D]; |
| 434 | assert(DMEntry == 0 && "Decl already exists in localdeclmap!"); |
| 435 | DMEntry = DeclPtr; |
Sanjiv Gupta | cc9b163 | 2008-05-30 10:30:31 +0000 | [diff] [blame] | 436 | |
| 437 | // Emit debug info for local var declaration. |
Anders Carlsson | e896d98 | 2009-02-13 08:11:52 +0000 | [diff] [blame] | 438 | if (CGDebugInfo *DI = getDebugInfo()) { |
Daniel Dunbar | 25b6ebf | 2009-07-19 07:03:11 +0000 | [diff] [blame] | 439 | assert(HaveInsertPoint() && "Unexpected unreachable point!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 440 | |
Daniel Dunbar | 66031a5 | 2008-10-17 16:15:48 +0000 | [diff] [blame] | 441 | DI->setLocation(D.getLocation()); |
Sanjiv Gupta | 4381d4b | 2009-05-22 13:54:25 +0000 | [diff] [blame] | 442 | if (Target.useGlobalsForAutomaticVariables()) { |
| 443 | DI->EmitGlobalVariable(static_cast<llvm::GlobalVariable *>(DeclPtr), &D); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 444 | } else |
| 445 | DI->EmitDeclareOfAutoVariable(&D, DeclPtr, Builder); |
Sanjiv Gupta | cc9b163 | 2008-05-30 10:30:31 +0000 | [diff] [blame] | 446 | } |
| 447 | |
Chris Lattner | 1978596 | 2007-07-12 00:39:48 +0000 | [diff] [blame] | 448 | // If this local has an initializer, emit it now. |
Daniel Dunbar | d286f05 | 2009-07-19 06:58:07 +0000 | [diff] [blame] | 449 | const Expr *Init = D.getInit(); |
| 450 | |
| 451 | // If we are at an unreachable point, we don't need to emit the initializer |
| 452 | // unless it contains a label. |
| 453 | if (!HaveInsertPoint()) { |
| 454 | if (!ContainsLabel(Init)) |
| 455 | Init = 0; |
| 456 | else |
| 457 | EnsureInsertPoint(); |
| 458 | } |
| 459 | |
| 460 | if (Init) { |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 461 | llvm::Value *Loc = DeclPtr; |
Anders Carlsson | 7dfa407 | 2009-09-12 02:14:24 +0000 | [diff] [blame] | 462 | if (isByRef) |
| 463 | Loc = Builder.CreateStructGEP(DeclPtr, getByRefValueLLVMField(&D), |
| 464 | D.getNameAsString()); |
| 465 | |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 466 | bool isVolatile = |
| 467 | getContext().getCanonicalType(D.getType()).isVolatileQualified(); |
| 468 | |
| 469 | // If the initializer was a simple constant initializer, we can optimize it |
| 470 | // in various ways. |
| 471 | if (IsSimpleConstantInitializer) { |
| 472 | llvm::Constant *Init = CGM.EmitConstantExpr(D.getInit(),D.getType(),this); |
| 473 | assert(Init != 0 && "Wasn't a simple constant init?"); |
| 474 | |
| 475 | llvm::Value *AlignVal = |
| 476 | llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Align); |
| 477 | const llvm::Type *IntPtr = |
| 478 | llvm::IntegerType::get(VMContext, LLVMPointerWidth); |
| 479 | llvm::Value *SizeVal = |
Ken Dyck | 4273f70 | 2009-12-18 15:55:54 +0000 | [diff] [blame] | 480 | llvm::ConstantInt::get(IntPtr, |
Ken Dyck | 199c3d6 | 2010-01-11 17:06:35 +0000 | [diff] [blame] | 481 | getContext().getTypeSizeInChars(Ty).getQuantity()); |
Chris Lattner | 761acc1 | 2009-12-05 08:22:11 +0000 | [diff] [blame] | 482 | |
| 483 | const llvm::Type *BP = llvm::Type::getInt8PtrTy(VMContext); |
| 484 | if (Loc->getType() != BP) |
| 485 | Loc = Builder.CreateBitCast(Loc, BP, "tmp"); |
| 486 | |
| 487 | // If the initializer is all zeros, codegen with memset. |
| 488 | if (isa<llvm::ConstantAggregateZero>(Init)) { |
| 489 | llvm::Value *Zero = |
| 490 | llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 0); |
| 491 | Builder.CreateCall4(CGM.getMemSetFn(), Loc, Zero, SizeVal, AlignVal); |
| 492 | } else { |
| 493 | // Otherwise, create a temporary global with the initializer then |
| 494 | // memcpy from the global to the alloca. |
| 495 | std::string Name = GetStaticDeclName(*this, D, "."); |
| 496 | llvm::GlobalVariable *GV = |
| 497 | new llvm::GlobalVariable(CGM.getModule(), Init->getType(), true, |
| 498 | llvm::GlobalValue::InternalLinkage, |
| 499 | Init, Name, 0, false, 0); |
| 500 | GV->setAlignment(Align); |
| 501 | |
| 502 | llvm::Value *SrcPtr = GV; |
| 503 | if (SrcPtr->getType() != BP) |
| 504 | SrcPtr = Builder.CreateBitCast(SrcPtr, BP, "tmp"); |
| 505 | |
| 506 | Builder.CreateCall4(CGM.getMemCpyFn(), Loc, SrcPtr, SizeVal, AlignVal); |
| 507 | } |
| 508 | } else if (Ty->isReferenceType()) { |
Anders Carlsson | 14c5cbf | 2009-08-16 07:36:22 +0000 | [diff] [blame] | 509 | RValue RV = EmitReferenceBindingToExpr(Init, Ty, /*IsInitializer=*/true); |
| 510 | EmitStoreOfScalar(RV.getScalarVal(), Loc, false, Ty); |
Eli Friedman | 4a18784 | 2009-05-27 05:39:06 +0000 | [diff] [blame] | 511 | } else if (!hasAggregateLLVMType(Init->getType())) { |
Chris Lattner | d31beb1 | 2007-08-26 07:29:23 +0000 | [diff] [blame] | 512 | llvm::Value *V = EmitScalarExpr(Init); |
Mike Stump | df317bf | 2009-11-03 23:25:48 +0000 | [diff] [blame] | 513 | EmitStoreOfScalar(V, Loc, isVolatile, D.getType()); |
Chris Lattner | 9b2dc28 | 2008-04-04 16:54:41 +0000 | [diff] [blame] | 514 | } else if (Init->getType()->isAnyComplexType()) { |
Mike Stump | df317bf | 2009-11-03 23:25:48 +0000 | [diff] [blame] | 515 | EmitComplexExprIntoAddr(Init, Loc, isVolatile); |
Chris Lattner | 9a19edf | 2007-08-26 05:13:54 +0000 | [diff] [blame] | 516 | } else { |
Mike Stump | df317bf | 2009-11-03 23:25:48 +0000 | [diff] [blame] | 517 | EmitAggExpr(Init, Loc, isVolatile); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 518 | } |
| 519 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 520 | |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 521 | if (isByRef) { |
Benjamin Kramer | 3c0ef8c | 2009-10-13 10:07:13 +0000 | [diff] [blame] | 522 | const llvm::PointerType *PtrToInt8Ty = llvm::Type::getInt8PtrTy(VMContext); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 523 | |
Daniel Dunbar | d286f05 | 2009-07-19 06:58:07 +0000 | [diff] [blame] | 524 | EnsureInsertPoint(); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 525 | llvm::Value *isa_field = Builder.CreateStructGEP(DeclPtr, 0); |
| 526 | llvm::Value *forwarding_field = Builder.CreateStructGEP(DeclPtr, 1); |
| 527 | llvm::Value *flags_field = Builder.CreateStructGEP(DeclPtr, 2); |
| 528 | llvm::Value *size_field = Builder.CreateStructGEP(DeclPtr, 3); |
| 529 | llvm::Value *V; |
| 530 | int flag = 0; |
| 531 | int flags = 0; |
| 532 | |
Mike Stump | f4bc312 | 2009-03-07 06:04:31 +0000 | [diff] [blame] | 533 | needsDispose = true; |
Mike Stump | 00470a1 | 2009-03-05 08:32:30 +0000 | [diff] [blame] | 534 | |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 535 | if (Ty->isBlockPointerType()) { |
| 536 | flag |= BLOCK_FIELD_IS_BLOCK; |
| 537 | flags |= BLOCK_HAS_COPY_DISPOSE; |
| 538 | } else if (BlockRequiresCopying(Ty)) { |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 539 | flag |= BLOCK_FIELD_IS_OBJECT; |
Mike Stump | 1851b68 | 2009-03-06 04:53:30 +0000 | [diff] [blame] | 540 | flags |= BLOCK_HAS_COPY_DISPOSE; |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 541 | } |
Mike Stump | f4bc312 | 2009-03-07 06:04:31 +0000 | [diff] [blame] | 542 | |
| 543 | // FIXME: Someone double check this. |
| 544 | if (Ty.isObjCGCWeak()) |
| 545 | flag |= BLOCK_FIELD_IS_WEAK; |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 546 | |
| 547 | int isa = 0; |
| 548 | if (flag&BLOCK_FIELD_IS_WEAK) |
| 549 | isa = 1; |
Owen Anderson | 0032b27 | 2009-08-13 21:57:51 +0000 | [diff] [blame] | 550 | V = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), isa); |
Mike Stump | a4f668f | 2009-03-06 01:33:24 +0000 | [diff] [blame] | 551 | V = Builder.CreateIntToPtr(V, PtrToInt8Ty, "isa"); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 552 | Builder.CreateStore(V, isa_field); |
| 553 | |
Anders Carlsson | 3604386 | 2009-09-10 01:32:12 +0000 | [diff] [blame] | 554 | Builder.CreateStore(DeclPtr, forwarding_field); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 555 | |
Owen Anderson | 0032b27 | 2009-08-13 21:57:51 +0000 | [diff] [blame] | 556 | V = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), flags); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 557 | Builder.CreateStore(V, flags_field); |
| 558 | |
Mike Stump | 00470a1 | 2009-03-05 08:32:30 +0000 | [diff] [blame] | 559 | const llvm::Type *V1; |
| 560 | V1 = cast<llvm::PointerType>(DeclPtr->getType())->getElementType(); |
Owen Anderson | 0032b27 | 2009-08-13 21:57:51 +0000 | [diff] [blame] | 561 | V = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), |
Mike Stump | 00470a1 | 2009-03-05 08:32:30 +0000 | [diff] [blame] | 562 | (CGM.getTargetData().getTypeStoreSizeInBits(V1) |
| 563 | / 8)); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 564 | Builder.CreateStore(V, size_field); |
| 565 | |
| 566 | if (flags & BLOCK_HAS_COPY_DISPOSE) { |
Mike Stump | 00470a1 | 2009-03-05 08:32:30 +0000 | [diff] [blame] | 567 | BlockHasCopyDispose = true; |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 568 | llvm::Value *copy_helper = Builder.CreateStructGEP(DeclPtr, 4); |
Mike Stump | 3899a7f | 2009-06-05 23:26:36 +0000 | [diff] [blame] | 569 | Builder.CreateStore(BuildbyrefCopyHelper(DeclPtr->getType(), flag, Align), |
Mike Stump | ee09422 | 2009-03-06 06:12:24 +0000 | [diff] [blame] | 570 | copy_helper); |
Mike Stump | dab514f | 2009-03-04 03:23:46 +0000 | [diff] [blame] | 571 | |
Mike Stump | 1851b68 | 2009-03-06 04:53:30 +0000 | [diff] [blame] | 572 | llvm::Value *destroy_helper = Builder.CreateStructGEP(DeclPtr, 5); |
Mike Stump | 3899a7f | 2009-06-05 23:26:36 +0000 | [diff] [blame] | 573 | Builder.CreateStore(BuildbyrefDestroyHelper(DeclPtr->getType(), flag, |
| 574 | Align), |
Mike Stump | 1851b68 | 2009-03-06 04:53:30 +0000 | [diff] [blame] | 575 | destroy_helper); |
Chris Lattner | 9a19edf | 2007-08-26 05:13:54 +0000 | [diff] [blame] | 576 | } |
Chris Lattner | 7f02f72 | 2007-08-24 05:35:26 +0000 | [diff] [blame] | 577 | } |
Anders Carlsson | 69c68b7 | 2009-02-07 23:51:38 +0000 | [diff] [blame] | 578 | |
Fariborz Jahanian | 6ca0b32 | 2009-08-03 20:20:07 +0000 | [diff] [blame] | 579 | // Handle CXX destruction of variables. |
Fariborz Jahanian | 667f36a | 2009-08-03 20:51:29 +0000 | [diff] [blame] | 580 | QualType DtorTy(Ty); |
Douglas Gregor | 89c49f0 | 2009-11-09 22:08:55 +0000 | [diff] [blame] | 581 | while (const ArrayType *Array = getContext().getAsArrayType(DtorTy)) |
Fariborz Jahanian | 6fba746 | 2009-10-29 16:22:54 +0000 | [diff] [blame] | 582 | DtorTy = getContext().getBaseElementType(Array); |
Fariborz Jahanian | 667f36a | 2009-08-03 20:51:29 +0000 | [diff] [blame] | 583 | if (const RecordType *RT = DtorTy->getAs<RecordType>()) |
Fariborz Jahanian | 6ca0b32 | 2009-08-03 20:20:07 +0000 | [diff] [blame] | 584 | if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { |
| 585 | if (!ClassDecl->hasTrivialDestructor()) { |
| 586 | const CXXDestructorDecl *D = ClassDecl->getDestructor(getContext()); |
| 587 | assert(D && "EmitLocalBlockVarDecl - destructor is nul"); |
Fariborz Jahanian | 6fba746 | 2009-10-29 16:22:54 +0000 | [diff] [blame] | 588 | |
Fariborz Jahanian | 6fba746 | 2009-10-29 16:22:54 +0000 | [diff] [blame] | 589 | if (const ConstantArrayType *Array = |
| 590 | getContext().getAsConstantArrayType(Ty)) { |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 591 | { |
| 592 | DelayedCleanupBlock Scope(*this); |
| 593 | QualType BaseElementTy = getContext().getBaseElementType(Array); |
| 594 | const llvm::Type *BasePtr = ConvertType(BaseElementTy); |
| 595 | BasePtr = llvm::PointerType::getUnqual(BasePtr); |
| 596 | llvm::Value *BaseAddrPtr = |
| 597 | Builder.CreateBitCast(DeclPtr, BasePtr); |
| 598 | EmitCXXAggrDestructorCall(D, Array, BaseAddrPtr); |
Fariborz Jahanian | 7799621 | 2009-11-04 17:57:40 +0000 | [diff] [blame] | 599 | |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 600 | // Make sure to jump to the exit block. |
| 601 | EmitBranch(Scope.getCleanupExitBlock()); |
| 602 | } |
| 603 | if (Exceptions) { |
| 604 | EHCleanupBlock Cleanup(*this); |
| 605 | QualType BaseElementTy = getContext().getBaseElementType(Array); |
| 606 | const llvm::Type *BasePtr = ConvertType(BaseElementTy); |
| 607 | BasePtr = llvm::PointerType::getUnqual(BasePtr); |
| 608 | llvm::Value *BaseAddrPtr = |
| 609 | Builder.CreateBitCast(DeclPtr, BasePtr); |
| 610 | EmitCXXAggrDestructorCall(D, Array, BaseAddrPtr); |
| 611 | } |
Fariborz Jahanian | 7799621 | 2009-11-04 17:57:40 +0000 | [diff] [blame] | 612 | } else { |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 613 | { |
| 614 | DelayedCleanupBlock Scope(*this); |
| 615 | EmitCXXDestructorCall(D, Dtor_Complete, DeclPtr); |
Mike Stump | 7302030 | 2009-12-02 23:28:08 +0000 | [diff] [blame] | 616 | |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 617 | // Make sure to jump to the exit block. |
| 618 | EmitBranch(Scope.getCleanupExitBlock()); |
| 619 | } |
| 620 | if (Exceptions) { |
| 621 | EHCleanupBlock Cleanup(*this); |
| 622 | EmitCXXDestructorCall(D, Dtor_Complete, DeclPtr); |
| 623 | } |
Fariborz Jahanian | 7799621 | 2009-11-04 17:57:40 +0000 | [diff] [blame] | 624 | } |
Fariborz Jahanian | 6ca0b32 | 2009-08-03 20:20:07 +0000 | [diff] [blame] | 625 | } |
| 626 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 627 | |
Anders Carlsson | 69c68b7 | 2009-02-07 23:51:38 +0000 | [diff] [blame] | 628 | // Handle the cleanup attribute |
Argyrios Kyrtzidis | 40b598e | 2009-06-30 02:34:44 +0000 | [diff] [blame] | 629 | if (const CleanupAttr *CA = D.getAttr<CleanupAttr>()) { |
Anders Carlsson | 69c68b7 | 2009-02-07 23:51:38 +0000 | [diff] [blame] | 630 | const FunctionDecl *FD = CA->getFunctionDecl(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 631 | |
Anders Carlsson | 555b4bb | 2009-09-10 23:43:36 +0000 | [diff] [blame] | 632 | llvm::Constant* F = CGM.GetAddrOfFunction(FD); |
Anders Carlsson | 69c68b7 | 2009-02-07 23:51:38 +0000 | [diff] [blame] | 633 | assert(F && "Could not find function!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 634 | |
Anders Carlsson | cabec03 | 2009-04-26 00:34:20 +0000 | [diff] [blame] | 635 | const CGFunctionInfo &Info = CGM.getTypes().getFunctionInfo(FD); |
| 636 | |
| 637 | // In some cases, the type of the function argument will be different from |
| 638 | // the type of the pointer. An example of this is |
| 639 | // void f(void* arg); |
| 640 | // __attribute__((cleanup(f))) void *g; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 641 | // |
Anders Carlsson | cabec03 | 2009-04-26 00:34:20 +0000 | [diff] [blame] | 642 | // To fix this we insert a bitcast here. |
| 643 | QualType ArgTy = Info.arg_begin()->type; |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 644 | { |
| 645 | DelayedCleanupBlock scope(*this); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 646 | |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 647 | CallArgList Args; |
| 648 | Args.push_back(std::make_pair(RValue::get(Builder.CreateBitCast(DeclPtr, |
| 649 | ConvertType(ArgTy))), |
| 650 | getContext().getPointerType(D.getType()))); |
Anders Carlsson | f3c47c9 | 2009-12-24 19:25:24 +0000 | [diff] [blame] | 651 | EmitCall(Info, F, ReturnValueSlot(), Args); |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 652 | } |
| 653 | if (Exceptions) { |
| 654 | EHCleanupBlock Cleanup(*this); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 655 | |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 656 | CallArgList Args; |
| 657 | Args.push_back(std::make_pair(RValue::get(Builder.CreateBitCast(DeclPtr, |
| 658 | ConvertType(ArgTy))), |
| 659 | getContext().getPointerType(D.getType()))); |
Anders Carlsson | f3c47c9 | 2009-12-24 19:25:24 +0000 | [diff] [blame] | 660 | EmitCall(Info, F, ReturnValueSlot(), Args); |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 661 | } |
Anders Carlsson | 69c68b7 | 2009-02-07 23:51:38 +0000 | [diff] [blame] | 662 | } |
Mike Stump | 797b632 | 2009-03-05 01:23:13 +0000 | [diff] [blame] | 663 | |
Mike Stump | d9e0fae | 2009-03-05 02:34:38 +0000 | [diff] [blame] | 664 | if (needsDispose && CGM.getLangOptions().getGCMode() != LangOptions::GCOnly) { |
Mike Stump | d88ea56 | 2009-12-09 03:35:49 +0000 | [diff] [blame] | 665 | { |
| 666 | DelayedCleanupBlock scope(*this); |
| 667 | llvm::Value *V = Builder.CreateStructGEP(DeclPtr, 1, "forwarding"); |
| 668 | V = Builder.CreateLoad(V); |
| 669 | BuildBlockRelease(V); |
| 670 | } |
| 671 | // FIXME: Turn this on and audit the codegen |
| 672 | if (0 && Exceptions) { |
| 673 | EHCleanupBlock Cleanup(*this); |
| 674 | llvm::Value *V = Builder.CreateStructGEP(DeclPtr, 1, "forwarding"); |
| 675 | V = Builder.CreateLoad(V); |
| 676 | BuildBlockRelease(V); |
| 677 | } |
Mike Stump | 797b632 | 2009-03-05 01:23:13 +0000 | [diff] [blame] | 678 | } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 679 | } |
| 680 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 681 | /// Emit an alloca (or GlobalValue depending on target) |
Chris Lattner | 2621fd1 | 2008-05-08 05:58:21 +0000 | [diff] [blame] | 682 | /// for the specified parameter and set up LocalDeclMap. |
Daniel Dunbar | b7ec246 | 2008-08-16 03:19:19 +0000 | [diff] [blame] | 683 | void CodeGenFunction::EmitParmDecl(const VarDecl &D, llvm::Value *Arg) { |
| 684 | // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl? |
Sanjiv Gupta | 31fc07d | 2008-10-31 09:52:39 +0000 | [diff] [blame] | 685 | assert((isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) && |
Daniel Dunbar | b7ec246 | 2008-08-16 03:19:19 +0000 | [diff] [blame] | 686 | "Invalid argument to EmitParmDecl"); |
Chris Lattner | 8bcfc5b | 2008-04-06 23:10:54 +0000 | [diff] [blame] | 687 | QualType Ty = D.getType(); |
Mike Stump | df317bf | 2009-11-03 23:25:48 +0000 | [diff] [blame] | 688 | CanQualType CTy = getContext().getCanonicalType(Ty); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 689 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 690 | llvm::Value *DeclPtr; |
Eli Friedman | 3c2b317 | 2008-02-15 12:20:59 +0000 | [diff] [blame] | 691 | if (!Ty->isConstantSizeType()) { |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 692 | // Variable sized values always are passed by-reference. |
| 693 | DeclPtr = Arg; |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 694 | } else { |
Dan Gohman | d79a726 | 2008-05-22 22:12:56 +0000 | [diff] [blame] | 695 | // A fixed sized single-value variable becomes an alloca in the entry block. |
Eli Friedman | a3460ac | 2009-03-04 04:25:14 +0000 | [diff] [blame] | 696 | const llvm::Type *LTy = ConvertTypeForMem(Ty); |
Dan Gohman | d79a726 | 2008-05-22 22:12:56 +0000 | [diff] [blame] | 697 | if (LTy->isSingleValueType()) { |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 698 | // TODO: Alignment |
Chris Lattner | f146684 | 2009-03-22 00:24:14 +0000 | [diff] [blame] | 699 | DeclPtr = CreateTempAlloca(LTy); |
Benjamin Kramer | a4d6ca1 | 2009-12-08 13:07:37 +0000 | [diff] [blame] | 700 | DeclPtr->setName(D.getNameAsString() + llvm::StringRef(".addr")); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 701 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 702 | // Store the initial value into the alloca. |
Mike Stump | df317bf | 2009-11-03 23:25:48 +0000 | [diff] [blame] | 703 | EmitStoreOfScalar(Arg, DeclPtr, CTy.isVolatileQualified(), Ty); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 704 | } else { |
| 705 | // Otherwise, if this is an aggregate, just use the input pointer. |
| 706 | DeclPtr = Arg; |
| 707 | } |
Chris Lattner | 39f34e9 | 2008-11-24 04:00:27 +0000 | [diff] [blame] | 708 | Arg->setName(D.getNameAsString()); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 709 | } |
| 710 | |
| 711 | llvm::Value *&DMEntry = LocalDeclMap[&D]; |
| 712 | assert(DMEntry == 0 && "Decl already exists in localdeclmap!"); |
| 713 | DMEntry = DeclPtr; |
Sanjiv Gupta | cc9b163 | 2008-05-30 10:30:31 +0000 | [diff] [blame] | 714 | |
| 715 | // Emit debug info for param declaration. |
Devang Patel | fee53aa | 2009-10-09 22:06:15 +0000 | [diff] [blame] | 716 | if (CGDebugInfo *DI = getDebugInfo()) { |
| 717 | DI->setLocation(D.getLocation()); |
Chris Lattner | 9c85ba3 | 2008-11-10 06:08:34 +0000 | [diff] [blame] | 718 | DI->EmitDeclareOfArgVariable(&D, DeclPtr, Builder); |
Devang Patel | fee53aa | 2009-10-09 22:06:15 +0000 | [diff] [blame] | 719 | } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 720 | } |