Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 1 | //===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===// |
| 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 coordinates the per-function state used while generating code. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "CodeGenFunction.h" |
| 15 | #include "CodeGenModule.h" |
John McCall | 4c40d98 | 2010-08-31 07:33:07 +0000 | [diff] [blame] | 16 | #include "CGCXXABI.h" |
Eli Friedman | 3f2af10 | 2008-05-22 01:40:10 +0000 | [diff] [blame] | 17 | #include "CGDebugInfo.h" |
John McCall | f1549f6 | 2010-07-06 01:34:17 +0000 | [diff] [blame] | 18 | #include "CGException.h" |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 19 | #include "clang/Basic/TargetInfo.h" |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 20 | #include "clang/AST/APValue.h" |
Daniel Dunbar | de7fb84 | 2008-08-11 05:00:27 +0000 | [diff] [blame] | 21 | #include "clang/AST/ASTContext.h" |
Daniel Dunbar | c4a1dea | 2008-08-11 05:35:13 +0000 | [diff] [blame] | 22 | #include "clang/AST/Decl.h" |
Anders Carlsson | 2b77ba8 | 2009-04-04 20:47:02 +0000 | [diff] [blame] | 23 | #include "clang/AST/DeclCXX.h" |
Mike Stump | 6a1e0eb | 2009-12-04 23:26:17 +0000 | [diff] [blame] | 24 | #include "clang/AST/StmtCXX.h" |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 25 | #include "clang/Frontend/CodeGenOptions.h" |
Mike Stump | 4e7a1f7 | 2009-02-21 20:00:35 +0000 | [diff] [blame] | 26 | #include "llvm/Target/TargetData.h" |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 27 | #include "llvm/Intrinsics.h" |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 28 | using namespace clang; |
| 29 | using namespace CodeGen; |
| 30 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 31 | CodeGenFunction::CodeGenFunction(CodeGenModule &cgm) |
John McCall | 5936e33 | 2011-02-15 09:22:45 +0000 | [diff] [blame] | 32 | : CodeGenTypeCache(cgm), CGM(cgm), |
Douglas Gregor | bcfd1f5 | 2011-09-02 00:18:52 +0000 | [diff] [blame] | 33 | Target(CGM.getContext().getTargetInfo()), Builder(cgm.getModule().getContext()), |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 34 | AutoreleaseResult(false), BlockInfo(0), BlockPointer(0), |
John McCall | 777d6e5 | 2011-08-11 02:22:43 +0000 | [diff] [blame] | 35 | NormalCleanupDest(0), NextCleanupDestIndex(1), |
| 36 | EHResumeBlock(0), ExceptionSlot(0), EHSelectorSlot(0), |
John McCall | 93c332a | 2011-05-28 21:13:02 +0000 | [diff] [blame] | 37 | DebugInfo(0), DisableDebugInfo(false), DidCallStackSave(false), |
| 38 | IndirectBranch(0), SwitchInsn(0), CaseRangeBlock(0), UnreachableBlock(0), |
John McCall | 2504941 | 2010-02-16 22:04:33 +0000 | [diff] [blame] | 39 | CXXThisDecl(0), CXXThisValue(0), CXXVTTDecl(0), CXXVTTValue(0), |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 40 | OutermostConditional(0), TerminateLandingPad(0), TerminateHandler(0), |
Chris Lattner | 83252dc | 2010-07-20 21:07:09 +0000 | [diff] [blame] | 41 | TrapBB(0) { |
Anders Carlsson | c1cfdf8 | 2011-02-20 00:20:27 +0000 | [diff] [blame] | 42 | |
Mike Stump | 9c276ae | 2009-12-12 01:27:46 +0000 | [diff] [blame] | 43 | CatchUndefined = getContext().getLangOptions().CatchUndefined; |
John McCall | 4c40d98 | 2010-08-31 07:33:07 +0000 | [diff] [blame] | 44 | CGM.getCXXABI().getMangleContext().startNewFunction(); |
Chris Lattner | 4111024 | 2008-06-17 18:05:57 +0000 | [diff] [blame] | 45 | } |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 46 | |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 47 | |
Chris Lattner | 9cbe4f0 | 2011-07-09 17:41:47 +0000 | [diff] [blame] | 48 | llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { |
Daniel Dunbar | 8b1a343 | 2009-02-03 23:03:55 +0000 | [diff] [blame] | 49 | return CGM.getTypes().ConvertTypeForMem(T); |
| 50 | } |
| 51 | |
Chris Lattner | 9cbe4f0 | 2011-07-09 17:41:47 +0000 | [diff] [blame] | 52 | llvm::Type *CodeGenFunction::ConvertType(QualType T) { |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 53 | return CGM.getTypes().ConvertType(T); |
| 54 | } |
| 55 | |
John McCall | f2aac84 | 2011-05-15 02:34:36 +0000 | [diff] [blame] | 56 | bool CodeGenFunction::hasAggregateLLVMType(QualType type) { |
| 57 | switch (type.getCanonicalType()->getTypeClass()) { |
| 58 | #define TYPE(name, parent) |
| 59 | #define ABSTRACT_TYPE(name, parent) |
| 60 | #define NON_CANONICAL_TYPE(name, parent) case Type::name: |
| 61 | #define DEPENDENT_TYPE(name, parent) case Type::name: |
| 62 | #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name: |
| 63 | #include "clang/AST/TypeNodes.def" |
| 64 | llvm_unreachable("non-canonical or dependent type in IR-generation"); |
| 65 | |
| 66 | case Type::Builtin: |
| 67 | case Type::Pointer: |
| 68 | case Type::BlockPointer: |
| 69 | case Type::LValueReference: |
| 70 | case Type::RValueReference: |
| 71 | case Type::MemberPointer: |
| 72 | case Type::Vector: |
| 73 | case Type::ExtVector: |
| 74 | case Type::FunctionProto: |
| 75 | case Type::FunctionNoProto: |
| 76 | case Type::Enum: |
| 77 | case Type::ObjCObjectPointer: |
| 78 | return false; |
| 79 | |
| 80 | // Complexes, arrays, records, and Objective-C objects. |
| 81 | case Type::Complex: |
| 82 | case Type::ConstantArray: |
| 83 | case Type::IncompleteArray: |
| 84 | case Type::VariableArray: |
| 85 | case Type::Record: |
| 86 | case Type::ObjCObject: |
| 87 | case Type::ObjCInterface: |
| 88 | return true; |
| 89 | } |
| 90 | llvm_unreachable("unknown type kind!"); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 91 | } |
| 92 | |
Daniel Dunbar | 1c1d607 | 2009-01-26 23:27:52 +0000 | [diff] [blame] | 93 | void CodeGenFunction::EmitReturnBlock() { |
| 94 | // For cleanliness, we try to avoid emitting the return block for |
| 95 | // simple cases. |
| 96 | llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); |
| 97 | |
| 98 | if (CurBB) { |
| 99 | assert(!CurBB->getTerminator() && "Unexpected terminated block."); |
| 100 | |
Daniel Dunbar | 96e18b0 | 2009-07-19 08:24:34 +0000 | [diff] [blame] | 101 | // We have a valid insert point, reuse it if it is empty or there are no |
| 102 | // explicit jumps to the return block. |
John McCall | ff8e115 | 2010-07-23 21:56:41 +0000 | [diff] [blame] | 103 | if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { |
| 104 | ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); |
| 105 | delete ReturnBlock.getBlock(); |
Daniel Dunbar | 96e18b0 | 2009-07-19 08:24:34 +0000 | [diff] [blame] | 106 | } else |
John McCall | ff8e115 | 2010-07-23 21:56:41 +0000 | [diff] [blame] | 107 | EmitBlock(ReturnBlock.getBlock()); |
Daniel Dunbar | 1c1d607 | 2009-01-26 23:27:52 +0000 | [diff] [blame] | 108 | return; |
| 109 | } |
| 110 | |
| 111 | // Otherwise, if the return block is the target of a single direct |
| 112 | // branch then we can just put the code in that block instead. This |
| 113 | // cleans up functions which started with a unified return block. |
John McCall | ff8e115 | 2010-07-23 21:56:41 +0000 | [diff] [blame] | 114 | if (ReturnBlock.getBlock()->hasOneUse()) { |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 115 | llvm::BranchInst *BI = |
John McCall | ff8e115 | 2010-07-23 21:56:41 +0000 | [diff] [blame] | 116 | dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); |
John McCall | f1549f6 | 2010-07-06 01:34:17 +0000 | [diff] [blame] | 117 | if (BI && BI->isUnconditional() && |
John McCall | ff8e115 | 2010-07-23 21:56:41 +0000 | [diff] [blame] | 118 | BI->getSuccessor(0) == ReturnBlock.getBlock()) { |
Eric Christopher | acae011 | 2011-09-09 21:53:04 +0000 | [diff] [blame] | 119 | // Reset insertion point, including debug location, and delete the branch. |
| 120 | Builder.SetCurrentDebugLocation(BI->getDebugLoc()); |
Daniel Dunbar | 1c1d607 | 2009-01-26 23:27:52 +0000 | [diff] [blame] | 121 | Builder.SetInsertPoint(BI->getParent()); |
| 122 | BI->eraseFromParent(); |
John McCall | ff8e115 | 2010-07-23 21:56:41 +0000 | [diff] [blame] | 123 | delete ReturnBlock.getBlock(); |
Daniel Dunbar | 1c1d607 | 2009-01-26 23:27:52 +0000 | [diff] [blame] | 124 | return; |
| 125 | } |
| 126 | } |
| 127 | |
Mike Stump | f5408fe | 2009-05-16 07:57:57 +0000 | [diff] [blame] | 128 | // FIXME: We are at an unreachable point, there is no reason to emit the block |
| 129 | // unless it has uses. However, we still need a place to put the debug |
| 130 | // region.end for now. |
Daniel Dunbar | 1c1d607 | 2009-01-26 23:27:52 +0000 | [diff] [blame] | 131 | |
John McCall | ff8e115 | 2010-07-23 21:56:41 +0000 | [diff] [blame] | 132 | EmitBlock(ReturnBlock.getBlock()); |
John McCall | f1549f6 | 2010-07-06 01:34:17 +0000 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { |
| 136 | if (!BB) return; |
| 137 | if (!BB->use_empty()) |
| 138 | return CGF.CurFn->getBasicBlockList().push_back(BB); |
| 139 | delete BB; |
Daniel Dunbar | 1c1d607 | 2009-01-26 23:27:52 +0000 | [diff] [blame] | 140 | } |
| 141 | |
Daniel Dunbar | af05bb9 | 2008-08-26 08:29:31 +0000 | [diff] [blame] | 142 | void CodeGenFunction::FinishFunction(SourceLocation EndLoc) { |
Chris Lattner | da13870 | 2007-07-16 21:28:45 +0000 | [diff] [blame] | 143 | assert(BreakContinueStack.empty() && |
| 144 | "mismatched push/pop in break/continue stack!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 145 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 146 | // Pop any cleanups that might have been associated with the |
| 147 | // parameters. Do this in whatever block we're currently in; it's |
| 148 | // important to do this before we enter the return block or return |
| 149 | // edges will be *really* confused. |
| 150 | if (EHStack.stable_begin() != PrologueCleanupDepth) |
| 151 | PopCleanupBlocks(PrologueCleanupDepth); |
| 152 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 153 | // Emit function epilog (to return). |
Daniel Dunbar | 1c1d607 | 2009-01-26 23:27:52 +0000 | [diff] [blame] | 154 | EmitReturnBlock(); |
Daniel Dunbar | f5bd45c | 2008-11-11 20:59:54 +0000 | [diff] [blame] | 155 | |
Daniel Dunbar | a18652f | 2011-02-10 17:32:22 +0000 | [diff] [blame] | 156 | if (ShouldInstrumentFunction()) |
| 157 | EmitFunctionInstrumentation("__cyg_profile_func_exit"); |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 158 | |
Daniel Dunbar | f5bd45c | 2008-11-11 20:59:54 +0000 | [diff] [blame] | 159 | // Emit debug descriptor for function end. |
Anders Carlsson | e896d98 | 2009-02-13 08:11:52 +0000 | [diff] [blame] | 160 | if (CGDebugInfo *DI = getDebugInfo()) { |
Daniel Dunbar | f5bd45c | 2008-11-11 20:59:54 +0000 | [diff] [blame] | 161 | DI->setLocation(EndLoc); |
Devang Patel | 5a6fbcf | 2010-07-22 22:29:16 +0000 | [diff] [blame] | 162 | DI->EmitFunctionEnd(Builder); |
Daniel Dunbar | f5bd45c | 2008-11-11 20:59:54 +0000 | [diff] [blame] | 163 | } |
| 164 | |
Chris Lattner | 35b21b8 | 2010-06-27 01:06:27 +0000 | [diff] [blame] | 165 | EmitFunctionEpilog(*CurFnInfo); |
Mike Stump | cce3d4f | 2009-12-07 23:38:24 +0000 | [diff] [blame] | 166 | EmitEndEHSpec(CurCodeDecl); |
Daniel Dunbar | 5ca2084 | 2008-09-09 21:00:17 +0000 | [diff] [blame] | 167 | |
John McCall | f1549f6 | 2010-07-06 01:34:17 +0000 | [diff] [blame] | 168 | assert(EHStack.empty() && |
| 169 | "did not remove all scopes from cleanup stack!"); |
| 170 | |
Chris Lattner | d9becd1 | 2009-10-28 23:59:40 +0000 | [diff] [blame] | 171 | // If someone did an indirect goto, emit the indirect goto block at the end of |
| 172 | // the function. |
| 173 | if (IndirectBranch) { |
| 174 | EmitBlock(IndirectBranch->getParent()); |
| 175 | Builder.ClearInsertionPoint(); |
| 176 | } |
| 177 | |
Chris Lattner | 5a2fa14 | 2007-12-02 06:32:24 +0000 | [diff] [blame] | 178 | // Remove the AllocaInsertPt instruction, which is just a convenience for us. |
Chris Lattner | 481769b | 2009-03-31 22:17:44 +0000 | [diff] [blame] | 179 | llvm::Instruction *Ptr = AllocaInsertPt; |
Chris Lattner | 5a2fa14 | 2007-12-02 06:32:24 +0000 | [diff] [blame] | 180 | AllocaInsertPt = 0; |
Chris Lattner | 481769b | 2009-03-31 22:17:44 +0000 | [diff] [blame] | 181 | Ptr->eraseFromParent(); |
Chris Lattner | d9becd1 | 2009-10-28 23:59:40 +0000 | [diff] [blame] | 182 | |
| 183 | // If someone took the address of a label but never did an indirect goto, we |
| 184 | // made a zero entry PHI node, which is illegal, zap it now. |
| 185 | if (IndirectBranch) { |
| 186 | llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); |
| 187 | if (PN->getNumIncomingValues() == 0) { |
| 188 | PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); |
| 189 | PN->eraseFromParent(); |
| 190 | } |
| 191 | } |
John McCall | f1549f6 | 2010-07-06 01:34:17 +0000 | [diff] [blame] | 192 | |
John McCall | 777d6e5 | 2011-08-11 02:22:43 +0000 | [diff] [blame] | 193 | EmitIfUsed(*this, EHResumeBlock); |
John McCall | f1549f6 | 2010-07-06 01:34:17 +0000 | [diff] [blame] | 194 | EmitIfUsed(*this, TerminateLandingPad); |
| 195 | EmitIfUsed(*this, TerminateHandler); |
| 196 | EmitIfUsed(*this, UnreachableBlock); |
John McCall | 744016d | 2010-07-06 23:57:41 +0000 | [diff] [blame] | 197 | |
| 198 | if (CGM.getCodeGenOpts().EmitDeclMetadata) |
| 199 | EmitDeclMetadata(); |
Reid Spencer | 5f016e2 | 2007-07-11 17:01:13 +0000 | [diff] [blame] | 200 | } |
| 201 | |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 202 | /// ShouldInstrumentFunction - Return true if the current function should be |
| 203 | /// instrumented with __cyg_profile_func_* calls |
| 204 | bool CodeGenFunction::ShouldInstrumentFunction() { |
| 205 | if (!CGM.getCodeGenOpts().InstrumentFunctions) |
| 206 | return false; |
Ted Kremenek | 7aa488a | 2011-05-16 23:49:20 +0000 | [diff] [blame] | 207 | if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 208 | return false; |
| 209 | return true; |
| 210 | } |
| 211 | |
| 212 | /// EmitFunctionInstrumentation - Emit LLVM code to call the specified |
| 213 | /// instrumentation function with the current function and the call site, if |
| 214 | /// function instrumentation is enabled. |
| 215 | void CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { |
Chris Lattner | 8dab657 | 2010-06-23 05:21:28 +0000 | [diff] [blame] | 216 | // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); |
Chris Lattner | 9cbe4f0 | 2011-07-09 17:41:47 +0000 | [diff] [blame] | 217 | llvm::PointerType *PointerTy = Int8PtrTy; |
| 218 | llvm::Type *ProfileFuncArgs[] = { PointerTy, PointerTy }; |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 219 | llvm::FunctionType *FunctionTy = |
Benjamin Kramer | 95d318c | 2011-05-28 14:26:31 +0000 | [diff] [blame] | 220 | llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), |
| 221 | ProfileFuncArgs, false); |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 222 | |
| 223 | llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); |
| 224 | llvm::CallInst *CallSite = Builder.CreateCall( |
Benjamin Kramer | 8dd55a3 | 2011-07-14 17:45:50 +0000 | [diff] [blame] | 225 | CGM.getIntrinsic(llvm::Intrinsic::returnaddress), |
Chris Lattner | 77b89b8 | 2010-06-27 07:15:29 +0000 | [diff] [blame] | 226 | llvm::ConstantInt::get(Int32Ty, 0), |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 227 | "callsite"); |
| 228 | |
Chris Lattner | 8dab657 | 2010-06-23 05:21:28 +0000 | [diff] [blame] | 229 | Builder.CreateCall2(F, |
| 230 | llvm::ConstantExpr::getBitCast(CurFn, PointerTy), |
| 231 | CallSite); |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 232 | } |
| 233 | |
Roman Divacky | be4c870 | 2011-02-10 16:52:03 +0000 | [diff] [blame] | 234 | void CodeGenFunction::EmitMCountInstrumentation() { |
| 235 | llvm::FunctionType *FTy = |
| 236 | llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), false); |
| 237 | |
| 238 | llvm::Constant *MCountFn = CGM.CreateRuntimeFunction(FTy, |
| 239 | Target.getMCountName()); |
| 240 | Builder.CreateCall(MCountFn); |
| 241 | } |
| 242 | |
Anders Carlsson | 0ff8baf | 2009-09-11 00:07:24 +0000 | [diff] [blame] | 243 | void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, |
Daniel Dunbar | 7c08651 | 2008-09-09 23:14:03 +0000 | [diff] [blame] | 244 | llvm::Function *Fn, |
John McCall | d26bc76 | 2011-03-09 04:27:21 +0000 | [diff] [blame] | 245 | const CGFunctionInfo &FnInfo, |
Daniel Dunbar | 2284ac9 | 2008-10-18 18:22:23 +0000 | [diff] [blame] | 246 | const FunctionArgList &Args, |
Tilmann Scheller | 9c6082f | 2011-03-02 21:36:49 +0000 | [diff] [blame] | 247 | SourceLocation StartLoc) { |
Anders Carlsson | 0ff8baf | 2009-09-11 00:07:24 +0000 | [diff] [blame] | 248 | const Decl *D = GD.getDecl(); |
| 249 | |
Anders Carlsson | 4cc1a47 | 2009-02-09 20:20:56 +0000 | [diff] [blame] | 250 | DidCallStackSave = false; |
Chris Lattner | b5437d2 | 2009-04-23 05:30:27 +0000 | [diff] [blame] | 251 | CurCodeDecl = CurFuncDecl = D; |
Daniel Dunbar | 7c08651 | 2008-09-09 23:14:03 +0000 | [diff] [blame] | 252 | FnRetTy = RetTy; |
Daniel Dunbar | bd012ff | 2008-07-29 23:18:29 +0000 | [diff] [blame] | 253 | CurFn = Fn; |
John McCall | d26bc76 | 2011-03-09 04:27:21 +0000 | [diff] [blame] | 254 | CurFnInfo = &FnInfo; |
Chris Lattner | 4111024 | 2008-06-17 18:05:57 +0000 | [diff] [blame] | 255 | assert(CurFn->isDeclaration() && "Function already has body?"); |
| 256 | |
Jakob Stoklund Olesen | a3fe284 | 2010-02-09 00:10:00 +0000 | [diff] [blame] | 257 | // Pass inline keyword to optimizer if it appears explicitly on any |
| 258 | // declaration. |
| 259 | if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) |
| 260 | for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), |
| 261 | RE = FD->redecls_end(); RI != RE; ++RI) |
| 262 | if (RI->isInlineSpecified()) { |
| 263 | Fn->addFnAttr(llvm::Attribute::InlineHint); |
| 264 | break; |
| 265 | } |
| 266 | |
Peter Collingbourne | f315fa8 | 2011-02-14 01:42:53 +0000 | [diff] [blame] | 267 | if (getContext().getLangOptions().OpenCL) { |
| 268 | // Add metadata for a kernel function. |
| 269 | if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) |
| 270 | if (FD->hasAttr<OpenCLKernelAttr>()) { |
| 271 | llvm::LLVMContext &Context = getLLVMContext(); |
| 272 | llvm::NamedMDNode *OpenCLMetadata = |
| 273 | CGM.getModule().getOrInsertNamedMetadata("opencl.kernels"); |
| 274 | |
| 275 | llvm::Value *Op = Fn; |
Jay Foad | 6f14165 | 2011-04-21 19:59:12 +0000 | [diff] [blame] | 276 | OpenCLMetadata->addOperand(llvm::MDNode::get(Context, Op)); |
Peter Collingbourne | f315fa8 | 2011-02-14 01:42:53 +0000 | [diff] [blame] | 277 | } |
| 278 | } |
| 279 | |
Daniel Dunbar | 55e8742 | 2008-11-11 02:29:29 +0000 | [diff] [blame] | 280 | llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); |
Daniel Dunbar | 5ca2084 | 2008-09-09 21:00:17 +0000 | [diff] [blame] | 281 | |
Chris Lattner | 4111024 | 2008-06-17 18:05:57 +0000 | [diff] [blame] | 282 | // Create a marker to make it easy to insert allocas into the entryblock |
| 283 | // later. Don't create this with the builder, because we don't want it |
| 284 | // folded. |
Chris Lattner | 77b89b8 | 2010-06-27 07:15:29 +0000 | [diff] [blame] | 285 | llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); |
| 286 | AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); |
Chris Lattner | f146684 | 2009-03-22 00:24:14 +0000 | [diff] [blame] | 287 | if (Builder.isNamePreserving()) |
| 288 | AllocaInsertPt->setName("allocapt"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 289 | |
John McCall | f1549f6 | 2010-07-06 01:34:17 +0000 | [diff] [blame] | 290 | ReturnBlock = getJumpDestInCurrentScope("return"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 291 | |
Chris Lattner | 4111024 | 2008-06-17 18:05:57 +0000 | [diff] [blame] | 292 | Builder.SetInsertPoint(EntryBB); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 293 | |
Sanjiv Gupta | af99417 | 2008-07-04 11:04:26 +0000 | [diff] [blame] | 294 | // Emit subprogram debug descriptor. |
Anders Carlsson | e896d98 | 2009-02-13 08:11:52 +0000 | [diff] [blame] | 295 | if (CGDebugInfo *DI = getDebugInfo()) { |
John McCall | e23cf43 | 2010-12-14 08:05:40 +0000 | [diff] [blame] | 296 | // FIXME: what is going on here and why does it ignore all these |
| 297 | // interesting type properties? |
| 298 | QualType FnType = |
| 299 | getContext().getFunctionType(RetTy, 0, 0, |
| 300 | FunctionProtoType::ExtProtoInfo()); |
| 301 | |
Daniel Dunbar | 2284ac9 | 2008-10-18 18:22:23 +0000 | [diff] [blame] | 302 | DI->setLocation(StartLoc); |
Devang Patel | 9c6c3a0 | 2010-01-14 00:36:21 +0000 | [diff] [blame] | 303 | DI->EmitFunctionStart(GD, FnType, CurFn, Builder); |
Sanjiv Gupta | af99417 | 2008-07-04 11:04:26 +0000 | [diff] [blame] | 304 | } |
| 305 | |
Daniel Dunbar | a18652f | 2011-02-10 17:32:22 +0000 | [diff] [blame] | 306 | if (ShouldInstrumentFunction()) |
| 307 | EmitFunctionInstrumentation("__cyg_profile_func_enter"); |
Chris Lattner | 7255a2d | 2010-06-22 00:03:40 +0000 | [diff] [blame] | 308 | |
Roman Divacky | be4c870 | 2011-02-10 16:52:03 +0000 | [diff] [blame] | 309 | if (CGM.getCodeGenOpts().InstrumentForProfiling) |
| 310 | EmitMCountInstrumentation(); |
| 311 | |
Eli Friedman | b17daf9 | 2009-12-04 02:43:40 +0000 | [diff] [blame] | 312 | if (RetTy->isVoidType()) { |
| 313 | // Void type; nothing to return. |
| 314 | ReturnValue = 0; |
| 315 | } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && |
| 316 | hasAggregateLLVMType(CurFnInfo->getReturnType())) { |
| 317 | // Indirect aggregate return; emit returned value directly into sret slot. |
Daniel Dunbar | 647a1ec | 2010-02-16 19:45:20 +0000 | [diff] [blame] | 318 | // This reduces code size, and affects correctness in C++. |
Eli Friedman | b17daf9 | 2009-12-04 02:43:40 +0000 | [diff] [blame] | 319 | ReturnValue = CurFn->arg_begin(); |
| 320 | } else { |
Daniel Dunbar | 647a1ec | 2010-02-16 19:45:20 +0000 | [diff] [blame] | 321 | ReturnValue = CreateIRTemp(RetTy, "retval"); |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 322 | |
| 323 | // Tell the epilog emitter to autorelease the result. We do this |
| 324 | // now so that various specialized functions can suppress it |
| 325 | // during their IR-generation. |
| 326 | if (getLangOptions().ObjCAutoRefCount && |
| 327 | !CurFnInfo->isReturnsRetained() && |
| 328 | RetTy->isObjCRetainableType()) |
| 329 | AutoreleaseResult = true; |
Eli Friedman | b17daf9 | 2009-12-04 02:43:40 +0000 | [diff] [blame] | 330 | } |
| 331 | |
Mike Stump | cce3d4f | 2009-12-07 23:38:24 +0000 | [diff] [blame] | 332 | EmitStartEHSpec(CurCodeDecl); |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 333 | |
| 334 | PrologueCleanupDepth = EHStack.stable_begin(); |
Daniel Dunbar | 88b5396 | 2009-02-02 22:03:45 +0000 | [diff] [blame] | 335 | EmitFunctionProlog(*CurFnInfo, CurFn, Args); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 336 | |
John McCall | 4c40d98 | 2010-08-31 07:33:07 +0000 | [diff] [blame] | 337 | if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) |
| 338 | CGM.getCXXABI().EmitInstanceFunctionProlog(*this); |
John McCall | 2504941 | 2010-02-16 22:04:33 +0000 | [diff] [blame] | 339 | |
Anders Carlsson | 751358f | 2008-12-20 21:28:43 +0000 | [diff] [blame] | 340 | // If any of the arguments have a variably modified type, make sure to |
| 341 | // emit the type size. |
| 342 | for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); |
| 343 | i != e; ++i) { |
John McCall | d26bc76 | 2011-03-09 04:27:21 +0000 | [diff] [blame] | 344 | QualType Ty = (*i)->getType(); |
Anders Carlsson | 751358f | 2008-12-20 21:28:43 +0000 | [diff] [blame] | 345 | |
| 346 | if (Ty->isVariablyModifiedType()) |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 347 | EmitVariablyModifiedType(Ty); |
Anders Carlsson | 751358f | 2008-12-20 21:28:43 +0000 | [diff] [blame] | 348 | } |
Daniel Dunbar | 7c08651 | 2008-09-09 23:14:03 +0000 | [diff] [blame] | 349 | } |
Eli Friedman | eb4b705 | 2008-08-25 21:31:01 +0000 | [diff] [blame] | 350 | |
John McCall | 9fc6a77 | 2010-02-19 09:25:03 +0000 | [diff] [blame] | 351 | void CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) { |
| 352 | const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl()); |
Douglas Gregor | 06a9f36 | 2010-05-01 20:49:11 +0000 | [diff] [blame] | 353 | assert(FD->getBody()); |
| 354 | EmitStmt(FD->getBody()); |
John McCall | a355e07 | 2010-02-18 03:17:58 +0000 | [diff] [blame] | 355 | } |
| 356 | |
John McCall | 39dad53 | 2010-08-03 22:46:07 +0000 | [diff] [blame] | 357 | /// Tries to mark the given function nounwind based on the |
| 358 | /// non-existence of any throwing calls within it. We believe this is |
| 359 | /// lightweight enough to do at -O0. |
| 360 | static void TryMarkNoThrow(llvm::Function *F) { |
John McCall | b3a29f1 | 2010-08-11 22:38:33 +0000 | [diff] [blame] | 361 | // LLVM treats 'nounwind' on a function as part of the type, so we |
| 362 | // can't do this on functions that can be overwritten. |
| 363 | if (F->mayBeOverridden()) return; |
| 364 | |
John McCall | 39dad53 | 2010-08-03 22:46:07 +0000 | [diff] [blame] | 365 | for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) |
| 366 | for (llvm::BasicBlock::iterator |
| 367 | BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) |
Bill Wendling | 285cfd8 | 2011-09-19 20:31:14 +0000 | [diff] [blame] | 368 | if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) { |
John McCall | 39dad53 | 2010-08-03 22:46:07 +0000 | [diff] [blame] | 369 | if (!Call->doesNotThrow()) |
| 370 | return; |
Bill Wendling | 285cfd8 | 2011-09-19 20:31:14 +0000 | [diff] [blame] | 371 | } else if (isa<llvm::ResumeInst>(&*BI)) { |
| 372 | return; |
| 373 | } |
John McCall | 39dad53 | 2010-08-03 22:46:07 +0000 | [diff] [blame] | 374 | F->setDoesNotThrow(true); |
| 375 | } |
| 376 | |
John McCall | d26bc76 | 2011-03-09 04:27:21 +0000 | [diff] [blame] | 377 | void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn, |
| 378 | const CGFunctionInfo &FnInfo) { |
Anders Carlsson | 0ff8baf | 2009-09-11 00:07:24 +0000 | [diff] [blame] | 379 | const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); |
| 380 | |
Anders Carlsson | e896d98 | 2009-02-13 08:11:52 +0000 | [diff] [blame] | 381 | // Check if we should generate debug info for this function. |
Devang Patel | aa11289 | 2011-03-07 18:45:56 +0000 | [diff] [blame] | 382 | if (CGM.getModuleDebugInfo() && !FD->hasAttr<NoDebugAttr>()) |
| 383 | DebugInfo = CGM.getModuleDebugInfo(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 384 | |
Daniel Dunbar | 7c08651 | 2008-09-09 23:14:03 +0000 | [diff] [blame] | 385 | FunctionArgList Args; |
John McCall | 4c40d98 | 2010-08-31 07:33:07 +0000 | [diff] [blame] | 386 | QualType ResTy = FD->getResultType(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 387 | |
Mike Stump | 6a1e0eb | 2009-12-04 23:26:17 +0000 | [diff] [blame] | 388 | CurGD = GD; |
John McCall | 4c40d98 | 2010-08-31 07:33:07 +0000 | [diff] [blame] | 389 | if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance()) |
| 390 | CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 391 | |
John McCall | d26bc76 | 2011-03-09 04:27:21 +0000 | [diff] [blame] | 392 | if (FD->getNumParams()) |
Daniel Dunbar | 7c08651 | 2008-09-09 23:14:03 +0000 | [diff] [blame] | 393 | for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) |
John McCall | d26bc76 | 2011-03-09 04:27:21 +0000 | [diff] [blame] | 394 | Args.push_back(FD->getParamDecl(i)); |
Daniel Dunbar | af05bb9 | 2008-08-26 08:29:31 +0000 | [diff] [blame] | 395 | |
John McCall | a355e07 | 2010-02-18 03:17:58 +0000 | [diff] [blame] | 396 | SourceRange BodyRange; |
| 397 | if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); |
Anders Carlsson | 4365bba | 2009-11-06 02:55:43 +0000 | [diff] [blame] | 398 | |
John McCall | a355e07 | 2010-02-18 03:17:58 +0000 | [diff] [blame] | 399 | // Emit the standard function prologue. |
John McCall | d26bc76 | 2011-03-09 04:27:21 +0000 | [diff] [blame] | 400 | StartFunction(GD, ResTy, Fn, FnInfo, Args, BodyRange.getBegin()); |
Anders Carlsson | 4365bba | 2009-11-06 02:55:43 +0000 | [diff] [blame] | 401 | |
John McCall | a355e07 | 2010-02-18 03:17:58 +0000 | [diff] [blame] | 402 | // Generate the body of the function. |
John McCall | 9fc6a77 | 2010-02-19 09:25:03 +0000 | [diff] [blame] | 403 | if (isa<CXXDestructorDecl>(FD)) |
| 404 | EmitDestructorBody(Args); |
| 405 | else if (isa<CXXConstructorDecl>(FD)) |
| 406 | EmitConstructorBody(Args); |
| 407 | else |
| 408 | EmitFunctionBody(Args); |
Anders Carlsson | 1851a12 | 2010-02-07 19:45:40 +0000 | [diff] [blame] | 409 | |
John McCall | a355e07 | 2010-02-18 03:17:58 +0000 | [diff] [blame] | 410 | // Emit the standard function epilogue. |
| 411 | FinishFunction(BodyRange.getEnd()); |
John McCall | 39dad53 | 2010-08-03 22:46:07 +0000 | [diff] [blame] | 412 | |
| 413 | // If we haven't marked the function nothrow through other means, do |
| 414 | // a quick pass now to see if we can. |
| 415 | if (!CurFn->doesNotThrow()) |
| 416 | TryMarkNoThrow(CurFn); |
Chris Lattner | 4111024 | 2008-06-17 18:05:57 +0000 | [diff] [blame] | 417 | } |
| 418 | |
Chris Lattner | 0946ccd | 2008-11-11 07:41:27 +0000 | [diff] [blame] | 419 | /// ContainsLabel - Return true if the statement contains a label in it. If |
| 420 | /// this statement is not executed normally, it not containing a label means |
| 421 | /// that we can just remove the code. |
| 422 | bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { |
| 423 | // Null statement, not a label! |
| 424 | if (S == 0) return false; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 425 | |
Chris Lattner | 0946ccd | 2008-11-11 07:41:27 +0000 | [diff] [blame] | 426 | // If this is a label, we have to emit the code, consider something like: |
| 427 | // if (0) { ... foo: bar(); } goto foo; |
Chris Lattner | ef425a6 | 2011-02-28 00:18:40 +0000 | [diff] [blame] | 428 | // |
| 429 | // TODO: If anyone cared, we could track __label__'s, since we know that you |
| 430 | // can't jump to one from outside their declared region. |
Chris Lattner | 0946ccd | 2008-11-11 07:41:27 +0000 | [diff] [blame] | 431 | if (isa<LabelStmt>(S)) |
| 432 | return true; |
Chris Lattner | ef425a6 | 2011-02-28 00:18:40 +0000 | [diff] [blame] | 433 | |
Chris Lattner | 0946ccd | 2008-11-11 07:41:27 +0000 | [diff] [blame] | 434 | // If this is a case/default statement, and we haven't seen a switch, we have |
| 435 | // to emit the code. |
| 436 | if (isa<SwitchCase>(S) && !IgnoreCaseStmts) |
| 437 | return true; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 438 | |
Chris Lattner | 0946ccd | 2008-11-11 07:41:27 +0000 | [diff] [blame] | 439 | // If this is a switch statement, we want to ignore cases below it. |
| 440 | if (isa<SwitchStmt>(S)) |
| 441 | IgnoreCaseStmts = true; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 442 | |
Chris Lattner | 0946ccd | 2008-11-11 07:41:27 +0000 | [diff] [blame] | 443 | // Scan subexpressions for verboten labels. |
John McCall | 7502c1d | 2011-02-13 04:07:26 +0000 | [diff] [blame] | 444 | for (Stmt::const_child_range I = S->children(); I; ++I) |
Chris Lattner | 0946ccd | 2008-11-11 07:41:27 +0000 | [diff] [blame] | 445 | if (ContainsLabel(*I, IgnoreCaseStmts)) |
| 446 | return true; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 447 | |
Chris Lattner | 0946ccd | 2008-11-11 07:41:27 +0000 | [diff] [blame] | 448 | return false; |
| 449 | } |
| 450 | |
Chris Lattner | ef425a6 | 2011-02-28 00:18:40 +0000 | [diff] [blame] | 451 | /// containsBreak - Return true if the statement contains a break out of it. |
| 452 | /// If the statement (recursively) contains a switch or loop with a break |
| 453 | /// inside of it, this is fine. |
| 454 | bool CodeGenFunction::containsBreak(const Stmt *S) { |
| 455 | // Null statement, not a label! |
| 456 | if (S == 0) return false; |
| 457 | |
| 458 | // If this is a switch or loop that defines its own break scope, then we can |
| 459 | // include it and anything inside of it. |
| 460 | if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) || |
| 461 | isa<ForStmt>(S)) |
Chris Lattner | 2bef7f5 | 2011-02-28 00:42:31 +0000 | [diff] [blame] | 462 | return false; |
| 463 | |
| 464 | if (isa<BreakStmt>(S)) |
Chris Lattner | ef425a6 | 2011-02-28 00:18:40 +0000 | [diff] [blame] | 465 | return true; |
| 466 | |
| 467 | // Scan subexpressions for verboten breaks. |
| 468 | for (Stmt::const_child_range I = S->children(); I; ++I) |
| 469 | if (containsBreak(*I)) |
| 470 | return true; |
| 471 | |
| 472 | return false; |
| 473 | } |
| 474 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 475 | |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 476 | /// ConstantFoldsToSimpleInteger - If the specified expression does not fold |
| 477 | /// to a constant, or if it does but contains a label, return false. If it |
| 478 | /// constant folds return true and set the boolean result in Result. |
| 479 | bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond, |
| 480 | bool &ResultBool) { |
Chris Lattner | ef425a6 | 2011-02-28 00:18:40 +0000 | [diff] [blame] | 481 | llvm::APInt ResultInt; |
| 482 | if (!ConstantFoldsToSimpleInteger(Cond, ResultInt)) |
| 483 | return false; |
| 484 | |
| 485 | ResultBool = ResultInt.getBoolValue(); |
| 486 | return true; |
| 487 | } |
| 488 | |
| 489 | /// ConstantFoldsToSimpleInteger - If the specified expression does not fold |
| 490 | /// to a constant, or if it does but contains a label, return false. If it |
| 491 | /// constant folds return true and set the folded value. |
| 492 | bool CodeGenFunction:: |
| 493 | ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APInt &ResultInt) { |
Daniel Dunbar | 36bc14c | 2008-11-12 22:37:10 +0000 | [diff] [blame] | 494 | // FIXME: Rename and handle conversion of other evaluatable things |
| 495 | // to bool. |
Anders Carlsson | 64712f1 | 2008-12-01 02:46:24 +0000 | [diff] [blame] | 496 | Expr::EvalResult Result; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 497 | if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() || |
Anders Carlsson | 64712f1 | 2008-12-01 02:46:24 +0000 | [diff] [blame] | 498 | Result.HasSideEffects) |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 499 | return false; // Not foldable, not integer or not fully evaluatable. |
Chris Lattner | ef425a6 | 2011-02-28 00:18:40 +0000 | [diff] [blame] | 500 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 501 | if (CodeGenFunction::ContainsLabel(Cond)) |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 502 | return false; // Contains a label. |
Chris Lattner | ef425a6 | 2011-02-28 00:18:40 +0000 | [diff] [blame] | 503 | |
| 504 | ResultInt = Result.Val.getInt(); |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 505 | return true; |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 506 | } |
| 507 | |
| 508 | |
Chris Lattner | ef425a6 | 2011-02-28 00:18:40 +0000 | [diff] [blame] | 509 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 510 | /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if |
| 511 | /// statement) to the specified blocks. Based on the condition, this might try |
| 512 | /// to simplify the codegen of the conditional based on the branch. |
| 513 | /// |
| 514 | void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, |
| 515 | llvm::BasicBlock *TrueBlock, |
| 516 | llvm::BasicBlock *FalseBlock) { |
Peter Collingbourne | f111d93 | 2011-04-15 00:35:48 +0000 | [diff] [blame] | 517 | Cond = Cond->IgnoreParens(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 518 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 519 | if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { |
| 520 | // Handle X && Y in a condition. |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 521 | if (CondBOp->getOpcode() == BO_LAnd) { |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 522 | // If we have "1 && X", simplify the code. "0 && X" would have constant |
| 523 | // folded if the case was simple enough. |
Bill Wendling | e3eb83b | 2011-03-04 21:46:03 +0000 | [diff] [blame] | 524 | bool ConstantBool = false; |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 525 | if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && |
| 526 | ConstantBool) { |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 527 | // br(1 && X) -> br(X). |
| 528 | return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); |
| 529 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 530 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 531 | // If we have "X && 1", simplify the code to use an uncond branch. |
| 532 | // "X && 0" would have been constant folded to 0. |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 533 | if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && |
| 534 | ConstantBool) { |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 535 | // br(X && 1) -> br(X). |
| 536 | return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); |
| 537 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 538 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 539 | // Emit the LHS as a conditional. If the LHS conditional is false, we |
| 540 | // want to jump to the FalseBlock. |
Daniel Dunbar | 9615ecb | 2008-11-13 01:38:36 +0000 | [diff] [blame] | 541 | llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 542 | |
| 543 | ConditionalEvaluation eval(*this); |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 544 | EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); |
| 545 | EmitBlock(LHSTrue); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 546 | |
Anders Carlsson | 08e9e45 | 2010-01-24 00:20:05 +0000 | [diff] [blame] | 547 | // Any temporaries created here are conditional. |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 548 | eval.begin(*this); |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 549 | EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 550 | eval.end(*this); |
Anders Carlsson | 08e9e45 | 2010-01-24 00:20:05 +0000 | [diff] [blame] | 551 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 552 | return; |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 553 | } |
| 554 | |
| 555 | if (CondBOp->getOpcode() == BO_LOr) { |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 556 | // If we have "0 || X", simplify the code. "1 || X" would have constant |
| 557 | // folded if the case was simple enough. |
Bill Wendling | e3eb83b | 2011-03-04 21:46:03 +0000 | [diff] [blame] | 558 | bool ConstantBool = false; |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 559 | if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && |
| 560 | !ConstantBool) { |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 561 | // br(0 || X) -> br(X). |
| 562 | return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); |
| 563 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 564 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 565 | // If we have "X || 0", simplify the code to use an uncond branch. |
| 566 | // "X || 1" would have been constant folded to 1. |
Chris Lattner | c2c9001 | 2011-02-27 23:02:32 +0000 | [diff] [blame] | 567 | if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && |
| 568 | !ConstantBool) { |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 569 | // br(X || 0) -> br(X). |
| 570 | return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); |
| 571 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 572 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 573 | // Emit the LHS as a conditional. If the LHS conditional is true, we |
| 574 | // want to jump to the TrueBlock. |
Daniel Dunbar | 9615ecb | 2008-11-13 01:38:36 +0000 | [diff] [blame] | 575 | llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 576 | |
| 577 | ConditionalEvaluation eval(*this); |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 578 | EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); |
| 579 | EmitBlock(LHSFalse); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 580 | |
Anders Carlsson | 08e9e45 | 2010-01-24 00:20:05 +0000 | [diff] [blame] | 581 | // Any temporaries created here are conditional. |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 582 | eval.begin(*this); |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 583 | EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 584 | eval.end(*this); |
Anders Carlsson | 08e9e45 | 2010-01-24 00:20:05 +0000 | [diff] [blame] | 585 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 586 | return; |
| 587 | } |
Chris Lattner | 552f4c4 | 2008-11-12 08:13:36 +0000 | [diff] [blame] | 588 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 589 | |
Chris Lattner | 552f4c4 | 2008-11-12 08:13:36 +0000 | [diff] [blame] | 590 | if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { |
| 591 | // br(!x, t, f) -> br(x, f, t) |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 592 | if (CondUOp->getOpcode() == UO_LNot) |
Chris Lattner | 552f4c4 | 2008-11-12 08:13:36 +0000 | [diff] [blame] | 593 | return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 594 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 595 | |
Daniel Dunbar | 09b1489 | 2008-11-12 10:30:32 +0000 | [diff] [blame] | 596 | if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { |
| 597 | // Handle ?: operator. |
| 598 | |
| 599 | // Just ignore GNU ?: extension. |
| 600 | if (CondOp->getLHS()) { |
| 601 | // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) |
| 602 | llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); |
| 603 | llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 604 | |
| 605 | ConditionalEvaluation cond(*this); |
Daniel Dunbar | 09b1489 | 2008-11-12 10:30:32 +0000 | [diff] [blame] | 606 | EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 607 | |
| 608 | cond.begin(*this); |
Daniel Dunbar | 09b1489 | 2008-11-12 10:30:32 +0000 | [diff] [blame] | 609 | EmitBlock(LHSBlock); |
| 610 | EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 611 | cond.end(*this); |
| 612 | |
| 613 | cond.begin(*this); |
Daniel Dunbar | 09b1489 | 2008-11-12 10:30:32 +0000 | [diff] [blame] | 614 | EmitBlock(RHSBlock); |
| 615 | EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); |
John McCall | 150b462 | 2011-01-26 04:00:11 +0000 | [diff] [blame] | 616 | cond.end(*this); |
| 617 | |
Daniel Dunbar | 09b1489 | 2008-11-12 10:30:32 +0000 | [diff] [blame] | 618 | return; |
| 619 | } |
| 620 | } |
| 621 | |
Chris Lattner | 31a0984 | 2008-11-12 08:04:58 +0000 | [diff] [blame] | 622 | // Emit the code with the fully general case. |
| 623 | llvm::Value *CondV = EvaluateExprAsBool(Cond); |
| 624 | Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); |
| 625 | } |
| 626 | |
Daniel Dunbar | 488e993 | 2008-08-16 00:56:44 +0000 | [diff] [blame] | 627 | /// ErrorUnsupported - Print out an error that codegen doesn't support the |
Chris Lattner | dc5e826 | 2007-12-02 01:43:38 +0000 | [diff] [blame] | 628 | /// specified stmt yet. |
Daniel Dunbar | 90df4b6 | 2008-09-04 03:43:08 +0000 | [diff] [blame] | 629 | void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, |
| 630 | bool OmitOnError) { |
| 631 | CGM.ErrorUnsupported(S, Type, OmitOnError); |
Chris Lattner | dc5e826 | 2007-12-02 01:43:38 +0000 | [diff] [blame] | 632 | } |
| 633 | |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 634 | /// emitNonZeroVLAInit - Emit the "zero" initialization of a |
| 635 | /// variable-length array whose elements have a non-zero bit-pattern. |
| 636 | /// |
| 637 | /// \param src - a char* pointing to the bit-pattern for a single |
| 638 | /// base element of the array |
| 639 | /// \param sizeInChars - the total size of the VLA, in chars |
| 640 | /// \param align - the total alignment of the VLA |
| 641 | static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, |
| 642 | llvm::Value *dest, llvm::Value *src, |
| 643 | llvm::Value *sizeInChars) { |
| 644 | std::pair<CharUnits,CharUnits> baseSizeAndAlign |
| 645 | = CGF.getContext().getTypeInfoInChars(baseType); |
| 646 | |
| 647 | CGBuilderTy &Builder = CGF.Builder; |
| 648 | |
| 649 | llvm::Value *baseSizeInChars |
| 650 | = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity()); |
| 651 | |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 652 | llvm::Type *i8p = Builder.getInt8PtrTy(); |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 653 | |
| 654 | llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin"); |
| 655 | llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end"); |
| 656 | |
| 657 | llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); |
| 658 | llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); |
| 659 | llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont"); |
| 660 | |
| 661 | // Make a loop over the VLA. C99 guarantees that the VLA element |
| 662 | // count must be nonzero. |
| 663 | CGF.EmitBlock(loopBB); |
| 664 | |
Jay Foad | bbf3bac | 2011-03-30 11:28:58 +0000 | [diff] [blame] | 665 | llvm::PHINode *cur = Builder.CreatePHI(i8p, 2, "vla.cur"); |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 666 | cur->addIncoming(begin, originBB); |
| 667 | |
| 668 | // memcpy the individual element bit-pattern. |
| 669 | Builder.CreateMemCpy(cur, src, baseSizeInChars, |
| 670 | baseSizeAndAlign.second.getQuantity(), |
| 671 | /*volatile*/ false); |
| 672 | |
| 673 | // Go to the next element. |
| 674 | llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next"); |
| 675 | |
| 676 | // Leave if that's the end of the VLA. |
| 677 | llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone"); |
| 678 | Builder.CreateCondBr(done, contBB, loopBB); |
| 679 | cur->addIncoming(next, loopBB); |
| 680 | |
| 681 | CGF.EmitBlock(contBB); |
| 682 | } |
| 683 | |
Anders Carlsson | 1884eb0 | 2010-05-22 17:35:42 +0000 | [diff] [blame] | 684 | void |
| 685 | CodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { |
Anders Carlsson | 0d7c583 | 2010-05-03 01:20:20 +0000 | [diff] [blame] | 686 | // Ignore empty classes in C++. |
| 687 | if (getContext().getLangOptions().CPlusPlus) { |
| 688 | if (const RecordType *RT = Ty->getAs<RecordType>()) { |
| 689 | if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) |
| 690 | return; |
| 691 | } |
| 692 | } |
John McCall | 9021718 | 2010-08-07 08:21:30 +0000 | [diff] [blame] | 693 | |
| 694 | // Cast the dest ptr to the appropriate i8 pointer type. |
| 695 | unsigned DestAS = |
| 696 | cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 697 | llvm::Type *BP = Builder.getInt8PtrTy(DestAS); |
Anders Carlsson | 3d8400d | 2008-08-30 19:51:14 +0000 | [diff] [blame] | 698 | if (DestPtr->getType() != BP) |
Benjamin Kramer | 578faa8 | 2011-09-27 21:06:10 +0000 | [diff] [blame^] | 699 | DestPtr = Builder.CreateBitCast(DestPtr, BP); |
Anders Carlsson | 3d8400d | 2008-08-30 19:51:14 +0000 | [diff] [blame] | 700 | |
| 701 | // Get size and alignment info for this aggregate. |
Ken Dyck | 79be76c | 2011-04-22 17:51:05 +0000 | [diff] [blame] | 702 | std::pair<CharUnits, CharUnits> TypeInfo = |
| 703 | getContext().getTypeInfoInChars(Ty); |
| 704 | CharUnits Size = TypeInfo.first; |
| 705 | CharUnits Align = TypeInfo.second; |
Anders Carlsson | 3d8400d | 2008-08-30 19:51:14 +0000 | [diff] [blame] | 706 | |
John McCall | 5576d9b | 2011-01-14 10:37:58 +0000 | [diff] [blame] | 707 | llvm::Value *SizeVal; |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 708 | const VariableArrayType *vla; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 709 | |
John McCall | 5576d9b | 2011-01-14 10:37:58 +0000 | [diff] [blame] | 710 | // Don't bother emitting a zero-byte memset. |
Ken Dyck | 79be76c | 2011-04-22 17:51:05 +0000 | [diff] [blame] | 711 | if (Size.isZero()) { |
John McCall | 5576d9b | 2011-01-14 10:37:58 +0000 | [diff] [blame] | 712 | // But note that getTypeInfo returns 0 for a VLA. |
| 713 | if (const VariableArrayType *vlaType = |
| 714 | dyn_cast_or_null<VariableArrayType>( |
| 715 | getContext().getAsArrayType(Ty))) { |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 716 | QualType eltType; |
| 717 | llvm::Value *numElts; |
| 718 | llvm::tie(numElts, eltType) = getVLASize(vlaType); |
| 719 | |
| 720 | SizeVal = numElts; |
| 721 | CharUnits eltSize = getContext().getTypeSizeInChars(eltType); |
| 722 | if (!eltSize.isOne()) |
| 723 | SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize)); |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 724 | vla = vlaType; |
John McCall | 5576d9b | 2011-01-14 10:37:58 +0000 | [diff] [blame] | 725 | } else { |
| 726 | return; |
| 727 | } |
| 728 | } else { |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 729 | SizeVal = CGM.getSize(Size); |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 730 | vla = 0; |
John McCall | 5576d9b | 2011-01-14 10:37:58 +0000 | [diff] [blame] | 731 | } |
John McCall | 9021718 | 2010-08-07 08:21:30 +0000 | [diff] [blame] | 732 | |
| 733 | // If the type contains a pointer to data member we can't memset it to zero. |
| 734 | // Instead, create a null constant and copy it to the destination. |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 735 | // TODO: there are other patterns besides zero that we can usefully memset, |
| 736 | // like -1, which happens to be the pattern used by member-pointers. |
John McCall | f16aa10 | 2010-08-22 21:01:12 +0000 | [diff] [blame] | 737 | if (!CGM.getTypes().isZeroInitializable(Ty)) { |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 738 | // For a VLA, emit a single element, then splat that over the VLA. |
| 739 | if (vla) Ty = getContext().getBaseElementType(vla); |
John McCall | 5576d9b | 2011-01-14 10:37:58 +0000 | [diff] [blame] | 740 | |
John McCall | 9021718 | 2010-08-07 08:21:30 +0000 | [diff] [blame] | 741 | llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); |
| 742 | |
| 743 | llvm::GlobalVariable *NullVariable = |
| 744 | new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), |
| 745 | /*isConstant=*/true, |
| 746 | llvm::GlobalVariable::PrivateLinkage, |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 747 | NullConstant, Twine()); |
John McCall | 9021718 | 2010-08-07 08:21:30 +0000 | [diff] [blame] | 748 | llvm::Value *SrcPtr = |
| 749 | Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); |
| 750 | |
John McCall | 7143325 | 2011-02-01 21:35:06 +0000 | [diff] [blame] | 751 | if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal); |
| 752 | |
John McCall | 9021718 | 2010-08-07 08:21:30 +0000 | [diff] [blame] | 753 | // Get and call the appropriate llvm.memcpy overload. |
Ken Dyck | 79be76c | 2011-04-22 17:51:05 +0000 | [diff] [blame] | 754 | Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity(), false); |
John McCall | 9021718 | 2010-08-07 08:21:30 +0000 | [diff] [blame] | 755 | return; |
| 756 | } |
| 757 | |
| 758 | // Otherwise, just memset the whole thing to zero. This is legal |
| 759 | // because in LLVM, all default initializers (other than the ones we just |
| 760 | // handled above) are guaranteed to have a bit pattern of all zeros. |
Ken Dyck | 79be76c | 2011-04-22 17:51:05 +0000 | [diff] [blame] | 761 | Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, |
| 762 | Align.getQuantity(), false); |
Anders Carlsson | 3d8400d | 2008-08-30 19:51:14 +0000 | [diff] [blame] | 763 | } |
| 764 | |
Chris Lattner | ad8dcf4 | 2011-02-17 07:39:24 +0000 | [diff] [blame] | 765 | llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) { |
Chris Lattner | d9becd1 | 2009-10-28 23:59:40 +0000 | [diff] [blame] | 766 | // Make sure that there is a block for the indirect goto. |
| 767 | if (IndirectBranch == 0) |
| 768 | GetIndirectGotoBlock(); |
Chris Lattner | 3d00fdc | 2009-10-13 06:55:33 +0000 | [diff] [blame] | 769 | |
John McCall | ff8e115 | 2010-07-23 21:56:41 +0000 | [diff] [blame] | 770 | llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); |
Chris Lattner | 3d00fdc | 2009-10-13 06:55:33 +0000 | [diff] [blame] | 771 | |
Chris Lattner | d9becd1 | 2009-10-28 23:59:40 +0000 | [diff] [blame] | 772 | // Make sure the indirect branch includes all of the address-taken blocks. |
| 773 | IndirectBranch->addDestination(BB); |
| 774 | return llvm::BlockAddress::get(CurFn, BB); |
Chris Lattner | 3d00fdc | 2009-10-13 06:55:33 +0000 | [diff] [blame] | 775 | } |
| 776 | |
| 777 | llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { |
Chris Lattner | d9becd1 | 2009-10-28 23:59:40 +0000 | [diff] [blame] | 778 | // If we already made the indirect branch for indirect goto, return its block. |
| 779 | if (IndirectBranch) return IndirectBranch->getParent(); |
Chris Lattner | 3d00fdc | 2009-10-13 06:55:33 +0000 | [diff] [blame] | 780 | |
Chris Lattner | d9becd1 | 2009-10-28 23:59:40 +0000 | [diff] [blame] | 781 | CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); |
Chris Lattner | 3d00fdc | 2009-10-13 06:55:33 +0000 | [diff] [blame] | 782 | |
| 783 | // Create the PHI node that indirect gotos will add entries to. |
Jay Foad | bbf3bac | 2011-03-30 11:28:58 +0000 | [diff] [blame] | 784 | llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0, |
| 785 | "indirect.goto.dest"); |
Chris Lattner | 3d00fdc | 2009-10-13 06:55:33 +0000 | [diff] [blame] | 786 | |
Chris Lattner | d9becd1 | 2009-10-28 23:59:40 +0000 | [diff] [blame] | 787 | // Create the indirect branch instruction. |
| 788 | IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); |
| 789 | return IndirectBranch->getParent(); |
Daniel Dunbar | 0ffb125 | 2008-08-04 16:51:22 +0000 | [diff] [blame] | 790 | } |
Anders Carlsson | ddf7cac | 2008-11-04 05:30:00 +0000 | [diff] [blame] | 791 | |
John McCall | bdc4d80 | 2011-07-09 01:37:26 +0000 | [diff] [blame] | 792 | /// Computes the length of an array in elements, as well as the base |
| 793 | /// element type and a properly-typed first element pointer. |
| 794 | llvm::Value *CodeGenFunction::emitArrayLength(const ArrayType *origArrayType, |
| 795 | QualType &baseType, |
| 796 | llvm::Value *&addr) { |
| 797 | const ArrayType *arrayType = origArrayType; |
| 798 | |
| 799 | // If it's a VLA, we have to load the stored size. Note that |
| 800 | // this is the size of the VLA in bytes, not its size in elements. |
| 801 | llvm::Value *numVLAElements = 0; |
| 802 | if (isa<VariableArrayType>(arrayType)) { |
| 803 | numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).first; |
| 804 | |
| 805 | // Walk into all VLAs. This doesn't require changes to addr, |
| 806 | // which has type T* where T is the first non-VLA element type. |
| 807 | do { |
| 808 | QualType elementType = arrayType->getElementType(); |
| 809 | arrayType = getContext().getAsArrayType(elementType); |
| 810 | |
| 811 | // If we only have VLA components, 'addr' requires no adjustment. |
| 812 | if (!arrayType) { |
| 813 | baseType = elementType; |
| 814 | return numVLAElements; |
| 815 | } |
| 816 | } while (isa<VariableArrayType>(arrayType)); |
| 817 | |
| 818 | // We get out here only if we find a constant array type |
| 819 | // inside the VLA. |
| 820 | } |
| 821 | |
| 822 | // We have some number of constant-length arrays, so addr should |
| 823 | // have LLVM type [M x [N x [...]]]*. Build a GEP that walks |
| 824 | // down to the first element of addr. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 825 | SmallVector<llvm::Value*, 8> gepIndices; |
John McCall | bdc4d80 | 2011-07-09 01:37:26 +0000 | [diff] [blame] | 826 | |
| 827 | // GEP down to the array type. |
| 828 | llvm::ConstantInt *zero = Builder.getInt32(0); |
| 829 | gepIndices.push_back(zero); |
| 830 | |
| 831 | // It's more efficient to calculate the count from the LLVM |
| 832 | // constant-length arrays than to re-evaluate the array bounds. |
| 833 | uint64_t countFromCLAs = 1; |
| 834 | |
Chris Lattner | 2acc6e3 | 2011-07-18 04:24:23 +0000 | [diff] [blame] | 835 | llvm::ArrayType *llvmArrayType = |
John McCall | bdc4d80 | 2011-07-09 01:37:26 +0000 | [diff] [blame] | 836 | cast<llvm::ArrayType>( |
| 837 | cast<llvm::PointerType>(addr->getType())->getElementType()); |
| 838 | while (true) { |
| 839 | assert(isa<ConstantArrayType>(arrayType)); |
| 840 | assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue() |
| 841 | == llvmArrayType->getNumElements()); |
| 842 | |
| 843 | gepIndices.push_back(zero); |
| 844 | countFromCLAs *= llvmArrayType->getNumElements(); |
| 845 | |
| 846 | llvmArrayType = |
| 847 | dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType()); |
| 848 | if (!llvmArrayType) break; |
| 849 | |
| 850 | arrayType = getContext().getAsArrayType(arrayType->getElementType()); |
| 851 | assert(arrayType && "LLVM and Clang types are out-of-synch"); |
| 852 | } |
| 853 | |
| 854 | baseType = arrayType->getElementType(); |
| 855 | |
| 856 | // Create the actual GEP. |
Jay Foad | 0f6ac7c | 2011-07-22 08:16:57 +0000 | [diff] [blame] | 857 | addr = Builder.CreateInBoundsGEP(addr, gepIndices, "array.begin"); |
John McCall | bdc4d80 | 2011-07-09 01:37:26 +0000 | [diff] [blame] | 858 | |
| 859 | llvm::Value *numElements |
| 860 | = llvm::ConstantInt::get(SizeTy, countFromCLAs); |
| 861 | |
| 862 | // If we had any VLA dimensions, factor them in. |
| 863 | if (numVLAElements) |
| 864 | numElements = Builder.CreateNUWMul(numVLAElements, numElements); |
| 865 | |
| 866 | return numElements; |
| 867 | } |
| 868 | |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 869 | std::pair<llvm::Value*, QualType> |
| 870 | CodeGenFunction::getVLASize(QualType type) { |
| 871 | const VariableArrayType *vla = getContext().getAsVariableArrayType(type); |
| 872 | assert(vla && "type was not a variable array type!"); |
| 873 | return getVLASize(vla); |
Anders Carlsson | f666b77 | 2008-12-20 20:27:15 +0000 | [diff] [blame] | 874 | } |
Anders Carlsson | dcc90d8 | 2008-12-12 07:19:02 +0000 | [diff] [blame] | 875 | |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 876 | std::pair<llvm::Value*, QualType> |
| 877 | CodeGenFunction::getVLASize(const VariableArrayType *type) { |
| 878 | // The number of elements so far; always size_t. |
| 879 | llvm::Value *numElements = 0; |
| 880 | |
| 881 | QualType elementType; |
| 882 | do { |
| 883 | elementType = type->getElementType(); |
| 884 | llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()]; |
| 885 | assert(vlaSize && "no size for VLA!"); |
| 886 | assert(vlaSize->getType() == SizeTy); |
| 887 | |
| 888 | if (!numElements) { |
| 889 | numElements = vlaSize; |
| 890 | } else { |
| 891 | // It's undefined behavior if this wraps around, so mark it that way. |
| 892 | numElements = Builder.CreateNUWMul(numElements, vlaSize); |
| 893 | } |
| 894 | } while ((type = getContext().getAsVariableArrayType(elementType))); |
| 895 | |
| 896 | return std::pair<llvm::Value*,QualType>(numElements, elementType); |
| 897 | } |
| 898 | |
| 899 | void CodeGenFunction::EmitVariablyModifiedType(QualType type) { |
| 900 | assert(type->isVariablyModifiedType() && |
Anders Carlsson | 60d3541 | 2008-12-20 20:46:34 +0000 | [diff] [blame] | 901 | "Must pass variably modified type to EmitVLASizes!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 902 | |
Daniel Dunbar | d286f05 | 2009-07-19 06:58:07 +0000 | [diff] [blame] | 903 | EnsureInsertPoint(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 904 | |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 905 | // We're going to walk down into the type and look for VLA |
| 906 | // expressions. |
| 907 | type = type.getCanonicalType(); |
| 908 | do { |
| 909 | assert(type->isVariablyModifiedType()); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 910 | |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 911 | const Type *ty = type.getTypePtr(); |
| 912 | switch (ty->getTypeClass()) { |
| 913 | #define TYPE(Class, Base) |
| 914 | #define ABSTRACT_TYPE(Class, Base) |
| 915 | #define NON_CANONICAL_TYPE(Class, Base) case Type::Class: |
| 916 | #define DEPENDENT_TYPE(Class, Base) case Type::Class: |
| 917 | #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: |
| 918 | #include "clang/AST/TypeNodes.def" |
| 919 | llvm_unreachable("unexpected dependent or non-canonical type!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 920 | |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 921 | // These types are never variably-modified. |
| 922 | case Type::Builtin: |
| 923 | case Type::Complex: |
| 924 | case Type::Vector: |
| 925 | case Type::ExtVector: |
| 926 | case Type::Record: |
| 927 | case Type::Enum: |
| 928 | case Type::ObjCObject: |
| 929 | case Type::ObjCInterface: |
| 930 | case Type::ObjCObjectPointer: |
| 931 | llvm_unreachable("type class is never variably-modified!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 932 | |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 933 | case Type::Pointer: |
| 934 | type = cast<PointerType>(ty)->getPointeeType(); |
| 935 | break; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 936 | |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 937 | case Type::BlockPointer: |
| 938 | type = cast<BlockPointerType>(ty)->getPointeeType(); |
| 939 | break; |
| 940 | |
| 941 | case Type::LValueReference: |
| 942 | case Type::RValueReference: |
| 943 | type = cast<ReferenceType>(ty)->getPointeeType(); |
| 944 | break; |
| 945 | |
| 946 | case Type::MemberPointer: |
| 947 | type = cast<MemberPointerType>(ty)->getPointeeType(); |
| 948 | break; |
| 949 | |
| 950 | case Type::ConstantArray: |
| 951 | case Type::IncompleteArray: |
| 952 | // Losing element qualification here is fine. |
| 953 | type = cast<ArrayType>(ty)->getElementType(); |
| 954 | break; |
| 955 | |
| 956 | case Type::VariableArray: { |
| 957 | // Losing element qualification here is fine. |
| 958 | const VariableArrayType *vat = cast<VariableArrayType>(ty); |
| 959 | |
| 960 | // Unknown size indication requires no size computation. |
| 961 | // Otherwise, evaluate and record it. |
| 962 | if (const Expr *size = vat->getSizeExpr()) { |
| 963 | // It's possible that we might have emitted this already, |
| 964 | // e.g. with a typedef and a pointer to it. |
| 965 | llvm::Value *&entry = VLASizeMap[size]; |
| 966 | if (!entry) { |
| 967 | // Always zexting here would be wrong if it weren't |
| 968 | // undefined behavior to have a negative bound. |
| 969 | entry = Builder.CreateIntCast(EmitScalarExpr(size), SizeTy, |
| 970 | /*signed*/ false); |
| 971 | } |
| 972 | } |
| 973 | type = vat->getElementType(); |
| 974 | break; |
Anders Carlsson | 60d3541 | 2008-12-20 20:46:34 +0000 | [diff] [blame] | 975 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 976 | |
John McCall | bc8d40d | 2011-06-24 21:55:10 +0000 | [diff] [blame] | 977 | case Type::FunctionProto: |
| 978 | case Type::FunctionNoProto: |
| 979 | type = cast<FunctionType>(ty)->getResultType(); |
| 980 | break; |
| 981 | } |
| 982 | } while (type->isVariablyModifiedType()); |
Anders Carlsson | dcc90d8 | 2008-12-12 07:19:02 +0000 | [diff] [blame] | 983 | } |
Eli Friedman | 4fd0aa5 | 2009-01-20 17:46:04 +0000 | [diff] [blame] | 984 | |
| 985 | llvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { |
Dan Gohman | bc07a55 | 2010-10-29 22:47:07 +0000 | [diff] [blame] | 986 | if (getContext().getBuiltinVaListType()->isArrayType()) |
Eli Friedman | 4fd0aa5 | 2009-01-20 17:46:04 +0000 | [diff] [blame] | 987 | return EmitScalarExpr(E); |
Eli Friedman | 4fd0aa5 | 2009-01-20 17:46:04 +0000 | [diff] [blame] | 988 | return EmitLValue(E).getAddress(); |
| 989 | } |
Anders Carlsson | 6ccc476 | 2009-02-07 22:53:43 +0000 | [diff] [blame] | 990 | |
Devang Patel | 8d30838 | 2010-08-10 07:24:25 +0000 | [diff] [blame] | 991 | void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, |
John McCall | 189d6ef | 2010-10-09 01:34:31 +0000 | [diff] [blame] | 992 | llvm::Constant *Init) { |
Devang Patel | 25c2c8f | 2010-08-10 17:53:33 +0000 | [diff] [blame] | 993 | assert (Init && "Invalid DeclRefExpr initializer!"); |
| 994 | if (CGDebugInfo *Dbg = getDebugInfo()) |
Devang Patel | d2829b7 | 2010-10-06 15:58:57 +0000 | [diff] [blame] | 995 | Dbg->EmitGlobalVariable(E->getDecl(), Init); |
Devang Patel | 8d30838 | 2010-08-10 07:24:25 +0000 | [diff] [blame] | 996 | } |
John McCall | 56ca35d | 2011-02-17 10:25:35 +0000 | [diff] [blame] | 997 | |
| 998 | CodeGenFunction::PeepholeProtection |
| 999 | CodeGenFunction::protectFromPeepholes(RValue rvalue) { |
| 1000 | // At the moment, the only aggressive peephole we do in IR gen |
| 1001 | // is trunc(zext) folding, but if we add more, we can easily |
| 1002 | // extend this protection. |
| 1003 | |
| 1004 | if (!rvalue.isScalar()) return PeepholeProtection(); |
| 1005 | llvm::Value *value = rvalue.getScalarVal(); |
| 1006 | if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection(); |
| 1007 | |
| 1008 | // Just make an extra bitcast. |
| 1009 | assert(HaveInsertPoint()); |
| 1010 | llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "", |
| 1011 | Builder.GetInsertBlock()); |
| 1012 | |
| 1013 | PeepholeProtection protection; |
| 1014 | protection.Inst = inst; |
| 1015 | return protection; |
| 1016 | } |
| 1017 | |
| 1018 | void CodeGenFunction::unprotectFromPeepholes(PeepholeProtection protection) { |
| 1019 | if (!protection.Inst) return; |
| 1020 | |
| 1021 | // In theory, we could try to duplicate the peepholes now, but whatever. |
| 1022 | protection.Inst->eraseFromParent(); |
| 1023 | } |
Julien Lerouge | 77f68bb | 2011-09-09 22:41:49 +0000 | [diff] [blame] | 1024 | |
| 1025 | llvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Value *AnnotationFn, |
| 1026 | llvm::Value *AnnotatedVal, |
| 1027 | llvm::StringRef AnnotationStr, |
| 1028 | SourceLocation Location) { |
| 1029 | llvm::Value *Args[4] = { |
| 1030 | AnnotatedVal, |
| 1031 | Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy), |
| 1032 | Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy), |
| 1033 | CGM.EmitAnnotationLineNo(Location) |
| 1034 | }; |
| 1035 | return Builder.CreateCall(AnnotationFn, Args); |
| 1036 | } |
| 1037 | |
| 1038 | void CodeGenFunction::EmitVarAnnotations(const VarDecl *D, llvm::Value *V) { |
| 1039 | assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); |
| 1040 | // FIXME We create a new bitcast for every annotation because that's what |
| 1041 | // llvm-gcc was doing. |
| 1042 | for (specific_attr_iterator<AnnotateAttr> |
| 1043 | ai = D->specific_attr_begin<AnnotateAttr>(), |
| 1044 | ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) |
| 1045 | EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation), |
| 1046 | Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()), |
| 1047 | (*ai)->getAnnotation(), D->getLocation()); |
| 1048 | } |
| 1049 | |
| 1050 | llvm::Value *CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D, |
| 1051 | llvm::Value *V) { |
| 1052 | assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); |
| 1053 | llvm::Type *VTy = V->getType(); |
| 1054 | llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation, |
| 1055 | CGM.Int8PtrTy); |
| 1056 | |
| 1057 | for (specific_attr_iterator<AnnotateAttr> |
| 1058 | ai = D->specific_attr_begin<AnnotateAttr>(), |
| 1059 | ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) { |
| 1060 | // FIXME Always emit the cast inst so we can differentiate between |
| 1061 | // annotation on the first field of a struct and annotation on the struct |
| 1062 | // itself. |
| 1063 | if (VTy != CGM.Int8PtrTy) |
| 1064 | V = Builder.Insert(new llvm::BitCastInst(V, CGM.Int8PtrTy)); |
| 1065 | V = EmitAnnotationCall(F, V, (*ai)->getAnnotation(), D->getLocation()); |
| 1066 | V = Builder.CreateBitCast(V, VTy); |
| 1067 | } |
| 1068 | |
| 1069 | return V; |
| 1070 | } |