446 lines
15 KiB
C++
446 lines
15 KiB
C++
//===--- CodeGenFunction.h - Per-Function state for LLVM CodeGen ----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This is the internal per-function state used for llvm translation.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef CODEGEN_CODEGENFUNCTION_H
|
|
#define CODEGEN_CODEGENFUNCTION_H
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Support/LLVMBuilder.h"
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
class Module;
|
|
}
|
|
|
|
namespace clang {
|
|
class ASTContext;
|
|
class Decl;
|
|
class FunctionDecl;
|
|
class TargetInfo;
|
|
class QualType;
|
|
class FunctionTypeProto;
|
|
|
|
class Stmt;
|
|
class CompoundStmt;
|
|
class LabelStmt;
|
|
class GotoStmt;
|
|
class IfStmt;
|
|
class WhileStmt;
|
|
class DoStmt;
|
|
class ForStmt;
|
|
class ReturnStmt;
|
|
class DeclStmt;
|
|
class CaseStmt;
|
|
class DefaultStmt;
|
|
class SwitchStmt;
|
|
|
|
class Expr;
|
|
class DeclRefExpr;
|
|
class StringLiteral;
|
|
class IntegerLiteral;
|
|
class FloatingLiteral;
|
|
class CharacterLiteral;
|
|
class TypesCompatibleExpr;
|
|
|
|
class ImplicitCastExpr;
|
|
class CastExpr;
|
|
class CallExpr;
|
|
class UnaryOperator;
|
|
class BinaryOperator;
|
|
class CompoundAssignOperator;
|
|
class ArraySubscriptExpr;
|
|
class OCUVectorElementExpr;
|
|
class ConditionalOperator;
|
|
class ChooseExpr;
|
|
class PreDefinedExpr;
|
|
class ObjCStringLiteral;
|
|
class MemberExpr;
|
|
|
|
class BlockVarDecl;
|
|
class EnumConstantDecl;
|
|
class ParmVarDecl;
|
|
namespace CodeGen {
|
|
class CodeGenModule;
|
|
class CodeGenTypes;
|
|
class CGRecordLayout;
|
|
|
|
/// RValue - This trivial value class is used to represent the result of an
|
|
/// expression that is evaluated. It can be one of three things: either a
|
|
/// simple LLVM SSA value, a pair of SSA values for complex numbers, or the
|
|
/// address of an aggregate value in memory.
|
|
class RValue {
|
|
llvm::Value *V1, *V2;
|
|
// TODO: Encode this into the low bit of pointer for more efficient
|
|
// return-by-value.
|
|
enum { Scalar, Complex, Aggregate } Flavor;
|
|
|
|
// FIXME: Aggregate rvalues need to retain information about whether they are
|
|
// volatile or not.
|
|
public:
|
|
|
|
bool isScalar() const { return Flavor == Scalar; }
|
|
bool isComplex() const { return Flavor == Complex; }
|
|
bool isAggregate() const { return Flavor == Aggregate; }
|
|
|
|
/// getScalar() - Return the Value* of this scalar value.
|
|
llvm::Value *getScalarVal() const {
|
|
assert(isScalar() && "Not a scalar!");
|
|
return V1;
|
|
}
|
|
|
|
/// getComplexVal - Return the real/imag components of this complex value.
|
|
///
|
|
std::pair<llvm::Value *, llvm::Value *> getComplexVal() const {
|
|
return std::pair<llvm::Value *, llvm::Value *>(V1, V2);
|
|
}
|
|
|
|
/// getAggregateAddr() - Return the Value* of the address of the aggregate.
|
|
llvm::Value *getAggregateAddr() const {
|
|
assert(isAggregate() && "Not an aggregate!");
|
|
return V1;
|
|
}
|
|
|
|
static RValue get(llvm::Value *V) {
|
|
RValue ER;
|
|
ER.V1 = V;
|
|
ER.Flavor = Scalar;
|
|
return ER;
|
|
}
|
|
static RValue getComplex(llvm::Value *V1, llvm::Value *V2) {
|
|
RValue ER;
|
|
ER.V1 = V1;
|
|
ER.V2 = V2;
|
|
ER.Flavor = Complex;
|
|
return ER;
|
|
}
|
|
static RValue getComplex(const std::pair<llvm::Value *, llvm::Value *> &C) {
|
|
RValue ER;
|
|
ER.V1 = C.first;
|
|
ER.V2 = C.second;
|
|
ER.Flavor = Complex;
|
|
return ER;
|
|
}
|
|
static RValue getAggregate(llvm::Value *V) {
|
|
RValue ER;
|
|
ER.V1 = V;
|
|
ER.Flavor = Aggregate;
|
|
return ER;
|
|
}
|
|
};
|
|
|
|
|
|
/// LValue - This represents an lvalue references. Because C/C++ allow
|
|
/// bitfields, this is not a simple LLVM pointer, it may be a pointer plus a
|
|
/// bitrange.
|
|
class LValue {
|
|
// FIXME: Volatility. Restrict?
|
|
// alignment?
|
|
|
|
enum {
|
|
Simple, // This is a normal l-value, use getAddress().
|
|
VectorElt, // This is a vector element l-value (V[i]), use getVector*
|
|
BitField, // This is a bitfield l-value, use getBitfield*.
|
|
OCUVectorElt // This is an ocu vector subset, use getOCUVectorComp
|
|
} LVType;
|
|
|
|
llvm::Value *V;
|
|
|
|
union {
|
|
llvm::Value *VectorIdx; // Index into a vector subscript: V[i]
|
|
unsigned VectorElts; // Encoded OCUVector element subset: V.xyx
|
|
};
|
|
public:
|
|
bool isSimple() const { return LVType == Simple; }
|
|
bool isVectorElt() const { return LVType == VectorElt; }
|
|
bool isBitfield() const { return LVType == BitField; }
|
|
bool isOCUVectorElt() const { return LVType == OCUVectorElt; }
|
|
|
|
// simple lvalue
|
|
llvm::Value *getAddress() const { assert(isSimple()); return V; }
|
|
// vector elt lvalue
|
|
llvm::Value *getVectorAddr() const { assert(isVectorElt()); return V; }
|
|
llvm::Value *getVectorIdx() const { assert(isVectorElt()); return VectorIdx; }
|
|
// ocu vector elements.
|
|
llvm::Value *getOCUVectorAddr() const { assert(isOCUVectorElt()); return V; }
|
|
unsigned getOCUVectorElts() const {
|
|
assert(isOCUVectorElt());
|
|
return VectorElts;
|
|
}
|
|
|
|
|
|
static LValue MakeAddr(llvm::Value *V) {
|
|
LValue R;
|
|
R.LVType = Simple;
|
|
R.V = V;
|
|
return R;
|
|
}
|
|
|
|
static LValue MakeVectorElt(llvm::Value *Vec, llvm::Value *Idx) {
|
|
LValue R;
|
|
R.LVType = VectorElt;
|
|
R.V = Vec;
|
|
R.VectorIdx = Idx;
|
|
return R;
|
|
}
|
|
|
|
static LValue MakeOCUVectorElt(llvm::Value *Vec, unsigned Elements) {
|
|
LValue R;
|
|
R.LVType = OCUVectorElt;
|
|
R.V = Vec;
|
|
R.VectorElts = Elements;
|
|
return R;
|
|
}
|
|
};
|
|
|
|
/// CodeGenFunction - This class organizes the per-function state that is used
|
|
/// while generating LLVM code.
|
|
class CodeGenFunction {
|
|
public:
|
|
CodeGenModule &CGM; // Per-module state.
|
|
TargetInfo &Target;
|
|
|
|
typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
|
|
llvm::LLVMFoldingBuilder Builder;
|
|
|
|
const FunctionDecl *CurFuncDecl;
|
|
llvm::Function *CurFn;
|
|
|
|
/// AllocaInsertPoint - This is an instruction in the entry block before which
|
|
/// we prefer to insert allocas.
|
|
llvm::Instruction *AllocaInsertPt;
|
|
|
|
const llvm::Type *LLVMIntTy;
|
|
uint32_t LLVMPointerWidth;
|
|
|
|
private:
|
|
/// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
|
|
/// decls.
|
|
llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
|
|
|
|
/// LabelMap - This keeps track of the LLVM basic block for each C label.
|
|
llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap;
|
|
|
|
// BreakContinueStack - This keeps track of where break and continue
|
|
// statements should jump to.
|
|
struct BreakContinue {
|
|
BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb)
|
|
: BreakBlock(bb), ContinueBlock(cb) {}
|
|
|
|
llvm::BasicBlock *BreakBlock;
|
|
llvm::BasicBlock *ContinueBlock;
|
|
};
|
|
llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
|
|
|
|
/// SwitchInsn - This is nearest current switch instruction. It is null if
|
|
/// if current context is not in a switch.
|
|
llvm::SwitchInst *SwitchInsn;
|
|
|
|
/// CaseRangeBlock - This block holds if condition check for last case
|
|
/// statement range in current switch instruction.
|
|
llvm::BasicBlock *CaseRangeBlock;
|
|
|
|
public:
|
|
CodeGenFunction(CodeGenModule &cgm);
|
|
|
|
ASTContext &getContext() const;
|
|
|
|
void GenerateCode(const FunctionDecl *FD);
|
|
|
|
const llvm::Type *ConvertType(QualType T);
|
|
|
|
/// hasAggregateLLVMType - Return true if the specified AST type will map into
|
|
/// an aggregate LLVM type or is void.
|
|
static bool hasAggregateLLVMType(QualType T);
|
|
|
|
/// getBasicBlockForLabel - Return the LLVM basicblock that the specified
|
|
/// label maps to.
|
|
llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S);
|
|
|
|
|
|
void EmitBlock(llvm::BasicBlock *BB);
|
|
|
|
/// WarnUnsupported - Print out a warning that codegen doesn't support the
|
|
/// specified stmt yet.
|
|
void WarnUnsupported(const Stmt *S, const char *Type);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Helpers
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// CreateTempAlloca - This creates a alloca and inserts it into the entry
|
|
/// block.
|
|
llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
|
|
const char *Name = "tmp");
|
|
|
|
/// EvaluateExprAsBool - Perform the usual unary conversions on the specified
|
|
/// expression and compare the result against zero, returning an Int1Ty value.
|
|
llvm::Value *EvaluateExprAsBool(const Expr *E);
|
|
|
|
/// EmitAnyExpr - Emit code to compute the specified expression which can have
|
|
/// any type. The result is returned as an RValue struct. If this is an
|
|
/// aggregate expression, the aggloc/agglocvolatile arguments indicate where
|
|
/// the result should be returned.
|
|
RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
|
|
bool isAggLocVolatile = false);
|
|
|
|
/// isDummyBlock - Return true if BB is an empty basic block
|
|
/// with no predecessors.
|
|
static bool isDummyBlock(const llvm::BasicBlock *BB);
|
|
|
|
/// StartBlock - Start new block named N. If insert block is a dummy block
|
|
/// then reuse it.
|
|
void StartBlock(const char *N);
|
|
|
|
/// getCGRecordLayout - Return record layout info.
|
|
const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy);
|
|
//===--------------------------------------------------------------------===//
|
|
// Declaration Emission
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
void EmitDecl(const Decl &D);
|
|
void EmitEnumConstantDecl(const EnumConstantDecl &D);
|
|
void EmitBlockVarDecl(const BlockVarDecl &D);
|
|
void EmitLocalBlockVarDecl(const BlockVarDecl &D);
|
|
void EmitStaticBlockVarDecl(const BlockVarDecl &D);
|
|
void EmitParmDecl(const ParmVarDecl &D, llvm::Value *Arg);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Statement Emission
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
void EmitStmt(const Stmt *S);
|
|
RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
|
|
llvm::Value *AggLoc = 0, bool isAggVol = false);
|
|
void EmitLabelStmt(const LabelStmt &S);
|
|
void EmitGotoStmt(const GotoStmt &S);
|
|
void EmitIfStmt(const IfStmt &S);
|
|
void EmitWhileStmt(const WhileStmt &S);
|
|
void EmitDoStmt(const DoStmt &S);
|
|
void EmitForStmt(const ForStmt &S);
|
|
void EmitReturnStmt(const ReturnStmt &S);
|
|
void EmitDeclStmt(const DeclStmt &S);
|
|
void EmitBreakStmt();
|
|
void EmitContinueStmt();
|
|
void EmitSwitchStmt(const SwitchStmt &S);
|
|
void EmitDefaultStmt(const DefaultStmt &S);
|
|
void EmitCaseStmt(const CaseStmt &S);
|
|
void EmitCaseStmtRange(const CaseStmt &S);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// LValue Expression Emission
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// EmitLValue - Emit code to compute a designator that specifies the location
|
|
/// of the expression.
|
|
///
|
|
/// This can return one of two things: a simple address or a bitfield
|
|
/// reference. In either case, the LLVM Value* in the LValue structure is
|
|
/// guaranteed to be an LLVM pointer type.
|
|
///
|
|
/// If this returns a bitfield reference, nothing about the pointee type of
|
|
/// the LLVM value is known: For example, it may not be a pointer to an
|
|
/// integer.
|
|
///
|
|
/// If this returns a normal address, and if the lvalue's C type is fixed
|
|
/// size, this method guarantees that the returned pointer type will point to
|
|
/// an LLVM type of the same size of the lvalue's type. If the lvalue has a
|
|
/// variable length type, this is not possible.
|
|
///
|
|
LValue EmitLValue(const Expr *E);
|
|
|
|
/// EmitLoadOfLValue - Given an expression that represents a value lvalue,
|
|
/// this method emits the address of the lvalue, then loads the result as an
|
|
/// rvalue, returning the rvalue.
|
|
RValue EmitLoadOfLValue(LValue V, QualType LVType);
|
|
RValue EmitLoadOfOCUElementLValue(LValue V, QualType LVType);
|
|
|
|
|
|
/// EmitStoreThroughLValue - Store the specified rvalue into the specified
|
|
/// lvalue, where both are guaranteed to the have the same type, and that type
|
|
/// is 'Ty'.
|
|
void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
|
|
void EmitStoreThroughOCUComponentLValue(RValue Src, LValue Dst, QualType Ty);
|
|
|
|
// Note: only availabe for agg return types
|
|
LValue EmitCallExprLValue(const CallExpr *E);
|
|
|
|
LValue EmitDeclRefLValue(const DeclRefExpr *E);
|
|
LValue EmitStringLiteralLValue(const StringLiteral *E);
|
|
LValue EmitPreDefinedLValue(const PreDefinedExpr *E);
|
|
LValue EmitUnaryOpLValue(const UnaryOperator *E);
|
|
LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
|
|
LValue EmitOCUVectorElementExpr(const OCUVectorElementExpr *E);
|
|
LValue EmitMemberExpr(const MemberExpr *E);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Scalar Expression Emission
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
RValue EmitCallExpr(const CallExpr *E);
|
|
RValue EmitCallExpr(Expr *FnExpr, Expr *const *Args);
|
|
RValue EmitCallExpr(llvm::Value *Callee, QualType FnType, Expr *const *Args);
|
|
RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
|
|
|
|
llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
|
|
llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
|
|
|
|
llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...);
|
|
llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals,
|
|
bool isSplat = false);
|
|
|
|
llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Expression Emission
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Expressions are broken into three classes: scalar, complex, aggregate.
|
|
|
|
/// EmitScalarExpr - Emit the computation of the specified expression of
|
|
/// LLVM scalar type, returning the result.
|
|
llvm::Value *EmitScalarExpr(const Expr *E);
|
|
|
|
/// EmitScalarConversion - Emit a conversion from the specified type to the
|
|
/// specified destination type, both of which are LLVM scalar types.
|
|
llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
|
|
QualType DstTy);
|
|
|
|
/// EmitComplexToScalarConversion - Emit a conversion from the specified
|
|
/// complex type to the specified destination type, where the destination
|
|
/// type is an LLVM scalar type.
|
|
llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
|
|
QualType DstTy);
|
|
|
|
|
|
/// EmitAggExpr - Emit the computation of the specified expression of
|
|
/// aggregate type. The result is computed into DestPtr. Note that if
|
|
/// DestPtr is null, the value of the aggregate expression is not needed.
|
|
void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest);
|
|
|
|
/// EmitComplexExpr - Emit the computation of the specified expression of
|
|
/// complex type, returning the result.
|
|
ComplexPairTy EmitComplexExpr(const Expr *E);
|
|
|
|
/// EmitComplexExprIntoAddr - Emit the computation of the specified expression
|
|
/// of complex type, storing into the specified Value*.
|
|
void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
|
|
bool DestIsVolatile);
|
|
/// LoadComplexFromAddr - Load a complex number from the specified address.
|
|
ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
|
|
};
|
|
} // end namespace CodeGen
|
|
} // end namespace clang
|
|
|
|
#endif
|