CodeGenFunction.h revision 69ce1dff4a1f86d5bd7135c0491fd628d2d76cc7 
1//===--- CodeGenFunction.h - Per-Function state for LLVM CodeGen ----------===//
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/ExprObjC.h"
23
24#include <vector>
25
26namespace llvm {
27  class Module;
28}
29
30namespace clang {
31  class ASTContext;
32  class Decl;
33  class FunctionDecl;
34  class ObjCMethodDecl;
35  class TargetInfo;
36  class FunctionTypeProto;
37
38namespace CodeGen {
39  class CodeGenModule;
40  class CodeGenTypes;
41  class CGRecordLayout;
42
43/// RValue - This trivial value class is used to represent the result of an
44/// expression that is evaluated.  It can be one of three things: either a
45/// simple LLVM SSA value, a pair of SSA values for complex numbers, or the
46/// address of an aggregate value in memory.
47class RValue {
48  llvm::Value *V1, *V2;
49  // TODO: Encode this into the low bit of pointer for more efficient
50  // return-by-value.
51  enum { Scalar, Complex, Aggregate } Flavor;
52
53  // FIXME: Aggregate rvalues need to retain information about whether they are
54  // volatile or not.
55public:
56
57  bool isScalar() const { return Flavor == Scalar; }
58  bool isComplex() const { return Flavor == Complex; }
59  bool isAggregate() const { return Flavor == Aggregate; }
60
61  /// getScalar() - Return the Value* of this scalar value.
62  llvm::Value *getScalarVal() const {
63    assert(isScalar() && "Not a scalar!");
64    return V1;
65  }
66
67  /// getComplexVal - Return the real/imag components of this complex value.
68  ///
69  std::pair<llvm::Value *, llvm::Value *> getComplexVal() const {
70    return std::pair<llvm::Value *, llvm::Value *>(V1, V2);
71  }
72
73  /// getAggregateAddr() - Return the Value* of the address of the aggregate.
74  llvm::Value *getAggregateAddr() const {
75    assert(isAggregate() && "Not an aggregate!");
76    return V1;
77  }
78
79  static RValue get(llvm::Value *V) {
80    RValue ER;
81    ER.V1 = V;
82    ER.Flavor = Scalar;
83    return ER;
84  }
85  static RValue getComplex(llvm::Value *V1, llvm::Value *V2) {
86    RValue ER;
87    ER.V1 = V1;
88    ER.V2 = V2;
89    ER.Flavor = Complex;
90    return ER;
91  }
92  static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) {
93    RValue ER;
94    ER.V1 = C.first;
95    ER.V2 = C.second;
96    ER.Flavor = Complex;
97    return ER;
98  }
99  static RValue getAggregate(llvm::Value *V) {
100    RValue ER;
101    ER.V1 = V;
102    ER.Flavor = Aggregate;
103    return ER;
104  }
105};
106
107
108/// LValue - This represents an lvalue references.  Because C/C++ allow
109/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a
110/// bitrange.
111class LValue {
112  // FIXME: alignment?
113
114  enum {
115    Simple,       // This is a normal l-value, use getAddress().
116    VectorElt,    // This is a vector element l-value (V[i]), use getVector*
117    BitField,     // This is a bitfield l-value, use getBitfield*.
118    ExtVectorElt  // This is an extended vector subset, use getExtVectorComp
119  } LVType;
120
121  llvm::Value *V;
122
123  union {
124    // Index into a vector subscript: V[i]
125    llvm::Value *VectorIdx;
126
127    // ExtVector element subset: V.xyx
128    llvm::Constant *VectorElts;
129
130    // BitField start bit and size
131    struct {
132      unsigned short StartBit;
133      unsigned short Size;
134      bool IsSigned;
135    } BitfieldData;
136  };
137
138  bool Volatile:1;
139  // FIXME: set but never used, what effect should it have?
140  bool Restrict:1;
141
142private:
143  static void SetQualifiers(unsigned Qualifiers, LValue& R) {
144    R.Volatile = (Qualifiers&QualType::Volatile)!=0;
145    R.Restrict = (Qualifiers&QualType::Restrict)!=0;
146  }
147
148public:
149  bool isSimple() const { return LVType == Simple; }
150  bool isVectorElt() const { return LVType == VectorElt; }
151  bool isBitfield() const { return LVType == BitField; }
152  bool isExtVectorElt() const { return LVType == ExtVectorElt; }
153
154  bool isVolatileQualified() const { return Volatile; }
155  bool isRestrictQualified() const { return Restrict; }
156
157  // simple lvalue
158  llvm::Value *getAddress() const { assert(isSimple()); return V; }
159  // vector elt lvalue
160  llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; }
161  llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; }
162  // extended vector elements.
163  llvm::Value *getExtVectorAddr() const { assert(isExtVectorElt()); return V; }
164  llvm::Constant *getExtVectorElts() const {
165    assert(isExtVectorElt());
166    return VectorElts;
167  }
168  // bitfield lvalue
169  llvm::Value *getBitfieldAddr() const { assert(isBitfield()); return V; }
170  unsigned short getBitfieldStartBit() const {
171    assert(isBitfield());
172    return BitfieldData.StartBit;
173  }
174  unsigned short getBitfieldSize() const {
175    assert(isBitfield());
176    return BitfieldData.Size;
177  }
178  bool isBitfieldSigned() const {
179    assert(isBitfield());
180    return BitfieldData.IsSigned;
181  }
182
183  static LValue MakeAddr(llvm::Value *V, unsigned Qualifiers) {
184    LValue R;
185    R.LVType = Simple;
186    R.V = V;
187    SetQualifiers(Qualifiers,R);
188    return R;
189  }
190
191  static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx,
192                              unsigned Qualifiers) {
193    LValue R;
194    R.LVType = VectorElt;
195    R.V = Vec;
196    R.VectorIdx = Idx;
197    SetQualifiers(Qualifiers,R);
198    return R;
199  }
200
201  static LValue MakeExtVectorElt(llvm::Value *Vec, llvm::Constant *Elts,
202                                 unsigned Qualifiers) {
203    LValue R;
204    R.LVType = ExtVectorElt;
205    R.V = Vec;
206    R.VectorElts = Elts;
207    SetQualifiers(Qualifiers,R);
208    return R;
209  }
210
211  static LValue MakeBitfield(llvm::Value *V, unsigned short StartBit,
212                             unsigned short Size, bool IsSigned,
213                             unsigned Qualifiers) {
214    LValue R;
215    R.LVType = BitField;
216    R.V = V;
217    R.BitfieldData.StartBit = StartBit;
218    R.BitfieldData.Size = Size;
219    R.BitfieldData.IsSigned = IsSigned;
220    SetQualifiers(Qualifiers,R);
221    return R;
222  }
223};
224
225/// CodeGenFunction - This class organizes the per-function state that is used
226/// while generating LLVM code.
227class CodeGenFunction {
228public:
229  CodeGenModule &CGM;  // Per-module state.
230  TargetInfo &Target;
231
232  typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
233  llvm::IRBuilder Builder;
234
235  // Holds the Decl for the current function or method
236  const Decl *CurFuncDecl;
237  QualType FnRetTy;
238  llvm::Function *CurFn;
239
240  /// AllocaInsertPoint - This is an instruction in the entry block before which
241  /// we prefer to insert allocas.
242  llvm::Instruction *AllocaInsertPt;
243
244  const llvm::Type *LLVMIntTy;
245  uint32_t LLVMPointerWidth;
246
247private:
248  /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
249  /// decls.
250  llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
251
252  /// LabelMap - This keeps track of the LLVM basic block for each C label.
253  llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
254
255  // BreakContinueStack - This keeps track of where break and continue
256  // statements should jump to.
257  struct BreakContinue {
258    BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb)
259      : BreakBlock(bb), ContinueBlock(cb) {}
260
261    llvm::BasicBlock *BreakBlock;
262    llvm::BasicBlock *ContinueBlock;
263  };
264  llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
265
266  /// SwitchInsn - This is nearest current switch instruction. It is null if
267  /// if current context is not in a switch.
268  llvm::SwitchInst *SwitchInsn;
269
270  /// CaseRangeBlock - This block holds if condition check for last case
271  /// statement range in current switch instruction.
272  llvm::BasicBlock *CaseRangeBlock;
273
274public:
275  CodeGenFunction(CodeGenModule &cgm);
276
277  ASTContext &getContext() const;
278
279  void GenerateObjCMethod(const ObjCMethodDecl *OMD);
280  void GenerateCode(const FunctionDecl *FD);
281  void GenerateFunction(const Stmt *Body);
282
283  const llvm::Type *ConvertType(QualType T);
284
285  llvm::Value *LoadObjCSelf();
286
287  /// isObjCPointerType - Return true if the specificed AST type will map onto
288  /// some Objective-C pointer type.
289  static bool isObjCPointerType(QualType T);
290
291  /// hasAggregateLLVMType - Return true if the specified AST type will map into
292  /// an aggregate LLVM type or is void.
293  static bool hasAggregateLLVMType(QualType T);
294
295  /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
296  /// label maps to.
297  llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
298
299
300  void EmitBlock(llvm::BasicBlock *BB);
301
302  /// WarnUnsupported - Print out a warning that codegen doesn't support the
303  /// specified stmt yet.
304  void WarnUnsupported(const Stmt *S, const char *Type);
305
306  //===--------------------------------------------------------------------===//
307  //                                  Helpers
308  //===--------------------------------------------------------------------===//
309
310  /// CreateTempAlloca - This creates a alloca and inserts it into the entry
311  /// block.
312  llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
313                                     const char *Name = "tmp");
314
315  /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
316  /// expression and compare the result against zero, returning an Int1Ty value.
317  llvm::Value *EvaluateExprAsBool(const Expr *E);
318
319  /// EmitAnyExpr - Emit code to compute the specified expression which can have
320  /// any type.  The result is returned as an RValue struct.  If this is an
321  /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
322  /// the result should be returned.
323  RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
324                     bool isAggLocVolatile = false);
325
326  /// isDummyBlock - Return true if BB is an empty basic block
327  /// with no predecessors.
328  static bool isDummyBlock(const llvm::BasicBlock *BB);
329
330  /// StartBlock - Start new block named N. If insert block is a dummy block
331  /// then reuse it.
332  void StartBlock(const char *N);
333
334  /// getCGRecordLayout - Return record layout info.
335  const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
336
337  /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
338  llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD);
339
340  /// getAccessedFieldNo - Given an encoded value and a result number, return
341  /// the input field number being accessed.
342  static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
343
344  //===--------------------------------------------------------------------===//
345  //                            Declaration Emission
346  //===--------------------------------------------------------------------===//
347
348  void EmitDecl(const Decl &D);
349  void EmitEnumConstantDecl(const EnumConstantDecl &D);
350  void EmitBlockVarDecl(const VarDecl &D);
351  void EmitLocalBlockVarDecl(const VarDecl &D);
352  void EmitStaticBlockVarDecl(const VarDecl &D);
353  void EmitParmDecl(const ParmVarDecl &D, llvm::Value *Arg);
354
355  //===--------------------------------------------------------------------===//
356  //                             Statement Emission
357  //===--------------------------------------------------------------------===//
358
359  void EmitStmt(const Stmt *S);
360  RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
361                          llvm::Value *AggLoc = 0, bool isAggVol = false);
362  void EmitLabelStmt(const LabelStmt &S);
363  void EmitGotoStmt(const GotoStmt &S);
364  void EmitIfStmt(const IfStmt &S);
365  void EmitWhileStmt(const WhileStmt &S);
366  void EmitDoStmt(const DoStmt &S);
367  void EmitForStmt(const ForStmt &S);
368  void EmitReturnStmt(const ReturnStmt &S);
369  void EmitDeclStmt(const DeclStmt &S);
370  void EmitBreakStmt();
371  void EmitContinueStmt();
372  void EmitSwitchStmt(const SwitchStmt &S);
373  void EmitDefaultStmt(const DefaultStmt &S);
374  void EmitCaseStmt(const CaseStmt &S);
375  void EmitCaseStmtRange(const CaseStmt &S);
376  void EmitAsmStmt(const AsmStmt &S);
377
378  //===--------------------------------------------------------------------===//
379  //                         LValue Expression Emission
380  //===--------------------------------------------------------------------===//
381
382  /// EmitLValue - Emit code to compute a designator that specifies the location
383  /// of the expression.
384  ///
385  /// This can return one of two things: a simple address or a bitfield
386  /// reference.  In either case, the LLVM Value* in the LValue structure is
387  /// guaranteed to be an LLVM pointer type.
388  ///
389  /// If this returns a bitfield reference, nothing about the pointee type of
390  /// the LLVM value is known: For example, it may not be a pointer to an
391  /// integer.
392  ///
393  /// If this returns a normal address, and if the lvalue's C type is fixed
394  /// size, this method guarantees that the returned pointer type will point to
395  /// an LLVM type of the same size of the lvalue's type.  If the lvalue has a
396  /// variable length type, this is not possible.
397  ///
398  LValue EmitLValue(const Expr *E);
399
400  /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
401  /// this method emits the address of the lvalue, then loads the result as an
402  /// rvalue, returning the rvalue.
403  RValue EmitLoadOfLValue(LValue V, QualType LVType);
404  RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
405  RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
406
407
408  /// EmitStoreThroughLValue - Store the specified rvalue into the specified
409  /// lvalue, where both are guaranteed to the have the same type, and that type
410  /// is 'Ty'.
411  void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
412  void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
413                                                QualType Ty);
414  void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty);
415
416  // Note: only availabe for agg return types
417  LValue EmitCallExprLValue(const CallExpr *E);
418
419  LValue EmitDeclRefLValue(const DeclRefExpr *E);
420  LValue EmitStringLiteralLValue(const StringLiteral *E);
421  LValue EmitPreDefinedLValue(const PreDefinedExpr *E);
422  LValue EmitUnaryOpLValue(const UnaryOperator *E);
423  LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
424  LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
425  LValue EmitMemberExpr(const MemberExpr *E);
426  LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
427
428  LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field,
429                            bool isUnion, unsigned CVRQualifiers);
430
431  LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
432  //===--------------------------------------------------------------------===//
433  //                         Scalar Expression Emission
434  //===--------------------------------------------------------------------===//
435
436  RValue EmitCallExpr(const CallExpr *E);
437
438  RValue EmitCallExpr(Expr *FnExpr, CallExpr::const_arg_iterator ArgBeg,
439                      CallExpr::const_arg_iterator ArgEnd);
440
441  RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
442                      CallExpr::const_arg_iterator ArgBeg,
443                      CallExpr::const_arg_iterator ArgEnd);
444
445  RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
446
447  llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
448  llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
449
450  llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
451  llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
452                          bool isSplat = false);
453
454  llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
455  llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
456  llvm::Value *EmitObjCMessageExpr(const ObjCMessageExpr *E);
457
458
459
460  //===--------------------------------------------------------------------===//
461  //                           Expression Emission
462  //===--------------------------------------------------------------------===//
463
464  // Expressions are broken into three classes: scalar, complex, aggregate.
465
466  /// EmitScalarExpr - Emit the computation of the specified expression of
467  /// LLVM scalar type, returning the result.
468  llvm::Value *EmitScalarExpr(const Expr *E);
469
470  /// 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
475  /// 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
481
482  /// 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);
486
487  /// EmitComplexExpr - Emit the computation of the specified expression of
488  /// complex type, returning the result.
489  ComplexPairTy EmitComplexExpr(const Expr *E);
490
491  /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
492  /// of complex type, storing into the specified Value*.
493  void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
494                               bool DestIsVolatile);
495  /// LoadComplexFromAddr - Load a complex number from the specified address.
496  ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
497
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);
503};
504}  // end namespace CodeGen
505}  // end namespace clang
506
507#endif
508