blob: 1bacff2480bfdd30b3e5c3a3e2d785d8adda826d [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//
10// This is the internal per-function state used for llvm translation.
11//
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;
Devang Patel7a78e432007-11-01 19:11:01 +000059 class CGRecordLayout;
Daniel Dunbard916e6e2008-11-01 01:53:16 +000060
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;
Chris Lattner41b1fca2007-08-26 23:13:56 +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;
Chris Lattner4b009652007-07-25 00:24:17 +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;
Chris Lattnerb326b172008-03-30 23:03:07 +000073 QualType FnRetTy;
Chris Lattner4b009652007-07-25 00:24:17 +000074 llvm::Function *CurFn;
75
Daniel Dunbar9fb751f2008-09-09 21:00:17 +000076 /// ReturnBlock - Unified return block.
77 llvm::BasicBlock *ReturnBlock;
78 /// ReturnValue - The temporary alloca to hold the return value. This
79 /// is null iff the function has no return value.
80 llvm::Instruction *ReturnValue;
81
Chris Lattner4b009652007-07-25 00:24:17 +000082 /// AllocaInsertPoint - This is an instruction in the entry block before which
83 /// we prefer to insert allocas.
84 llvm::Instruction *AllocaInsertPt;
Daniel Dunbar879788d2008-08-04 16:51:22 +000085
Chris Lattner4b009652007-07-25 00:24:17 +000086 const llvm::Type *LLVMIntTy;
Hartmut Kaiserff08d2c2007-10-17 15:00:17 +000087 uint32_t LLVMPointerWidth;
Daniel Dunbar83544842008-09-28 01:03:14 +000088
89public:
90 // FIXME: The following should be private once EH code is moved out
91 // of NeXT runtime.
92
93 // ObjCEHStack - This keeps track of which object to rethrow from
94 // inside @catch blocks and which @finally block exits from an EH
95 // scope should be chained through.
96 struct ObjCEHEntry {
Daniel Dunbare9900eb2008-09-30 01:06:03 +000097 ObjCEHEntry(llvm::BasicBlock *fb, llvm::BasicBlock *fne,
98 llvm::SwitchInst *fs, llvm::Value *dc)
99 : FinallyBlock(fb), FinallyNoExit(fne), FinallySwitch(fs),
100 DestCode(dc), Exception(0) {}
Daniel Dunbar83544842008-09-28 01:03:14 +0000101
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000102 /// Entry point to the finally block.
103 llvm::BasicBlock *FinallyBlock;
104
105 /// Entry point to the finally block which skips execution of the
106 /// try_exit runtime function.
107 llvm::BasicBlock *FinallyNoExit;
108
109 /// Switch instruction which runs at the end of the finally block
110 /// to forward jumps through the finally block.
111 llvm::SwitchInst *FinallySwitch;
112
113 /// Variable holding the code for the destination of a jump
114 /// through the @finally block.
115 llvm::Value *DestCode;
116
117 /// The exception object being handled, during IR generation for a
118 /// @catch block.
119 llvm::Value *Exception;
Daniel Dunbar83544842008-09-28 01:03:14 +0000120 };
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000121
122 typedef llvm::SmallVector<ObjCEHEntry*, 8> ObjCEHStackType;
123 ObjCEHStackType ObjCEHStack;
124
125 /// EmitJumpThroughFinally - Emit a branch from the current insert
126 /// point through the finally handling code for \arg Entry and then
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000127 /// on to \arg Dest. It is legal to call this function even if there
128 /// is no current insertion point.
Daniel Dunbare9900eb2008-09-30 01:06:03 +0000129 ///
130 /// \param ExecuteTryExit - When true, the try_exit runtime function
131 /// should be called prior to executing the finally code.
132 void EmitJumpThroughFinally(ObjCEHEntry *Entry, llvm::BasicBlock *Dest,
133 bool ExecuteTryExit=true);
Chris Lattner4b009652007-07-25 00:24:17 +0000134
Chris Lattner9fba49a2007-08-24 05:35:26 +0000135private:
Daniel Dunbar879788d2008-08-04 16:51:22 +0000136 /// LabelIDs - Track arbitrary ids assigned to labels for use in
137 /// implementing the GCC address-of-label extension and indirect
138 /// goto. IDs are assigned to labels inside getIDForAddrOfLabel().
139 std::map<const LabelStmt*, unsigned> LabelIDs;
140
141 /// IndirectSwitches - Record the list of switches for indirect
142 /// gotos. Emission of the actual switching code needs to be delayed
143 /// until all AddrLabelExprs have been seen.
144 std::vector<llvm::SwitchInst*> IndirectSwitches;
145
Chris Lattner4b009652007-07-25 00:24:17 +0000146 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
147 /// decls.
148 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
149
150 /// LabelMap - This keeps track of the LLVM basic block for each C label.
151 llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
152
153 // BreakContinueStack - This keeps track of where break and continue
Anders Carlssonc2176192008-12-13 22:52:24 +0000154 // statements should jump to, as well as the size of the eh stack.
Chris Lattner4b009652007-07-25 00:24:17 +0000155 struct BreakContinue {
Anders Carlssonc2176192008-12-13 22:52:24 +0000156 BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb, size_t ehss)
157 : BreakBlock(bb), ContinueBlock(cb), EHStackSize(ehss) {}
Chris Lattner4b009652007-07-25 00:24:17 +0000158
159 llvm::BasicBlock *BreakBlock;
160 llvm::BasicBlock *ContinueBlock;
Anders Carlssonc2176192008-12-13 22:52:24 +0000161 size_t EHStackSize;
Chris Lattner4b009652007-07-25 00:24:17 +0000162 };
163 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
Daniel Dunbar83544842008-09-28 01:03:14 +0000164
Devang Patelbc372382007-10-09 17:08:50 +0000165 /// SwitchInsn - This is nearest current switch instruction. It is null if
166 /// if current context is not in a switch.
Devang Patele58e0802007-10-04 23:45:31 +0000167 llvm::SwitchInst *SwitchInsn;
168
Devang Patelbc372382007-10-09 17:08:50 +0000169 /// CaseRangeBlock - This block holds if condition check for last case
170 /// statement range in current switch instruction.
Devang Patel347ca322007-10-08 20:57:48 +0000171 llvm::BasicBlock *CaseRangeBlock;
172
Anders Carlsson32aa0c22008-12-12 07:19:02 +0000173 // VLASizeMap - This keeps track of the associated size for each VLA type
174 // FIXME: Maybe this could be a stack of maps that is pushed/popped as
175 // we enter/leave scopes.
176 llvm::DenseMap<const VariableArrayType*, llvm::Value*> VLASizeMap;
177
Anders Carlsson438ddd82008-12-12 05:52:00 +0000178 /// StackSaveValues - A stack(!) of stack save values. When a new scope is
179 /// entered, a null is pushed on this stack. If a VLA is emitted, then
180 /// the return value of llvm.stacksave() is stored at the top of this stack.
181 llvm::SmallVector<llvm::Value*, 8> StackSaveValues;
182
Chris Lattner4b009652007-07-25 00:24:17 +0000183public:
184 CodeGenFunction(CodeGenModule &cgm);
185
186 ASTContext &getContext() const;
187
Chris Lattnerb326b172008-03-30 23:03:07 +0000188 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000189
Fariborz Jahanian0adaa8a2009-01-10 21:06:09 +0000190 void StartObjCMethod(const ObjCMethodDecl *MD,
191 const ObjCContainerDecl *CD);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000192
193 /// GenerateObjCGetter - Synthesize an Objective-C property getter
194 /// function.
Fariborz Jahanian91dd9d32008-12-09 20:23:04 +0000195 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
196 const ObjCPropertyImplDecl *PID);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000197
198 /// GenerateObjCSetter - Synthesize an Objective-C property setter
199 /// function for the given property.
Fariborz Jahanian91dd9d32008-12-09 20:23:04 +0000200 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
201 const ObjCPropertyImplDecl *PID);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000202
Daniel Dunbar7bf5b3d2008-07-29 23:18:29 +0000203 void GenerateCode(const FunctionDecl *FD,
204 llvm::Function *Fn);
Daniel Dunbar96816832008-09-09 23:14:03 +0000205 void StartFunction(const Decl *D, QualType RetTy,
206 llvm::Function *Fn,
Daniel Dunbar54968bf2008-10-18 18:22:23 +0000207 const FunctionArgList &Args,
208 SourceLocation StartLoc);
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000209
Daniel Dunbar924f4ea2009-01-26 23:27:52 +0000210 /// EmitReturnBlock - Emit the unified return block, trying to avoid
211 /// its emission when possible.
212 void EmitReturnBlock();
213
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000214 /// FinishFunction - Complete IR generation of the current
215 /// function. It is legal to call this function even if there is no
216 /// current insertion point.
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000217 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Daniel Dunbarfc1a9c42008-09-09 23:27:19 +0000218
219 /// EmitFunctionProlog - Emit the target specific LLVM code to load
220 /// the arguments for the given function. This is also responsible
221 /// for naming the LLVM function arguments.
222 void EmitFunctionProlog(llvm::Function *Fn, QualType RetTy,
223 const FunctionArgList &Args);
224
225 /// EmitFunctionEpilog - Emit the target specific LLVM code to
226 /// return the given temporary.
227 void EmitFunctionEpilog(QualType RetTy,
228 llvm::Value *ReturnValue);
229
Chris Lattner4b009652007-07-25 00:24:17 +0000230 const llvm::Type *ConvertType(QualType T);
Chris Lattner6e6a5972008-04-04 04:07:35 +0000231
Daniel Dunbarace33292008-08-16 03:19:19 +0000232 /// LoadObjCSelf - Load the value of self. This function is only
233 /// valid while generating code for an Objective-C method.
Chris Lattner6e6a5972008-04-04 04:07:35 +0000234 llvm::Value *LoadObjCSelf();
Chris Lattner8c7c6a12008-06-17 18:05:57 +0000235
236 /// isObjCPointerType - Return true if the specificed AST type will map onto
237 /// some Objective-C pointer type.
238 static bool isObjCPointerType(QualType T);
239
Chris Lattner4b009652007-07-25 00:24:17 +0000240 /// hasAggregateLLVMType - Return true if the specified AST type will map into
241 /// an aggregate LLVM type or is void.
242 static bool hasAggregateLLVMType(QualType T);
Daniel Dunbar72f96552008-11-11 02:29:29 +0000243
244 /// createBasicBlock - Create an LLVM basic block.
245 llvm::BasicBlock *createBasicBlock(const char *Name="",
246 llvm::Function *Parent=0,
247 llvm::BasicBlock *InsertBefore=0) {
Daniel Dunbar4dcabf32008-11-12 00:01:12 +0000248#ifdef NDEBUG
249 return llvm::BasicBlock::Create("", Parent, InsertBefore);
250#else
Daniel Dunbar72f96552008-11-11 02:29:29 +0000251 return llvm::BasicBlock::Create(Name, Parent, InsertBefore);
Daniel Dunbar4dcabf32008-11-12 00:01:12 +0000252#endif
Daniel Dunbar72f96552008-11-11 02:29:29 +0000253 }
254
Chris Lattner4b009652007-07-25 00:24:17 +0000255 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
256 /// label maps to.
257 llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
258
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000259 /// EmitBlock - Emit the given block \arg BB and set it as the
260 /// insert point, adding a fall-through branch from the current
261 /// insert block if necessary. It is legal to call this function
262 /// even if there is no current insertion point.
Daniel Dunbare2202612008-11-13 01:24:05 +0000263 ///
264 /// IsFinished - If true, indicates that the caller has finished
265 /// emitting branches to the given block and does not expect to emit
266 /// code into it. This means the block can be ignored if it is
267 /// unreachable.
268 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
Daniel Dunbara2209a62008-11-11 04:34:23 +0000269
Daniel Dunbar5276caa2008-11-11 09:41:28 +0000270 /// EmitBranch - Emit a branch to the specified basic block from the
271 /// current insert block, taking care to avoid creation of branches
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000272 /// from dummy blocks. It is legal to call this function even if
273 /// there is no current insertion point.
Daniel Dunbarc55b7c52008-11-11 22:06:59 +0000274 ///
275 /// This function clears the current insertion point. The caller
276 /// should follow calls to this function with calls to Emit*Block
277 /// prior to generation new code.
Daniel Dunbar5276caa2008-11-11 09:41:28 +0000278 void EmitBranch(llvm::BasicBlock *Block);
279
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000280 /// HaveInsertPoint - True if an insertion point is defined. If not,
281 /// this indicates that the current code being emitted is
282 /// unreachable.
283 bool HaveInsertPoint() const {
284 return Builder.GetInsertBlock() != 0;
285 }
286
287 /// EnsureInsertPoint - Ensure that an insertion point is defined so
288 /// that emitted IR has a place to go. Note that by definition, if
289 /// this function creates a block then that block is unreachable;
290 /// callers may do better to detect when no insertion point is
291 /// defined and simply skip IR generation.
292 void EnsureInsertPoint() {
293 if (!HaveInsertPoint())
294 EmitBlock(createBasicBlock());
295 }
Chris Lattner9d4e6202007-12-02 01:43:38 +0000296
Daniel Dunbar9503b782008-08-16 00:56:44 +0000297 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner9d4e6202007-12-02 01:43:38 +0000298 /// specified stmt yet.
Daniel Dunbar49bddf72008-09-04 03:43:08 +0000299 void ErrorUnsupported(const Stmt *S, const char *Type,
300 bool OmitOnError=false);
Chris Lattner4b009652007-07-25 00:24:17 +0000301
302 //===--------------------------------------------------------------------===//
303 // Helpers
304 //===--------------------------------------------------------------------===//
305
306 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
307 /// block.
308 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
309 const char *Name = "tmp");
310
311 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
312 /// expression and compare the result against zero, returning an Int1Ty value.
313 llvm::Value *EvaluateExprAsBool(const Expr *E);
314
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000315 /// EmitAnyExpr - Emit code to compute the specified expression which can have
316 /// any type. The result is returned as an RValue struct. If this is an
317 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
318 /// the result should be returned.
319 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
320 bool isAggLocVolatile = false);
Devang Patel97299362007-09-28 21:49:18 +0000321
Eli Friedman8f5e8782009-01-20 17:46:04 +0000322 // EmitVAListRef - Emit a "reference" to a va_list; this is either the
323 // address or the value of the expression, depending on how va_list is
324 // defined.
325 llvm::Value *EmitVAListRef(const Expr *E);
326
Daniel Dunbar0a2da0f2008-09-09 01:06:48 +0000327 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result
328 /// will always be accessible even if no aggregate location is
329 /// provided.
330 RValue EmitAnyExprToTemp(const Expr *E, llvm::Value *AggLoc = 0,
331 bool isAggLocVolatile = false);
332
Daniel Dunbarbde0c9d2008-09-09 20:49:46 +0000333 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
334 QualType EltTy);
335
336 void EmitAggregateClear(llvm::Value *DestPtr, QualType Ty);
337
Devang Patele58e0802007-10-04 23:45:31 +0000338 /// StartBlock - Start new block named N. If insert block is a dummy block
339 /// then reuse it.
340 void StartBlock(const char *N);
341
Devang Patel7a78e432007-11-01 19:11:01 +0000342 /// getCGRecordLayout - Return record layout info.
343 const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
Lauro Ramos Venancio934fb022008-02-26 21:41:45 +0000344
345 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
Steve Naroff72a6ebc2008-04-15 22:42:06 +0000346 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD);
Dan Gohman4751a3a2008-05-22 00:50:06 +0000347
Anders Carlsson75d86732008-09-11 09:15:33 +0000348 /// GetAddrOfLocalVar - Return the address of a local variable.
349 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD);
350
Dan Gohman4751a3a2008-05-22 00:50:06 +0000351 /// getAccessedFieldNo - Given an encoded value and a result number, return
352 /// the input field number being accessed.
353 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
354
Daniel Dunbar879788d2008-08-04 16:51:22 +0000355 unsigned GetIDForAddrOfLabel(const LabelStmt *L);
356
Anders Carlsson82b0d0c2008-08-30 19:51:14 +0000357 /// EmitMemSetToZero - Generate code to memset a value of the given type to 0;
358 void EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty);
Anders Carlsson285611e2008-11-04 05:30:00 +0000359
360 // EmitVAArg - Generate code to get an argument from the passed in pointer
361 // and update it accordingly. The return value is a pointer to the argument.
362 // FIXME: We should be able to get rid of this method and use the va_arg
363 // instruction in LLVM instead once it works well enough.
364 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
Anders Carlssonf860e022008-12-20 20:27:15 +0000365
Anders Carlssond9767612008-12-20 20:46:34 +0000366 // EmitVLASize - Generate code for any VLA size expressions that might occur
367 // in a variably modified type. If Ty is a VLA, will return the value that
368 // corresponds to the size in bytes of the VLA type. Will return 0 otherwise.
369 llvm::Value *EmitVLASize(QualType Ty);
Anders Carlssonf860e022008-12-20 20:27:15 +0000370
Anders Carlsson32aa0c22008-12-12 07:19:02 +0000371 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes
372 // of a variable length array type.
373 llvm::Value *GetVLASize(const VariableArrayType *);
374
Chris Lattner4b009652007-07-25 00:24:17 +0000375 //===--------------------------------------------------------------------===//
Chris Lattner4b009652007-07-25 00:24:17 +0000376 // Declaration Emission
377 //===--------------------------------------------------------------------===//
378
379 void EmitDecl(const Decl &D);
Steve Naroff72a6ebc2008-04-15 22:42:06 +0000380 void EmitBlockVarDecl(const VarDecl &D);
381 void EmitLocalBlockVarDecl(const VarDecl &D);
382 void EmitStaticBlockVarDecl(const VarDecl &D);
Daniel Dunbarace33292008-08-16 03:19:19 +0000383
384 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
385 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg);
Chris Lattner4b009652007-07-25 00:24:17 +0000386
387 //===--------------------------------------------------------------------===//
388 // Statement Emission
389 //===--------------------------------------------------------------------===//
390
Daniel Dunbar6c81e562008-11-12 08:21:33 +0000391 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug
392 /// info.
393 void EmitStopPoint(const Stmt *S);
394
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000395 /// EmitStmt - Emit the code for the statement \arg S. It is legal
396 /// to call this function even if there is no current insertion
397 /// point.
398 ///
399 /// This function may clear the current insertion point; callers
400 /// should use EnsureInsertPoint if they wish to subsequently
401 /// generate code without first calling EmitBlock, EmitBranch, or
402 /// EmitStmt.
Chris Lattner4b009652007-07-25 00:24:17 +0000403 void EmitStmt(const Stmt *S);
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000404
Daniel Dunbar6c81e562008-11-12 08:21:33 +0000405 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
406 /// necessarily require an insertion point or debug information;
407 /// typically because the statement amounts to a jump or a container
408 /// of other statements.
409 ///
410 /// \return True if the statement was handled.
411 bool EmitSimpleStmt(const Stmt *S);
412
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000413 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
414 llvm::Value *AggLoc = 0, bool isAggVol = false);
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000415
416 /// EmitLabel - Emit the block for the given label. It is legal
417 /// to call this function even if there is no current insertion
418 /// point.
Chris Lattner09cee852008-07-26 20:23:23 +0000419 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt.
Daniel Dunbar5aa22bc2008-11-11 23:11:34 +0000420
Chris Lattner4b009652007-07-25 00:24:17 +0000421 void EmitLabelStmt(const LabelStmt &S);
422 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar879788d2008-08-04 16:51:22 +0000423 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Chris Lattner4b009652007-07-25 00:24:17 +0000424 void EmitIfStmt(const IfStmt &S);
425 void EmitWhileStmt(const WhileStmt &S);
426 void EmitDoStmt(const DoStmt &S);
427 void EmitForStmt(const ForStmt &S);
428 void EmitReturnStmt(const ReturnStmt &S);
429 void EmitDeclStmt(const DeclStmt &S);
Daniel Dunbar6c81e562008-11-12 08:21:33 +0000430 void EmitBreakStmt(const BreakStmt &S);
431 void EmitContinueStmt(const ContinueStmt &S);
Devang Patele58e0802007-10-04 23:45:31 +0000432 void EmitSwitchStmt(const SwitchStmt &S);
433 void EmitDefaultStmt(const DefaultStmt &S);
434 void EmitCaseStmt(const CaseStmt &S);
Devang Patel347ca322007-10-08 20:57:48 +0000435 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlssonaf6a6c22008-02-05 16:35:33 +0000436 void EmitAsmStmt(const AsmStmt &S);
437
Anders Carlsson82b0d0c2008-08-30 19:51:14 +0000438 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
Anders Carlssonb01a2112008-09-09 10:04:29 +0000439 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
440 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
Chris Lattnerdd978702008-11-15 21:26:17 +0000441 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
Anders Carlsson82b0d0c2008-08-30 19:51:14 +0000442
Chris Lattner4b009652007-07-25 00:24:17 +0000443 //===--------------------------------------------------------------------===//
444 // LValue Expression Emission
445 //===--------------------------------------------------------------------===//
446
Daniel Dunbare3a6a682009-01-09 16:50:52 +0000447 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
448 /// and issue an ErrorUnsupported style diagnostic (using the
449 /// provided Name).
450 RValue EmitUnsupportedRValue(const Expr *E,
451 const char *Name);
452
Daniel Dunbarde1bd942008-08-25 20:45:57 +0000453 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E
454 /// and issue an ErrorUnsupported style diagnostic (using the
455 /// provided Name).
456 LValue EmitUnsupportedLValue(const Expr *E,
457 const char *Name);
458
Chris Lattner4b009652007-07-25 00:24:17 +0000459 /// EmitLValue - Emit code to compute a designator that specifies the location
460 /// of the expression.
461 ///
462 /// This can return one of two things: a simple address or a bitfield
463 /// reference. In either case, the LLVM Value* in the LValue structure is
464 /// guaranteed to be an LLVM pointer type.
465 ///
466 /// If this returns a bitfield reference, nothing about the pointee type of
467 /// the LLVM value is known: For example, it may not be a pointer to an
468 /// integer.
469 ///
470 /// If this returns a normal address, and if the lvalue's C type is fixed
471 /// size, this method guarantees that the returned pointer type will point to
472 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
473 /// variable length type, this is not possible.
474 ///
475 LValue EmitLValue(const Expr *E);
476
477 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
478 /// this method emits the address of the lvalue, then loads the result as an
479 /// rvalue, returning the rvalue.
Chris Lattner4b009652007-07-25 00:24:17 +0000480 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000481 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
Lauro Ramos Venanciob40307c2008-01-22 20:17:04 +0000482 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000483 RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType);
Fariborz Jahanianb0973da2008-11-22 22:30:21 +0000484 RValue EmitLoadOfKVCRefLValue(LValue LV, QualType ExprType);
Chris Lattner4b009652007-07-25 00:24:17 +0000485
Chris Lattner944f7962007-08-03 16:18:34 +0000486
Chris Lattner4b009652007-07-25 00:24:17 +0000487 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
488 /// lvalue, where both are guaranteed to the have the same type, and that type
489 /// is 'Ty'.
490 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000491 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
492 QualType Ty);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000493 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty);
Fariborz Jahanianb0973da2008-11-22 22:30:21 +0000494 void EmitStoreThroughKVCRefLValue(RValue Src, LValue Dst, QualType Ty);
Daniel Dunbar2668dd12008-11-19 09:36:46 +0000495
496 /// EmitStoreThroughLValue - Store Src into Dst with same
497 /// constraints as EmitStoreThroughLValue.
498 ///
499 /// \param Result [out] - If non-null, this will be set to a Value*
500 /// for the bit-field contents after the store, appropriate for use
501 /// as the result of an assignment to the bit-field.
502 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty,
503 llvm::Value **Result=0);
Christopher Lambad327ba2007-12-29 05:02:41 +0000504
505 // Note: only availabe for agg return types
Daniel Dunbaref0d4c72008-09-04 03:20:13 +0000506 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
507 // Note: only availabe for agg return types
Christopher Lambad327ba2007-12-29 05:02:41 +0000508 LValue EmitCallExprLValue(const CallExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000509 LValue EmitDeclRefLValue(const DeclRefExpr *E);
510 LValue EmitStringLiteralLValue(const StringLiteral *E);
Daniel Dunbara9f0be22008-10-17 21:58:32 +0000511 LValue EmitPredefinedFunctionName(unsigned Type);
Chris Lattner69909292008-08-10 01:53:14 +0000512 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000513 LValue EmitUnaryOpLValue(const UnaryOperator *E);
514 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000515 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patelaebd83f2007-10-23 02:10:49 +0000516 LValue EmitMemberExpr(const MemberExpr *E);
Eli Friedmanf3c2cb42008-05-13 23:18:27 +0000517 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
Eli Friedmand3550112008-02-09 08:50:58 +0000518
Daniel Dunbare856ac22008-09-24 04:00:38 +0000519 llvm::Value *EmitIvarOffset(ObjCInterfaceDecl *Interface,
520 const ObjCIvarDecl *Ivar);
Eli Friedmand3550112008-02-09 08:50:58 +0000521 LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field,
Eli Friedman2e630542008-06-13 23:01:12 +0000522 bool isUnion, unsigned CVRQualifiers);
Daniel Dunbare856ac22008-09-24 04:00:38 +0000523 LValue EmitLValueForIvar(llvm::Value* Base, const ObjCIvarDecl *Ivar,
Fariborz Jahanian86008c02008-12-15 20:35:07 +0000524 const FieldDecl *Field,
Daniel Dunbare856ac22008-09-24 04:00:38 +0000525 unsigned CVRQualifiers);
526
Fariborz Jahanian86008c02008-12-15 20:35:07 +0000527 LValue EmitLValueForBitfield(llvm::Value* Base, FieldDecl* Field,
528 unsigned CVRQualifiers, unsigned idx);
529
Argiris Kirtzidisbf615b02008-09-10 02:36:38 +0000530 LValue EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E);
531
Daniel Dunbar5e105892008-08-23 10:51:21 +0000532 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattnerb326b172008-03-30 23:03:07 +0000533 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000534 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
Fariborz Jahanianb0973da2008-11-22 22:30:21 +0000535 LValue EmitObjCKVCRefLValue(const ObjCKVCRefExpr *E);
Douglas Gregord8606632008-11-04 14:56:14 +0000536 LValue EmitObjCSuperExpr(const ObjCSuperExpr *E);
Daniel Dunbar5e105892008-08-23 10:51:21 +0000537
Chris Lattner4b009652007-07-25 00:24:17 +0000538 //===--------------------------------------------------------------------===//
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000539 // Scalar Expression Emission
Chris Lattner4b009652007-07-25 00:24:17 +0000540 //===--------------------------------------------------------------------===//
541
Daniel Dunbardd851282008-08-30 05:35:15 +0000542 /// EmitCall - Generate a call of the given function, expecting the
543 /// given result type, and using the given argument list which
544 /// specifies both the LLVM arguments and the types they were
545 /// derived from.
Daniel Dunbar0ed60b02008-08-30 03:02:31 +0000546 RValue EmitCall(llvm::Value *Callee,
Daniel Dunbar9fc15a82009-02-02 21:43:58 +0000547 const CGFunctionInfo &FnInfo,
Daniel Dunbar0ed60b02008-08-30 03:02:31 +0000548 const CallArgList &Args);
549
Chris Lattner4b009652007-07-25 00:24:17 +0000550 RValue EmitCallExpr(const CallExpr *E);
Ted Kremenek2719e982008-06-17 02:43:46 +0000551
552 RValue EmitCallExpr(Expr *FnExpr, CallExpr::const_arg_iterator ArgBeg,
553 CallExpr::const_arg_iterator ArgEnd);
554
Eli Friedman261f4ad2008-01-30 01:32:06 +0000555 RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
Ted Kremenek2719e982008-06-17 02:43:46 +0000556 CallExpr::const_arg_iterator ArgBeg,
557 CallExpr::const_arg_iterator ArgEnd);
558
Chris Lattner35055b82007-08-26 22:58:05 +0000559 RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000560
Daniel Dunbar1cdfe142008-10-10 00:24:54 +0000561 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0
562 /// if the call is unhandled by the current target.
563 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
564
Anders Carlssone1449c12007-12-09 23:17:02 +0000565 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
566 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
567
Anders Carlssona9234fe2007-12-10 19:35:18 +0000568 llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
Nate Begemanec2d1062007-12-30 02:59:45 +0000569 llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
570 bool isSplat = false);
Anders Carlsson68b8be92007-12-15 21:23:30 +0000571
Daniel Dunbarf1f7f192008-08-20 00:28:19 +0000572 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner9fba49a2007-08-24 05:35:26 +0000573 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Chris Lattner6ee20e32008-06-24 17:04:18 +0000574 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
Daniel Dunbara04840b2008-08-23 03:46:30 +0000575 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E);
Fariborz Jahanianf18d4c82008-11-22 18:39:36 +0000576 RValue EmitObjCPropertyGet(const Expr *E);
Fariborz Jahanianb0973da2008-11-22 22:30:21 +0000577 void EmitObjCPropertySet(const Expr *E, RValue Src);
Chris Lattner6ee20e32008-06-24 17:04:18 +0000578
579
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000580 //===--------------------------------------------------------------------===//
Chris Lattner41b1fca2007-08-26 23:13:56 +0000581 // Expression Emission
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000582 //===--------------------------------------------------------------------===//
Chris Lattner41b1fca2007-08-26 23:13:56 +0000583
584 // Expressions are broken into three classes: scalar, complex, aggregate.
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000585
Chris Lattner9fba49a2007-08-24 05:35:26 +0000586 /// EmitScalarExpr - Emit the computation of the specified expression of
587 /// LLVM scalar type, returning the result.
588 llvm::Value *EmitScalarExpr(const Expr *E);
589
Chris Lattner4e05d1e2007-08-26 06:48:56 +0000590 /// EmitScalarConversion - Emit a conversion from the specified type to the
591 /// specified destination type, both of which are LLVM scalar types.
592 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
593 QualType DstTy);
594
Chris Lattnerfb182ee2007-08-26 16:34:22 +0000595 /// EmitComplexToScalarConversion - Emit a conversion from the specified
596 /// complex type to the specified destination type, where the destination
597 /// type is an LLVM scalar type.
598 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
599 QualType DstTy);
600
Chris Lattner4e05d1e2007-08-26 06:48:56 +0000601
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000602 /// EmitAggExpr - Emit the computation of the specified expression of
603 /// aggregate type. The result is computed into DestPtr. Note that if
604 /// DestPtr is null, the value of the aggregate expression is not needed.
605 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest);
Chris Lattner8d0cc2f2007-08-21 05:54:00 +0000606
607 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner348c8a22007-08-23 23:43:33 +0000608 /// complex type, returning the result.
Chris Lattner5280c5f2007-08-21 16:57:55 +0000609 ComplexPairTy EmitComplexExpr(const Expr *E);
Chris Lattner348c8a22007-08-23 23:43:33 +0000610
611 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
612 /// of complex type, storing into the specified Value*.
Chris Lattner8e1f6e02007-08-26 16:22:13 +0000613 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
614 bool DestIsVolatile);
Daniel Dunbardd851282008-08-30 05:35:15 +0000615
616 /// StoreComplexToAddr - Store a complex number into the specified address.
617 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
618 bool DestIsVolatile);
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000619 /// LoadComplexFromAddr - Load a complex number from the specified address.
620 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattner85970f32008-05-08 05:58:21 +0000621
622 /// GenerateStaticBlockVarDecl - return the the static
623 /// declaration of local variable.
624 llvm::GlobalValue *GenerateStaticBlockVarDecl(const VarDecl &D,
625 bool NoInit,
626 const char *Separator);
Daniel Dunbar879788d2008-08-04 16:51:22 +0000627
Anders Carlssonc9f8ccd2008-08-22 16:00:37 +0000628 // GenerateStaticBlockVarDecl - return the static declaration of
629 // a local variable. Performs initialization of the variable if necessary.
630 llvm::GlobalValue *GenerateStaticCXXBlockVarDecl(const VarDecl &D);
631
Daniel Dunbar879788d2008-08-04 16:51:22 +0000632 //===--------------------------------------------------------------------===//
633 // Internal Helpers
634 //===--------------------------------------------------------------------===//
635
Chris Lattner3f73d0d2008-11-11 07:41:27 +0000636 /// ContainsLabel - Return true if the statement contains a label in it. If
637 /// this statement is not executed normally, it not containing a label means
638 /// that we can just remove the code.
639 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
640
Daniel Dunbar45e38672008-11-12 10:12:14 +0000641 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
Chris Lattner3d6606b2008-11-12 08:04:58 +0000642 /// to a constant, or if it does but contains a label, return 0. If it
643 /// constant folds to 'true' and does not contain a label, return 1, if it
644 /// constant folds to 'false' and does not contain a label, return -1.
645 int ConstantFoldsToSimpleInteger(const Expr *Cond);
646
647 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
648 /// if statement) to the specified blocks. Based on the condition, this might
649 /// try to simplify the codegen of the conditional based on the branch.
650 ///
Chris Lattner1875ba22008-11-12 07:46:33 +0000651 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
Daniel Dunbar45e38672008-11-12 10:12:14 +0000652 llvm::BasicBlock *FalseBlock);
Chris Lattner3d6606b2008-11-12 08:04:58 +0000653private:
Chris Lattner3f73d0d2008-11-11 07:41:27 +0000654
Daniel Dunbar879788d2008-08-04 16:51:22 +0000655 /// EmitIndirectSwitches - Emit code for all of the switch
656 /// instructions in IndirectSwitches.
657 void EmitIndirectSwitches();
Daniel Dunbar04d35782008-09-17 00:51:38 +0000658
Daniel Dunbare856ac22008-09-24 04:00:38 +0000659 void EmitReturnOfRValue(RValue RV, QualType Ty);
660
Daniel Dunbar04d35782008-09-17 00:51:38 +0000661 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
662 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
663 ///
664 /// \param AI - The first function argument of the expansion.
665 /// \return The argument following the last expanded function
666 /// argument.
667 llvm::Function::arg_iterator
668 ExpandTypeFromArgs(QualType Ty, LValue Dst,
669 llvm::Function::arg_iterator AI);
670
671 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type
672 /// for \arg Ty, into individual arguments on the provided vector
673 /// \arg Args. See ABIArgInfo::Expand.
674 void ExpandTypeToArgs(QualType Ty, RValue Src,
675 llvm::SmallVector<llvm::Value*, 16> &Args);
Anders Carlsson60bb4d42009-01-11 19:40:10 +0000676
677 llvm::Value* EmitAsmInput(const AsmStmt &S, TargetInfo::ConstraintInfo Info,
678 const Expr *InputExpr, std::string &ConstraintStr);
679
Chris Lattner4b009652007-07-25 00:24:17 +0000680};
681} // end namespace CodeGen
682} // end namespace clang
683
684#endif