blob: b3881538361250afe22a5cc1718537592ee1805f [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"
Chris Lattner676bf212008-04-13 07:32:11 +000020#include "llvm/Support/IRBuilder.h"
Ted Kremenek2719e982008-06-17 02:43:46 +000021#include "clang/AST/Expr.h"
22#include "clang/AST/ExprObjC.h"
23
Chris Lattner4b009652007-07-25 00:24:17 +000024#include <vector>
Daniel Dunbar879788d2008-08-04 16:51:22 +000025#include <map>
Chris Lattner4b009652007-07-25 00:24:17 +000026
Daniel Dunbara04840b2008-08-23 03:46:30 +000027#include "CGValue.h"
28
Chris Lattner4b009652007-07-25 00:24:17 +000029namespace llvm {
Daniel Dunbar64789f82008-08-11 05:35:13 +000030 class BasicBlock;
Chris Lattner4b009652007-07-25 00:24:17 +000031 class Module;
32}
33
34namespace clang {
35 class ASTContext;
36 class Decl;
Daniel Dunbar64789f82008-08-11 05:35:13 +000037 class EnumConstantDecl;
Chris Lattner4b009652007-07-25 00:24:17 +000038 class FunctionDecl;
Daniel Dunbar64789f82008-08-11 05:35:13 +000039 class FunctionTypeProto;
40 class LabelStmt;
Chris Lattnerb326b172008-03-30 23:03:07 +000041 class ObjCMethodDecl;
Daniel Dunbar6b57d432008-08-26 08:29:31 +000042 class ObjCPropertyImplDecl;
Chris Lattner4b009652007-07-25 00:24:17 +000043 class TargetInfo;
Daniel Dunbar64789f82008-08-11 05:35:13 +000044 class VarDecl;
Devang Patelaebd83f2007-10-23 02:10:49 +000045
Chris Lattner4b009652007-07-25 00:24:17 +000046namespace CodeGen {
47 class CodeGenModule;
Devang Patelaebd83f2007-10-23 02:10:49 +000048 class CodeGenTypes;
Devang Patel7a78e432007-11-01 19:11:01 +000049 class CGRecordLayout;
Chris Lattner4b009652007-07-25 00:24:17 +000050
Chris Lattner4b009652007-07-25 00:24:17 +000051/// CodeGenFunction - This class organizes the per-function state that is used
52/// while generating LLVM code.
53class CodeGenFunction {
Chris Lattner41b1fca2007-08-26 23:13:56 +000054public:
Chris Lattner4b009652007-07-25 00:24:17 +000055 CodeGenModule &CGM; // Per-module state.
56 TargetInfo &Target;
Chris Lattner41b1fca2007-08-26 23:13:56 +000057
Chris Lattner5280c5f2007-08-21 16:57:55 +000058 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Chris Lattnerfaf23db2008-08-08 19:57:58 +000059 llvm::IRBuilder<> Builder;
Chris Lattner4b009652007-07-25 00:24:17 +000060
Chris Lattner6e6a5972008-04-04 04:07:35 +000061 // Holds the Decl for the current function or method
Chris Lattner8c7c6a12008-06-17 18:05:57 +000062 const Decl *CurFuncDecl;
Chris Lattnerb326b172008-03-30 23:03:07 +000063 QualType FnRetTy;
Chris Lattner4b009652007-07-25 00:24:17 +000064 llvm::Function *CurFn;
65
66 /// AllocaInsertPoint - This is an instruction in the entry block before which
67 /// we prefer to insert allocas.
68 llvm::Instruction *AllocaInsertPt;
Daniel Dunbar879788d2008-08-04 16:51:22 +000069
Chris Lattner4b009652007-07-25 00:24:17 +000070 const llvm::Type *LLVMIntTy;
Hartmut Kaiserff08d2c2007-10-17 15:00:17 +000071 uint32_t LLVMPointerWidth;
Chris Lattner4b009652007-07-25 00:24:17 +000072
Chris Lattner9fba49a2007-08-24 05:35:26 +000073private:
Daniel Dunbar879788d2008-08-04 16:51:22 +000074 /// LabelIDs - Track arbitrary ids assigned to labels for use in
75 /// implementing the GCC address-of-label extension and indirect
76 /// goto. IDs are assigned to labels inside getIDForAddrOfLabel().
77 std::map<const LabelStmt*, unsigned> LabelIDs;
78
79 /// IndirectSwitches - Record the list of switches for indirect
80 /// gotos. Emission of the actual switching code needs to be delayed
81 /// until all AddrLabelExprs have been seen.
82 std::vector<llvm::SwitchInst*> IndirectSwitches;
83
Chris Lattner4b009652007-07-25 00:24:17 +000084 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
85 /// decls.
86 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
87
88 /// LabelMap - This keeps track of the LLVM basic block for each C label.
89 llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
90
91 // BreakContinueStack - This keeps track of where break and continue
92 // statements should jump to.
93 struct BreakContinue {
94 BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb)
95 : BreakBlock(bb), ContinueBlock(cb) {}
96
97 llvm::BasicBlock *BreakBlock;
98 llvm::BasicBlock *ContinueBlock;
99 };
100 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
101
Devang Patelbc372382007-10-09 17:08:50 +0000102 /// SwitchInsn - This is nearest current switch instruction. It is null if
103 /// if current context is not in a switch.
Devang Patele58e0802007-10-04 23:45:31 +0000104 llvm::SwitchInst *SwitchInsn;
105
Devang Patelbc372382007-10-09 17:08:50 +0000106 /// CaseRangeBlock - This block holds if condition check for last case
107 /// statement range in current switch instruction.
Devang Patel347ca322007-10-08 20:57:48 +0000108 llvm::BasicBlock *CaseRangeBlock;
109
Chris Lattner4b009652007-07-25 00:24:17 +0000110public:
111 CodeGenFunction(CodeGenModule &cgm);
112
113 ASTContext &getContext() const;
114
Chris Lattnerb326b172008-03-30 23:03:07 +0000115 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000116
117 void StartObjCMethod(const ObjCMethodDecl *MD);
118
119 /// GenerateObjCGetter - Synthesize an Objective-C property getter
120 /// function.
121 void GenerateObjCGetter(const ObjCPropertyImplDecl *PID);
122
123 /// GenerateObjCSetter - Synthesize an Objective-C property setter
124 /// function for the given property.
125 void GenerateObjCSetter(const ObjCPropertyImplDecl *PID);
126
Daniel Dunbar7bf5b3d2008-07-29 23:18:29 +0000127 void GenerateCode(const FunctionDecl *FD,
128 llvm::Function *Fn);
Daniel Dunbar6b57d432008-08-26 08:29:31 +0000129 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Chris Lattner4b009652007-07-25 00:24:17 +0000130
131 const llvm::Type *ConvertType(QualType T);
Chris Lattner6e6a5972008-04-04 04:07:35 +0000132
Daniel Dunbarace33292008-08-16 03:19:19 +0000133 /// LoadObjCSelf - Load the value of self. This function is only
134 /// valid while generating code for an Objective-C method.
Chris Lattner6e6a5972008-04-04 04:07:35 +0000135 llvm::Value *LoadObjCSelf();
Chris Lattner8c7c6a12008-06-17 18:05:57 +0000136
137 /// isObjCPointerType - Return true if the specificed AST type will map onto
138 /// some Objective-C pointer type.
139 static bool isObjCPointerType(QualType T);
140
Chris Lattner4b009652007-07-25 00:24:17 +0000141 /// hasAggregateLLVMType - Return true if the specified AST type will map into
142 /// an aggregate LLVM type or is void.
143 static bool hasAggregateLLVMType(QualType T);
144
145 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
146 /// label maps to.
147 llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
148
149
150 void EmitBlock(llvm::BasicBlock *BB);
Chris Lattner9d4e6202007-12-02 01:43:38 +0000151
Daniel Dunbar9503b782008-08-16 00:56:44 +0000152 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner9d4e6202007-12-02 01:43:38 +0000153 /// specified stmt yet.
Daniel Dunbar49bddf72008-09-04 03:43:08 +0000154 void ErrorUnsupported(const Stmt *S, const char *Type,
155 bool OmitOnError=false);
Chris Lattner4b009652007-07-25 00:24:17 +0000156
157 //===--------------------------------------------------------------------===//
158 // Helpers
159 //===--------------------------------------------------------------------===//
160
161 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
162 /// block.
163 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
164 const char *Name = "tmp");
165
166 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
167 /// expression and compare the result against zero, returning an Int1Ty value.
168 llvm::Value *EvaluateExprAsBool(const Expr *E);
169
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000170 /// EmitAnyExpr - Emit code to compute the specified expression which can have
171 /// any type. The result is returned as an RValue struct. If this is an
172 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
173 /// the result should be returned.
174 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
175 bool isAggLocVolatile = false);
Devang Patel97299362007-09-28 21:49:18 +0000176
177 /// isDummyBlock - Return true if BB is an empty basic block
178 /// with no predecessors.
179 static bool isDummyBlock(const llvm::BasicBlock *BB);
180
Devang Patele58e0802007-10-04 23:45:31 +0000181 /// StartBlock - Start new block named N. If insert block is a dummy block
182 /// then reuse it.
183 void StartBlock(const char *N);
184
Devang Patel7a78e432007-11-01 19:11:01 +0000185 /// getCGRecordLayout - Return record layout info.
186 const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
Lauro Ramos Venancio934fb022008-02-26 21:41:45 +0000187
188 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
Steve Naroff72a6ebc2008-04-15 22:42:06 +0000189 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD);
Dan Gohman4751a3a2008-05-22 00:50:06 +0000190
191 /// getAccessedFieldNo - Given an encoded value and a result number, return
192 /// the input field number being accessed.
193 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
194
Daniel Dunbar879788d2008-08-04 16:51:22 +0000195 unsigned GetIDForAddrOfLabel(const LabelStmt *L);
196
Anders Carlsson82b0d0c2008-08-30 19:51:14 +0000197 /// EmitMemSetToZero - Generate code to memset a value of the given type to 0;
198 void EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty);
199
Chris Lattner4b009652007-07-25 00:24:17 +0000200 //===--------------------------------------------------------------------===//
Chris Lattner4b009652007-07-25 00:24:17 +0000201 // Declaration Emission
202 //===--------------------------------------------------------------------===//
203
204 void EmitDecl(const Decl &D);
Steve Naroff72a6ebc2008-04-15 22:42:06 +0000205 void EmitBlockVarDecl(const VarDecl &D);
206 void EmitLocalBlockVarDecl(const VarDecl &D);
207 void EmitStaticBlockVarDecl(const VarDecl &D);
Daniel Dunbarace33292008-08-16 03:19:19 +0000208
209 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
210 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg);
Chris Lattner4b009652007-07-25 00:24:17 +0000211
212 //===--------------------------------------------------------------------===//
213 // Statement Emission
214 //===--------------------------------------------------------------------===//
215
216 void EmitStmt(const Stmt *S);
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000217 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
218 llvm::Value *AggLoc = 0, bool isAggVol = false);
Chris Lattner09cee852008-07-26 20:23:23 +0000219 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt.
Chris Lattner4b009652007-07-25 00:24:17 +0000220 void EmitLabelStmt(const LabelStmt &S);
221 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar879788d2008-08-04 16:51:22 +0000222 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Chris Lattner4b009652007-07-25 00:24:17 +0000223 void EmitIfStmt(const IfStmt &S);
224 void EmitWhileStmt(const WhileStmt &S);
225 void EmitDoStmt(const DoStmt &S);
226 void EmitForStmt(const ForStmt &S);
227 void EmitReturnStmt(const ReturnStmt &S);
228 void EmitDeclStmt(const DeclStmt &S);
229 void EmitBreakStmt();
230 void EmitContinueStmt();
Devang Patele58e0802007-10-04 23:45:31 +0000231 void EmitSwitchStmt(const SwitchStmt &S);
232 void EmitDefaultStmt(const DefaultStmt &S);
233 void EmitCaseStmt(const CaseStmt &S);
Devang Patel347ca322007-10-08 20:57:48 +0000234 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlssonaf6a6c22008-02-05 16:35:33 +0000235 void EmitAsmStmt(const AsmStmt &S);
236
Anders Carlsson82b0d0c2008-08-30 19:51:14 +0000237 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
238
Chris Lattner4b009652007-07-25 00:24:17 +0000239 //===--------------------------------------------------------------------===//
240 // LValue Expression Emission
241 //===--------------------------------------------------------------------===//
242
Daniel Dunbarde1bd942008-08-25 20:45:57 +0000243 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E
244 /// and issue an ErrorUnsupported style diagnostic (using the
245 /// provided Name).
246 LValue EmitUnsupportedLValue(const Expr *E,
247 const char *Name);
248
Chris Lattner4b009652007-07-25 00:24:17 +0000249 /// EmitLValue - Emit code to compute a designator that specifies the location
250 /// of the expression.
251 ///
252 /// This can return one of two things: a simple address or a bitfield
253 /// reference. In either case, the LLVM Value* in the LValue structure is
254 /// guaranteed to be an LLVM pointer type.
255 ///
256 /// If this returns a bitfield reference, nothing about the pointee type of
257 /// the LLVM value is known: For example, it may not be a pointer to an
258 /// integer.
259 ///
260 /// If this returns a normal address, and if the lvalue's C type is fixed
261 /// size, this method guarantees that the returned pointer type will point to
262 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
263 /// variable length type, this is not possible.
264 ///
265 LValue EmitLValue(const Expr *E);
266
267 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
268 /// this method emits the address of the lvalue, then loads the result as an
269 /// rvalue, returning the rvalue.
Chris Lattner4b009652007-07-25 00:24:17 +0000270 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000271 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
Lauro Ramos Venanciob40307c2008-01-22 20:17:04 +0000272 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000273 RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType);
Chris Lattner4b009652007-07-25 00:24:17 +0000274
Chris Lattner944f7962007-08-03 16:18:34 +0000275
Chris Lattner4b009652007-07-25 00:24:17 +0000276 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
277 /// lvalue, where both are guaranteed to the have the same type, and that type
278 /// is 'Ty'.
279 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000280 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
281 QualType Ty);
Lauro Ramos Venancio2d7a34c2008-01-22 22:36:45 +0000282 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000283 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty);
Christopher Lambad327ba2007-12-29 05:02:41 +0000284
285 // Note: only availabe for agg return types
Daniel Dunbaref0d4c72008-09-04 03:20:13 +0000286 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
287 // Note: only availabe for agg return types
Christopher Lambad327ba2007-12-29 05:02:41 +0000288 LValue EmitCallExprLValue(const CallExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000289
290 LValue EmitDeclRefLValue(const DeclRefExpr *E);
291 LValue EmitStringLiteralLValue(const StringLiteral *E);
Chris Lattner69909292008-08-10 01:53:14 +0000292 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000293 LValue EmitUnaryOpLValue(const UnaryOperator *E);
294 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begemanaf6ed502008-04-18 23:10:10 +0000295 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patelaebd83f2007-10-23 02:10:49 +0000296 LValue EmitMemberExpr(const MemberExpr *E);
Eli Friedmanf3c2cb42008-05-13 23:18:27 +0000297 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
Eli Friedmand3550112008-02-09 08:50:58 +0000298
299 LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field,
Eli Friedman2e630542008-06-13 23:01:12 +0000300 bool isUnion, unsigned CVRQualifiers);
Chris Lattnerb326b172008-03-30 23:03:07 +0000301
Daniel Dunbar5e105892008-08-23 10:51:21 +0000302 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattnerb326b172008-03-30 23:03:07 +0000303 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000304 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
Daniel Dunbar5e105892008-08-23 10:51:21 +0000305
Chris Lattner4b009652007-07-25 00:24:17 +0000306 //===--------------------------------------------------------------------===//
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000307 // Scalar Expression Emission
Chris Lattner4b009652007-07-25 00:24:17 +0000308 //===--------------------------------------------------------------------===//
309
Daniel Dunbardd851282008-08-30 05:35:15 +0000310 /// CallArgList - Type for representing both the value and type of
311 /// arguments in a call.
Daniel Dunbar0ed60b02008-08-30 03:02:31 +0000312 typedef llvm::SmallVector<std::pair<llvm::Value*, QualType>, 16> CallArgList;
Daniel Dunbardd851282008-08-30 05:35:15 +0000313
314 /// EmitCallArg - Emit the given expression and append the result
315 /// onto the given Args list.
Daniel Dunbar0ed60b02008-08-30 03:02:31 +0000316 void EmitCallArg(const Expr *E, CallArgList &Args);
Daniel Dunbardd851282008-08-30 05:35:15 +0000317
318 /// EmitCallArg - Append the appropriate call argument for the given
319 /// rvalue and type onto the Args list.
320 void EmitCallArg(RValue RV, QualType Ty, CallArgList &Args);
321
322 /// EmitCall - Generate a call of the given function, expecting the
323 /// given result type, and using the given argument list which
324 /// specifies both the LLVM arguments and the types they were
325 /// derived from.
Daniel Dunbar0ed60b02008-08-30 03:02:31 +0000326 RValue EmitCall(llvm::Value *Callee,
327 QualType ResultType,
328 const CallArgList &Args);
329
Chris Lattner4b009652007-07-25 00:24:17 +0000330 RValue EmitCallExpr(const CallExpr *E);
Ted Kremenek2719e982008-06-17 02:43:46 +0000331
332 RValue EmitCallExpr(Expr *FnExpr, CallExpr::const_arg_iterator ArgBeg,
333 CallExpr::const_arg_iterator ArgEnd);
334
Eli Friedman261f4ad2008-01-30 01:32:06 +0000335 RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
Ted Kremenek2719e982008-06-17 02:43:46 +0000336 CallExpr::const_arg_iterator ArgBeg,
337 CallExpr::const_arg_iterator ArgEnd);
338
Chris Lattner35055b82007-08-26 22:58:05 +0000339 RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Chris Lattner4b009652007-07-25 00:24:17 +0000340
Anders Carlssone1449c12007-12-09 23:17:02 +0000341 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
342 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
343
Anders Carlssona9234fe2007-12-10 19:35:18 +0000344 llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
Nate Begemanec2d1062007-12-30 02:59:45 +0000345 llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
346 bool isSplat = false);
Anders Carlsson68b8be92007-12-15 21:23:30 +0000347
Daniel Dunbarf1f7f192008-08-20 00:28:19 +0000348 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner9fba49a2007-08-24 05:35:26 +0000349 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Chris Lattner6ee20e32008-06-24 17:04:18 +0000350 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
Daniel Dunbara04840b2008-08-23 03:46:30 +0000351 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E);
Daniel Dunbar91cc4022008-08-27 06:57:25 +0000352 RValue EmitObjCPropertyGet(const ObjCPropertyRefExpr *E);
Daniel Dunbare6c31752008-08-29 08:11:39 +0000353 void EmitObjCPropertySet(const ObjCPropertyRefExpr *E, RValue Src);
Chris Lattner6ee20e32008-06-24 17:04:18 +0000354
355
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000356 //===--------------------------------------------------------------------===//
Chris Lattner41b1fca2007-08-26 23:13:56 +0000357 // Expression Emission
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000358 //===--------------------------------------------------------------------===//
Chris Lattner41b1fca2007-08-26 23:13:56 +0000359
360 // Expressions are broken into three classes: scalar, complex, aggregate.
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000361
Chris Lattner9fba49a2007-08-24 05:35:26 +0000362 /// EmitScalarExpr - Emit the computation of the specified expression of
363 /// LLVM scalar type, returning the result.
364 llvm::Value *EmitScalarExpr(const Expr *E);
365
Chris Lattner4e05d1e2007-08-26 06:48:56 +0000366 /// EmitScalarConversion - Emit a conversion from the specified type to the
367 /// specified destination type, both of which are LLVM scalar types.
368 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
369 QualType DstTy);
370
Chris Lattnerfb182ee2007-08-26 16:34:22 +0000371 /// EmitComplexToScalarConversion - Emit a conversion from the specified
372 /// complex type to the specified destination type, where the destination
373 /// type is an LLVM scalar type.
374 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
375 QualType DstTy);
376
Chris Lattner4e05d1e2007-08-26 06:48:56 +0000377
Chris Lattnerbdb8ffb2007-08-11 00:04:45 +0000378 /// EmitAggExpr - Emit the computation of the specified expression of
379 /// aggregate type. The result is computed into DestPtr. Note that if
380 /// DestPtr is null, the value of the aggregate expression is not needed.
381 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest);
Chris Lattner8d0cc2f2007-08-21 05:54:00 +0000382
383 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner348c8a22007-08-23 23:43:33 +0000384 /// complex type, returning the result.
Chris Lattner5280c5f2007-08-21 16:57:55 +0000385 ComplexPairTy EmitComplexExpr(const Expr *E);
Chris Lattner348c8a22007-08-23 23:43:33 +0000386
387 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
388 /// of complex type, storing into the specified Value*.
Chris Lattner8e1f6e02007-08-26 16:22:13 +0000389 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
390 bool DestIsVolatile);
Daniel Dunbardd851282008-08-30 05:35:15 +0000391
392 /// StoreComplexToAddr - Store a complex number into the specified address.
393 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
394 bool DestIsVolatile);
Chris Lattnere24c4cf2007-08-31 22:49:20 +0000395 /// LoadComplexFromAddr - Load a complex number from the specified address.
396 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattner85970f32008-05-08 05:58:21 +0000397
398 /// GenerateStaticBlockVarDecl - return the the static
399 /// declaration of local variable.
400 llvm::GlobalValue *GenerateStaticBlockVarDecl(const VarDecl &D,
401 bool NoInit,
402 const char *Separator);
Daniel Dunbar879788d2008-08-04 16:51:22 +0000403
Anders Carlssonc9f8ccd2008-08-22 16:00:37 +0000404 // GenerateStaticBlockVarDecl - return the static declaration of
405 // a local variable. Performs initialization of the variable if necessary.
406 llvm::GlobalValue *GenerateStaticCXXBlockVarDecl(const VarDecl &D);
407
Daniel Dunbar879788d2008-08-04 16:51:22 +0000408 //===--------------------------------------------------------------------===//
409 // Internal Helpers
410 //===--------------------------------------------------------------------===//
411
412private:
413 /// EmitIndirectSwitches - Emit code for all of the switch
414 /// instructions in IndirectSwitches.
415 void EmitIndirectSwitches();
Chris Lattner4b009652007-07-25 00:24:17 +0000416};
417} // end namespace CodeGen
418} // end namespace clang
419
420#endif