blob: 8047b4cb9c0229398131eda45539e79d92bf57fb [file] [log] [blame]
Daniel Dunbar7bf5b3d2008-07-29 23:18:29 +00001//===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
Chris Lattner4b009652007-07-25 00:24:17 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-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 Lattner4b009652007-07-25 00:24:17 +00007//
8//===----------------------------------------------------------------------===//
9//
Mike Stumpb699aa62009-02-08 23:14:22 +000010// This is the internal per-function state used for llvm translation.
Chris Lattner4b009652007-07-25 00:24:17 +000011//
12//===----------------------------------------------------------------------===//
13
Chris Lattner2629b882008-02-29 17:10:38 +000014#ifndef CLANG_CODEGEN_CODEGENFUNCTION_H
15#define CLANG_CODEGEN_CODEGENFUNCTION_H
Chris Lattner4b009652007-07-25 00:24:17 +000016
Chris Lattnerb326b172008-03-30 23:03:07 +000017#include "clang/AST/Type.h"
Chris Lattner4b009652007-07-25 00:24:17 +000018#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/SmallVector.h"
Anders Carlsson60bb4d42009-01-11 19:40:10 +000020#include "clang/Basic/TargetInfo.h"
Ted Kremenek2719e982008-06-17 02:43:46 +000021#include "clang/AST/Expr.h"
Argiris Kirtzidisbf615b02008-09-10 02:36:38 +000022#include "clang/AST/ExprCXX.h"
Ted Kremenek2719e982008-06-17 02:43:46 +000023#include "clang/AST/ExprObjC.h"
24
Chris Lattner4b009652007-07-25 00:24:17 +000025#include <vector>
Daniel Dunbar879788d2008-08-04 16:51:22 +000026#include <map>
Chris Lattner4b009652007-07-25 00:24:17 +000027
Daniel Dunbard916e6e2008-11-01 01:53:16 +000028#include "CGBuilder.h"
Daniel Dunbara8f02052008-09-08 21:33:45 +000029#include "CGCall.h"
Daniel Dunbara04840b2008-08-23 03:46:30 +000030#include "CGValue.h"
31
Chris Lattner4b009652007-07-25 00:24:17 +000032namespace llvm {
Daniel Dunbar64789f82008-08-11 05:35:13 +000033 class BasicBlock;
Chris Lattner4b009652007-07-25 00:24:17 +000034 class Module;
Daniel Dunbare9900eb2008-09-30 01:06:03 +000035 class SwitchInst;
Daniel Dunbar2668dd12008-11-19 09:36:46 +000036 class Value;
Chris Lattner4b009652007-07-25 00:24:17 +000037}
38
39namespace clang {
40 class ASTContext;
41 class Decl;
Daniel Dunbar64789f82008-08-11 05:35:13 +000042 class EnumConstantDecl;
Chris Lattner4b009652007-07-25 00:24:17 +000043 class FunctionDecl;
Daniel Dunbar64789f82008-08-11 05:35:13 +000044 class FunctionTypeProto;
45 class LabelStmt;
Fariborz Jahanian0adaa8a2009-01-10 21:06:09 +000046 class ObjCContainerDecl;
Daniel Dunbare856ac22008-09-24 04:00:38 +000047 class ObjCInterfaceDecl;
48 class ObjCIvarDecl;
Chris Lattnerb326b172008-03-30 23:03:07 +000049 class ObjCMethodDecl;
Fariborz Jahanian91dd9d32008-12-09 20:23:04 +000050 class ObjCImplementationDecl;
Daniel Dunbar6b57d432008-08-26 08:29:31 +000051 class ObjCPropertyImplDecl;
Chris Lattner4b009652007-07-25 00:24:17 +000052 class TargetInfo;
Daniel Dunbar64789f82008-08-11 05:35:13 +000053 class VarDecl;
Devang Patelaebd83f2007-10-23 02:10:49 +000054
Chris Lattner4b009652007-07-25 00:24:17 +000055namespace CodeGen {
56 class CodeGenModule;
Devang Patelaebd83f2007-10-23 02:10:49 +000057 class CodeGenTypes;
Daniel Dunbar9fc15a82009-02-02 21:43:58 +000058 class CGFunctionInfo;
Mike Stumpb699aa62009-02-08 23:14:22 +000059 class CGRecordLayout;
60
Chris Lattner4b009652007-07-25 00:24:17 +000061/// CodeGenFunction - This class organizes the per-function state that is used
62/// while generating LLVM code.
63class CodeGenFunction {
Chris Lattner41b1fca2007-08-26 23:13:56 +000064public:
Chris Lattner4b009652007-07-25 00:24:17 +000065 CodeGenModule &CGM; // Per-module state.
66 TargetInfo &Target;
Mike Stumpb699aa62009-02-08 23:14:22 +000067
Chris Lattner5280c5f2007-08-21 16:57:55 +000068 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Daniel Dunbard916e6e2008-11-01 01:53:16 +000069 CGBuilderTy Builder;
Mike Stumpb699aa62009-02-08 23:14:22 +000070
Chris Lattner6e6a5972008-04-04 04:07:35 +000071 // Holds the Decl for the current function or method
Chris Lattner8c7c6a12008-06-17 18:05:57 +000072 const Decl *CurFuncDecl;
Daniel Dunbar6ee022b2009-02-02 22:03:45 +000073 const CGFunctionInfo *CurFnInfo;
Chris Lattnerb326b172008-03-30 23:03:07 +000074 QualType FnRetTy;
Chris Lattner4b009652007-07-25 00:24:17 +000075 llvm::Function *CurFn;
76
Daniel Dunbar9fb751f2008-09-09 21:00:17 +000077 /// ReturnBlock - Unified return block.
78 llvm::BasicBlock *ReturnBlock;
Mike Stumpb699aa62009-02-08 23:14:22 +000079 /// ReturnValue - The temporary alloca to hold the return value. This is null
80 /// iff the function has no return value.
Daniel Dunbar9fb751f2008-09-09 21:00:17 +000081 llvm::Instruction *ReturnValue;
Mike Stumpb699aa62009-02-08 23:14:22 +000082
Chris Lattner4b009652007-07-25 00:24:17 +000083 /// AllocaInsertPoint - This is an instruction in the entry block before which
84 /// we prefer to insert allocas.
85 llvm::Instruction *AllocaInsertPt;
Daniel Dunbar879788d2008-08-04 16:51:22 +000086
Chris Lattner4b009652007-07-25 00:24:17 +000087 const llvm::Type *LLVMIntTy;
Hartmut Kaiserff08d2c2007-10-17 15:00:17 +000088 uint32_t LLVMPointerWidth;
Daniel Dunbar83544842008-09-28 01:03:14 +000089
90public:
Mike Stumpb699aa62009-02-08 23:14:22 +000091 // FIXME: The following should be private once EH code is moved out of NeXT
92 // runtime.
Daniel Dunbar83544842008-09-28 01:03:14 +000093
Mike Stumpb699aa62009-02-08 23:14:22 +000094 // ObjCEHStack - This keeps track of which object to rethrow from inside
95 // @catch blocks and which @finally block exits from an EH scope should be
96 // chained through.
Daniel Dunbar83544842008-09-28 01:03:14 +000097 struct ObjCEHEntry {
Anders Carlsson8559de12009-02-07 21:26:04 +000098 ObjCEHEntry(llvm::BasicBlock *fb, llvm::SwitchInst *fs, llvm::Value *dc)
Mike Stumpb699aa62009-02-08 23:14:22 +000099 : FinallyBlock(fb), FinallySwitch(fs),
Anders Carlssonecd81832009-02-07 21:37:21 +0000100 DestCode(dc) {}
Daniel Dunbar83544842008-09-28 01:03:14 +0000101
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000102 /// Entry point to the finally block.
Mike Stumpb699aa62009-02-08 23:14:22 +0000103 llvm::BasicBlock *FinallyBlock;
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000104
Mike Stumpb699aa62009-02-08 23:14:22 +0000105 /// Switch instruction which runs at the end of the finally block to forward
106 /// jumps through the finally block.
107 llvm::SwitchInst *FinallySwitch;
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000108
Mike Stumpb699aa62009-02-08 23:14:22 +0000109 /// Variable holding the code for the destination of a jump through the
110 /// @finally block.
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000111 llvm::Value *DestCode;
Daniel Dunbar83544842008-09-28 01:03:14 +0000112 };
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000113
Mike Stumpb699aa62009-02-08 23:14:22 +0000114 /// ObjCEHValueStack - Stack of exception objects being handled, during IR
115 /// generation for a @catch block.
Anders Carlssonecd81832009-02-07 21:37:21 +0000116 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack;
Mike Stumpb699aa62009-02-08 23:14:22 +0000117
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000118 typedef llvm::SmallVector<ObjCEHEntry*, 8> ObjCEHStackType;
119 ObjCEHStackType ObjCEHStack;
120
Mike Stumpb699aa62009-02-08 23:14:22 +0000121 /// EmitJumpThroughFinally - Emit a branch from the current insert point
122 /// through the finally handling code for \arg Entry and then on to \arg
123 /// Dest. It is legal to call this function even if there is no current
124 /// insertion point.
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000125 ///
Mike Stumpb699aa62009-02-08 23:14:22 +0000126 /// \param ExecuteTryExit - When true, the try_exit runtime function should be
127 /// called prior to executing the finally code.
Anders Carlssone833eba2009-02-08 22:25:30 +0000128 void EmitJumpThroughFinally(ObjCEHEntry *Entry, llvm::BasicBlock *Dest);
Mike Stumpb699aa62009-02-08 23:14:22 +0000129
Anders Carlssone833eba2009-02-08 22:25:30 +0000130 void EmitJumpThroughFinally(llvm::BasicBlock *Dest);
Chris Lattner4b009652007-07-25 00:24:17 +0000131
Anders Carlsson459ee362009-02-08 03:22:36 +0000132 /// PushCleanupBlock - Push a new cleanup entry on the stack and set the
133 /// passed in block as the cleanup block.
134 void PushCleanupBlock(llvm::BasicBlock *CleanupBlock);
Anders Carlssondf274192009-02-08 07:46:24 +0000135
Mike Stumpb699aa62009-02-08 23:14:22 +0000136 /// CleanupBlockInfo - A struct representing a popped cleanup block.
Anders Carlssondf274192009-02-08 07:46:24 +0000137 struct CleanupBlockInfo {
138 /// CleanupBlock - the cleanup block
139 llvm::BasicBlock *CleanupBlock;
Mike Stumpb699aa62009-02-08 23:14:22 +0000140
141 /// SwitchBlock - the block (if any) containing the switch instruction used
142 /// for jumping to the final destination.
Anders Carlssondf274192009-02-08 07:46:24 +0000143 llvm::BasicBlock *SwitchBlock;
Mike Stumpb699aa62009-02-08 23:14:22 +0000144
Anders Carlssondf274192009-02-08 07:46:24 +0000145 /// EndBlock - the default destination for the switch instruction.
146 llvm::BasicBlock *EndBlock;
Mike Stumpb699aa62009-02-08 23:14:22 +0000147
148 CleanupBlockInfo(llvm::BasicBlock *cb, llvm::BasicBlock *sb,
Anders Carlssondf274192009-02-08 07:46:24 +0000149 llvm::BasicBlock *eb)
150 : CleanupBlock(cb), SwitchBlock(sb), EndBlock(eb) {}
151 };
152
153 /// PopCleanupBlock - Will pop the cleanup entry on the stack, process all
Mike Stumpb699aa62009-02-08 23:14:22 +0000154 /// branch fixups and return a block info struct with the switch block and end
155 /// block.
Anders Carlssondf274192009-02-08 07:46:24 +0000156 CleanupBlockInfo PopCleanupBlock();
Mike Stumpb699aa62009-02-08 23:14:22 +0000157
158 /// CleanupScope - RAII object that will create a cleanup block and set the
159 /// insert point to that block. When destructed, it sets the insert point to
160 /// the previous block and pushes a new cleanup entry on the stack.
Anders Carlssonca2fec62009-02-07 23:30:41 +0000161 class CleanupScope {
162 CodeGenFunction& CGF;
163 llvm::BasicBlock *CurBB;
Anders Carlsson459ee362009-02-08 03:22:36 +0000164 llvm::BasicBlock *CleanupBB;
Mike Stumpb699aa62009-02-08 23:14:22 +0000165
Anders Carlssonca2fec62009-02-07 23:30:41 +0000166 public:
167 CleanupScope(CodeGenFunction &cgf)
168 : CGF(cgf), CurBB(CGF.Builder.GetInsertBlock()) {
Anders Carlsson459ee362009-02-08 03:22:36 +0000169 CleanupBB = CGF.createBasicBlock("cleanup");
170 CGF.Builder.SetInsertPoint(CleanupBB);
Anders Carlssonca2fec62009-02-07 23:30:41 +0000171 }
Mike Stumpb699aa62009-02-08 23:14:22 +0000172
Anders Carlssonca2fec62009-02-07 23:30:41 +0000173 ~CleanupScope() {
Anders Carlsson459ee362009-02-08 03:22:36 +0000174 CGF.PushCleanupBlock(CleanupBB);
Anders Carlssonca2fec62009-02-07 23:30:41 +0000175 CGF.Builder.SetInsertPoint(CurBB);
176 }
177 };
178
Anders Carlsson883fa552009-02-07 23:50:39 +0000179 /// EmitCleanupBlocks - Takes the old cleanup stack size and emits the cleanup
180 /// blocks that have been added.
181 void EmitCleanupBlocks(size_t OldCleanupStackSize);
182
Anders Carlssoned536bc2009-02-08 00:50:42 +0000183 /// EmitBranchThroughCleanup - Emit a branch from the current insert block
184 /// through the cleanup handling code (if any) and then on to \arg Dest.
185 ///
Mike Stumpb699aa62009-02-08 23:14:22 +0000186 /// FIXME: Maybe this should really be in EmitBranch? Don't we always want
Anders Carlssoned536bc2009-02-08 00:50:42 +0000187 /// this behavior for branches?
188 void EmitBranchThroughCleanup(llvm::BasicBlock *Dest);
Mike Stumpb699aa62009-02-08 23:14:22 +0000189
Chris Lattner9fba49a2007-08-24 05:35:26 +0000190private:
Mike Stumpb699aa62009-02-08 23:14:22 +0000191 /// LabelIDs - Track arbitrary ids assigned to labels for use in implementing
192 /// the GCC address-of-label extension and indirect goto. IDs are assigned to
193 /// labels inside getIDForAddrOfLabel().
Daniel Dunbar879788d2008-08-04 16:51:22 +0000194 std::map<const LabelStmt*, unsigned> LabelIDs;
195
196 /// IndirectSwitches - Record the list of switches for indirect
Mike Stumpb699aa62009-02-08 23:14:22 +0000197 /// gotos. Emission of the actual switching code needs to be delayed until all
198 /// AddrLabelExprs have been seen.
Daniel Dunbar879788d2008-08-04 16:51:22 +0000199 std::vector<llvm::SwitchInst*> IndirectSwitches;
200
Mike Stumpb699aa62009-02-08 23:14:22 +0000201 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
202 /// decls.
Chris Lattner4b009652007-07-25 00:24:17 +0000203 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
204
205 /// LabelMap - This keeps track of the LLVM basic block for each C label.
206 llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
Mike Stumpb699aa62009-02-08 23:14:22 +0000207
Mike Stumpb699aa62009-02-08 23:14:22 +0000208 // BreakContinueStack - This keeps track of where break and continue
Anders Carlsson7c314902009-02-10 05:52:02 +0000209 // statements should jump to.
Chris Lattner4b009652007-07-25 00:24:17 +0000210 struct BreakContinue {
Anders Carlsson7c314902009-02-10 05:52:02 +0000211 BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb)
212 : BreakBlock(bb), ContinueBlock(cb) {}
Mike Stumpb699aa62009-02-08 23:14:22 +0000213
Chris Lattner4b009652007-07-25 00:24:17 +0000214 llvm::BasicBlock *BreakBlock;
215 llvm::BasicBlock *ContinueBlock;
Mike Stumpb699aa62009-02-08 23:14:22 +0000216 };
Chris Lattner4b009652007-07-25 00:24:17 +0000217 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
Daniel Dunbar83544842008-09-28 01:03:14 +0000218
Mike Stumpb699aa62009-02-08 23:14:22 +0000219 /// SwitchInsn - This is nearest current switch instruction. It is null if if
220 /// current context is not in a switch.
Devang Patele58e0802007-10-04 23:45:31 +0000221 llvm::SwitchInst *SwitchInsn;
222
Mike Stumpb699aa62009-02-08 23:14:22 +0000223 /// CaseRangeBlock - This block holds if condition check for last case
Devang Patelbc372382007-10-09 17:08:50 +0000224 /// statement range in current switch instruction.
Devang Patel347ca322007-10-08 20:57:48 +0000225 llvm::BasicBlock *CaseRangeBlock;
226
Mike Stumpb699aa62009-02-08 23:14:22 +0000227 // VLASizeMap - This keeps track of the associated size for each VLA type.
228 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
229 // enter/leave scopes.
Anders Carlsson32aa0c22008-12-12 07:19:02 +0000230 llvm::DenseMap<const VariableArrayType*, llvm::Value*> VLASizeMap;
Mike Stumpb699aa62009-02-08 23:14:22 +0000231
232 /// StackDepth - This keeps track of the stack depth. It is used to notice
233 /// when control flow results in a change in stack depth and to arrange for
234 /// the appropriate stack depth to be restored. VLAs are the primary means by
235 /// which the stack depth changes.
Mike Stump88ad9112009-02-07 12:52:26 +0000236 llvm::Value *StackDepth;
237
Anders Carlsson60c4c402009-02-09 20:20:56 +0000238 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
239 /// calling llvm.stacksave for multiple VLAs in the same scope.
240 bool DidCallStackSave;
241
Anders Carlsson438ddd82008-12-12 05:52:00 +0000242 /// StackSaveValues - A stack(!) of stack save values. When a new scope is
Mike Stumpb699aa62009-02-08 23:14:22 +0000243 /// entered, a null is pushed on this stack. If a VLA is emitted, then the
244 /// return value of llvm.stacksave() is stored at the top of this stack.
Anders Carlsson438ddd82008-12-12 05:52:00 +0000245 llvm::SmallVector<llvm::Value*, 8> StackSaveValues;
Mike Stumpb699aa62009-02-08 23:14:22 +0000246
247 /// StackDepthMap - A association of stack depth that will be in effect for
248 /// each label. If control flow is transferred to a label, we have to restore
249 /// the desired stack depth at the destination label, beore we transfer to
250 /// that label.
Mike Stump7e39f182009-02-08 09:22:19 +0000251 llvm::DenseMap<const void*, llvm::Value *> StackDepthMap;
252
Mike Stumpb699aa62009-02-08 23:14:22 +0000253 /// StackFixupAtLabel - Routine to adjust the stack to the depth the stack
254 /// should be at by the time we transfer control flow to the label. This is
255 /// called as we emit destinations for control flow, such as user labels for
256 /// goto statements and compiler generated labels for break and continue
257 /// processsing. We return true, if for any reason we can't generate code for
258 /// the construct yet. See EmitStackUpdate for the paired routine to mark the
259 /// branch.
Mike Stump7e39f182009-02-08 09:22:19 +0000260 bool StackFixupAtLabel(const void *);
Mike Stump88ad9112009-02-07 12:52:26 +0000261
Mike Stumpb699aa62009-02-08 23:14:22 +0000262 /// EmitStackUpdate - Routine to adjust the stack to the depth the stack
263 /// should be at by the time we transfer control flow to the label. This is
264 /// called just before emitting branches for user level goto processing,
265 /// branhes for break or continue processing. The llvm::value overload is
266 /// used when handling break and continue, as we know the stack depth
267 /// directly. We return true, if for any reason we can't generate code for
268 /// the construct yet. See StackFixupAtLabel for the paired routine to mark
269 /// the destinations.
Mike Stump7e39f182009-02-08 09:22:19 +0000270 bool EmitStackUpdate(llvm::Value *V);
271 bool EmitStackUpdate(const void *S);
Mike Stump88ad9112009-02-07 12:52:26 +0000272
Anders Carlsson9c5b2a42009-02-07 22:53:43 +0000273 struct CleanupEntry {
274 /// CleanupBlock - The block of code that does the actual cleanup.
275 llvm::BasicBlock *CleanupBlock;
Mike Stumpb699aa62009-02-08 23:14:22 +0000276
Anders Carlsson9c5b2a42009-02-07 22:53:43 +0000277 /// Blocks - Basic blocks that were emitted in the current cleanup scope.
Anders Carlssondf274192009-02-08 07:46:24 +0000278 std::vector<llvm::BasicBlock *> Blocks;
Anders Carlsson9c5b2a42009-02-07 22:53:43 +0000279
280 /// BranchFixups - Branch instructions to basic blocks that haven't been
281 /// inserted into the current function yet.
Anders Carlssondf274192009-02-08 07:46:24 +0000282 std::vector<llvm::BranchInst *> BranchFixups;
Anders Carlsson9c5b2a42009-02-07 22:53:43 +0000283
284 explicit CleanupEntry(llvm::BasicBlock *cb)
285 : CleanupBlock(cb) {}
Mike Stumpb699aa62009-02-08 23:14:22 +0000286
Anders Carlssone7de3522009-02-08 00:16:35 +0000287 ~CleanupEntry() {
288 assert(Blocks.empty() && "Did not empty blocks!");
289 assert(BranchFixups.empty() && "Did not empty branch fixups!");
290 }
Anders Carlsson9c5b2a42009-02-07 22:53:43 +0000291 };
Mike Stumpb699aa62009-02-08 23:14:22 +0000292
Anders Carlsson9c5b2a42009-02-07 22:53:43 +0000293 /// CleanupEntries - Stack of cleanup entries.
294 llvm::SmallVector<CleanupEntry, 8> CleanupEntries;
295
Anders Carlssone7de3522009-02-08 00:16:35 +0000296 typedef llvm::DenseMap<llvm::BasicBlock*, size_t> BlockScopeMap;
297
298 /// BlockScopes - Map of which "cleanup scope" scope basic blocks have.
299 BlockScopeMap BlockScopes;
Mike Stumpb699aa62009-02-08 23:14:22 +0000300
Chris Lattner4b009652007-07-25 00:24:17 +0000301public:
302 CodeGenFunction(CodeGenModule &cgm);
Mike Stumpb699aa62009-02-08 23:14:22 +0000303
Chris Lattner4b009652007-07-25 00:24:17 +0000304 ASTContext &getContext() const;
305
Chris Lattnerb326b172008-03-30 23:03:07 +0000306 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000307
Mike Stumpb699aa62009-02-08 23:14:22 +0000308 void StartObjCMethod(const ObjCMethodDecl *MD,
Fariborz Jahanian0adaa8a2009-01-10 21:06:09 +0000309 const ObjCContainerDecl *CD);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000310
Mike Stumpb699aa62009-02-08 23:14:22 +0000311 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
Fariborz Jahanian91dd9d32008-12-09 20:23:04 +0000312 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
313 const ObjCPropertyImplDecl *PID);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000314
Mike Stumpb699aa62009-02-08 23:14:22 +0000315 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
316 /// for the given property.
Fariborz Jahanian91dd9d32008-12-09 20:23:04 +0000317 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
318 const ObjCPropertyImplDecl *PID);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000319
Daniel Dunbar7bf5b3d2008-07-29 23:18:29 +0000320 void GenerateCode(const FunctionDecl *FD,
321 llvm::Function *Fn);
Mike Stumpb699aa62009-02-08 23:14:22 +0000322 void StartFunction(const Decl *D, QualType RetTy,
Daniel Dunbar96816832008-09-09 23:14:03 +0000323 llvm::Function *Fn,
Daniel Dunbar54968bf2008-10-18 18:22:23 +0000324 const FunctionArgList &Args,
325 SourceLocation StartLoc);
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000326
Mike Stumpb699aa62009-02-08 23:14:22 +0000327 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
328 /// emission when possible.
Daniel Dunbar924f4ea2009-01-26 23:27:52 +0000329 void EmitReturnBlock();
330
Mike Stumpb699aa62009-02-08 23:14:22 +0000331 /// FinishFunction - Complete IR generation of the current function. It is
332 /// legal to call this function even if there is no current insertion point.
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000333 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Daniel Dunbarfc1a9c42008-09-09 23:27:19 +0000334
Mike Stumpb699aa62009-02-08 23:14:22 +0000335 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
336 /// arguments for the given function. This is also responsible for naming the
337 /// LLVM function arguments.
Daniel Dunbar6ee022b2009-02-02 22:03:45 +0000338 void EmitFunctionProlog(const CGFunctionInfo &FI,
339 llvm::Function *Fn,
Daniel Dunbarfc1a9c42008-09-09 23:27:19 +0000340 const FunctionArgList &Args);
341
Mike Stumpb699aa62009-02-08 23:14:22 +0000342 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
343 /// given temporary.
Daniel Dunbar6ee022b2009-02-02 22:03:45 +0000344 void EmitFunctionEpilog(const CGFunctionInfo &FI, llvm::Value *ReturnValue);
Daniel Dunbarfc1a9c42008-09-09 23:27:19 +0000345
Daniel Dunbar706059f2009-02-03 23:03:55 +0000346 const llvm::Type *ConvertTypeForMem(QualType T);
Chris Lattner4b009652007-07-25 00:24:17 +0000347 const llvm::Type *ConvertType(QualType T);
Chris Lattner6e6a5972008-04-04 04:07:35 +0000348
Mike Stumpb699aa62009-02-08 23:14:22 +0000349 /// LoadObjCSelf - Load the value of self. This function is only valid while
350 /// generating code for an Objective-C method.
Chris Lattner6e6a5972008-04-04 04:07:35 +0000351 llvm::Value *LoadObjCSelf();
Mike Stumpb699aa62009-02-08 23:14:22 +0000352
353 /// TypeOfSelfObject - Return type of object that this self represents.
Fariborz Jahanian55343922009-02-03 00:09:52 +0000354 QualType TypeOfSelfObject();
Chris Lattner8c7c6a12008-06-17 18:05:57 +0000355
356 /// isObjCPointerType - Return true if the specificed AST type will map onto
357 /// some Objective-C pointer type.
358 static bool isObjCPointerType(QualType T);
359
Chris Lattner4b009652007-07-25 00:24:17 +0000360 /// hasAggregateLLVMType - Return true if the specified AST type will map into
361 /// an aggregate LLVM type or is void.
362 static bool hasAggregateLLVMType(QualType T);
Daniel Dunbar72f96552008-11-11 02:29:29 +0000363
364 /// createBasicBlock - Create an LLVM basic block.
Mike Stumpb699aa62009-02-08 23:14:22 +0000365 llvm::BasicBlock *createBasicBlock(const char *Name="",
Daniel Dunbar72f96552008-11-11 02:29:29 +0000366 llvm::Function *Parent=0,
367 llvm::BasicBlock *InsertBefore=0) {
Daniel Dunbar4dcabf32008-11-12 00:01:12 +0000368#ifdef NDEBUG
369 return llvm::BasicBlock::Create("", Parent, InsertBefore);
370#else
Daniel Dunbar72f96552008-11-11 02:29:29 +0000371 return llvm::BasicBlock::Create(Name, Parent, InsertBefore);
Daniel Dunbar4dcabf32008-11-12 00:01:12 +0000372#endif
Daniel Dunbar72f96552008-11-11 02:29:29 +0000373 }
Mike Stumpb699aa62009-02-08 23:14:22 +0000374
Chris Lattner4b009652007-07-25 00:24:17 +0000375 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
376 /// label maps to.
377 llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
Mike Stumpb699aa62009-02-08 23:14:22 +0000378
379 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
380 /// adding a fall-through branch from the current insert block if
381 /// necessary. It is legal to call this function even if there is no current
382 /// insertion point.
Daniel Dunbare2202612008-11-13 01:24:05 +0000383 ///
Mike Stumpb699aa62009-02-08 23:14:22 +0000384 /// IsFinished - If true, indicates that the caller has finished emitting
385 /// branches to the given block and does not expect to emit code into it. This
386 /// means the block can be ignored if it is unreachable.
Daniel Dunbare2202612008-11-13 01:24:05 +0000387 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
Daniel Dunbara2209a62008-11-11 04:34:23 +0000388
Mike Stumpb699aa62009-02-08 23:14:22 +0000389 /// EmitBranch - Emit a branch to the specified basic block from the current
390 /// insert block, taking care to avoid creation of branches from dummy
391 /// blocks. It is legal to call this function even if there is no current
392 /// insertion point.
Daniel Dunbarc55b7c52008-11-11 22:06:59 +0000393 ///
Mike Stumpb699aa62009-02-08 23:14:22 +0000394 /// This function clears the current insertion point. The caller should follow
395 /// calls to this function with calls to Emit*Block prior to generation new
396 /// code.
Daniel Dunbar5276caa2008-11-11 09:41:28 +0000397 void EmitBranch(llvm::BasicBlock *Block);
398
Mike Stumpb699aa62009-02-08 23:14:22 +0000399 /// HaveInsertPoint - True if an insertion point is defined. If not, this
400 /// indicates that the current code being emitted is unreachable.
401 bool HaveInsertPoint() const {
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000402 return Builder.GetInsertBlock() != 0;
403 }
404
Mike Stumpb699aa62009-02-08 23:14:22 +0000405 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
406 /// emitted IR has a place to go. Note that by definition, if this function
407 /// creates a block then that block is unreachable; callers may do better to
408 /// detect when no insertion point is defined and simply skip IR generation.
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000409 void EnsureInsertPoint() {
410 if (!HaveInsertPoint())
411 EmitBlock(createBasicBlock());
412 }
Mike Stumpb699aa62009-02-08 23:14:22 +0000413
Daniel Dunbar9503b782008-08-16 00:56:44 +0000414 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner9d4e6202007-12-02 01:43:38 +0000415 /// specified stmt yet.
Daniel Dunbar49bddf72008-09-04 03:43:08 +0000416 void ErrorUnsupported(const Stmt *S, const char *Type,
417 bool OmitOnError=false);
Chris Lattner4b009652007-07-25 00:24:17 +0000418
419 //===--------------------------------------------------------------------===//
420 // Helpers
421 //===--------------------------------------------------------------------===//
Mike Stumpb699aa62009-02-08 23:14:22 +0000422
Chris Lattner4b009652007-07-25 00:24:17 +0000423 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
424 /// block.
425 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
426 const char *Name = "tmp");
Mike Stumpb699aa62009-02-08 23:14:22 +0000427
Chris Lattner4b009652007-07-25 00:24:17 +0000428 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
429 /// expression and compare the result against zero, returning an Int1Ty value.
430 llvm::Value *EvaluateExprAsBool(const Expr *E);
431
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000432 /// EmitAnyExpr - Emit code to compute the specified expression which can have
433 /// any type. The result is returned as an RValue struct. If this is an
434 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
435 /// the result should be returned.
Mike Stumpb699aa62009-02-08 23:14:22 +0000436 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000437 bool isAggLocVolatile = false);
Devang Patel97299362007-09-28 21:49:18 +0000438
Mike Stumpb699aa62009-02-08 23:14:22 +0000439 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
440 // or the value of the expression, depending on how va_list is defined.
Eli Friedman8f5e8782009-01-20 17:46:04 +0000441 llvm::Value *EmitVAListRef(const Expr *E);
442
Mike Stumpb699aa62009-02-08 23:14:22 +0000443 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
444 /// always be accessible even if no aggregate location is provided.
445 RValue EmitAnyExprToTemp(const Expr *E, llvm::Value *AggLoc = 0,
Daniel Dunbar0a2da0f2008-09-09 01:06:48 +0000446 bool isAggLocVolatile = false);
447
Daniel Dunbarbde0c9d2008-09-09 20:49:46 +0000448 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
449 QualType EltTy);
450
451 void EmitAggregateClear(llvm::Value *DestPtr, QualType Ty);
452
Devang Patele58e0802007-10-04 23:45:31 +0000453 /// StartBlock - Start new block named N. If insert block is a dummy block
454 /// then reuse it.
455 void StartBlock(const char *N);
456
Devang Patel7a78e432007-11-01 19:11:01 +0000457 /// getCGRecordLayout - Return record layout info.
458 const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
Lauro Ramos Venancio934fb022008-02-26 21:41:45 +0000459
460 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
Steve Naroff72a6ebc2008-04-15 22:42:06 +0000461 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD);
Dan Gohman4751a3a2008-05-22 00:50:06 +0000462
Anders Carlsson75d86732008-09-11 09:15:33 +0000463 /// GetAddrOfLocalVar - Return the address of a local variable.
464 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD);
Mike Stumpb699aa62009-02-08 23:14:22 +0000465
Dan Gohman4751a3a2008-05-22 00:50:06 +0000466 /// getAccessedFieldNo - Given an encoded value and a result number, return
467 /// the input field number being accessed.
468 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
469
Daniel Dunbar879788d2008-08-04 16:51:22 +0000470 unsigned GetIDForAddrOfLabel(const LabelStmt *L);
471
Mike Stumpb699aa62009-02-08 23:14:22 +0000472 /// EmitMemSetToZero - Generate code to memset a value of the given type to 0.
Anders Carlsson82b0d0c2008-08-30 19:51:14 +0000473 void EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty);
Anders Carlsson285611e2008-11-04 05:30:00 +0000474
475 // EmitVAArg - Generate code to get an argument from the passed in pointer
476 // and update it accordingly. The return value is a pointer to the argument.
477 // FIXME: We should be able to get rid of this method and use the va_arg
Mike Stumpb699aa62009-02-08 23:14:22 +0000478 // instruction in LLVM instead once it works well enough.
Anders Carlsson285611e2008-11-04 05:30:00 +0000479 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
Anders Carlssonf860e022008-12-20 20:27:15 +0000480
Anders Carlssond9767612008-12-20 20:46:34 +0000481 // EmitVLASize - Generate code for any VLA size expressions that might occur
482 // in a variably modified type. If Ty is a VLA, will return the value that
483 // corresponds to the size in bytes of the VLA type. Will return 0 otherwise.
484 llvm::Value *EmitVLASize(QualType Ty);
Mike Stumpb699aa62009-02-08 23:14:22 +0000485
Anders Carlsson32aa0c22008-12-12 07:19:02 +0000486 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes
487 // of a variable length array type.
488 llvm::Value *GetVLASize(const VariableArrayType *);
489
Chris Lattner4b009652007-07-25 00:24:17 +0000490 //===--------------------------------------------------------------------===//
Chris Lattner4b009652007-07-25 00:24:17 +0000491 // Declaration Emission
492 //===--------------------------------------------------------------------===//
Mike Stumpb699aa62009-02-08 23:14:22 +0000493
Chris Lattner4b009652007-07-25 00:24:17 +0000494 void EmitDecl(const Decl &D);
Steve Naroff72a6ebc2008-04-15 22:42:06 +0000495 void EmitBlockVarDecl(const VarDecl &D);
496 void EmitLocalBlockVarDecl(const VarDecl &D);
497 void EmitStaticBlockVarDecl(const VarDecl &D);
Daniel Dunbarace33292008-08-16 03:19:19 +0000498
499 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
500 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg);
Mike Stumpb699aa62009-02-08 23:14:22 +0000501
Chris Lattner4b009652007-07-25 00:24:17 +0000502 //===--------------------------------------------------------------------===//
503 // Statement Emission
504 //===--------------------------------------------------------------------===//
505
Mike Stumpb699aa62009-02-08 23:14:22 +0000506 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Daniel Dunbar6c81e562008-11-12 08:21:33 +0000507 void EmitStopPoint(const Stmt *S);
508
Mike Stumpb699aa62009-02-08 23:14:22 +0000509 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
510 /// this function even if there is no current insertion point.
511 ///
512 /// This function may clear the current insertion point; callers should use
513 /// EnsureInsertPoint if they wish to subsequently generate code without first
514 /// calling EmitBlock, EmitBranch, or EmitStmt.
Chris Lattner4b009652007-07-25 00:24:17 +0000515 void EmitStmt(const Stmt *S);
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000516
Daniel Dunbar6c81e562008-11-12 08:21:33 +0000517 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
Mike Stumpb699aa62009-02-08 23:14:22 +0000518 /// necessarily require an insertion point or debug information; typically
519 /// because the statement amounts to a jump or a container of other
520 /// statements.
Daniel Dunbar6c81e562008-11-12 08:21:33 +0000521 ///
522 /// \return True if the statement was handled.
523 bool EmitSimpleStmt(const Stmt *S);
524
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000525 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
526 llvm::Value *AggLoc = 0, bool isAggVol = false);
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000527
Mike Stumpb699aa62009-02-08 23:14:22 +0000528 /// EmitLabel - Emit the block for the given label. It is legal to call this
529 /// function even if there is no current insertion point.
Chris Lattner09cee852008-07-26 20:23:23 +0000530 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt.
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000531
Chris Lattner4b009652007-07-25 00:24:17 +0000532 void EmitLabelStmt(const LabelStmt &S);
533 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar879788d2008-08-04 16:51:22 +0000534 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Chris Lattner4b009652007-07-25 00:24:17 +0000535 void EmitIfStmt(const IfStmt &S);
536 void EmitWhileStmt(const WhileStmt &S);
537 void EmitDoStmt(const DoStmt &S);
538 void EmitForStmt(const ForStmt &S);
539 void EmitReturnStmt(const ReturnStmt &S);
540 void EmitDeclStmt(const DeclStmt &S);
Daniel Dunbar6c81e562008-11-12 08:21:33 +0000541 void EmitBreakStmt(const BreakStmt &S);
542 void EmitContinueStmt(const ContinueStmt &S);
Devang Patele58e0802007-10-04 23:45:31 +0000543 void EmitSwitchStmt(const SwitchStmt &S);
544 void EmitDefaultStmt(const DefaultStmt &S);
545 void EmitCaseStmt(const CaseStmt &S);
Devang Patel347ca322007-10-08 20:57:48 +0000546 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlssonaf6a6c22008-02-05 16:35:33 +0000547 void EmitAsmStmt(const AsmStmt &S);
Mike Stumpb699aa62009-02-08 23:14:22 +0000548
Anders Carlsson82b0d0c2008-08-30 19:51:14 +0000549 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
Anders Carlssonb01a2112008-09-09 10:04:29 +0000550 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
551 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
Chris Lattnerdd978702008-11-15 21:26:17 +0000552 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
Mike Stumpb699aa62009-02-08 23:14:22 +0000553
Chris Lattner4b009652007-07-25 00:24:17 +0000554 //===--------------------------------------------------------------------===//
555 // LValue Expression Emission
556 //===--------------------------------------------------------------------===//
557
Daniel Dunbar900c85a2009-02-05 07:09:07 +0000558 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
559 RValue GetUndefRValue(QualType Ty);
560
Daniel Dunbare3a6a682009-01-09 16:50:52 +0000561 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
562 /// and issue an ErrorUnsupported style diagnostic (using the
563 /// provided Name).
564 RValue EmitUnsupportedRValue(const Expr *E,
565 const char *Name);
566
Mike Stumpb699aa62009-02-08 23:14:22 +0000567 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
568 /// an ErrorUnsupported style diagnostic (using the provided Name).
Daniel Dunbarde1bd942008-08-25 20:45:57 +0000569 LValue EmitUnsupportedLValue(const Expr *E,
570 const char *Name);
571
Chris Lattner4b009652007-07-25 00:24:17 +0000572 /// EmitLValue - Emit code to compute a designator that specifies the location
573 /// of the expression.
574 ///
575 /// This can return one of two things: a simple address or a bitfield
576 /// reference. In either case, the LLVM Value* in the LValue structure is
577 /// guaranteed to be an LLVM pointer type.
578 ///
579 /// If this returns a bitfield reference, nothing about the pointee type of
580 /// the LLVM value is known: For example, it may not be a pointer to an
581 /// integer.
582 ///
583 /// If this returns a normal address, and if the lvalue's C type is fixed
584 /// size, this method guarantees that the returned pointer type will point to
585 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
586 /// variable length type, this is not possible.
587 ///
588 LValue EmitLValue(const Expr *E);
Mike Stumpb699aa62009-02-08 23:14:22 +0000589
Daniel Dunbarf1c5d842009-02-10 00:57:50 +0000590 /// EmitLoadOfScalar - Load a scalar value from an address, taking
591 /// care to appropriately convert from the memory representation to
592 /// the LLVM value representation.
593 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
594 QualType Ty);
595
596 /// EmitStoreOfScalar - Store a scalar value to an address, taking
597 /// care to appropriately convert from the memory representation to
598 /// the LLVM value representation.
599 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
600 bool Volatile);
601
Chris Lattner4b009652007-07-25 00:24:17 +0000602 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
603 /// this method emits the address of the lvalue, then loads the result as an
604 /// rvalue, returning the rvalue.
Chris Lattner4b009652007-07-25 00:24:17 +0000605 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000606 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
Lauro Ramos Venanciob40307c2008-01-22 20:17:04 +0000607 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000608 RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType);
Fariborz Jahanianb0973da2008-11-22 22:30:21 +0000609 RValue EmitLoadOfKVCRefLValue(LValue LV, QualType ExprType);
Chris Lattner4b009652007-07-25 00:24:17 +0000610
Mike Stumpb699aa62009-02-08 23:14:22 +0000611
Chris Lattner4b009652007-07-25 00:24:17 +0000612 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
613 /// lvalue, where both are guaranteed to the have the same type, and that type
614 /// is 'Ty'.
615 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000616 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
617 QualType Ty);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000618 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty);
Fariborz Jahanianb0973da2008-11-22 22:30:21 +0000619 void EmitStoreThroughKVCRefLValue(RValue Src, LValue Dst, QualType Ty);
Daniel Dunbar2668dd12008-11-19 09:36:46 +0000620
Mike Stumpb699aa62009-02-08 23:14:22 +0000621 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
622 /// EmitStoreThroughLValue.
Daniel Dunbar2668dd12008-11-19 09:36:46 +0000623 ///
Mike Stumpb699aa62009-02-08 23:14:22 +0000624 /// \param Result [out] - If non-null, this will be set to a Value* for the
625 /// bit-field contents after the store, appropriate for use as the result of
626 /// an assignment to the bit-field.
Daniel Dunbar2668dd12008-11-19 09:36:46 +0000627 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty,
628 llvm::Value **Result=0);
Mike Stumpb699aa62009-02-08 23:14:22 +0000629
Christopher Lambad327ba2007-12-29 05:02:41 +0000630 // Note: only availabe for agg return types
Daniel Dunbaref0d4c72008-09-04 03:20:13 +0000631 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
632 // Note: only availabe for agg return types
Christopher Lambad327ba2007-12-29 05:02:41 +0000633 LValue EmitCallExprLValue(const CallExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000634 LValue EmitDeclRefLValue(const DeclRefExpr *E);
635 LValue EmitStringLiteralLValue(const StringLiteral *E);
Daniel Dunbara9f0be22008-10-17 21:58:32 +0000636 LValue EmitPredefinedFunctionName(unsigned Type);
Chris Lattner69909292008-08-10 01:53:14 +0000637 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000638 LValue EmitUnaryOpLValue(const UnaryOperator *E);
639 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000640 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patelaebd83f2007-10-23 02:10:49 +0000641 LValue EmitMemberExpr(const MemberExpr *E);
Eli Friedmanf3c2cb42008-05-13 23:18:27 +0000642 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
Eli Friedmand3550112008-02-09 08:50:58 +0000643
Daniel Dunbare856ac22008-09-24 04:00:38 +0000644 llvm::Value *EmitIvarOffset(ObjCInterfaceDecl *Interface,
645 const ObjCIvarDecl *Ivar);
Eli Friedmand3550112008-02-09 08:50:58 +0000646 LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field,
Eli Friedman2e630542008-06-13 23:01:12 +0000647 bool isUnion, unsigned CVRQualifiers);
Fariborz Jahanian55343922009-02-03 00:09:52 +0000648 LValue EmitLValueForIvar(QualType ObjectTy,
649 llvm::Value* Base, const ObjCIvarDecl *Ivar,
Fariborz Jahanian86008c02008-12-15 20:35:07 +0000650 const FieldDecl *Field,
Daniel Dunbare856ac22008-09-24 04:00:38 +0000651 unsigned CVRQualifiers);
652
Fariborz Jahanian86008c02008-12-15 20:35:07 +0000653 LValue EmitLValueForBitfield(llvm::Value* Base, FieldDecl* Field,
Fariborz Jahanianc912eb72009-02-03 19:03:09 +0000654 unsigned CVRQualifiers);
Fariborz Jahanian86008c02008-12-15 20:35:07 +0000655
Argiris Kirtzidisbf615b02008-09-10 02:36:38 +0000656 LValue EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E);
657
Daniel Dunbar5e105892008-08-23 10:51:21 +0000658 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattnerb326b172008-03-30 23:03:07 +0000659 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000660 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
Fariborz Jahanianb0973da2008-11-22 22:30:21 +0000661 LValue EmitObjCKVCRefLValue(const ObjCKVCRefExpr *E);
Douglas Gregord8606632008-11-04 14:56:14 +0000662 LValue EmitObjCSuperExpr(const ObjCSuperExpr *E);
Daniel Dunbar5e105892008-08-23 10:51:21 +0000663
Chris Lattner4b009652007-07-25 00:24:17 +0000664 //===--------------------------------------------------------------------===//
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000665 // Scalar Expression Emission
Chris Lattner4b009652007-07-25 00:24:17 +0000666 //===--------------------------------------------------------------------===//
667
Mike Stumpb699aa62009-02-08 23:14:22 +0000668 /// EmitCall - Generate a call of the given function, expecting the given
669 /// result type, and using the given argument list which specifies both the
670 /// LLVM arguments and the types they were derived from.
Daniel Dunbar6ee022b2009-02-02 22:03:45 +0000671 RValue EmitCall(const CGFunctionInfo &FnInfo,
672 llvm::Value *Callee,
Daniel Dunbar0ed60b02008-08-30 03:02:31 +0000673 const CallArgList &Args);
674
Chris Lattner4b009652007-07-25 00:24:17 +0000675 RValue EmitCallExpr(const CallExpr *E);
Ted Kremenek2719e982008-06-17 02:43:46 +0000676
677 RValue EmitCallExpr(Expr *FnExpr, CallExpr::const_arg_iterator ArgBeg,
678 CallExpr::const_arg_iterator ArgEnd);
679
Eli Friedman261f4ad2008-01-30 01:32:06 +0000680 RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
Ted Kremenek2719e982008-06-17 02:43:46 +0000681 CallExpr::const_arg_iterator ArgBeg,
682 CallExpr::const_arg_iterator ArgEnd);
Mike Stumpb699aa62009-02-08 23:14:22 +0000683
Chris Lattner35055b82007-08-26 22:58:05 +0000684 RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000685
Mike Stumpb699aa62009-02-08 23:14:22 +0000686 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
687 /// is unhandled by the current target.
Daniel Dunbar1cdfe142008-10-10 00:24:54 +0000688 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
689
Anders Carlssone1449c12007-12-09 23:17:02 +0000690 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
691 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Mike Stumpb699aa62009-02-08 23:14:22 +0000692
Anders Carlssona9234fe2007-12-10 19:35:18 +0000693 llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
Nate Begemanec2d1062007-12-30 02:59:45 +0000694 llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
695 bool isSplat = false);
Mike Stumpb699aa62009-02-08 23:14:22 +0000696
Daniel Dunbarf1f7f192008-08-20 00:28:19 +0000697 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner9fba49a2007-08-24 05:35:26 +0000698 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Chris Lattner6ee20e32008-06-24 17:04:18 +0000699 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
Daniel Dunbara04840b2008-08-23 03:46:30 +0000700 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E);
Fariborz Jahanianf18d4c82008-11-22 18:39:36 +0000701 RValue EmitObjCPropertyGet(const Expr *E);
Fariborz Jahanianb0973da2008-11-22 22:30:21 +0000702 void EmitObjCPropertySet(const Expr *E, RValue Src);
Chris Lattner6ee20e32008-06-24 17:04:18 +0000703
704
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000705 //===--------------------------------------------------------------------===//
Chris Lattner41b1fca2007-08-26 23:13:56 +0000706 // Expression Emission
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000707 //===--------------------------------------------------------------------===//
Chris Lattner41b1fca2007-08-26 23:13:56 +0000708
709 // Expressions are broken into three classes: scalar, complex, aggregate.
Mike Stumpb699aa62009-02-08 23:14:22 +0000710
711 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
712 /// scalar type, returning the result.
Chris Lattner9fba49a2007-08-24 05:35:26 +0000713 llvm::Value *EmitScalarExpr(const Expr *E);
Mike Stumpb699aa62009-02-08 23:14:22 +0000714
Chris Lattner4e05d1e2007-08-26 06:48:56 +0000715 /// EmitScalarConversion - Emit a conversion from the specified type to the
716 /// specified destination type, both of which are LLVM scalar types.
717 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
718 QualType DstTy);
Mike Stumpb699aa62009-02-08 23:14:22 +0000719
Chris Lattnerfb182ee2007-08-26 16:34:22 +0000720 /// EmitComplexToScalarConversion - Emit a conversion from the specified
Mike Stumpb699aa62009-02-08 23:14:22 +0000721 /// complex type to the specified destination type, where the destination type
722 /// is an LLVM scalar type.
Chris Lattnerfb182ee2007-08-26 16:34:22 +0000723 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
724 QualType DstTy);
Mike Stumpb699aa62009-02-08 23:14:22 +0000725
726
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000727 /// EmitAggExpr - Emit the computation of the specified expression of
728 /// aggregate type. The result is computed into DestPtr. Note that if
729 /// DestPtr is null, the value of the aggregate expression is not needed.
730 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest);
Mike Stumpb699aa62009-02-08 23:14:22 +0000731
Chris Lattner8d0cc2f2007-08-21 05:54:00 +0000732 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner348c8a22007-08-23 23:43:33 +0000733 /// complex type, returning the result.
Chris Lattner5280c5f2007-08-21 16:57:55 +0000734 ComplexPairTy EmitComplexExpr(const Expr *E);
Mike Stumpb699aa62009-02-08 23:14:22 +0000735
Chris Lattner348c8a22007-08-23 23:43:33 +0000736 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
737 /// of complex type, storing into the specified Value*.
Chris Lattner8e1f6e02007-08-26 16:22:13 +0000738 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
739 bool DestIsVolatile);
Daniel Dunbardd851282008-08-30 05:35:15 +0000740
741 /// StoreComplexToAddr - Store a complex number into the specified address.
742 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
743 bool DestIsVolatile);
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000744 /// LoadComplexFromAddr - Load a complex number from the specified address.
745 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattner85970f32008-05-08 05:58:21 +0000746
Mike Stumpb699aa62009-02-08 23:14:22 +0000747 /// GenerateStaticBlockVarDecl - return the the static declaration of local
748 /// variable.
Sanjiv Guptaf7fd8e52009-02-03 18:07:49 +0000749 llvm::GlobalValue * GenerateStaticBlockVarDecl(const VarDecl &D,
750 bool NoInit,
751 const char *Separator,
752 llvm::GlobalValue
753 ::LinkageTypes Linkage);
Daniel Dunbar879788d2008-08-04 16:51:22 +0000754
Mike Stumpb699aa62009-02-08 23:14:22 +0000755 // GenerateStaticCXXBlockVarDecl - return the static declaration of a local
756 // variable. Performs initialization of the variable if necessary.
Anders Carlssonc9f8ccd2008-08-22 16:00:37 +0000757 llvm::GlobalValue *GenerateStaticCXXBlockVarDecl(const VarDecl &D);
758
Daniel Dunbar879788d2008-08-04 16:51:22 +0000759 //===--------------------------------------------------------------------===//
760 // Internal Helpers
761 //===--------------------------------------------------------------------===//
Mike Stumpb699aa62009-02-08 23:14:22 +0000762
Chris Lattner3f73d0d2008-11-11 07:41:27 +0000763 /// ContainsLabel - Return true if the statement contains a label in it. If
764 /// this statement is not executed normally, it not containing a label means
765 /// that we can just remove the code.
766 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
Mike Stumpb699aa62009-02-08 23:14:22 +0000767
Daniel Dunbar45e38672008-11-12 10:12:14 +0000768 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
Chris Lattner3d6606b2008-11-12 08:04:58 +0000769 /// to a constant, or if it does but contains a label, return 0. If it
770 /// constant folds to 'true' and does not contain a label, return 1, if it
771 /// constant folds to 'false' and does not contain a label, return -1.
772 int ConstantFoldsToSimpleInteger(const Expr *Cond);
Mike Stumpb699aa62009-02-08 23:14:22 +0000773
Chris Lattner3d6606b2008-11-12 08:04:58 +0000774 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
775 /// if statement) to the specified blocks. Based on the condition, this might
776 /// try to simplify the codegen of the conditional based on the branch.
Chris Lattner1875ba22008-11-12 07:46:33 +0000777 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
Daniel Dunbar45e38672008-11-12 10:12:14 +0000778 llvm::BasicBlock *FalseBlock);
Chris Lattner3d6606b2008-11-12 08:04:58 +0000779private:
Mike Stumpb699aa62009-02-08 23:14:22 +0000780
Daniel Dunbar879788d2008-08-04 16:51:22 +0000781 /// EmitIndirectSwitches - Emit code for all of the switch
782 /// instructions in IndirectSwitches.
783 void EmitIndirectSwitches();
Daniel Dunbar04d35782008-09-17 00:51:38 +0000784
Daniel Dunbare856ac22008-09-24 04:00:38 +0000785 void EmitReturnOfRValue(RValue RV, QualType Ty);
786
Daniel Dunbar04d35782008-09-17 00:51:38 +0000787 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
788 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
789 ///
790 /// \param AI - The first function argument of the expansion.
791 /// \return The argument following the last expanded function
792 /// argument.
Mike Stumpb699aa62009-02-08 23:14:22 +0000793 llvm::Function::arg_iterator
Daniel Dunbar04d35782008-09-17 00:51:38 +0000794 ExpandTypeFromArgs(QualType Ty, LValue Dst,
795 llvm::Function::arg_iterator AI);
796
Mike Stumpb699aa62009-02-08 23:14:22 +0000797 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg
798 /// Ty, into individual arguments on the provided vector \arg Args. See
799 /// ABIArgInfo::Expand.
800 void ExpandTypeToArgs(QualType Ty, RValue Src,
Daniel Dunbar04d35782008-09-17 00:51:38 +0000801 llvm::SmallVector<llvm::Value*, 16> &Args);
Anders Carlsson60bb4d42009-01-11 19:40:10 +0000802
803 llvm::Value* EmitAsmInput(const AsmStmt &S, TargetInfo::ConstraintInfo Info,
804 const Expr *InputExpr, std::string &ConstraintStr);
Mike Stumpb699aa62009-02-08 23:14:22 +0000805
Anders Carlsson883fa552009-02-07 23:50:39 +0000806 /// EmitCleanupBlock - emits a single cleanup block.
807 void EmitCleanupBlock();
808
Anders Carlssoned536bc2009-02-08 00:50:42 +0000809 /// AddBranchFixup - adds a branch instruction to the list of fixups for the
810 /// current cleanup scope.
811 void AddBranchFixup(llvm::BranchInst *BI);
Mike Stumpb699aa62009-02-08 23:14:22 +0000812
Chris Lattner4b009652007-07-25 00:24:17 +0000813};
814} // end namespace CodeGen
815} // end namespace clang
816
817#endif