blob: c741071d00d9afa4ff0df20c759ac9c2ea8eba91 [file] [log] [blame]
Chris Lattnerbed31442007-05-28 01:07:47 +00001//===--- CodeGenFunction.h - Per-Function state for LLVM CodeGen ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerbed31442007-05-28 01:07:47 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This is the internal per-function state used for llvm translation.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef CODEGEN_CODEGENFUNCTION_H
15#define CODEGEN_CODEGENFUNCTION_H
16
Chris Lattnerac248202007-05-30 00:13:02 +000017#include "llvm/ADT/DenseMap.h"
Chris Lattnere73e4322007-07-16 21:28:45 +000018#include "llvm/ADT/SmallVector.h"
Chris Lattner308f4312007-05-29 23:50:05 +000019#include "llvm/Support/LLVMBuilder.h"
Chris Lattner2ccb73b2007-06-16 00:16:26 +000020#include <vector>
Chris Lattner308f4312007-05-29 23:50:05 +000021
Chris Lattnerbed31442007-05-28 01:07:47 +000022namespace llvm {
23 class Module;
Chris Lattner23b7eb62007-06-15 23:05:46 +000024}
25
Chris Lattnerbed31442007-05-28 01:07:47 +000026namespace clang {
27 class ASTContext;
Chris Lattner84915fa2007-06-02 04:16:21 +000028 class Decl;
Chris Lattnerbed31442007-05-28 01:07:47 +000029 class FunctionDecl;
Chris Lattner2ccb73b2007-06-16 00:16:26 +000030 class TargetInfo;
Chris Lattner2ccb73b2007-06-16 00:16:26 +000031 class QualType;
32 class FunctionTypeProto;
Chris Lattner84915fa2007-06-02 04:16:21 +000033
Chris Lattner308f4312007-05-29 23:50:05 +000034 class Stmt;
35 class CompoundStmt;
Chris Lattnerac248202007-05-30 00:13:02 +000036 class LabelStmt;
37 class GotoStmt;
Chris Lattner5269c032007-05-30 21:03:58 +000038 class IfStmt;
Chris Lattner946aa312007-06-05 03:59:43 +000039 class WhileStmt;
Chris Lattner8394d792007-06-05 20:53:16 +000040 class DoStmt;
41 class ForStmt;
Chris Lattner3f3dbee2007-06-02 03:19:07 +000042 class ReturnStmt;
Chris Lattner84915fa2007-06-02 04:16:21 +000043 class DeclStmt;
Devang Patelda5d6bb2007-10-04 23:45:31 +000044 class CaseStmt;
45 class DefaultStmt;
46 class SwitchStmt;
Anders Carlsson952a9952008-02-05 16:35:33 +000047 class AsmStmt;
48
Chris Lattner208ae962007-05-30 17:57:17 +000049 class Expr;
Chris Lattnerd7f58862007-06-02 05:24:33 +000050 class DeclRefExpr;
Chris Lattner4347e3692007-06-06 04:54:52 +000051 class StringLiteral;
Chris Lattner208ae962007-05-30 17:57:17 +000052 class IntegerLiteral;
Chris Lattner2ada32e2007-07-09 23:03:16 +000053 class FloatingLiteral;
Chris Lattner6e9d9b32007-07-13 05:18:11 +000054 class CharacterLiteral;
Chris Lattner40480052007-08-03 17:51:03 +000055 class TypesCompatibleExpr;
56
Chris Lattner76ba8492007-08-20 22:37:10 +000057 class ImplicitCastExpr;
Chris Lattner8394d792007-06-05 20:53:16 +000058 class CastExpr;
Chris Lattner2b228c92007-06-15 21:34:29 +000059 class CallExpr;
Chris Lattnerf0106d22007-06-02 19:33:17 +000060 class UnaryOperator;
Chris Lattnerdb91b162007-06-02 00:16:28 +000061 class BinaryOperator;
Chris Lattner9369a562007-06-29 16:31:29 +000062 class CompoundAssignOperator;
Chris Lattnerd9d2fb12007-06-08 23:31:14 +000063 class ArraySubscriptExpr;
Chris Lattnerd268a7a2007-08-03 17:31:20 +000064 class OCUVectorElementExpr;
Chris Lattner6e9d9b32007-07-13 05:18:11 +000065 class ConditionalOperator;
Chris Lattner81a96882007-08-04 00:20:15 +000066 class ChooseExpr;
Anders Carlsson625bfc82007-07-21 05:21:51 +000067 class PreDefinedExpr;
Anders Carlsson76f4a902007-08-21 17:43:55 +000068 class ObjCStringLiteral;
Devang Patel3e11cce2007-10-23 02:10:49 +000069 class MemberExpr;
70
Chris Lattner84915fa2007-06-02 04:16:21 +000071 class BlockVarDecl;
72 class EnumConstantDecl;
Chris Lattner53621a52007-06-13 20:44:40 +000073 class ParmVarDecl;
Chris Lattnerbed31442007-05-28 01:07:47 +000074namespace CodeGen {
75 class CodeGenModule;
Devang Patel3e11cce2007-10-23 02:10:49 +000076 class CodeGenTypes;
Devang Patele11664a2007-11-01 19:11:01 +000077 class CGRecordLayout;
Chris Lattnerd7f58862007-06-02 05:24:33 +000078
Chris Lattner8394d792007-06-05 20:53:16 +000079/// RValue - This trivial value class is used to represent the result of an
Chris Lattner4647a212007-08-31 22:49:20 +000080/// expression that is evaluated. It can be one of three things: either a
81/// simple LLVM SSA value, a pair of SSA values for complex numbers, or the
82/// address of an aggregate value in memory.
Chris Lattner8394d792007-06-05 20:53:16 +000083class RValue {
Chris Lattner4647a212007-08-31 22:49:20 +000084 llvm::Value *V1, *V2;
Chris Lattnerdb91b162007-06-02 00:16:28 +000085 // TODO: Encode this into the low bit of pointer for more efficient
86 // return-by-value.
Chris Lattner4647a212007-08-31 22:49:20 +000087 enum { Scalar, Complex, Aggregate } Flavor;
Chris Lattner09153c02007-06-22 18:48:09 +000088
89 // FIXME: Aggregate rvalues need to retain information about whether they are
90 // volatile or not.
Chris Lattner5269c032007-05-30 21:03:58 +000091public:
92
Chris Lattner4647a212007-08-31 22:49:20 +000093 bool isScalar() const { return Flavor == Scalar; }
94 bool isComplex() const { return Flavor == Complex; }
95 bool isAggregate() const { return Flavor == Aggregate; }
Chris Lattner5269c032007-05-30 21:03:58 +000096
Chris Lattner4647a212007-08-31 22:49:20 +000097 /// getScalar() - Return the Value* of this scalar value.
98 llvm::Value *getScalarVal() const {
99 assert(isScalar() && "Not a scalar!");
100 return V1;
Chris Lattner5269c032007-05-30 21:03:58 +0000101 }
102
Chris Lattner4647a212007-08-31 22:49:20 +0000103 /// getComplexVal - Return the real/imag components of this complex value.
104 ///
105 std::pair<llvm::Value *, llvm::Value *> getComplexVal() const {
106 return std::pair<llvm::Value *, llvm::Value *>(V1, V2);
107 }
108
Chris Lattner09153c02007-06-22 18:48:09 +0000109 /// getAggregateAddr() - Return the Value* of the address of the aggregate.
110 llvm::Value *getAggregateAddr() const {
Chris Lattner5269c032007-05-30 21:03:58 +0000111 assert(isAggregate() && "Not an aggregate!");
Chris Lattner4647a212007-08-31 22:49:20 +0000112 return V1;
Chris Lattner5269c032007-05-30 21:03:58 +0000113 }
Chris Lattner208ae962007-05-30 17:57:17 +0000114
Chris Lattner23b7eb62007-06-15 23:05:46 +0000115 static RValue get(llvm::Value *V) {
Chris Lattner8394d792007-06-05 20:53:16 +0000116 RValue ER;
Chris Lattner4647a212007-08-31 22:49:20 +0000117 ER.V1 = V;
118 ER.Flavor = Scalar;
119 return ER;
120 }
121 static RValue getComplex(llvm::Value *V1, llvm::Value *V2) {
122 RValue ER;
123 ER.V1 = V1;
124 ER.V2 = V2;
125 ER.Flavor = Complex;
126 return ER;
127 }
128 static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) {
129 RValue ER;
130 ER.V1 = C.first;
131 ER.V2 = C.second;
132 ER.Flavor = Complex;
Chris Lattner208ae962007-05-30 17:57:17 +0000133 return ER;
134 }
Chris Lattner23b7eb62007-06-15 23:05:46 +0000135 static RValue getAggregate(llvm::Value *V) {
Chris Lattner8394d792007-06-05 20:53:16 +0000136 RValue ER;
Chris Lattner4647a212007-08-31 22:49:20 +0000137 ER.V1 = V;
138 ER.Flavor = Aggregate;
Chris Lattner208ae962007-05-30 17:57:17 +0000139 return ER;
140 }
141};
Chris Lattnerd7f58862007-06-02 05:24:33 +0000142
143
144/// LValue - This represents an lvalue references. Because C/C++ allow
145/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a
146/// bitrange.
147class LValue {
148 // FIXME: Volatility. Restrict?
Chris Lattner8394d792007-06-05 20:53:16 +0000149 // alignment?
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000150
151 enum {
Chris Lattner9e751ca2007-08-02 23:37:31 +0000152 Simple, // This is a normal l-value, use getAddress().
153 VectorElt, // This is a vector element l-value (V[i]), use getVector*
154 BitField, // This is a bitfield l-value, use getBitfield*.
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000155 OCUVectorElt // This is an ocu vector subset, use getOCUVectorComp
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000156 } LVType;
157
Chris Lattnerd7f58862007-06-02 05:24:33 +0000158 llvm::Value *V;
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000159
160 union {
Chris Lattner9e751ca2007-08-02 23:37:31 +0000161 llvm::Value *VectorIdx; // Index into a vector subscript: V[i]
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000162 unsigned VectorElts; // Encoded OCUVector element subset: V.xyx
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +0000163 struct {
164 unsigned short StartBit;
165 unsigned short Size;
166 bool IsSigned;
167 } BitfieldData; // BitField start bit and size
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000168 };
Chris Lattnerd7f58862007-06-02 05:24:33 +0000169public:
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000170 bool isSimple() const { return LVType == Simple; }
171 bool isVectorElt() const { return LVType == VectorElt; }
172 bool isBitfield() const { return LVType == BitField; }
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000173 bool isOCUVectorElt() const { return LVType == OCUVectorElt; }
Chris Lattner208ae962007-05-30 17:57:17 +0000174
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000175 // simple lvalue
176 llvm::Value *getAddress() const { assert(isSimple()); return V; }
177 // vector elt lvalue
178 llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; }
179 llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; }
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000180 // ocu vector elements.
181 llvm::Value *getOCUVectorAddr() const { assert(isOCUVectorElt()); return V; }
182 unsigned getOCUVectorElts() const {
183 assert(isOCUVectorElt());
184 return VectorElts;
Chris Lattner9e751ca2007-08-02 23:37:31 +0000185 }
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +0000186 // bitfield lvalue
187 llvm::Value *getBitfieldAddr() const { assert(isBitfield()); return V; }
188 unsigned short getBitfieldStartBit() const {
189 assert(isBitfield());
190 return BitfieldData.StartBit;
191 }
192 unsigned short getBitfieldSize() const {
193 assert(isBitfield());
194 return BitfieldData.Size;
195 }
196 bool isBitfieldSigned() const {
197 assert(isBitfield());
198 return BitfieldData.IsSigned;
199 }
200
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000201 static LValue MakeAddr(llvm::Value *V) {
Chris Lattnerd7f58862007-06-02 05:24:33 +0000202 LValue R;
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000203 R.LVType = Simple;
Chris Lattnerd7f58862007-06-02 05:24:33 +0000204 R.V = V;
205 return R;
206 }
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000207
208 static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx) {
209 LValue R;
210 R.LVType = VectorElt;
211 R.V = Vec;
212 R.VectorIdx = Idx;
213 return R;
214 }
215
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000216 static LValue MakeOCUVectorElt(llvm::Value *Vec, unsigned Elements) {
Chris Lattner9e751ca2007-08-02 23:37:31 +0000217 LValue R;
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000218 R.LVType = OCUVectorElt;
Chris Lattner9e751ca2007-08-02 23:37:31 +0000219 R.V = Vec;
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000220 R.VectorElts = Elements;
Chris Lattner9e751ca2007-08-02 23:37:31 +0000221 return R;
222 }
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +0000223
224 static LValue MakeBitfield(llvm::Value *V, unsigned short StartBit,
225 unsigned short Size, bool IsSigned) {
226 LValue R;
227 R.LVType = BitField;
228 R.V = V;
229 R.BitfieldData.StartBit = StartBit;
230 R.BitfieldData.Size = Size;
231 R.BitfieldData.IsSigned = IsSigned;
232 return R;
233 }
Chris Lattnerd7f58862007-06-02 05:24:33 +0000234};
235
Chris Lattnerbed31442007-05-28 01:07:47 +0000236/// CodeGenFunction - This class organizes the per-function state that is used
237/// while generating LLVM code.
238class CodeGenFunction {
Chris Lattnerbda69f82007-08-26 23:13:56 +0000239public:
Chris Lattnerbed31442007-05-28 01:07:47 +0000240 CodeGenModule &CGM; // Per-module state.
Chris Lattnerd1af2d22007-05-29 23:17:50 +0000241 TargetInfo &Target;
Chris Lattnerbda69f82007-08-26 23:13:56 +0000242
Chris Lattner96d72562007-08-21 16:57:55 +0000243 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Devang Patel7ad0c2f2007-10-09 19:49:58 +0000244 llvm::LLVMFoldingBuilder Builder;
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000245
246 const FunctionDecl *CurFuncDecl;
Chris Lattnerac248202007-05-30 00:13:02 +0000247 llvm::Function *CurFn;
248
Chris Lattner03df1222007-06-02 04:53:11 +0000249 /// AllocaInsertPoint - This is an instruction in the entry block before which
250 /// we prefer to insert allocas.
251 llvm::Instruction *AllocaInsertPt;
252
Chris Lattner6db1fb82007-06-02 22:49:07 +0000253 const llvm::Type *LLVMIntTy;
Hartmut Kaiser7078da82007-10-17 15:00:17 +0000254 uint32_t LLVMPointerWidth;
Chris Lattner6db1fb82007-06-02 22:49:07 +0000255
Chris Lattner2da04b32007-08-24 05:35:26 +0000256private:
Chris Lattner84915fa2007-06-02 04:16:21 +0000257 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
258 /// decls.
Chris Lattner23b7eb62007-06-15 23:05:46 +0000259 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
Chris Lattner84915fa2007-06-02 04:16:21 +0000260
Chris Lattnerac248202007-05-30 00:13:02 +0000261 /// LabelMap - This keeps track of the LLVM basic block for each C label.
Chris Lattner23b7eb62007-06-15 23:05:46 +0000262 llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
Chris Lattnere73e4322007-07-16 21:28:45 +0000263
264 // BreakContinueStack - This keeps track of where break and continue
265 // statements should jump to.
266 struct BreakContinue {
267 BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb)
268 : BreakBlock(bb), ContinueBlock(cb) {}
269
270 llvm::BasicBlock *BreakBlock;
271 llvm::BasicBlock *ContinueBlock;
272 };
273 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
274
Devang Patel49a44f32007-10-09 17:08:50 +0000275 /// SwitchInsn - This is nearest current switch instruction. It is null if
276 /// if current context is not in a switch.
Devang Patelda5d6bb2007-10-04 23:45:31 +0000277 llvm::SwitchInst *SwitchInsn;
278
Devang Patel49a44f32007-10-09 17:08:50 +0000279 /// CaseRangeBlock - This block holds if condition check for last case
280 /// statement range in current switch instruction.
Devang Patel11663122007-10-08 20:57:48 +0000281 llvm::BasicBlock *CaseRangeBlock;
282
Chris Lattnerbed31442007-05-28 01:07:47 +0000283public:
Chris Lattnerd1af2d22007-05-29 23:17:50 +0000284 CodeGenFunction(CodeGenModule &cgm);
Chris Lattnerbed31442007-05-28 01:07:47 +0000285
Chris Lattner6db1fb82007-06-02 22:49:07 +0000286 ASTContext &getContext() const;
287
Chris Lattner308f4312007-05-29 23:50:05 +0000288 void GenerateCode(const FunctionDecl *FD);
289
Chris Lattnerf033c142007-06-22 19:05:19 +0000290 const llvm::Type *ConvertType(QualType T);
Chris Lattnerac248202007-05-30 00:13:02 +0000291
Chris Lattner54fb19e2007-06-22 22:02:34 +0000292 /// hasAggregateLLVMType - Return true if the specified AST type will map into
293 /// an aggregate LLVM type or is void.
294 static bool hasAggregateLLVMType(QualType T);
295
Chris Lattnerac248202007-05-30 00:13:02 +0000296 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
297 /// label maps to.
298 llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
299
300
Chris Lattner23b7eb62007-06-15 23:05:46 +0000301 void EmitBlock(llvm::BasicBlock *BB);
Chris Lattnerfc944342007-12-02 01:43:38 +0000302
303 /// WarnUnsupported - Print out a warning that codegen doesn't support the
304 /// specified stmt yet.
Chris Lattnerf0780fa2007-12-02 01:49:16 +0000305 void WarnUnsupported(const Stmt *S, const char *Type);
Chris Lattner84915fa2007-06-02 04:16:21 +0000306
Chris Lattnere9a64532007-06-22 21:44:33 +0000307 //===--------------------------------------------------------------------===//
308 // Helpers
309 //===--------------------------------------------------------------------===//
310
311 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
312 /// block.
313 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
314 const char *Name = "tmp");
315
Chris Lattner8394d792007-06-05 20:53:16 +0000316 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
317 /// expression and compare the result against zero, returning an Int1Ty value.
Chris Lattner23b7eb62007-06-15 23:05:46 +0000318 llvm::Value *EvaluateExprAsBool(const Expr *E);
Chris Lattnere9a64532007-06-22 21:44:33 +0000319
Chris Lattner4647a212007-08-31 22:49:20 +0000320 /// EmitAnyExpr - Emit code to compute the specified expression which can have
321 /// any type. The result is returned as an RValue struct. If this is an
322 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
323 /// the result should be returned.
324 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
325 bool isAggLocVolatile = false);
Devang Patel8ec4f832007-09-28 21:49:18 +0000326
327 /// isDummyBlock - Return true if BB is an empty basic block
328 /// with no predecessors.
329 static bool isDummyBlock(const llvm::BasicBlock *BB);
330
Devang Patelda5d6bb2007-10-04 23:45:31 +0000331 /// StartBlock - Start new block named N. If insert block is a dummy block
332 /// then reuse it.
333 void StartBlock(const char *N);
334
Devang Patele11664a2007-11-01 19:11:01 +0000335 /// getCGRecordLayout - Return record layout info.
336 const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
Chris Lattner8394d792007-06-05 20:53:16 +0000337 //===--------------------------------------------------------------------===//
Chris Lattner53621a52007-06-13 20:44:40 +0000338 // Declaration Emission
Chris Lattner84915fa2007-06-02 04:16:21 +0000339 //===--------------------------------------------------------------------===//
340
Chris Lattner1ad38f82007-06-09 01:20:56 +0000341 void EmitDecl(const Decl &D);
Chris Lattner84915fa2007-06-02 04:16:21 +0000342 void EmitEnumConstantDecl(const EnumConstantDecl &D);
Chris Lattner03df1222007-06-02 04:53:11 +0000343 void EmitBlockVarDecl(const BlockVarDecl &D);
344 void EmitLocalBlockVarDecl(const BlockVarDecl &D);
Anders Carlssonf94cd1f2007-10-17 00:52:43 +0000345 void EmitStaticBlockVarDecl(const BlockVarDecl &D);
Chris Lattner53621a52007-06-13 20:44:40 +0000346 void EmitParmDecl(const ParmVarDecl &D, llvm::Value *Arg);
Chris Lattner03df1222007-06-02 04:53:11 +0000347
Chris Lattner84915fa2007-06-02 04:16:21 +0000348 //===--------------------------------------------------------------------===//
Chris Lattner308f4312007-05-29 23:50:05 +0000349 // Statement Emission
350 //===--------------------------------------------------------------------===//
351
352 void EmitStmt(const Stmt *S);
Chris Lattner4647a212007-08-31 22:49:20 +0000353 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
354 llvm::Value *AggLoc = 0, bool isAggVol = false);
Chris Lattnerac248202007-05-30 00:13:02 +0000355 void EmitLabelStmt(const LabelStmt &S);
356 void EmitGotoStmt(const GotoStmt &S);
Chris Lattner5269c032007-05-30 21:03:58 +0000357 void EmitIfStmt(const IfStmt &S);
Chris Lattner946aa312007-06-05 03:59:43 +0000358 void EmitWhileStmt(const WhileStmt &S);
Chris Lattner8394d792007-06-05 20:53:16 +0000359 void EmitDoStmt(const DoStmt &S);
360 void EmitForStmt(const ForStmt &S);
Chris Lattner3f3dbee2007-06-02 03:19:07 +0000361 void EmitReturnStmt(const ReturnStmt &S);
Chris Lattner1ad38f82007-06-09 01:20:56 +0000362 void EmitDeclStmt(const DeclStmt &S);
Chris Lattnere73e4322007-07-16 21:28:45 +0000363 void EmitBreakStmt();
364 void EmitContinueStmt();
Devang Patelda5d6bb2007-10-04 23:45:31 +0000365 void EmitSwitchStmt(const SwitchStmt &S);
366 void EmitDefaultStmt(const DefaultStmt &S);
367 void EmitCaseStmt(const CaseStmt &S);
Devang Patel11663122007-10-08 20:57:48 +0000368 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlsson952a9952008-02-05 16:35:33 +0000369 void EmitAsmStmt(const AsmStmt &S);
370
Chris Lattner208ae962007-05-30 17:57:17 +0000371 //===--------------------------------------------------------------------===//
Chris Lattnerd7f58862007-06-02 05:24:33 +0000372 // LValue Expression Emission
373 //===--------------------------------------------------------------------===//
Chris Lattner8394d792007-06-05 20:53:16 +0000374
375 /// EmitLValue - Emit code to compute a designator that specifies the location
376 /// of the expression.
377 ///
378 /// This can return one of two things: a simple address or a bitfield
379 /// reference. In either case, the LLVM Value* in the LValue structure is
380 /// guaranteed to be an LLVM pointer type.
381 ///
382 /// If this returns a bitfield reference, nothing about the pointee type of
383 /// the LLVM value is known: For example, it may not be a pointer to an
384 /// integer.
385 ///
386 /// If this returns a normal address, and if the lvalue's C type is fixed
387 /// size, this method guarantees that the returned pointer type will point to
388 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
389 /// variable length type, this is not possible.
390 ///
Chris Lattnerd7f58862007-06-02 05:24:33 +0000391 LValue EmitLValue(const Expr *E);
Chris Lattner8394d792007-06-05 20:53:16 +0000392
393 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
394 /// this method emits the address of the lvalue, then loads the result as an
395 /// rvalue, returning the rvalue.
Chris Lattner9369a562007-06-29 16:31:29 +0000396 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000397 RValue EmitLoadOfOCUElementLValue(LValue V, QualType LVType);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +0000398 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
Chris Lattner9369a562007-06-29 16:31:29 +0000399
Chris Lattner40ff7012007-08-03 16:18:34 +0000400
Chris Lattner8394d792007-06-05 20:53:16 +0000401 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
402 /// lvalue, where both are guaranteed to the have the same type, and that type
403 /// is 'Ty'.
404 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Chris Lattner41d480e2007-08-03 16:28:33 +0000405 void EmitStoreThroughOCUComponentLValue(RValue Src, LValue Dst, QualType Ty);
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +0000406 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty);
Christopher Lambd91c3d42007-12-29 05:02:41 +0000407
408 // Note: only availabe for agg return types
409 LValue EmitCallExprLValue(const CallExpr *E);
Chris Lattner8394d792007-06-05 20:53:16 +0000410
Chris Lattnerd7f58862007-06-02 05:24:33 +0000411 LValue EmitDeclRefLValue(const DeclRefExpr *E);
Chris Lattner4347e3692007-06-06 04:54:52 +0000412 LValue EmitStringLiteralLValue(const StringLiteral *E);
Anders Carlsson625bfc82007-07-21 05:21:51 +0000413 LValue EmitPreDefinedLValue(const PreDefinedExpr *E);
Chris Lattner8394d792007-06-05 20:53:16 +0000414 LValue EmitUnaryOpLValue(const UnaryOperator *E);
Chris Lattnerd9d2fb12007-06-08 23:31:14 +0000415 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Chris Lattnerd268a7a2007-08-03 17:31:20 +0000416 LValue EmitOCUVectorElementExpr(const OCUVectorElementExpr *E);
Devang Patel3e11cce2007-10-23 02:10:49 +0000417 LValue EmitMemberExpr(const MemberExpr *E);
Chris Lattnerd7f58862007-06-02 05:24:33 +0000418
419 //===--------------------------------------------------------------------===//
Chris Lattner6278e6a2007-08-11 00:04:45 +0000420 // Scalar Expression Emission
Chris Lattner208ae962007-05-30 17:57:17 +0000421 //===--------------------------------------------------------------------===//
422
Chris Lattner2b228c92007-06-15 21:34:29 +0000423 RValue EmitCallExpr(const CallExpr *E);
Eli Friedman9d92ce82008-01-30 01:32:06 +0000424 RValue EmitCallExpr(Expr *FnExpr, Expr *const *Args, unsigned NumArgs);
425 RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
426 Expr *const *Args, unsigned NumArgs);
Chris Lattner6c555f92007-08-26 22:58:05 +0000427 RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Chris Lattner8394d792007-06-05 20:53:16 +0000428
Anders Carlsson895af082007-12-09 23:17:02 +0000429 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
430 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
431
Anders Carlssonb9eb82c2007-12-10 19:35:18 +0000432 llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
Nate Begeman330aaa72007-12-30 02:59:45 +0000433 llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
434 bool isSplat = false);
Anders Carlssonf5f65442007-12-15 21:23:30 +0000435
Chris Lattner2da04b32007-08-24 05:35:26 +0000436 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Anders Carlsson76f4a902007-08-21 17:43:55 +0000437
Chris Lattner6278e6a2007-08-11 00:04:45 +0000438 //===--------------------------------------------------------------------===//
Chris Lattnerbda69f82007-08-26 23:13:56 +0000439 // Expression Emission
Chris Lattner6278e6a2007-08-11 00:04:45 +0000440 //===--------------------------------------------------------------------===//
Chris Lattnerbda69f82007-08-26 23:13:56 +0000441
442 // Expressions are broken into three classes: scalar, complex, aggregate.
Chris Lattner6278e6a2007-08-11 00:04:45 +0000443
Chris Lattner2da04b32007-08-24 05:35:26 +0000444 /// EmitScalarExpr - Emit the computation of the specified expression of
445 /// LLVM scalar type, returning the result.
446 llvm::Value *EmitScalarExpr(const Expr *E);
447
Chris Lattner3474c202007-08-26 06:48:56 +0000448 /// EmitScalarConversion - Emit a conversion from the specified type to the
449 /// specified destination type, both of which are LLVM scalar types.
450 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
451 QualType DstTy);
452
Chris Lattner42e6b812007-08-26 16:34:22 +0000453 /// EmitComplexToScalarConversion - Emit a conversion from the specified
454 /// complex type to the specified destination type, where the destination
455 /// type is an LLVM scalar type.
456 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
457 QualType DstTy);
458
Chris Lattner3474c202007-08-26 06:48:56 +0000459
Chris Lattner6278e6a2007-08-11 00:04:45 +0000460 /// EmitAggExpr - Emit the computation of the specified expression of
461 /// aggregate type. The result is computed into DestPtr. Note that if
462 /// DestPtr is null, the value of the aggregate expression is not needed.
463 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest);
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000464
465 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner08b15df2007-08-23 23:43:33 +0000466 /// complex type, returning the result.
Chris Lattner96d72562007-08-21 16:57:55 +0000467 ComplexPairTy EmitComplexExpr(const Expr *E);
Chris Lattner08b15df2007-08-23 23:43:33 +0000468
469 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
470 /// of complex type, storing into the specified Value*.
Chris Lattnerb84bb952007-08-26 16:22:13 +0000471 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
472 bool DestIsVolatile);
Chris Lattner4647a212007-08-31 22:49:20 +0000473 /// LoadComplexFromAddr - Load a complex number from the specified address.
474 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattnerbed31442007-05-28 01:07:47 +0000475};
476} // end namespace CodeGen
477} // end namespace clang
Chris Lattnerbed31442007-05-28 01:07:47 +0000478
479#endif