Stage two of getting CFE top correct.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@39734 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 354 insertions, 0 deletions

diff --git a/CodeGen/CodeGenFunction.h b/CodeGen/CodeGenFunction.h
new file mode 100644
index 0000000000..acefedf3cc
--- /dev/null
+++ b/CodeGen/CodeGenFunction.h
@@ -0,0 +1,354 @@
+//===--- CodeGenFunction.h - Per-Function state for LLVM CodeGen ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Chris Lattner and 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/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 Expr;
+  class DeclRefExpr;
+  class StringLiteral;
+  class IntegerLiteral;
+  class FloatingLiteral;
+  class CastExpr;
+  class CallExpr;
+  class UnaryOperator;
+  class BinaryOperator;
+  class CompoundAssignOperator;
+  class ArraySubscriptExpr;
+  
+  class BlockVarDecl;
+  class EnumConstantDecl;
+  class ParmVarDecl;
+namespace CodeGen {
+  class CodeGenModule;
+  
+
+/// RValue - This trivial value class is used to represent the result of an
+/// expression that is evaluated.  It can be one of two things: either a simple
+/// LLVM SSA value, or the address of an aggregate value in memory.  These two
+/// possibilities are discriminated by isAggregate/isScalar.
+class RValue {
+  llvm::Value *V;
+  // TODO: Encode this into the low bit of pointer for more efficient
+  // return-by-value.
+  bool IsAggregate;
+  
+  // FIXME: Aggregate rvalues need to retain information about whether they are
+  // volatile or not.
+public:
+  
+  bool isAggregate() const { return IsAggregate; }
+  bool isScalar() const { return !IsAggregate; }
+  
+  /// getVal() - Return the Value* of this scalar value.
+  llvm::Value *getVal() const {
+    assert(!isAggregate() && "Not a scalar!");
+    return V;
+  }
+
+  /// getAggregateAddr() - Return the Value* of the address of the aggregate.
+  llvm::Value *getAggregateAddr() const {
+    assert(isAggregate() && "Not an aggregate!");
+    return V;
+  }
+  
+  static RValue get(llvm::Value *V) {
+    RValue ER;
+    ER.V = V;
+    ER.IsAggregate = false;
+    return ER;
+  }
+  static RValue getAggregate(llvm::Value *V) {
+    RValue ER;
+    ER.V = V;
+    ER.IsAggregate = true;
+    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*.
+  } LVType;
+  
+  llvm::Value *V;
+  
+  union {
+    llvm::Value *VectorIdx;
+  };
+public:
+  bool isSimple() const { return LVType == Simple; }
+  bool isVectorElt() const { return LVType == VectorElt; }
+  bool isBitfield() const { return LVType == BitField; }
+  
+  // 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; }
+  
+  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;
+  }
+  
+};
+
+/// CodeGenFunction - This class organizes the per-function state that is used
+/// while generating LLVM code.
+class CodeGenFunction {
+  CodeGenModule &CGM;  // Per-module state.
+  TargetInfo &Target;
+  llvm::LLVMBuilder 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;
+  unsigned LLVMPointerWidth;
+  
+  /// 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;
+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);
+
+  //===--------------------------------------------------------------------===//
+  //                                  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);
+
+  
+  /// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
+  /// load the real and imaginary pieces, returning them as Real/Imag.
+  void EmitLoadOfComplex(RValue V, llvm::Value *&Real, llvm::Value *&Imag);
+  
+  /// EmitStoreOfComplex - Store the specified real/imag parts into the
+  /// specified value pointer.
+  void EmitStoreOfComplex(llvm::Value *Real, llvm::Value *Imag,
+                          llvm::Value *ResPtr);
+
+  //===--------------------------------------------------------------------===//
+  //                                Conversions
+  //===--------------------------------------------------------------------===//
+  
+  /// EmitConversion - Convert the value specied by Val, whose type is ValTy, to
+  /// the type specified by DstTy, following the rules of C99 6.3.
+  RValue EmitConversion(RValue Val, QualType ValTy, QualType DstTy);
+  
+  /// ConvertScalarValueToBool - Convert the specified expression value to a
+  /// boolean (i1) truth value.  This is equivalent to "Val == 0".
+  llvm::Value *ConvertScalarValueToBool(RValue Val, QualType Ty);
+  
+  //===--------------------------------------------------------------------===//
+  //                            Declaration Emission
+  //===--------------------------------------------------------------------===//
+  
+  void EmitDecl(const Decl &D);
+  void EmitEnumConstantDecl(const EnumConstantDecl &D);
+  void EmitBlockVarDecl(const BlockVarDecl &D);
+  void EmitLocalBlockVarDecl(const BlockVarDecl &D);
+  void EmitParmDecl(const ParmVarDecl &D, llvm::Value *Arg);
+  
+  //===--------------------------------------------------------------------===//
+  //                             Statement Emission
+  //===--------------------------------------------------------------------===//
+
+  void EmitStmt(const Stmt *S);
+  void EmitCompoundStmt(const CompoundStmt &S);
+  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);
+
+  //===--------------------------------------------------------------------===//
+  //                         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(const Expr *E);
+  RValue EmitLoadOfLValue(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);
+  
+  LValue EmitDeclRefLValue(const DeclRefExpr *E);
+  LValue EmitStringLiteralLValue(const StringLiteral *E);
+  LValue EmitUnaryOpLValue(const UnaryOperator *E);
+  LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
+    
+  //===--------------------------------------------------------------------===//
+  //                             Expression Emission
+  //===--------------------------------------------------------------------===//
+
+  RValue EmitExprWithUsualUnaryConversions(const Expr *E, QualType &ResTy);
+  QualType EmitUsualArithmeticConversions(const BinaryOperator *E,
+                                          RValue &LHS, RValue &RHS);
+  void EmitShiftOperands(const BinaryOperator *E, RValue &LHS, RValue &RHS);
+
+  void EmitCompoundAssignmentOperands(const CompoundAssignOperator *CAO,
+                                      LValue &LHSLV, RValue &LHS, RValue &RHS);
+  RValue EmitCompoundAssignmentResult(const CompoundAssignOperator *E,
+                                      LValue LHSLV, RValue ResV);
+  
+  
+  RValue EmitExpr(const Expr *E);
+  RValue EmitIntegerLiteral(const IntegerLiteral *E);
+  RValue EmitFloatingLiteral(const FloatingLiteral *E);
+  
+  RValue EmitCastExpr(const CastExpr *E);
+  RValue EmitCallExpr(const CallExpr *E);
+  RValue EmitArraySubscriptExprRV(const ArraySubscriptExpr *E);
+
+  // Unary Operators.
+  RValue EmitUnaryOperator(const UnaryOperator *E);
+  // FIXME: pre/post inc/dec
+  RValue EmitUnaryAddrOf  (const UnaryOperator *E);
+  RValue EmitUnaryPlus    (const UnaryOperator *E);
+  RValue EmitUnaryMinus   (const UnaryOperator *E);
+  RValue EmitUnaryNot     (const UnaryOperator *E);
+  RValue EmitUnaryLNot    (const UnaryOperator *E);
+  // FIXME: SIZEOF/ALIGNOF(expr).
+  // FIXME: real/imag
+  
+  // Binary Operators.
+  RValue EmitBinaryOperator(const BinaryOperator *E);
+  RValue EmitBinaryMul(const BinaryOperator *E);
+  RValue EmitBinaryDiv(const BinaryOperator *E);
+  RValue EmitBinaryRem(const BinaryOperator *E);
+  RValue EmitMul(RValue LHS, RValue RHS, QualType EltTy);
+  RValue EmitDiv(RValue LHS, RValue RHS, QualType EltTy);
+  RValue EmitRem(RValue LHS, RValue RHS, QualType EltTy);
+  RValue EmitAdd(RValue LHS, RValue RHS, QualType EltTy);
+  RValue EmitSub(RValue LHS, RValue RHS, QualType EltTy);
+  RValue EmitShl(RValue LHS, RValue RHS, QualType ResTy);
+  RValue EmitShr(RValue LHS, RValue RHS, QualType ResTy);
+  RValue EmitBinaryCompare(const BinaryOperator *E, unsigned UICmpOpc,
+                           unsigned SICmpOpc, unsigned FCmpOpc);
+  RValue EmitAnd(RValue LHS, RValue RHS, QualType EltTy);
+  RValue EmitOr (RValue LHS, RValue RHS, QualType EltTy);
+  RValue EmitXor(RValue LHS, RValue RHS, QualType EltTy);
+  RValue EmitBinaryLAnd(const BinaryOperator *E);
+  RValue EmitBinaryLOr(const BinaryOperator *E);
+  
+  RValue EmitBinaryAssign(const BinaryOperator *E);
+  RValue EmitBinaryComma(const BinaryOperator *E);
+};
+}  // end namespace CodeGen
+}  // end namespace clang
+
+#endif