CodeGenFunction.h revision dde0a94120915fa925d1ffcdb997c7b44dc9fa21 
1//===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This is the internal per-function state used for llvm translation.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef CLANG_CODEGEN_CODEGENFUNCTION_H
15#define CLANG_CODEGEN_CODEGENFUNCTION_H
16
17#include "clang/AST/Type.h"
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/Support/IRBuilder.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/AST/ExprObjC.h"
24
25#include <vector>
26#include <map>
27
28#include "CGCall.h"
29#include "CGValue.h"
30
31namespace llvm {
32  class BasicBlock;
33  class Module;
34}
35
36namespace clang {
37  class ASTContext;
38  class Decl;
39  class EnumConstantDecl;
40  class FunctionDecl;
41  class FunctionTypeProto;
42  class LabelStmt;
43  class ObjCMethodDecl;
44  class ObjCPropertyImplDecl;
45  class TargetInfo;
46  class VarDecl;
47
48namespace CodeGen {
49  class CodeGenModule;
50  class CodeGenTypes;
51  class CGRecordLayout;
52
53/// CodeGenFunction - This class organizes the per-function state that is used
54/// while generating LLVM code.
55class CodeGenFunction {
56public:
57  CodeGenModule &CGM;  // Per-module state.
58  TargetInfo &Target;
59
60  typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
61  llvm::IRBuilder<> Builder;
62
63  // Holds the Decl for the current function or method
64  const Decl *CurFuncDecl;
65  QualType FnRetTy;
66  llvm::Function *CurFn;
67
68  /// ReturnBlock - Unified return block.
69  llvm::BasicBlock *ReturnBlock;
70  /// ReturnValue - The temporary alloca to hold the return value. This
71  /// is null iff the function has no return value.
72  llvm::Instruction *ReturnValue;
73
74  /// AllocaInsertPoint - This is an instruction in the entry block before which
75  /// we prefer to insert allocas.
76  llvm::Instruction *AllocaInsertPt;
77
78  const llvm::Type *LLVMIntTy;
79  uint32_t LLVMPointerWidth;
80
81private:
82  /// LabelIDs - Track arbitrary ids assigned to labels for use in
83  /// implementing the GCC address-of-label extension and indirect
84  /// goto. IDs are assigned to labels inside getIDForAddrOfLabel().
85  std::map<const LabelStmt*, unsigned> LabelIDs;
86
87  /// IndirectSwitches - Record the list of switches for indirect
88  /// gotos. Emission of the actual switching code needs to be delayed
89  /// until all AddrLabelExprs have been seen.
90  std::vector<llvm::SwitchInst*> IndirectSwitches;
91
92  /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
93  /// decls.
94  llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
95
96  /// LabelMap - This keeps track of the LLVM basic block for each C label.
97  llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
98
99  // BreakContinueStack - This keeps track of where break and continue
100  // statements should jump to.
101  struct BreakContinue {
102    BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb)
103      : BreakBlock(bb), ContinueBlock(cb) {}
104
105    llvm::BasicBlock *BreakBlock;
106    llvm::BasicBlock *ContinueBlock;
107  };
108  llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
109
110  /// SwitchInsn - This is nearest current switch instruction. It is null if
111  /// if current context is not in a switch.
112  llvm::SwitchInst *SwitchInsn;
113
114  /// CaseRangeBlock - This block holds if condition check for last case
115  /// statement range in current switch instruction.
116  llvm::BasicBlock *CaseRangeBlock;
117
118public:
119  CodeGenFunction(CodeGenModule &cgm);
120
121  ASTContext &getContext() const;
122
123  void GenerateObjCMethod(const ObjCMethodDecl *OMD);
124
125  void StartObjCMethod(const ObjCMethodDecl *MD);
126
127  /// GenerateObjCGetter - Synthesize an Objective-C property getter
128  /// function.
129  void GenerateObjCGetter(const ObjCPropertyImplDecl *PID);
130
131  /// GenerateObjCSetter - Synthesize an Objective-C property setter
132  /// function for the given property.
133  void GenerateObjCSetter(const ObjCPropertyImplDecl *PID);
134
135  void GenerateCode(const FunctionDecl *FD,
136                    llvm::Function *Fn);
137  void StartFunction(const Decl *D, QualType RetTy,
138                     llvm::Function *Fn,
139                     const FunctionArgList &Args);
140  void FinishFunction(SourceLocation EndLoc=SourceLocation());
141
142  /// EmitFunctionProlog - Emit the target specific LLVM code to load
143  /// the arguments for the given function. This is also responsible
144  /// for naming the LLVM function arguments.
145  void EmitFunctionProlog(llvm::Function *Fn, QualType RetTy,
146                          const FunctionArgList &Args);
147
148  /// EmitFunctionEpilog - Emit the target specific LLVM code to
149  /// return the given temporary.
150  void EmitFunctionEpilog(QualType RetTy,
151                          llvm::Value *ReturnValue);
152
153  const llvm::Type *ConvertType(QualType T);
154
155  /// LoadObjCSelf - Load the value of self. This function is only
156  /// valid while generating code for an Objective-C method.
157  llvm::Value *LoadObjCSelf();
158
159  /// isObjCPointerType - Return true if the specificed AST type will map onto
160  /// some Objective-C pointer type.
161  static bool isObjCPointerType(QualType T);
162
163  /// hasAggregateLLVMType - Return true if the specified AST type will map into
164  /// an aggregate LLVM type or is void.
165  static bool hasAggregateLLVMType(QualType T);
166
167  /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
168  /// label maps to.
169  llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
170
171
172  void EmitBlock(llvm::BasicBlock *BB);
173
174  /// ErrorUnsupported - Print out an error that codegen doesn't support the
175  /// specified stmt yet.
176  void ErrorUnsupported(const Stmt *S, const char *Type,
177                        bool OmitOnError=false);
178
179  //===--------------------------------------------------------------------===//
180  //                                  Helpers
181  //===--------------------------------------------------------------------===//
182
183  /// CreateTempAlloca - This creates a alloca and inserts it into the entry
184  /// block.
185  llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
186                                     const char *Name = "tmp");
187
188  /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
189  /// expression and compare the result against zero, returning an Int1Ty value.
190  llvm::Value *EvaluateExprAsBool(const Expr *E);
191
192  /// EmitAnyExpr - Emit code to compute the specified expression which can have
193  /// any type.  The result is returned as an RValue struct.  If this is an
194  /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
195  /// the result should be returned.
196  RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
197                     bool isAggLocVolatile = false);
198
199  /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result
200  /// will always be accessible even if no aggregate location is
201  /// provided.
202  RValue EmitAnyExprToTemp(const Expr *E, llvm::Value *AggLoc = 0,
203                           bool isAggLocVolatile = false);
204
205  void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
206                         QualType EltTy);
207
208  void EmitAggregateClear(llvm::Value *DestPtr, QualType Ty);
209
210  /// isDummyBlock - Return true if BB is an empty basic block
211  /// with no predecessors.
212  static bool isDummyBlock(const llvm::BasicBlock *BB);
213
214  /// StartBlock - Start new block named N. If insert block is a dummy block
215  /// then reuse it.
216  void StartBlock(const char *N);
217
218  /// getCGRecordLayout - Return record layout info.
219  const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
220
221  /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
222  llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD);
223
224  /// GetAddrOfLocalVar - Return the address of a local variable.
225  llvm::Value *GetAddrOfLocalVar(const VarDecl *VD);
226
227  /// getAccessedFieldNo - Given an encoded value and a result number, return
228  /// the input field number being accessed.
229  static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
230
231  unsigned GetIDForAddrOfLabel(const LabelStmt *L);
232
233  /// EmitMemSetToZero - Generate code to memset a value of the given type to 0;
234  void EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty);
235
236  //===--------------------------------------------------------------------===//
237  //                            Declaration Emission
238  //===--------------------------------------------------------------------===//
239
240  void EmitDecl(const Decl &D);
241  void EmitBlockVarDecl(const VarDecl &D);
242  void EmitLocalBlockVarDecl(const VarDecl &D);
243  void EmitStaticBlockVarDecl(const VarDecl &D);
244
245  /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
246  void EmitParmDecl(const VarDecl &D, llvm::Value *Arg);
247
248  //===--------------------------------------------------------------------===//
249  //                             Statement Emission
250  //===--------------------------------------------------------------------===//
251
252  void EmitStmt(const Stmt *S);
253  RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
254                          llvm::Value *AggLoc = 0, bool isAggVol = false);
255  void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt.
256  void EmitLabelStmt(const LabelStmt &S);
257  void EmitGotoStmt(const GotoStmt &S);
258  void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
259  void EmitIfStmt(const IfStmt &S);
260  void EmitWhileStmt(const WhileStmt &S);
261  void EmitDoStmt(const DoStmt &S);
262  void EmitForStmt(const ForStmt &S);
263  void EmitReturnStmt(const ReturnStmt &S);
264  void EmitDeclStmt(const DeclStmt &S);
265  void EmitBreakStmt();
266  void EmitContinueStmt();
267  void EmitSwitchStmt(const SwitchStmt &S);
268  void EmitDefaultStmt(const DefaultStmt &S);
269  void EmitCaseStmt(const CaseStmt &S);
270  void EmitCaseStmtRange(const CaseStmt &S);
271  void EmitAsmStmt(const AsmStmt &S);
272
273  void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
274  void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
275  void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
276
277  //===--------------------------------------------------------------------===//
278  //                         LValue Expression Emission
279  //===--------------------------------------------------------------------===//
280
281  /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E
282  /// and issue an ErrorUnsupported style diagnostic (using the
283  /// provided Name).
284  LValue EmitUnsupportedLValue(const Expr *E,
285                               const char *Name);
286
287  /// EmitLValue - Emit code to compute a designator that specifies the location
288  /// of the expression.
289  ///
290  /// This can return one of two things: a simple address or a bitfield
291  /// reference.  In either case, the LLVM Value* in the LValue structure is
292  /// guaranteed to be an LLVM pointer type.
293  ///
294  /// If this returns a bitfield reference, nothing about the pointee type of
295  /// the LLVM value is known: For example, it may not be a pointer to an
296  /// integer.
297  ///
298  /// If this returns a normal address, and if the lvalue's C type is fixed
299  /// size, this method guarantees that the returned pointer type will point to
300  /// an LLVM type of the same size of the lvalue's type.  If the lvalue has a
301  /// variable length type, this is not possible.
302  ///
303  LValue EmitLValue(const Expr *E);
304
305  /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
306  /// this method emits the address of the lvalue, then loads the result as an
307  /// rvalue, returning the rvalue.
308  RValue EmitLoadOfLValue(LValue V, QualType LVType);
309  RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
310  RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
311  RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType);
312
313
314  /// EmitStoreThroughLValue - Store the specified rvalue into the specified
315  /// lvalue, where both are guaranteed to the have the same type, and that type
316  /// is 'Ty'.
317  void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
318  void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
319                                                QualType Ty);
320  void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty);
321  void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty);
322
323  // Note: only availabe for agg return types
324  LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
325  // Note: only availabe for agg return types
326  LValue EmitCallExprLValue(const CallExpr *E);
327
328  LValue EmitDeclRefLValue(const DeclRefExpr *E);
329  LValue EmitStringLiteralLValue(const StringLiteral *E);
330  LValue EmitPredefinedLValue(const PredefinedExpr *E);
331  LValue EmitUnaryOpLValue(const UnaryOperator *E);
332  LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
333  LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
334  LValue EmitMemberExpr(const MemberExpr *E);
335  LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
336
337  LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field,
338                            bool isUnion, unsigned CVRQualifiers);
339
340  LValue EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E);
341
342  LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
343  LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
344  LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
345
346  //===--------------------------------------------------------------------===//
347  //                         Scalar Expression Emission
348  //===--------------------------------------------------------------------===//
349
350  /// EmitCall - Generate a call of the given function, expecting the
351  /// given result type, and using the given argument list which
352  /// specifies both the LLVM arguments and the types they were
353  /// derived from.
354  RValue EmitCall(llvm::Value *Callee,
355                  QualType ResultType,
356                  const CallArgList &Args);
357
358  RValue EmitCallExpr(const CallExpr *E);
359
360  RValue EmitCallExpr(Expr *FnExpr, CallExpr::const_arg_iterator ArgBeg,
361                      CallExpr::const_arg_iterator ArgEnd);
362
363  RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
364                      CallExpr::const_arg_iterator ArgBeg,
365                      CallExpr::const_arg_iterator ArgEnd);
366
367  RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
368
369  llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
370  llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
371
372  llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
373  llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
374                          bool isSplat = false);
375
376  llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
377  llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
378  llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
379  RValue EmitObjCMessageExpr(const ObjCMessageExpr *E);
380  RValue EmitObjCPropertyGet(const ObjCPropertyRefExpr *E);
381  void EmitObjCPropertySet(const ObjCPropertyRefExpr *E, RValue Src);
382
383
384  //===--------------------------------------------------------------------===//
385  //                           Expression Emission
386  //===--------------------------------------------------------------------===//
387
388  // Expressions are broken into three classes: scalar, complex, aggregate.
389
390  /// EmitScalarExpr - Emit the computation of the specified expression of
391  /// LLVM scalar type, returning the result.
392  llvm::Value *EmitScalarExpr(const Expr *E);
393
394  /// EmitScalarConversion - Emit a conversion from the specified type to the
395  /// specified destination type, both of which are LLVM scalar types.
396  llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
397                                    QualType DstTy);
398
399  /// EmitComplexToScalarConversion - Emit a conversion from the specified
400  /// complex type to the specified destination type, where the destination
401  /// type is an LLVM scalar type.
402  llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
403                                             QualType DstTy);
404
405
406  /// EmitAggExpr - Emit the computation of the specified expression of
407  /// aggregate type.  The result is computed into DestPtr.  Note that if
408  /// DestPtr is null, the value of the aggregate expression is not needed.
409  void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest);
410
411  /// EmitComplexExpr - Emit the computation of the specified expression of
412  /// complex type, returning the result.
413  ComplexPairTy EmitComplexExpr(const Expr *E);
414
415  /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
416  /// of complex type, storing into the specified Value*.
417  void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
418                               bool DestIsVolatile);
419
420  /// StoreComplexToAddr - Store a complex number into the specified address.
421  void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
422                          bool DestIsVolatile);
423  /// LoadComplexFromAddr - Load a complex number from the specified address.
424  ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
425
426  /// GenerateStaticBlockVarDecl - return the the static
427  /// declaration of local variable.
428  llvm::GlobalValue *GenerateStaticBlockVarDecl(const VarDecl &D,
429                                                bool NoInit,
430                                                const char *Separator);
431
432  // GenerateStaticBlockVarDecl - return the static declaration of
433  // a local variable. Performs initialization of the variable if necessary.
434  llvm::GlobalValue *GenerateStaticCXXBlockVarDecl(const VarDecl &D);
435
436  //===--------------------------------------------------------------------===//
437  //                             Internal Helpers
438  //===--------------------------------------------------------------------===//
439
440private:
441  /// EmitIndirectSwitches - Emit code for all of the switch
442  /// instructions in IndirectSwitches.
443  void EmitIndirectSwitches();
444};
445}  // end namespace CodeGen
446}  // end namespace clang
447
448#endif
449