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