blob: 2cad46ed0177ce58b6844969c54ac103bafca0a9 [file] [log] [blame]
Daniel Dunbar9c426522008-07-29 23:18:29 +00001//===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
Chris Lattnerbed31442007-05-28 01:07:47 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerbed31442007-05-28 01:07:47 +00007//
8//===----------------------------------------------------------------------===//
9//
Mike Stumpfc496822009-02-08 23:14:22 +000010// This is the internal per-function state used for llvm translation.
Chris Lattnerbed31442007-05-28 01:07:47 +000011//
12//===----------------------------------------------------------------------===//
13
Chris Lattnerc18bfbb2008-02-29 17:10:38 +000014#ifndef CLANG_CODEGEN_CODEGENFUNCTION_H
15#define CLANG_CODEGEN_CODEGENFUNCTION_H
Chris Lattnerbed31442007-05-28 01:07:47 +000016
Chris Lattner4bd55962008-03-30 23:03:07 +000017#include "clang/AST/Type.h"
Argyrios Kyrtzidis07052352008-09-10 02:36:38 +000018#include "clang/AST/ExprCXX.h"
Ted Kremenek08e17112008-06-17 02:43:46 +000019#include "clang/AST/ExprObjC.h"
Chris Lattner2739d2b2009-03-31 22:17:44 +000020#include "clang/Basic/TargetInfo.h"
21#include "llvm/ADT/DenseMap.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/Support/ValueHandle.h"
Daniel Dunbar88402ce2008-08-04 16:51:22 +000024#include <map>
Mike Stumpedb252a2009-03-04 15:32:52 +000025#include "CGBlocks.h"
Daniel Dunbarcb463852008-11-01 01:53:16 +000026#include "CGBuilder.h"
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +000027#include "CGCall.h"
Anders Carlssonb7f8f592009-04-17 00:06:03 +000028#include "CGCXX.h"
Daniel Dunbar97db84c2008-08-23 03:46:30 +000029#include "CGValue.h"
30
Chris Lattnerbed31442007-05-28 01:07:47 +000031namespace llvm {
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000032 class BasicBlock;
Chris Lattnerbed31442007-05-28 01:07:47 +000033 class Module;
Daniel Dunbar2efd5382008-09-30 01:06:03 +000034 class SwitchInst;
Daniel Dunbar9b1335e2008-11-19 09:36:46 +000035 class Value;
Chris Lattner23b7eb62007-06-15 23:05:46 +000036}
37
Chris Lattnerbed31442007-05-28 01:07:47 +000038namespace clang {
39 class ASTContext;
Chris Lattner84915fa2007-06-02 04:16:21 +000040 class Decl;
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000041 class EnumConstantDecl;
Chris Lattnerbed31442007-05-28 01:07:47 +000042 class FunctionDecl;
Douglas Gregordeaad8c2009-02-26 23:50:07 +000043 class FunctionProtoType;
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000044 class LabelStmt;
Fariborz Jahanian0196a1c2009-01-10 21:06:09 +000045 class ObjCContainerDecl;
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +000046 class ObjCInterfaceDecl;
47 class ObjCIvarDecl;
Chris Lattner4bd55962008-03-30 23:03:07 +000048 class ObjCMethodDecl;
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +000049 class ObjCImplementationDecl;
Daniel Dunbar89654ee2008-08-26 08:29:31 +000050 class ObjCPropertyImplDecl;
Chris Lattner2ccb73b2007-06-16 00:16:26 +000051 class TargetInfo;
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000052 class VarDecl;
Devang Patel3e11cce2007-10-23 02:10:49 +000053
Chris Lattnerbed31442007-05-28 01:07:47 +000054namespace CodeGen {
55 class CodeGenModule;
Devang Patel3e11cce2007-10-23 02:10:49 +000056 class CodeGenTypes;
Anders Carlsson63784f42009-02-13 08:11:52 +000057 class CGDebugInfo;
Daniel Dunbar7633cbf2009-02-02 21:43:58 +000058 class CGFunctionInfo;
Mike Stumpfc496822009-02-08 23:14:22 +000059 class CGRecordLayout;
60
Chris Lattnerbed31442007-05-28 01:07:47 +000061/// CodeGenFunction - This class organizes the per-function state that is used
62/// while generating LLVM code.
Mike Stump95435672009-03-04 18:17:45 +000063class CodeGenFunction : public BlockFunction {
Anders Carlsson729a8202009-02-24 04:21:31 +000064 CodeGenFunction(const CodeGenFunction&); // DO NOT IMPLEMENT
65 void operator=(const CodeGenFunction&); // DO NOT IMPLEMENT
Chris Lattnerbda69f82007-08-26 23:13:56 +000066public:
Chris Lattnerbed31442007-05-28 01:07:47 +000067 CodeGenModule &CGM; // Per-module state.
Chris Lattnerd1af2d22007-05-29 23:17:50 +000068 TargetInfo &Target;
Mike Stumpfc496822009-02-08 23:14:22 +000069
Chris Lattner96d72562007-08-21 16:57:55 +000070 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Daniel Dunbarcb463852008-11-01 01:53:16 +000071 CGBuilderTy Builder;
Mike Stumpfc496822009-02-08 23:14:22 +000072
Chris Lattner28ec0cf2009-04-23 05:30:27 +000073 /// CurFuncDecl - Holds the Decl for the current function or ObjC method.
74 /// This excludes BlockDecls.
Chris Lattner5696e7b2008-06-17 18:05:57 +000075 const Decl *CurFuncDecl;
Chris Lattner28ec0cf2009-04-23 05:30:27 +000076 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
77 const Decl *CurCodeDecl;
Daniel Dunbard931a872009-02-02 22:03:45 +000078 const CGFunctionInfo *CurFnInfo;
Chris Lattner4bd55962008-03-30 23:03:07 +000079 QualType FnRetTy;
Chris Lattnerac248202007-05-30 00:13:02 +000080 llvm::Function *CurFn;
81
Daniel Dunbar54bb1932008-09-09 21:00:17 +000082 /// ReturnBlock - Unified return block.
83 llvm::BasicBlock *ReturnBlock;
Mike Stumpfc496822009-02-08 23:14:22 +000084 /// ReturnValue - The temporary alloca to hold the return value. This is null
85 /// iff the function has no return value.
Daniel Dunbar54bb1932008-09-09 21:00:17 +000086 llvm::Instruction *ReturnValue;
Mike Stumpfc496822009-02-08 23:14:22 +000087
Chris Lattner03df1222007-06-02 04:53:11 +000088 /// AllocaInsertPoint - This is an instruction in the entry block before which
89 /// we prefer to insert allocas.
Chris Lattner2739d2b2009-03-31 22:17:44 +000090 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
Daniel Dunbar88402ce2008-08-04 16:51:22 +000091
Chris Lattner6db1fb82007-06-02 22:49:07 +000092 const llvm::Type *LLVMIntTy;
Hartmut Kaiser7078da82007-10-17 15:00:17 +000093 uint32_t LLVMPointerWidth;
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +000094
95public:
Anders Carlsson33c1b652009-02-10 06:07:49 +000096 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
97 /// rethrows.
Anders Carlssonbf8a1be2009-02-07 21:37:21 +000098 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack;
Mike Stumpfc496822009-02-08 23:14:22 +000099
Anders Carlssona586ad72009-02-08 03:22:36 +0000100 /// PushCleanupBlock - Push a new cleanup entry on the stack and set the
101 /// passed in block as the cleanup block.
102 void PushCleanupBlock(llvm::BasicBlock *CleanupBlock);
Anders Carlsson66c384a2009-02-08 07:46:24 +0000103
Mike Stumpfc496822009-02-08 23:14:22 +0000104 /// CleanupBlockInfo - A struct representing a popped cleanup block.
Anders Carlsson66c384a2009-02-08 07:46:24 +0000105 struct CleanupBlockInfo {
106 /// CleanupBlock - the cleanup block
107 llvm::BasicBlock *CleanupBlock;
Mike Stumpfc496822009-02-08 23:14:22 +0000108
109 /// SwitchBlock - the block (if any) containing the switch instruction used
110 /// for jumping to the final destination.
Anders Carlsson66c384a2009-02-08 07:46:24 +0000111 llvm::BasicBlock *SwitchBlock;
Mike Stumpfc496822009-02-08 23:14:22 +0000112
Anders Carlsson66c384a2009-02-08 07:46:24 +0000113 /// EndBlock - the default destination for the switch instruction.
114 llvm::BasicBlock *EndBlock;
Mike Stumpfc496822009-02-08 23:14:22 +0000115
116 CleanupBlockInfo(llvm::BasicBlock *cb, llvm::BasicBlock *sb,
Anders Carlsson66c384a2009-02-08 07:46:24 +0000117 llvm::BasicBlock *eb)
118 : CleanupBlock(cb), SwitchBlock(sb), EndBlock(eb) {}
119 };
120
121 /// PopCleanupBlock - Will pop the cleanup entry on the stack, process all
Mike Stumpfc496822009-02-08 23:14:22 +0000122 /// branch fixups and return a block info struct with the switch block and end
123 /// block.
Anders Carlsson66c384a2009-02-08 07:46:24 +0000124 CleanupBlockInfo PopCleanupBlock();
Mike Stumpfc496822009-02-08 23:14:22 +0000125
126 /// CleanupScope - RAII object that will create a cleanup block and set the
127 /// insert point to that block. When destructed, it sets the insert point to
128 /// the previous block and pushes a new cleanup entry on the stack.
Anders Carlsson2cf8c442009-02-07 23:30:41 +0000129 class CleanupScope {
130 CodeGenFunction& CGF;
131 llvm::BasicBlock *CurBB;
Anders Carlssona586ad72009-02-08 03:22:36 +0000132 llvm::BasicBlock *CleanupBB;
Mike Stumpfc496822009-02-08 23:14:22 +0000133
Anders Carlsson2cf8c442009-02-07 23:30:41 +0000134 public:
135 CleanupScope(CodeGenFunction &cgf)
136 : CGF(cgf), CurBB(CGF.Builder.GetInsertBlock()) {
Anders Carlssona586ad72009-02-08 03:22:36 +0000137 CleanupBB = CGF.createBasicBlock("cleanup");
138 CGF.Builder.SetInsertPoint(CleanupBB);
Anders Carlsson2cf8c442009-02-07 23:30:41 +0000139 }
Mike Stumpfc496822009-02-08 23:14:22 +0000140
Anders Carlsson2cf8c442009-02-07 23:30:41 +0000141 ~CleanupScope() {
Anders Carlssona586ad72009-02-08 03:22:36 +0000142 CGF.PushCleanupBlock(CleanupBB);
Anders Carlsson2cf8c442009-02-07 23:30:41 +0000143 CGF.Builder.SetInsertPoint(CurBB);
144 }
145 };
146
Anders Carlssonbe0f76a2009-02-07 23:50:39 +0000147 /// EmitCleanupBlocks - Takes the old cleanup stack size and emits the cleanup
148 /// blocks that have been added.
149 void EmitCleanupBlocks(size_t OldCleanupStackSize);
150
Anders Carlsson7d70fd22009-02-08 00:50:42 +0000151 /// EmitBranchThroughCleanup - Emit a branch from the current insert block
152 /// through the cleanup handling code (if any) and then on to \arg Dest.
153 ///
Mike Stumpfc496822009-02-08 23:14:22 +0000154 /// FIXME: Maybe this should really be in EmitBranch? Don't we always want
Anders Carlsson7d70fd22009-02-08 00:50:42 +0000155 /// this behavior for branches?
156 void EmitBranchThroughCleanup(llvm::BasicBlock *Dest);
Mike Stumpfc496822009-02-08 23:14:22 +0000157
Chris Lattner2da04b32007-08-24 05:35:26 +0000158private:
Anders Carlsson63784f42009-02-13 08:11:52 +0000159 CGDebugInfo* DebugInfo;
Mike Stumpc6ea7c12009-02-17 17:00:02 +0000160
Mike Stumpfc496822009-02-08 23:14:22 +0000161 /// LabelIDs - Track arbitrary ids assigned to labels for use in implementing
162 /// the GCC address-of-label extension and indirect goto. IDs are assigned to
163 /// labels inside getIDForAddrOfLabel().
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000164 std::map<const LabelStmt*, unsigned> LabelIDs;
165
166 /// IndirectSwitches - Record the list of switches for indirect
Mike Stumpfc496822009-02-08 23:14:22 +0000167 /// gotos. Emission of the actual switching code needs to be delayed until all
168 /// AddrLabelExprs have been seen.
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000169 std::vector<llvm::SwitchInst*> IndirectSwitches;
170
Mike Stumpfc496822009-02-08 23:14:22 +0000171 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
172 /// decls.
Chris Lattner23b7eb62007-06-15 23:05:46 +0000173 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
Chris Lattner84915fa2007-06-02 04:16:21 +0000174
Chris Lattnerac248202007-05-30 00:13:02 +0000175 /// LabelMap - This keeps track of the LLVM basic block for each C label.
Chris Lattner23b7eb62007-06-15 23:05:46 +0000176 llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
Mike Stumpfc496822009-02-08 23:14:22 +0000177
Mike Stumpfc496822009-02-08 23:14:22 +0000178 // BreakContinueStack - This keeps track of where break and continue
Anders Carlsson33747b62009-02-10 05:52:02 +0000179 // statements should jump to.
Chris Lattnere73e4322007-07-16 21:28:45 +0000180 struct BreakContinue {
Anders Carlsson33747b62009-02-10 05:52:02 +0000181 BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb)
182 : BreakBlock(bb), ContinueBlock(cb) {}
Mike Stumpfc496822009-02-08 23:14:22 +0000183
Chris Lattnere73e4322007-07-16 21:28:45 +0000184 llvm::BasicBlock *BreakBlock;
185 llvm::BasicBlock *ContinueBlock;
Mike Stumpfc496822009-02-08 23:14:22 +0000186 };
Chris Lattnere73e4322007-07-16 21:28:45 +0000187 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +0000188
Mike Stumpfc496822009-02-08 23:14:22 +0000189 /// SwitchInsn - This is nearest current switch instruction. It is null if if
190 /// current context is not in a switch.
Devang Patelda5d6bb2007-10-04 23:45:31 +0000191 llvm::SwitchInst *SwitchInsn;
192
Mike Stumpfc496822009-02-08 23:14:22 +0000193 /// CaseRangeBlock - This block holds if condition check for last case
Devang Patel49a44f32007-10-09 17:08:50 +0000194 /// statement range in current switch instruction.
Devang Patel11663122007-10-08 20:57:48 +0000195 llvm::BasicBlock *CaseRangeBlock;
196
Daniel Dunbar12347492009-02-23 17:26:39 +0000197 /// InvokeDest - This is the nearest exception target for calls
198 /// which can unwind, when exceptions are being used.
199 llvm::BasicBlock *InvokeDest;
200
Mike Stumpfc496822009-02-08 23:14:22 +0000201 // VLASizeMap - This keeps track of the associated size for each VLA type.
202 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
203 // enter/leave scopes.
Anders Carlssonccbe9202008-12-12 07:19:02 +0000204 llvm::DenseMap<const VariableArrayType*, llvm::Value*> VLASizeMap;
Mike Stumpfc496822009-02-08 23:14:22 +0000205
Anders Carlssonf4478e92009-02-09 20:20:56 +0000206 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
207 /// calling llvm.stacksave for multiple VLAs in the same scope.
208 bool DidCallStackSave;
Mike Stumpc6ea7c12009-02-17 17:00:02 +0000209
Anders Carlsson15cb75a2009-02-07 22:53:43 +0000210 struct CleanupEntry {
211 /// CleanupBlock - The block of code that does the actual cleanup.
212 llvm::BasicBlock *CleanupBlock;
Mike Stumpfc496822009-02-08 23:14:22 +0000213
Anders Carlsson15cb75a2009-02-07 22:53:43 +0000214 /// Blocks - Basic blocks that were emitted in the current cleanup scope.
Anders Carlsson66c384a2009-02-08 07:46:24 +0000215 std::vector<llvm::BasicBlock *> Blocks;
Anders Carlsson15cb75a2009-02-07 22:53:43 +0000216
217 /// BranchFixups - Branch instructions to basic blocks that haven't been
218 /// inserted into the current function yet.
Anders Carlsson66c384a2009-02-08 07:46:24 +0000219 std::vector<llvm::BranchInst *> BranchFixups;
Anders Carlsson15cb75a2009-02-07 22:53:43 +0000220
221 explicit CleanupEntry(llvm::BasicBlock *cb)
222 : CleanupBlock(cb) {}
223 };
Mike Stumpfc496822009-02-08 23:14:22 +0000224
Anders Carlsson15cb75a2009-02-07 22:53:43 +0000225 /// CleanupEntries - Stack of cleanup entries.
226 llvm::SmallVector<CleanupEntry, 8> CleanupEntries;
227
Anders Carlssonfbfb5e62009-02-08 00:16:35 +0000228 typedef llvm::DenseMap<llvm::BasicBlock*, size_t> BlockScopeMap;
229
230 /// BlockScopes - Map of which "cleanup scope" scope basic blocks have.
231 BlockScopeMap BlockScopes;
Mike Stumpfc496822009-02-08 23:14:22 +0000232
Anders Carlsson468fa632009-04-04 20:47:02 +0000233 /// CXXThisDecl - When parsing an C++ function, this will hold the implicit
234 /// 'this' declaration.
235 ImplicitParamDecl *CXXThisDecl;
236
Chris Lattnerbed31442007-05-28 01:07:47 +0000237public:
Chris Lattnerd1af2d22007-05-29 23:17:50 +0000238 CodeGenFunction(CodeGenModule &cgm);
Mike Stumpfc496822009-02-08 23:14:22 +0000239
Chris Lattner6db1fb82007-06-02 22:49:07 +0000240 ASTContext &getContext() const;
Anders Carlsson63784f42009-02-13 08:11:52 +0000241 CGDebugInfo *getDebugInfo() { return DebugInfo; }
Chris Lattner6db1fb82007-06-02 22:49:07 +0000242
Daniel Dunbar12347492009-02-23 17:26:39 +0000243 llvm::BasicBlock *getInvokeDest() { return InvokeDest; }
244 void setInvokeDest(llvm::BasicBlock *B) { InvokeDest = B; }
245
246 //===--------------------------------------------------------------------===//
247 // Objective-C
248 //===--------------------------------------------------------------------===//
249
Chris Lattner4bd55962008-03-30 23:03:07 +0000250 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbar89654ee2008-08-26 08:29:31 +0000251
Mike Stumpfc496822009-02-08 23:14:22 +0000252 void StartObjCMethod(const ObjCMethodDecl *MD,
Fariborz Jahanian0196a1c2009-01-10 21:06:09 +0000253 const ObjCContainerDecl *CD);
Daniel Dunbar89654ee2008-08-26 08:29:31 +0000254
Mike Stumpfc496822009-02-08 23:14:22 +0000255 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +0000256 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
257 const ObjCPropertyImplDecl *PID);
Daniel Dunbar89654ee2008-08-26 08:29:31 +0000258
Mike Stumpfc496822009-02-08 23:14:22 +0000259 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
260 /// for the given property.
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +0000261 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
262 const ObjCPropertyImplDecl *PID);
Daniel Dunbar89654ee2008-08-26 08:29:31 +0000263
Mike Stumpcb2fbcb2009-02-21 20:00:35 +0000264 //===--------------------------------------------------------------------===//
265 // Block Bits
266 //===--------------------------------------------------------------------===//
267
Mike Stumpb750d922009-02-25 23:33:13 +0000268 llvm::Value *BuildBlockLiteralTmp(const BlockExpr *);
Mike Stumpd2142cf2009-03-25 17:58:24 +0000269 llvm::Constant *BuildDescriptorBlockDecl(bool BlockHasCopyDispose,
270 uint64_t Size,
Mike Stumpaeb0ffd2009-03-07 02:35:30 +0000271 const llvm::StructType *,
272 std::vector<HelperInfo> *);
Mike Stumpcb2fbcb2009-02-21 20:00:35 +0000273
Chris Lattner3385fe122009-02-28 19:01:03 +0000274 llvm::Function *GenerateBlockFunction(const BlockExpr *BExpr,
Mike Stumpcb2fbcb2009-02-21 20:00:35 +0000275 const BlockInfo& Info,
Mike Stump692c6e32009-03-20 21:53:12 +0000276 const Decl *OuterFuncDecl,
Mike Stump5469f292009-03-13 23:34:28 +0000277 llvm::DenseMap<const Decl*, llvm::Value*> ldm,
Mike Stumpb750d922009-02-25 23:33:13 +0000278 uint64_t &Size, uint64_t &Align,
Mike Stump4446dcf2009-03-05 08:32:30 +0000279 llvm::SmallVector<const Expr *, 8> &subBlockDeclRefDecls,
280 bool &subBlockHasCopyDispose);
Mike Stumpcb2fbcb2009-02-21 20:00:35 +0000281
Mike Stump692c6e32009-03-20 21:53:12 +0000282 void BlockForwardSelf();
Mike Stumpcb2fbcb2009-02-21 20:00:35 +0000283 llvm::Value *LoadBlockStruct();
284
Mike Stump1db7d042009-02-28 09:07:16 +0000285 llvm::Value *GetAddrOfBlockDecl(const BlockDeclRefExpr *E);
Mike Stump0e7d7b62009-02-14 22:49:33 +0000286
Mike Stump97d01d52009-03-04 03:23:46 +0000287 const llvm::Type *BuildByRefType(QualType Ty, uint64_t Align);
Mike Stump97d01d52009-03-04 03:23:46 +0000288
Daniel Dunbar9c426522008-07-29 23:18:29 +0000289 void GenerateCode(const FunctionDecl *FD,
290 llvm::Function *Fn);
Mike Stumpfc496822009-02-08 23:14:22 +0000291 void StartFunction(const Decl *D, QualType RetTy,
Daniel Dunbarbc915f42008-09-09 23:14:03 +0000292 llvm::Function *Fn,
Daniel Dunbar354d2782008-10-18 18:22:23 +0000293 const FunctionArgList &Args,
294 SourceLocation StartLoc);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +0000295
Mike Stumpfc496822009-02-08 23:14:22 +0000296 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
297 /// emission when possible.
Daniel Dunbarfd346a32009-01-26 23:27:52 +0000298 void EmitReturnBlock();
299
Mike Stumpfc496822009-02-08 23:14:22 +0000300 /// FinishFunction - Complete IR generation of the current function. It is
301 /// legal to call this function even if there is no current insertion point.
Daniel Dunbar89654ee2008-08-26 08:29:31 +0000302 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Daniel Dunbar613855c2008-09-09 23:27:19 +0000303
Mike Stumpfc496822009-02-08 23:14:22 +0000304 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
305 /// arguments for the given function. This is also responsible for naming the
306 /// LLVM function arguments.
Daniel Dunbard931a872009-02-02 22:03:45 +0000307 void EmitFunctionProlog(const CGFunctionInfo &FI,
308 llvm::Function *Fn,
Daniel Dunbar613855c2008-09-09 23:27:19 +0000309 const FunctionArgList &Args);
310
Mike Stumpfc496822009-02-08 23:14:22 +0000311 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
312 /// given temporary.
Daniel Dunbard931a872009-02-02 22:03:45 +0000313 void EmitFunctionEpilog(const CGFunctionInfo &FI, llvm::Value *ReturnValue);
Daniel Dunbar613855c2008-09-09 23:27:19 +0000314
Daniel Dunbaree3da872009-02-03 23:03:55 +0000315 const llvm::Type *ConvertTypeForMem(QualType T);
Chris Lattnerf033c142007-06-22 19:05:19 +0000316 const llvm::Type *ConvertType(QualType T);
Chris Lattner5506f8c2008-04-04 04:07:35 +0000317
Mike Stumpfc496822009-02-08 23:14:22 +0000318 /// LoadObjCSelf - Load the value of self. This function is only valid while
319 /// generating code for an Objective-C method.
Chris Lattner5506f8c2008-04-04 04:07:35 +0000320 llvm::Value *LoadObjCSelf();
Mike Stumpfc496822009-02-08 23:14:22 +0000321
322 /// TypeOfSelfObject - Return type of object that this self represents.
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +0000323 QualType TypeOfSelfObject();
Chris Lattner5696e7b2008-06-17 18:05:57 +0000324
Chris Lattner54fb19e2007-06-22 22:02:34 +0000325 /// hasAggregateLLVMType - Return true if the specified AST type will map into
326 /// an aggregate LLVM type or is void.
327 static bool hasAggregateLLVMType(QualType T);
Daniel Dunbar75283ff2008-11-11 02:29:29 +0000328
329 /// createBasicBlock - Create an LLVM basic block.
Mike Stumpfc496822009-02-08 23:14:22 +0000330 llvm::BasicBlock *createBasicBlock(const char *Name="",
Daniel Dunbar75283ff2008-11-11 02:29:29 +0000331 llvm::Function *Parent=0,
332 llvm::BasicBlock *InsertBefore=0) {
Daniel Dunbar851eec12008-11-12 00:01:12 +0000333#ifdef NDEBUG
334 return llvm::BasicBlock::Create("", Parent, InsertBefore);
335#else
Daniel Dunbar75283ff2008-11-11 02:29:29 +0000336 return llvm::BasicBlock::Create(Name, Parent, InsertBefore);
Daniel Dunbar851eec12008-11-12 00:01:12 +0000337#endif
Daniel Dunbar75283ff2008-11-11 02:29:29 +0000338 }
Mike Stumpfc496822009-02-08 23:14:22 +0000339
Chris Lattnerac248202007-05-30 00:13:02 +0000340 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
341 /// label maps to.
342 llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
Mike Stumpfc496822009-02-08 23:14:22 +0000343
Daniel Dunbarf77e2922009-04-01 04:37:47 +0000344 /// SimplifyForwardingBlocks - If the given basic block is only a
345 /// branch to another basic block, simplify it. This assumes that no
346 /// other code could potentially reference the basic block.
347 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
348
Mike Stumpfc496822009-02-08 23:14:22 +0000349 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
350 /// adding a fall-through branch from the current insert block if
351 /// necessary. It is legal to call this function even if there is no current
352 /// insertion point.
Daniel Dunbarfcac22e2008-11-13 01:24:05 +0000353 ///
Mike Stumpfc496822009-02-08 23:14:22 +0000354 /// IsFinished - If true, indicates that the caller has finished emitting
355 /// branches to the given block and does not expect to emit code into it. This
356 /// means the block can be ignored if it is unreachable.
Daniel Dunbarfcac22e2008-11-13 01:24:05 +0000357 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
Daniel Dunbar29ac59f2008-11-11 04:34:23 +0000358
Mike Stumpfc496822009-02-08 23:14:22 +0000359 /// EmitBranch - Emit a branch to the specified basic block from the current
360 /// insert block, taking care to avoid creation of branches from dummy
361 /// blocks. It is legal to call this function even if there is no current
362 /// insertion point.
Daniel Dunbarab197eb2008-11-11 22:06:59 +0000363 ///
Mike Stumpfc496822009-02-08 23:14:22 +0000364 /// This function clears the current insertion point. The caller should follow
365 /// calls to this function with calls to Emit*Block prior to generation new
366 /// code.
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000367 void EmitBranch(llvm::BasicBlock *Block);
368
Mike Stumpfc496822009-02-08 23:14:22 +0000369 /// HaveInsertPoint - True if an insertion point is defined. If not, this
370 /// indicates that the current code being emitted is unreachable.
371 bool HaveInsertPoint() const {
Daniel Dunbar5c7e3932008-11-11 23:11:34 +0000372 return Builder.GetInsertBlock() != 0;
373 }
374
Mike Stumpfc496822009-02-08 23:14:22 +0000375 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
376 /// emitted IR has a place to go. Note that by definition, if this function
377 /// creates a block then that block is unreachable; callers may do better to
378 /// detect when no insertion point is defined and simply skip IR generation.
Daniel Dunbar5c7e3932008-11-11 23:11:34 +0000379 void EnsureInsertPoint() {
380 if (!HaveInsertPoint())
381 EmitBlock(createBasicBlock());
382 }
Mike Stumpfc496822009-02-08 23:14:22 +0000383
Daniel Dunbara7c8cf62008-08-16 00:56:44 +0000384 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerfc944342007-12-02 01:43:38 +0000385 /// specified stmt yet.
Daniel Dunbarf2cf6d12008-09-04 03:43:08 +0000386 void ErrorUnsupported(const Stmt *S, const char *Type,
387 bool OmitOnError=false);
Chris Lattner84915fa2007-06-02 04:16:21 +0000388
Chris Lattnere9a64532007-06-22 21:44:33 +0000389 //===--------------------------------------------------------------------===//
390 // Helpers
391 //===--------------------------------------------------------------------===//
Mike Stumpfc496822009-02-08 23:14:22 +0000392
Chris Lattnere9a64532007-06-22 21:44:33 +0000393 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
394 /// block.
395 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
396 const char *Name = "tmp");
Mike Stumpfc496822009-02-08 23:14:22 +0000397
Chris Lattner8394d792007-06-05 20:53:16 +0000398 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
399 /// expression and compare the result against zero, returning an Int1Ty value.
Chris Lattner23b7eb62007-06-15 23:05:46 +0000400 llvm::Value *EvaluateExprAsBool(const Expr *E);
Chris Lattnere9a64532007-06-22 21:44:33 +0000401
Chris Lattner4647a212007-08-31 22:49:20 +0000402 /// EmitAnyExpr - Emit code to compute the specified expression which can have
403 /// any type. The result is returned as an RValue struct. If this is an
404 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
405 /// the result should be returned.
Mike Stumpfc496822009-02-08 23:14:22 +0000406 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
Chris Lattner4647a212007-08-31 22:49:20 +0000407 bool isAggLocVolatile = false);
Devang Patel8ec4f832007-09-28 21:49:18 +0000408
Mike Stumpfc496822009-02-08 23:14:22 +0000409 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
410 // or the value of the expression, depending on how va_list is defined.
Eli Friedmanddea0ad2009-01-20 17:46:04 +0000411 llvm::Value *EmitVAListRef(const Expr *E);
412
Mike Stumpfc496822009-02-08 23:14:22 +0000413 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
414 /// always be accessible even if no aggregate location is provided.
415 RValue EmitAnyExprToTemp(const Expr *E, llvm::Value *AggLoc = 0,
Daniel Dunbar41cf9de2008-09-09 01:06:48 +0000416 bool isAggLocVolatile = false);
417
Daniel Dunbar0bc8e862008-09-09 20:49:46 +0000418 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
419 QualType EltTy);
420
421 void EmitAggregateClear(llvm::Value *DestPtr, QualType Ty);
422
Devang Patelda5d6bb2007-10-04 23:45:31 +0000423 /// StartBlock - Start new block named N. If insert block is a dummy block
424 /// then reuse it.
425 void StartBlock(const char *N);
426
Devang Patele11664a2007-11-01 19:11:01 +0000427 /// getCGRecordLayout - Return record layout info.
428 const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
Lauro Ramos Venancio01a72ff2008-02-26 21:41:45 +0000429
430 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
Steve Naroff08899ff2008-04-15 22:42:06 +0000431 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD);
Dan Gohman75d69da2008-05-22 00:50:06 +0000432
Anders Carlsson9396a892008-09-11 09:15:33 +0000433 /// GetAddrOfLocalVar - Return the address of a local variable.
434 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD);
Mike Stumpfc496822009-02-08 23:14:22 +0000435
Dan Gohman75d69da2008-05-22 00:50:06 +0000436 /// getAccessedFieldNo - Given an encoded value and a result number, return
437 /// the input field number being accessed.
438 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
439
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000440 unsigned GetIDForAddrOfLabel(const LabelStmt *L);
441
Mike Stumpfc496822009-02-08 23:14:22 +0000442 /// EmitMemSetToZero - Generate code to memset a value of the given type to 0.
Anders Carlsson2e744e82008-08-30 19:51:14 +0000443 void EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty);
Anders Carlsson13abd7e2008-11-04 05:30:00 +0000444
445 // EmitVAArg - Generate code to get an argument from the passed in pointer
446 // and update it accordingly. The return value is a pointer to the argument.
447 // FIXME: We should be able to get rid of this method and use the va_arg
Mike Stumpfc496822009-02-08 23:14:22 +0000448 // instruction in LLVM instead once it works well enough.
Anders Carlsson13abd7e2008-11-04 05:30:00 +0000449 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
Anders Carlssone388a5b2008-12-20 20:27:15 +0000450
Anders Carlsson8a01b792008-12-20 20:46:34 +0000451 // EmitVLASize - Generate code for any VLA size expressions that might occur
452 // in a variably modified type. If Ty is a VLA, will return the value that
453 // corresponds to the size in bytes of the VLA type. Will return 0 otherwise.
454 llvm::Value *EmitVLASize(QualType Ty);
Mike Stumpfc496822009-02-08 23:14:22 +0000455
Anders Carlssonccbe9202008-12-12 07:19:02 +0000456 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes
457 // of a variable length array type.
458 llvm::Value *GetVLASize(const VariableArrayType *);
459
Anders Carlssona5d077d2009-04-14 16:58:56 +0000460 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
461 /// generating code for an C++ member function.
462 llvm::Value *LoadCXXThis();
463
Anders Carlssonb7f8f592009-04-17 00:06:03 +0000464 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
465 llvm::Value *This,
466 CallExpr::const_arg_iterator ArgBeg,
467 CallExpr::const_arg_iterator ArgEnd);
468
Chris Lattner8394d792007-06-05 20:53:16 +0000469 //===--------------------------------------------------------------------===//
Chris Lattner53621a52007-06-13 20:44:40 +0000470 // Declaration Emission
Chris Lattner84915fa2007-06-02 04:16:21 +0000471 //===--------------------------------------------------------------------===//
Mike Stumpfc496822009-02-08 23:14:22 +0000472
Chris Lattner1ad38f82007-06-09 01:20:56 +0000473 void EmitDecl(const Decl &D);
Steve Naroff08899ff2008-04-15 22:42:06 +0000474 void EmitBlockVarDecl(const VarDecl &D);
475 void EmitLocalBlockVarDecl(const VarDecl &D);
476 void EmitStaticBlockVarDecl(const VarDecl &D);
Daniel Dunbara94ecd22008-08-16 03:19:19 +0000477
478 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
479 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg);
Mike Stumpfc496822009-02-08 23:14:22 +0000480
Chris Lattner84915fa2007-06-02 04:16:21 +0000481 //===--------------------------------------------------------------------===//
Chris Lattner308f4312007-05-29 23:50:05 +0000482 // Statement Emission
483 //===--------------------------------------------------------------------===//
484
Mike Stumpfc496822009-02-08 23:14:22 +0000485 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000486 void EmitStopPoint(const Stmt *S);
487
Mike Stumpfc496822009-02-08 23:14:22 +0000488 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
489 /// this function even if there is no current insertion point.
490 ///
491 /// This function may clear the current insertion point; callers should use
492 /// EnsureInsertPoint if they wish to subsequently generate code without first
493 /// calling EmitBlock, EmitBranch, or EmitStmt.
Chris Lattner308f4312007-05-29 23:50:05 +0000494 void EmitStmt(const Stmt *S);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +0000495
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000496 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
Mike Stumpfc496822009-02-08 23:14:22 +0000497 /// necessarily require an insertion point or debug information; typically
498 /// because the statement amounts to a jump or a container of other
499 /// statements.
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000500 ///
501 /// \return True if the statement was handled.
502 bool EmitSimpleStmt(const Stmt *S);
503
Chris Lattner4647a212007-08-31 22:49:20 +0000504 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
505 llvm::Value *AggLoc = 0, bool isAggVol = false);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +0000506
Mike Stumpfc496822009-02-08 23:14:22 +0000507 /// EmitLabel - Emit the block for the given label. It is legal to call this
508 /// function even if there is no current insertion point.
Chris Lattner7e800972008-07-26 20:23:23 +0000509 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt.
Daniel Dunbar5c7e3932008-11-11 23:11:34 +0000510
Chris Lattnerac248202007-05-30 00:13:02 +0000511 void EmitLabelStmt(const LabelStmt &S);
512 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000513 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Chris Lattner5269c032007-05-30 21:03:58 +0000514 void EmitIfStmt(const IfStmt &S);
Chris Lattner946aa312007-06-05 03:59:43 +0000515 void EmitWhileStmt(const WhileStmt &S);
Chris Lattner8394d792007-06-05 20:53:16 +0000516 void EmitDoStmt(const DoStmt &S);
517 void EmitForStmt(const ForStmt &S);
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000518 void EmitReturnStmt(const ReturnStmt &S);
Chris Lattner1ad38f82007-06-09 01:20:56 +0000519 void EmitDeclStmt(const DeclStmt &S);
Daniel Dunbar5fc28712008-11-12 08:21:33 +0000520 void EmitBreakStmt(const BreakStmt &S);
521 void EmitContinueStmt(const ContinueStmt &S);
Devang Patelda5d6bb2007-10-04 23:45:31 +0000522 void EmitSwitchStmt(const SwitchStmt &S);
523 void EmitDefaultStmt(const DefaultStmt &S);
524 void EmitCaseStmt(const CaseStmt &S);
Devang Patel11663122007-10-08 20:57:48 +0000525 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlsson952a9952008-02-05 16:35:33 +0000526 void EmitAsmStmt(const AsmStmt &S);
Mike Stumpfc496822009-02-08 23:14:22 +0000527
Anders Carlsson2e744e82008-08-30 19:51:14 +0000528 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
Anders Carlsson1963b0c2008-09-09 10:04:29 +0000529 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
530 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
Chris Lattnere132e242008-11-15 21:26:17 +0000531 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
Mike Stumpfc496822009-02-08 23:14:22 +0000532
Chris Lattner208ae962007-05-30 17:57:17 +0000533 //===--------------------------------------------------------------------===//
Chris Lattnerd7f58862007-06-02 05:24:33 +0000534 // LValue Expression Emission
535 //===--------------------------------------------------------------------===//
Chris Lattner8394d792007-06-05 20:53:16 +0000536
Daniel Dunbarc79407f2009-02-05 07:09:07 +0000537 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
538 RValue GetUndefRValue(QualType Ty);
539
Daniel Dunbarbb197e42009-01-09 16:50:52 +0000540 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
541 /// and issue an ErrorUnsupported style diagnostic (using the
542 /// provided Name).
543 RValue EmitUnsupportedRValue(const Expr *E,
544 const char *Name);
545
Mike Stumpfc496822009-02-08 23:14:22 +0000546 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
547 /// an ErrorUnsupported style diagnostic (using the provided Name).
Daniel Dunbarf2e69882008-08-25 20:45:57 +0000548 LValue EmitUnsupportedLValue(const Expr *E,
549 const char *Name);
550
Chris Lattner8394d792007-06-05 20:53:16 +0000551 /// EmitLValue - Emit code to compute a designator that specifies the location
552 /// of the expression.
553 ///
554 /// This can return one of two things: a simple address or a bitfield
555 /// reference. In either case, the LLVM Value* in the LValue structure is
556 /// guaranteed to be an LLVM pointer type.
557 ///
558 /// If this returns a bitfield reference, nothing about the pointee type of
559 /// the LLVM value is known: For example, it may not be a pointer to an
560 /// integer.
561 ///
562 /// If this returns a normal address, and if the lvalue's C type is fixed
563 /// size, this method guarantees that the returned pointer type will point to
564 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
565 /// variable length type, this is not possible.
566 ///
Chris Lattnerd7f58862007-06-02 05:24:33 +0000567 LValue EmitLValue(const Expr *E);
Mike Stumpfc496822009-02-08 23:14:22 +0000568
Daniel Dunbar1d425462009-02-10 00:57:50 +0000569 /// EmitLoadOfScalar - Load a scalar value from an address, taking
570 /// care to appropriately convert from the memory representation to
571 /// the LLVM value representation.
Mike Stumpc6ea7c12009-02-17 17:00:02 +0000572 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Daniel Dunbar1d425462009-02-10 00:57:50 +0000573 QualType Ty);
574
575 /// EmitStoreOfScalar - Store a scalar value to an address, taking
576 /// care to appropriately convert from the memory representation to
577 /// the LLVM value representation.
Mike Stumpc6ea7c12009-02-17 17:00:02 +0000578 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Daniel Dunbar1d425462009-02-10 00:57:50 +0000579 bool Volatile);
580
Chris Lattner8394d792007-06-05 20:53:16 +0000581 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
582 /// this method emits the address of the lvalue, then loads the result as an
583 /// rvalue, returning the rvalue.
Chris Lattner9369a562007-06-29 16:31:29 +0000584 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Nate Begemance4d7fc2008-04-18 23:10:10 +0000585 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +0000586 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
Daniel Dunbar9e22c0d2008-08-29 08:11:39 +0000587 RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType);
Fariborz Jahanian9ac53512008-11-22 22:30:21 +0000588 RValue EmitLoadOfKVCRefLValue(LValue LV, QualType ExprType);
Chris Lattner9369a562007-06-29 16:31:29 +0000589
Mike Stumpfc496822009-02-08 23:14:22 +0000590
Chris Lattner8394d792007-06-05 20:53:16 +0000591 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
592 /// lvalue, where both are guaranteed to the have the same type, and that type
593 /// is 'Ty'.
594 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Nate Begemance4d7fc2008-04-18 23:10:10 +0000595 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
596 QualType Ty);
Daniel Dunbar9e22c0d2008-08-29 08:11:39 +0000597 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty);
Fariborz Jahanian9ac53512008-11-22 22:30:21 +0000598 void EmitStoreThroughKVCRefLValue(RValue Src, LValue Dst, QualType Ty);
Daniel Dunbar9b1335e2008-11-19 09:36:46 +0000599
Mike Stumpfc496822009-02-08 23:14:22 +0000600 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
601 /// EmitStoreThroughLValue.
Daniel Dunbar9b1335e2008-11-19 09:36:46 +0000602 ///
Mike Stumpfc496822009-02-08 23:14:22 +0000603 /// \param Result [out] - If non-null, this will be set to a Value* for the
604 /// bit-field contents after the store, appropriate for use as the result of
605 /// an assignment to the bit-field.
Daniel Dunbar9b1335e2008-11-19 09:36:46 +0000606 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty,
607 llvm::Value **Result=0);
Mike Stumpfc496822009-02-08 23:14:22 +0000608
Christopher Lambd91c3d42007-12-29 05:02:41 +0000609 // Note: only availabe for agg return types
Daniel Dunbar8cde00a2008-09-04 03:20:13 +0000610 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +0000611 // Note: only available for agg return types
Christopher Lambd91c3d42007-12-29 05:02:41 +0000612 LValue EmitCallExprLValue(const CallExpr *E);
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +0000613 // Note: only available for agg return types
614 LValue EmitVAArgExprLValue(const VAArgExpr *E);
Chris Lattnerd7f58862007-06-02 05:24:33 +0000615 LValue EmitDeclRefLValue(const DeclRefExpr *E);
Chris Lattner4347e3692007-06-06 04:54:52 +0000616 LValue EmitStringLiteralLValue(const StringLiteral *E);
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +0000617 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
Daniel Dunbarb3517472008-10-17 21:58:32 +0000618 LValue EmitPredefinedFunctionName(unsigned Type);
Chris Lattner6307f192008-08-10 01:53:14 +0000619 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Chris Lattner8394d792007-06-05 20:53:16 +0000620 LValue EmitUnaryOpLValue(const UnaryOperator *E);
Chris Lattnerd9d2fb12007-06-08 23:31:14 +0000621 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begemance4d7fc2008-04-18 23:10:10 +0000622 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patel3e11cce2007-10-23 02:10:49 +0000623 LValue EmitMemberExpr(const MemberExpr *E);
Eli Friedman9fd8b682008-05-13 23:18:27 +0000624 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
Daniel Dunbarbf1fe8c2009-03-24 02:38:23 +0000625 LValue EmitConditionalOperator(const ConditionalOperator *E);
Chris Lattner28bcf1a2009-03-18 18:28:57 +0000626 LValue EmitCastLValue(const CastExpr *E);
Eli Friedmana62f3e12008-02-09 08:50:58 +0000627
Daniel Dunbar722f4242009-04-22 05:08:15 +0000628 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +0000629 const ObjCIvarDecl *Ivar);
Eli Friedmana62f3e12008-02-09 08:50:58 +0000630 LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field,
Eli Friedman327944b2008-06-13 23:01:12 +0000631 bool isUnion, unsigned CVRQualifiers);
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +0000632 LValue EmitLValueForIvar(QualType ObjectTy,
633 llvm::Value* Base, const ObjCIvarDecl *Ivar,
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +0000634 unsigned CVRQualifiers);
635
Fariborz Jahanianb517e902008-12-15 20:35:07 +0000636 LValue EmitLValueForBitfield(llvm::Value* Base, FieldDecl* Field,
Fariborz Jahanian712bfa62009-02-03 19:03:09 +0000637 unsigned CVRQualifiers);
Fariborz Jahanianb517e902008-12-15 20:35:07 +0000638
Mike Stump1db7d042009-02-28 09:07:16 +0000639 LValue EmitBlockDeclRefLValue(const BlockDeclRefExpr *E);
640
Argyrios Kyrtzidis07052352008-09-10 02:36:38 +0000641 LValue EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E);
Anders Carlssonb7f8f592009-04-17 00:06:03 +0000642 LValue EmitCXXTemporaryObjectExprLValue(const CXXTemporaryObjectExpr *E);
Argyrios Kyrtzidis07052352008-09-10 02:36:38 +0000643
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000644 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattner4bd55962008-03-30 23:03:07 +0000645 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Daniel Dunbar9e22c0d2008-08-29 08:11:39 +0000646 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
Fariborz Jahanian9ac53512008-11-22 22:30:21 +0000647 LValue EmitObjCKVCRefLValue(const ObjCKVCRefExpr *E);
Douglas Gregor8ea1f532008-11-04 14:56:14 +0000648 LValue EmitObjCSuperExpr(const ObjCSuperExpr *E);
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000649
Chris Lattnerd7f58862007-06-02 05:24:33 +0000650 //===--------------------------------------------------------------------===//
Chris Lattner6278e6a2007-08-11 00:04:45 +0000651 // Scalar Expression Emission
Chris Lattner208ae962007-05-30 17:57:17 +0000652 //===--------------------------------------------------------------------===//
653
Mike Stumpfc496822009-02-08 23:14:22 +0000654 /// EmitCall - Generate a call of the given function, expecting the given
655 /// result type, and using the given argument list which specifies both the
656 /// LLVM arguments and the types they were derived from.
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +0000657 ///
658 /// \param TargetDecl - If given, the decl of the function in a
659 /// direct call; used to set attributes on the call (noreturn,
660 /// etc.).
Daniel Dunbard931a872009-02-02 22:03:45 +0000661 RValue EmitCall(const CGFunctionInfo &FnInfo,
662 llvm::Value *Callee,
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +0000663 const CallArgList &Args,
664 const Decl *TargetDecl = 0);
Daniel Dunbarc722b852008-08-30 03:02:31 +0000665
Chris Lattner2b228c92007-06-15 21:34:29 +0000666 RValue EmitCallExpr(const CallExpr *E);
Anders Carlssone5fd6f22009-04-03 22:50:24 +0000667 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E);
Ted Kremenek08e17112008-06-17 02:43:46 +0000668
Eli Friedman9d92ce82008-01-30 01:32:06 +0000669 RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
Ted Kremenek08e17112008-06-17 02:43:46 +0000670 CallExpr::const_arg_iterator ArgBeg,
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +0000671 CallExpr::const_arg_iterator ArgEnd,
672 const Decl *TargetDecl = 0);
Mike Stumpfc496822009-02-08 23:14:22 +0000673
Daniel Dunbar8eb018a2009-02-16 22:43:43 +0000674 RValue EmitBuiltinExpr(const FunctionDecl *FD,
675 unsigned BuiltinID, const CallExpr *E);
Chris Lattner8394d792007-06-05 20:53:16 +0000676
Anders Carlsson2437cbf2009-02-12 00:39:25 +0000677 RValue EmitBlockCallExpr(const CallExpr *E);
Mike Stumpc6ea7c12009-02-17 17:00:02 +0000678
Mike Stumpfc496822009-02-08 23:14:22 +0000679 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
680 /// is unhandled by the current target.
Daniel Dunbareca513d2008-10-10 00:24:54 +0000681 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
682
Anders Carlsson895af082007-12-09 23:17:02 +0000683 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
684 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Mike Stumpfc496822009-02-08 23:14:22 +0000685
Anders Carlssonb9eb82c2007-12-10 19:35:18 +0000686 llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
Nate Begeman330aaa72007-12-30 02:59:45 +0000687 llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
688 bool isSplat = false);
Mike Stumpfc496822009-02-08 23:14:22 +0000689
Daniel Dunbar66912a12008-08-20 00:28:19 +0000690 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner2da04b32007-08-24 05:35:26 +0000691 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Chris Lattnerb1d329d2008-06-24 17:04:18 +0000692 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
Daniel Dunbar97db84c2008-08-23 03:46:30 +0000693 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E);
Fariborz Jahanian8a1810f2008-11-22 18:39:36 +0000694 RValue EmitObjCPropertyGet(const Expr *E);
Fariborz Jahanian391d4fc2009-03-20 19:18:21 +0000695 RValue EmitObjCSuperPropertyGet(const Expr *Exp, const Selector &S);
Fariborz Jahanian9ac53512008-11-22 22:30:21 +0000696 void EmitObjCPropertySet(const Expr *E, RValue Src);
Fariborz Jahanian391d4fc2009-03-20 19:18:21 +0000697 void EmitObjCSuperPropertySet(const Expr *E, const Selector &S, RValue Src);
Chris Lattnerb1d329d2008-06-24 17:04:18 +0000698
699
Chris Lattner6278e6a2007-08-11 00:04:45 +0000700 //===--------------------------------------------------------------------===//
Chris Lattnerbda69f82007-08-26 23:13:56 +0000701 // Expression Emission
Chris Lattner6278e6a2007-08-11 00:04:45 +0000702 //===--------------------------------------------------------------------===//
Chris Lattnerbda69f82007-08-26 23:13:56 +0000703
704 // Expressions are broken into three classes: scalar, complex, aggregate.
Mike Stumpfc496822009-02-08 23:14:22 +0000705
706 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
707 /// scalar type, returning the result.
Chris Lattner2da04b32007-08-24 05:35:26 +0000708 llvm::Value *EmitScalarExpr(const Expr *E);
Mike Stumpfc496822009-02-08 23:14:22 +0000709
Chris Lattner3474c202007-08-26 06:48:56 +0000710 /// EmitScalarConversion - Emit a conversion from the specified type to the
711 /// specified destination type, both of which are LLVM scalar types.
712 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
713 QualType DstTy);
Mike Stumpfc496822009-02-08 23:14:22 +0000714
Chris Lattner42e6b812007-08-26 16:34:22 +0000715 /// EmitComplexToScalarConversion - Emit a conversion from the specified
Mike Stumpfc496822009-02-08 23:14:22 +0000716 /// complex type to the specified destination type, where the destination type
717 /// is an LLVM scalar type.
Chris Lattner42e6b812007-08-26 16:34:22 +0000718 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
719 QualType DstTy);
Mike Stumpfc496822009-02-08 23:14:22 +0000720
721
Chris Lattner6278e6a2007-08-11 00:04:45 +0000722 /// EmitAggExpr - Emit the computation of the specified expression of
723 /// aggregate type. The result is computed into DestPtr. Note that if
724 /// DestPtr is null, the value of the aggregate expression is not needed.
725 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest);
Mike Stumpfc496822009-02-08 23:14:22 +0000726
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000727 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner08b15df2007-08-23 23:43:33 +0000728 /// complex type, returning the result.
Chris Lattner96d72562007-08-21 16:57:55 +0000729 ComplexPairTy EmitComplexExpr(const Expr *E);
Mike Stumpfc496822009-02-08 23:14:22 +0000730
Chris Lattner08b15df2007-08-23 23:43:33 +0000731 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
732 /// of complex type, storing into the specified Value*.
Chris Lattnerb84bb952007-08-26 16:22:13 +0000733 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
734 bool DestIsVolatile);
Daniel Dunbar4b8c6db2008-08-30 05:35:15 +0000735
736 /// StoreComplexToAddr - Store a complex number into the specified address.
737 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
738 bool DestIsVolatile);
Chris Lattner4647a212007-08-31 22:49:20 +0000739 /// LoadComplexFromAddr - Load a complex number from the specified address.
740 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattnerb781dc792008-05-08 05:58:21 +0000741
Daniel Dunbar22a87f92009-02-25 19:24:29 +0000742 /// CreateStaticBlockVarDecl - Create a zero-initialized LLVM global
743 /// for a static block var decl.
744 llvm::GlobalVariable * CreateStaticBlockVarDecl(const VarDecl &D,
745 const char *Separator,
746 llvm::GlobalValue::LinkageTypes
747 Linkage);
748
Daniel Dunbar22a87f92009-02-25 19:24:29 +0000749 /// GenerateStaticCXXBlockVarDecl - Create the initializer for a C++
750 /// runtime initialized static block var decl.
751 void GenerateStaticCXXBlockVarDeclInit(const VarDecl &D,
752 llvm::GlobalVariable *GV);
Anders Carlsson87fc5a52008-08-22 16:00:37 +0000753
Anders Carlssonb7f8f592009-04-17 00:06:03 +0000754 void EmitCXXTemporaryObjectExpr(llvm::Value *Dest,
755 const CXXTemporaryObjectExpr *E);
756
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000757 //===--------------------------------------------------------------------===//
758 // Internal Helpers
759 //===--------------------------------------------------------------------===//
Mike Stumpfc496822009-02-08 23:14:22 +0000760
Chris Lattner5b1964b2008-11-11 07:41:27 +0000761 /// ContainsLabel - Return true if the statement contains a label in it. If
762 /// this statement is not executed normally, it not containing a label means
763 /// that we can just remove the code.
764 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
Mike Stumpfc496822009-02-08 23:14:22 +0000765
Daniel Dunbar682712c2008-11-12 10:12:14 +0000766 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
Chris Lattnercd439292008-11-12 08:04:58 +0000767 /// to a constant, or if it does but contains a label, return 0. If it
768 /// constant folds to 'true' and does not contain a label, return 1, if it
769 /// constant folds to 'false' and does not contain a label, return -1.
770 int ConstantFoldsToSimpleInteger(const Expr *Cond);
Mike Stumpfc496822009-02-08 23:14:22 +0000771
Chris Lattnercd439292008-11-12 08:04:58 +0000772 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
773 /// if statement) to the specified blocks. Based on the condition, this might
774 /// try to simplify the codegen of the conditional based on the branch.
Chris Lattnerb7a9e162008-11-12 07:46:33 +0000775 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
Daniel Dunbar682712c2008-11-12 10:12:14 +0000776 llvm::BasicBlock *FalseBlock);
Chris Lattnercd439292008-11-12 08:04:58 +0000777private:
Mike Stumpfc496822009-02-08 23:14:22 +0000778
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000779 /// EmitIndirectSwitches - Emit code for all of the switch
780 /// instructions in IndirectSwitches.
781 void EmitIndirectSwitches();
Daniel Dunbar8fc81b02008-09-17 00:51:38 +0000782
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +0000783 void EmitReturnOfRValue(RValue RV, QualType Ty);
784
Daniel Dunbar8fc81b02008-09-17 00:51:38 +0000785 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
786 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
787 ///
788 /// \param AI - The first function argument of the expansion.
789 /// \return The argument following the last expanded function
790 /// argument.
Mike Stumpfc496822009-02-08 23:14:22 +0000791 llvm::Function::arg_iterator
Daniel Dunbar8fc81b02008-09-17 00:51:38 +0000792 ExpandTypeFromArgs(QualType Ty, LValue Dst,
793 llvm::Function::arg_iterator AI);
794
Mike Stumpfc496822009-02-08 23:14:22 +0000795 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg
796 /// Ty, into individual arguments on the provided vector \arg Args. See
797 /// ABIArgInfo::Expand.
798 void ExpandTypeToArgs(QualType Ty, RValue Src,
Daniel Dunbar8fc81b02008-09-17 00:51:38 +0000799 llvm::SmallVector<llvm::Value*, 16> &Args);
Anders Carlsson03aaf112009-01-11 19:40:10 +0000800
801 llvm::Value* EmitAsmInput(const AsmStmt &S, TargetInfo::ConstraintInfo Info,
802 const Expr *InputExpr, std::string &ConstraintStr);
Mike Stumpfc496822009-02-08 23:14:22 +0000803
Anders Carlssonbe0f76a2009-02-07 23:50:39 +0000804 /// EmitCleanupBlock - emits a single cleanup block.
805 void EmitCleanupBlock();
806
Anders Carlsson7d70fd22009-02-08 00:50:42 +0000807 /// AddBranchFixup - adds a branch instruction to the list of fixups for the
808 /// current cleanup scope.
809 void AddBranchFixup(llvm::BranchInst *BI);
Mike Stumpfc496822009-02-08 23:14:22 +0000810
Anders Carlsson60ce3fe2009-04-08 20:47:54 +0000811 /// EmitCallArg - Emit a single call argument.
812 RValue EmitCallArg(const Expr *E, QualType ArgType);
813
814 /// EmitCallArgs - Emit call arguments for a function.
Anders Carlsson603d6af2009-04-18 20:20:22 +0000815 /// The CallArgTypeInfo parameter is used for iterating over the known
816 /// argument types of the function being called.
817 template<typename T>
818 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo,
Anders Carlsson60ce3fe2009-04-08 20:47:54 +0000819 CallExpr::const_arg_iterator ArgBeg,
Anders Carlsson603d6af2009-04-18 20:20:22 +0000820 CallExpr::const_arg_iterator ArgEnd) {
821 CallExpr::const_arg_iterator Arg = ArgBeg;
Anders Carlsson60ce3fe2009-04-08 20:47:54 +0000822
Anders Carlsson603d6af2009-04-18 20:20:22 +0000823 // First, use the argument types that the type info knows about
824 if (CallArgTypeInfo) {
825 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(),
826 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
827 QualType ArgType = *I;
828
829 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
830 getTypePtr() ==
831 getContext().getCanonicalType(Arg->getType()).getTypePtr() &&
832 "type mismatch in call argument!");
833
834 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
835 ArgType));
836 }
837
838 // Either we've emitted all the call args, or we have a call to a
839 // variadic function.
Eli Friedmanfe92e702009-04-19 20:21:56 +0000840 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) &&
Anders Carlsson603d6af2009-04-18 20:20:22 +0000841 "Extra arguments in non-variadic function!");
842
843 }
844
845 // If we still have any arguments, emit them using the type of the argument.
846 for (; Arg != ArgEnd; ++Arg) {
847 QualType ArgType = Arg->getType();
848 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
849 ArgType));
850 }
851 }
Chris Lattnerbed31442007-05-28 01:07:47 +0000852};
Anders Carlsson603d6af2009-04-18 20:20:22 +0000853
854
Chris Lattnerbed31442007-05-28 01:07:47 +0000855} // end namespace CodeGen
856} // end namespace clang
Chris Lattnerbed31442007-05-28 01:07:47 +0000857
858#endif