blob: 0693781bce8f7364b80b8d6b800a4b1a17134c71 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- CodeGenFunction.h - Per-Function state for LLVM CodeGen ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This is the internal per-function state used for llvm translation.
11//
12//===----------------------------------------------------------------------===//
13
Chris Lattneref52a2f2008-02-29 17:10:38 +000014#ifndef CLANG_CODEGEN_CODEGENFUNCTION_H
15#define CLANG_CODEGEN_CODEGENFUNCTION_H
Reid Spencer5f016e22007-07-11 17:01:13 +000016
Chris Lattner391d77a2008-03-30 23:03:07 +000017#include "clang/AST/Type.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000018#include "llvm/ADT/DenseMap.h"
Chris Lattnerda138702007-07-16 21:28:45 +000019#include "llvm/ADT/SmallVector.h"
Chris Lattner50b36742008-04-13 07:32:11 +000020#include "llvm/Support/IRBuilder.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000021#include <vector>
22
23namespace llvm {
24 class Module;
25}
26
27namespace clang {
28 class ASTContext;
29 class Decl;
30 class FunctionDecl;
Chris Lattner391d77a2008-03-30 23:03:07 +000031 class ObjCMethodDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000032 class TargetInfo;
Reid Spencer5f016e22007-07-11 17:01:13 +000033 class FunctionTypeProto;
34
35 class Stmt;
36 class CompoundStmt;
37 class LabelStmt;
38 class GotoStmt;
39 class IfStmt;
40 class WhileStmt;
41 class DoStmt;
42 class ForStmt;
43 class ReturnStmt;
44 class DeclStmt;
Devang Patel51b09f22007-10-04 23:45:31 +000045 class CaseStmt;
46 class DefaultStmt;
47 class SwitchStmt;
Anders Carlssonfb1aeb82008-02-05 16:35:33 +000048 class AsmStmt;
49
Reid Spencer5f016e22007-07-11 17:01:13 +000050 class Expr;
51 class DeclRefExpr;
52 class StringLiteral;
53 class IntegerLiteral;
54 class FloatingLiteral;
Chris Lattnerb0a721a2007-07-13 05:18:11 +000055 class CharacterLiteral;
Chris Lattner30bf3ae2007-08-03 17:51:03 +000056 class TypesCompatibleExpr;
57
Chris Lattner7016a702007-08-20 22:37:10 +000058 class ImplicitCastExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +000059 class CastExpr;
60 class CallExpr;
61 class UnaryOperator;
62 class BinaryOperator;
63 class CompoundAssignOperator;
64 class ArraySubscriptExpr;
Nate Begeman213541a2008-04-18 23:10:10 +000065 class ExtVectorElementExpr;
Chris Lattnerb0a721a2007-07-13 05:18:11 +000066 class ConditionalOperator;
Chris Lattner94f05e32007-08-04 00:20:15 +000067 class ChooseExpr;
Anders Carlsson22742662007-07-21 05:21:51 +000068 class PreDefinedExpr;
Anders Carlsson55085182007-08-21 17:43:55 +000069 class ObjCStringLiteral;
Chris Lattner391d77a2008-03-30 23:03:07 +000070 class ObjCIvarRefExpr;
Devang Patelb84a06e2007-10-23 02:10:49 +000071 class MemberExpr;
Eli Friedman06e863f2008-05-13 23:18:27 +000072 class CompoundLiteralExpr;
Devang Patelb84a06e2007-10-23 02:10:49 +000073
Steve Naroff248a7532008-04-15 22:42:06 +000074 class VarDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000075 class EnumConstantDecl;
76 class ParmVarDecl;
Eli Friedman472778e2008-02-09 08:50:58 +000077 class FieldDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000078namespace CodeGen {
79 class CodeGenModule;
Devang Patelb84a06e2007-10-23 02:10:49 +000080 class CodeGenTypes;
Devang Patel88a981b2007-11-01 19:11:01 +000081 class CGRecordLayout;
Reid Spencer5f016e22007-07-11 17:01:13 +000082
83/// RValue - This trivial value class is used to represent the result of an
Chris Lattner9b655512007-08-31 22:49:20 +000084/// expression that is evaluated. It can be one of three things: either a
85/// simple LLVM SSA value, a pair of SSA values for complex numbers, or the
86/// address of an aggregate value in memory.
Reid Spencer5f016e22007-07-11 17:01:13 +000087class RValue {
Chris Lattner9b655512007-08-31 22:49:20 +000088 llvm::Value *V1, *V2;
Reid Spencer5f016e22007-07-11 17:01:13 +000089 // TODO: Encode this into the low bit of pointer for more efficient
90 // return-by-value.
Chris Lattner9b655512007-08-31 22:49:20 +000091 enum { Scalar, Complex, Aggregate } Flavor;
Reid Spencer5f016e22007-07-11 17:01:13 +000092
93 // FIXME: Aggregate rvalues need to retain information about whether they are
94 // volatile or not.
95public:
96
Chris Lattner9b655512007-08-31 22:49:20 +000097 bool isScalar() const { return Flavor == Scalar; }
98 bool isComplex() const { return Flavor == Complex; }
99 bool isAggregate() const { return Flavor == Aggregate; }
Reid Spencer5f016e22007-07-11 17:01:13 +0000100
Chris Lattner9b655512007-08-31 22:49:20 +0000101 /// getScalar() - Return the Value* of this scalar value.
102 llvm::Value *getScalarVal() const {
103 assert(isScalar() && "Not a scalar!");
104 return V1;
Reid Spencer5f016e22007-07-11 17:01:13 +0000105 }
106
Chris Lattner9b655512007-08-31 22:49:20 +0000107 /// getComplexVal - Return the real/imag components of this complex value.
108 ///
109 std::pair<llvm::Value *, llvm::Value *> getComplexVal() const {
110 return std::pair<llvm::Value *, llvm::Value *>(V1, V2);
111 }
112
Reid Spencer5f016e22007-07-11 17:01:13 +0000113 /// getAggregateAddr() - Return the Value* of the address of the aggregate.
114 llvm::Value *getAggregateAddr() const {
115 assert(isAggregate() && "Not an aggregate!");
Chris Lattner9b655512007-08-31 22:49:20 +0000116 return V1;
Reid Spencer5f016e22007-07-11 17:01:13 +0000117 }
118
119 static RValue get(llvm::Value *V) {
120 RValue ER;
Chris Lattner9b655512007-08-31 22:49:20 +0000121 ER.V1 = V;
122 ER.Flavor = Scalar;
123 return ER;
124 }
125 static RValue getComplex(llvm::Value *V1, llvm::Value *V2) {
126 RValue ER;
127 ER.V1 = V1;
128 ER.V2 = V2;
129 ER.Flavor = Complex;
130 return ER;
131 }
132 static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) {
133 RValue ER;
134 ER.V1 = C.first;
135 ER.V2 = C.second;
136 ER.Flavor = Complex;
Reid Spencer5f016e22007-07-11 17:01:13 +0000137 return ER;
138 }
139 static RValue getAggregate(llvm::Value *V) {
140 RValue ER;
Chris Lattner9b655512007-08-31 22:49:20 +0000141 ER.V1 = V;
142 ER.Flavor = Aggregate;
Reid Spencer5f016e22007-07-11 17:01:13 +0000143 return ER;
144 }
145};
146
147
148/// LValue - This represents an lvalue references. Because C/C++ allow
149/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a
150/// bitrange.
151class LValue {
152 // FIXME: Volatility. Restrict?
153 // alignment?
154
155 enum {
Chris Lattner349aaec2007-08-02 23:37:31 +0000156 Simple, // This is a normal l-value, use getAddress().
157 VectorElt, // This is a vector element l-value (V[i]), use getVector*
158 BitField, // This is a bitfield l-value, use getBitfield*.
Nate Begeman213541a2008-04-18 23:10:10 +0000159 ExtVectorElt // This is an extended vector subset, use getExtVectorComp
Reid Spencer5f016e22007-07-11 17:01:13 +0000160 } LVType;
161
162 llvm::Value *V;
163
164 union {
Nate Begeman8a997642008-05-09 06:41:27 +0000165 // Index into a vector subscript: V[i]
166 llvm::Value *VectorIdx;
167
168 // ExtVector element subset: V.xyx
169 llvm::Constant *VectorElts;
170
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000171 struct {
172 unsigned short StartBit;
173 unsigned short Size;
174 bool IsSigned;
175 } BitfieldData; // BitField start bit and size
Reid Spencer5f016e22007-07-11 17:01:13 +0000176 };
177public:
178 bool isSimple() const { return LVType == Simple; }
179 bool isVectorElt() const { return LVType == VectorElt; }
180 bool isBitfield() const { return LVType == BitField; }
Nate Begeman213541a2008-04-18 23:10:10 +0000181 bool isExtVectorElt() const { return LVType == ExtVectorElt; }
Reid Spencer5f016e22007-07-11 17:01:13 +0000182
183 // simple lvalue
184 llvm::Value *getAddress() const { assert(isSimple()); return V; }
185 // vector elt lvalue
186 llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; }
187 llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; }
Nate Begeman213541a2008-04-18 23:10:10 +0000188 // extended vector elements.
189 llvm::Value *getExtVectorAddr() const { assert(isExtVectorElt()); return V; }
Nate Begeman8a997642008-05-09 06:41:27 +0000190 llvm::Constant *getExtVectorElts() const {
Nate Begeman213541a2008-04-18 23:10:10 +0000191 assert(isExtVectorElt());
Chris Lattner6481a572007-08-03 17:31:20 +0000192 return VectorElts;
Chris Lattner349aaec2007-08-02 23:37:31 +0000193 }
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000194 // bitfield lvalue
195 llvm::Value *getBitfieldAddr() const { assert(isBitfield()); return V; }
196 unsigned short getBitfieldStartBit() const {
197 assert(isBitfield());
198 return BitfieldData.StartBit;
199 }
200 unsigned short getBitfieldSize() const {
201 assert(isBitfield());
202 return BitfieldData.Size;
203 }
204 bool isBitfieldSigned() const {
205 assert(isBitfield());
206 return BitfieldData.IsSigned;
207 }
208
Reid Spencer5f016e22007-07-11 17:01:13 +0000209 static LValue MakeAddr(llvm::Value *V) {
210 LValue R;
211 R.LVType = Simple;
212 R.V = V;
213 return R;
214 }
215
216 static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx) {
217 LValue R;
218 R.LVType = VectorElt;
219 R.V = Vec;
220 R.VectorIdx = Idx;
221 return R;
222 }
223
Nate Begeman8a997642008-05-09 06:41:27 +0000224 static LValue MakeExtVectorElt(llvm::Value *Vec, llvm::Constant *Elts) {
Chris Lattner349aaec2007-08-02 23:37:31 +0000225 LValue R;
Nate Begeman213541a2008-04-18 23:10:10 +0000226 R.LVType = ExtVectorElt;
Chris Lattner349aaec2007-08-02 23:37:31 +0000227 R.V = Vec;
Nate Begeman8a997642008-05-09 06:41:27 +0000228 R.VectorElts = Elts;
Chris Lattner349aaec2007-08-02 23:37:31 +0000229 return R;
230 }
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000231
232 static LValue MakeBitfield(llvm::Value *V, unsigned short StartBit,
233 unsigned short Size, bool IsSigned) {
234 LValue R;
235 R.LVType = BitField;
236 R.V = V;
237 R.BitfieldData.StartBit = StartBit;
238 R.BitfieldData.Size = Size;
239 R.BitfieldData.IsSigned = IsSigned;
240 return R;
241 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000242};
243
244/// CodeGenFunction - This class organizes the per-function state that is used
245/// while generating LLVM code.
246class CodeGenFunction {
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +0000247public:
Reid Spencer5f016e22007-07-11 17:01:13 +0000248 CodeGenModule &CGM; // Per-module state.
249 TargetInfo &Target;
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +0000250
Chris Lattner58dee102007-08-21 16:57:55 +0000251 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Chris Lattner50b36742008-04-13 07:32:11 +0000252 llvm::IRBuilder Builder;
Reid Spencer5f016e22007-07-11 17:01:13 +0000253
Chris Lattnerc8aa5f12008-04-04 04:07:35 +0000254 // Holds the Decl for the current function or method
255 const Decl *CurFuncDecl;
Chris Lattner391d77a2008-03-30 23:03:07 +0000256 QualType FnRetTy;
Reid Spencer5f016e22007-07-11 17:01:13 +0000257 llvm::Function *CurFn;
258
259 /// AllocaInsertPoint - This is an instruction in the entry block before which
260 /// we prefer to insert allocas.
261 llvm::Instruction *AllocaInsertPt;
262
263 const llvm::Type *LLVMIntTy;
Hartmut Kaiser7b660002007-10-17 15:00:17 +0000264 uint32_t LLVMPointerWidth;
Reid Spencer5f016e22007-07-11 17:01:13 +0000265
Chris Lattner7f02f722007-08-24 05:35:26 +0000266private:
Reid Spencer5f016e22007-07-11 17:01:13 +0000267 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
268 /// decls.
269 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
270
271 /// LabelMap - This keeps track of the LLVM basic block for each C label.
272 llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
Chris Lattnerda138702007-07-16 21:28:45 +0000273
274 // BreakContinueStack - This keeps track of where break and continue
275 // statements should jump to.
276 struct BreakContinue {
277 BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb)
278 : BreakBlock(bb), ContinueBlock(cb) {}
279
280 llvm::BasicBlock *BreakBlock;
281 llvm::BasicBlock *ContinueBlock;
282 };
283 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
284
Devang Patel80fd5f92007-10-09 17:08:50 +0000285 /// SwitchInsn - This is nearest current switch instruction. It is null if
286 /// if current context is not in a switch.
Devang Patel51b09f22007-10-04 23:45:31 +0000287 llvm::SwitchInst *SwitchInsn;
288
Devang Patel80fd5f92007-10-09 17:08:50 +0000289 /// CaseRangeBlock - This block holds if condition check for last case
290 /// statement range in current switch instruction.
Devang Patelc049e4f2007-10-08 20:57:48 +0000291 llvm::BasicBlock *CaseRangeBlock;
292
Reid Spencer5f016e22007-07-11 17:01:13 +0000293public:
294 CodeGenFunction(CodeGenModule &cgm);
295
296 ASTContext &getContext() const;
297
Chris Lattner391d77a2008-03-30 23:03:07 +0000298 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Reid Spencer5f016e22007-07-11 17:01:13 +0000299 void GenerateCode(const FunctionDecl *FD);
300
301 const llvm::Type *ConvertType(QualType T);
Chris Lattnerc8aa5f12008-04-04 04:07:35 +0000302
303 llvm::Value *LoadObjCSelf();
Reid Spencer5f016e22007-07-11 17:01:13 +0000304
305 /// hasAggregateLLVMType - Return true if the specified AST type will map into
306 /// an aggregate LLVM type or is void.
307 static bool hasAggregateLLVMType(QualType T);
308
309 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
310 /// label maps to.
311 llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
312
313
314 void EmitBlock(llvm::BasicBlock *BB);
Chris Lattnerdc5e8262007-12-02 01:43:38 +0000315
316 /// WarnUnsupported - Print out a warning that codegen doesn't support the
317 /// specified stmt yet.
Chris Lattnerdc4d2802007-12-02 01:49:16 +0000318 void WarnUnsupported(const Stmt *S, const char *Type);
Reid Spencer5f016e22007-07-11 17:01:13 +0000319
320 //===--------------------------------------------------------------------===//
321 // Helpers
322 //===--------------------------------------------------------------------===//
323
324 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
325 /// block.
326 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
327 const char *Name = "tmp");
328
329 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
330 /// expression and compare the result against zero, returning an Int1Ty value.
331 llvm::Value *EvaluateExprAsBool(const Expr *E);
332
Chris Lattner9b655512007-08-31 22:49:20 +0000333 /// EmitAnyExpr - Emit code to compute the specified expression which can have
334 /// any type. The result is returned as an RValue struct. If this is an
335 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
336 /// the result should be returned.
337 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
338 bool isAggLocVolatile = false);
Devang Pateld9363c32007-09-28 21:49:18 +0000339
340 /// isDummyBlock - Return true if BB is an empty basic block
341 /// with no predecessors.
342 static bool isDummyBlock(const llvm::BasicBlock *BB);
343
Devang Patel51b09f22007-10-04 23:45:31 +0000344 /// StartBlock - Start new block named N. If insert block is a dummy block
345 /// then reuse it.
346 void StartBlock(const char *N);
347
Devang Patel88a981b2007-11-01 19:11:01 +0000348 /// getCGRecordLayout - Return record layout info.
349 const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
Lauro Ramos Venancio81373352008-02-26 21:41:45 +0000350
351 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
Steve Naroff248a7532008-04-15 22:42:06 +0000352 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD);
Reid Spencer5f016e22007-07-11 17:01:13 +0000353 //===--------------------------------------------------------------------===//
Reid Spencer5f016e22007-07-11 17:01:13 +0000354 // Declaration Emission
355 //===--------------------------------------------------------------------===//
356
357 void EmitDecl(const Decl &D);
358 void EmitEnumConstantDecl(const EnumConstantDecl &D);
Steve Naroff248a7532008-04-15 22:42:06 +0000359 void EmitBlockVarDecl(const VarDecl &D);
360 void EmitLocalBlockVarDecl(const VarDecl &D);
361 void EmitStaticBlockVarDecl(const VarDecl &D);
Reid Spencer5f016e22007-07-11 17:01:13 +0000362 void EmitParmDecl(const ParmVarDecl &D, llvm::Value *Arg);
363
364 //===--------------------------------------------------------------------===//
365 // Statement Emission
366 //===--------------------------------------------------------------------===//
367
368 void EmitStmt(const Stmt *S);
Chris Lattner9b655512007-08-31 22:49:20 +0000369 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
370 llvm::Value *AggLoc = 0, bool isAggVol = false);
Reid Spencer5f016e22007-07-11 17:01:13 +0000371 void EmitLabelStmt(const LabelStmt &S);
372 void EmitGotoStmt(const GotoStmt &S);
373 void EmitIfStmt(const IfStmt &S);
374 void EmitWhileStmt(const WhileStmt &S);
375 void EmitDoStmt(const DoStmt &S);
376 void EmitForStmt(const ForStmt &S);
377 void EmitReturnStmt(const ReturnStmt &S);
378 void EmitDeclStmt(const DeclStmt &S);
Chris Lattnerda138702007-07-16 21:28:45 +0000379 void EmitBreakStmt();
380 void EmitContinueStmt();
Devang Patel51b09f22007-10-04 23:45:31 +0000381 void EmitSwitchStmt(const SwitchStmt &S);
382 void EmitDefaultStmt(const DefaultStmt &S);
383 void EmitCaseStmt(const CaseStmt &S);
Devang Patelc049e4f2007-10-08 20:57:48 +0000384 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlssonfb1aeb82008-02-05 16:35:33 +0000385 void EmitAsmStmt(const AsmStmt &S);
386
Reid Spencer5f016e22007-07-11 17:01:13 +0000387 //===--------------------------------------------------------------------===//
388 // LValue Expression Emission
389 //===--------------------------------------------------------------------===//
390
391 /// EmitLValue - Emit code to compute a designator that specifies the location
392 /// of the expression.
393 ///
394 /// This can return one of two things: a simple address or a bitfield
395 /// reference. In either case, the LLVM Value* in the LValue structure is
396 /// guaranteed to be an LLVM pointer type.
397 ///
398 /// If this returns a bitfield reference, nothing about the pointee type of
399 /// the LLVM value is known: For example, it may not be a pointer to an
400 /// integer.
401 ///
402 /// If this returns a normal address, and if the lvalue's C type is fixed
403 /// size, this method guarantees that the returned pointer type will point to
404 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
405 /// variable length type, this is not possible.
406 ///
407 LValue EmitLValue(const Expr *E);
408
409 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
410 /// this method emits the address of the lvalue, then loads the result as an
411 /// rvalue, returning the rvalue.
Reid Spencer5f016e22007-07-11 17:01:13 +0000412 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Nate Begeman213541a2008-04-18 23:10:10 +0000413 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000414 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
Reid Spencer5f016e22007-07-11 17:01:13 +0000415
Chris Lattner34cdc862007-08-03 16:18:34 +0000416
Reid Spencer5f016e22007-07-11 17:01:13 +0000417 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
418 /// lvalue, where both are guaranteed to the have the same type, and that type
419 /// is 'Ty'.
420 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Nate Begeman213541a2008-04-18 23:10:10 +0000421 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
422 QualType Ty);
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000423 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty);
Christopher Lamb22c940e2007-12-29 05:02:41 +0000424
425 // Note: only availabe for agg return types
426 LValue EmitCallExprLValue(const CallExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +0000427
428 LValue EmitDeclRefLValue(const DeclRefExpr *E);
429 LValue EmitStringLiteralLValue(const StringLiteral *E);
Anders Carlsson22742662007-07-21 05:21:51 +0000430 LValue EmitPreDefinedLValue(const PreDefinedExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +0000431 LValue EmitUnaryOpLValue(const UnaryOperator *E);
432 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begeman213541a2008-04-18 23:10:10 +0000433 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patelb84a06e2007-10-23 02:10:49 +0000434 LValue EmitMemberExpr(const MemberExpr *E);
Eli Friedman06e863f2008-05-13 23:18:27 +0000435 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
Eli Friedman472778e2008-02-09 08:50:58 +0000436
437 LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field,
438 bool isUnion);
Chris Lattner391d77a2008-03-30 23:03:07 +0000439
440 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +0000441 //===--------------------------------------------------------------------===//
Chris Lattner883f6a72007-08-11 00:04:45 +0000442 // Scalar Expression Emission
Reid Spencer5f016e22007-07-11 17:01:13 +0000443 //===--------------------------------------------------------------------===//
444
Reid Spencer5f016e22007-07-11 17:01:13 +0000445 RValue EmitCallExpr(const CallExpr *E);
Eli Friedman5193b8a2008-01-30 01:32:06 +0000446 RValue EmitCallExpr(Expr *FnExpr, Expr *const *Args, unsigned NumArgs);
447 RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
448 Expr *const *Args, unsigned NumArgs);
Chris Lattner1e4d21e2007-08-26 22:58:05 +0000449 RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +0000450
Anders Carlsson564f1de2007-12-09 23:17:02 +0000451 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
452 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
453
Anders Carlssoncc23aca2007-12-10 19:35:18 +0000454 llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
Nate Begeman4119d1a2007-12-30 02:59:45 +0000455 llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
456 bool isSplat = false);
Anders Carlsson6086bbd2007-12-15 21:23:30 +0000457
Chris Lattner7f02f722007-08-24 05:35:26 +0000458 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Anders Carlsson55085182007-08-21 17:43:55 +0000459
Chris Lattner883f6a72007-08-11 00:04:45 +0000460 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +0000461 // Expression Emission
Chris Lattner883f6a72007-08-11 00:04:45 +0000462 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +0000463
464 // Expressions are broken into three classes: scalar, complex, aggregate.
Chris Lattner883f6a72007-08-11 00:04:45 +0000465
Chris Lattner7f02f722007-08-24 05:35:26 +0000466 /// EmitScalarExpr - Emit the computation of the specified expression of
467 /// LLVM scalar type, returning the result.
468 llvm::Value *EmitScalarExpr(const Expr *E);
469
Chris Lattner3707b252007-08-26 06:48:56 +0000470 /// EmitScalarConversion - Emit a conversion from the specified type to the
471 /// specified destination type, both of which are LLVM scalar types.
472 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
473 QualType DstTy);
474
Chris Lattner4f1a7b32007-08-26 16:34:22 +0000475 /// EmitComplexToScalarConversion - Emit a conversion from the specified
476 /// complex type to the specified destination type, where the destination
477 /// type is an LLVM scalar type.
478 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
479 QualType DstTy);
480
Chris Lattner3707b252007-08-26 06:48:56 +0000481
Chris Lattner883f6a72007-08-11 00:04:45 +0000482 /// EmitAggExpr - Emit the computation of the specified expression of
483 /// aggregate type. The result is computed into DestPtr. Note that if
484 /// DestPtr is null, the value of the aggregate expression is not needed.
485 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest);
Chris Lattnerb6ef18a2007-08-21 05:54:00 +0000486
487 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner23b1cdb2007-08-23 23:43:33 +0000488 /// complex type, returning the result.
Chris Lattner58dee102007-08-21 16:57:55 +0000489 ComplexPairTy EmitComplexExpr(const Expr *E);
Chris Lattner23b1cdb2007-08-23 23:43:33 +0000490
491 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
492 /// of complex type, storing into the specified Value*.
Chris Lattner190dbe22007-08-26 16:22:13 +0000493 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
494 bool DestIsVolatile);
Chris Lattner9b655512007-08-31 22:49:20 +0000495 /// LoadComplexFromAddr - Load a complex number from the specified address.
496 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattner2621fd12008-05-08 05:58:21 +0000497
498 /// GenerateStaticBlockVarDecl - return the the static
499 /// declaration of local variable.
500 llvm::GlobalValue *GenerateStaticBlockVarDecl(const VarDecl &D,
501 bool NoInit,
502 const char *Separator);
Reid Spencer5f016e22007-07-11 17:01:13 +0000503};
504} // end namespace CodeGen
505} // end namespace clang
506
507#endif