intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-27 06:06:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

move EmitLoadOfComplex/EmitStoreOfComplex into ComplexExprEmitter.

Browse Source 
llvm-svn: 41236
This commit is contained in:
Chris Lattner
2007-08-21 17:28:34 +00:00
parent 3cf417b369
commit 4b0e7873f6
4 changed files with 39 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
clang/CodeGen/CGAggExpr.cpp
View File

@@ -160,14 +160,7 @@ void CodeGenFunction::EmitAggExpr(const Expr *E, llvm::Value *DestPtr,
// FIXME: Handle volatility!
void CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr,
llvm::Value *SrcPtr, QualType Ty) {
// Don't use memcpy for complex numbers.
// FIXME: split complex number handling out of here.
if (Ty->isComplexType()) {
llvm::Value *Real, *Imag;
EmitLoadOfComplex(SrcPtr, Real, Imag);
EmitStoreOfComplex(Real, Imag, DestPtr);
return;
}
assert(!Ty->isComplexType() && "Shouldn't happen for complex");
// Aggregate assignment turns into llvm.memcpy.
const llvm::Type *BP = llvm::PointerType::get(llvm::Type::Int8Ty);

49
clang/CodeGen/CGComplexExpr.cpp
View File

@@ -42,8 +42,17 @@ public:
/// EmitLoadOfLValue - Given an expression with complex type that represents a
/// value l-value, this method emits the address of the l-value, then loads
/// and returns the result.
ComplexPairTy EmitLoadOfLValue(const Expr *E);
ComplexPairTy EmitLoadOfLValue(const Expr *E) {
return EmitLoadOfComplex(CGF.EmitLValue(E).getAddress());
}
/// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load
/// the real and imaginary pieces.
ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr);
/// EmitStoreOfComplex - Store the specified real/imag parts into the
/// specified value pointer.
void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr);
//===--------------------------------------------------------------------===//
// Visitor Methods
@@ -89,19 +98,37 @@ public:
// Utilities
//===----------------------------------------------------------------------===//
/// EmitLoadOfLValue - Given an expression with complex type that represents a
/// value l-value, this method emits the address of the l-value, then loads
/// and returns the result.
ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(const Expr *E) {
LValue LV = CGF.EmitLValue(E);
assert(LV.isSimple() && "Can't have complex bitfield, vector, etc");
/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
/// load the real and imaginary pieces, returning them as Real/Imag.
ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr) {
llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
llvm::Constant *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
// FIXME: It would be nice to make this "Ptr->getName()+realp"
llvm::Value *RealPtr = CGF.Builder.CreateGEP(SrcPtr, Zero, Zero, "realp");
llvm::Value *ImagPtr = CGF.Builder.CreateGEP(SrcPtr, Zero, One, "imagp");
// Load the real/imag values.
llvm::Value *Real, *Imag;
CGF.EmitLoadOfComplex(LV.getAddress(), Real, Imag);
// FIXME: Handle volatility.
// FIXME: It would be nice to make this "Ptr->getName()+real"
llvm::Value *Real = CGF.Builder.CreateLoad(RealPtr, "real");
llvm::Value *Imag = CGF.Builder.CreateLoad(ImagPtr, "imag");
return ComplexPairTy(Real, Imag);
}
/// EmitStoreOfComplex - Store the specified real/imag parts into the
/// specified value pointer.
void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy V, llvm::Value *Ptr) {
llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
llvm::Constant *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
llvm::Value *RealPtr = CGF.Builder.CreateGEP(Ptr, Zero, Zero, "real");
llvm::Value *ImagPtr = CGF.Builder.CreateGEP(Ptr, Zero, One, "imag");
// FIXME: Handle volatility.
CGF.Builder.CreateStore(V.first, RealPtr);
CGF.Builder.CreateStore(V.second, ImagPtr);
}
//===----------------------------------------------------------------------===//
// Visitor Methods
//===----------------------------------------------------------------------===//
@@ -148,7 +175,7 @@ ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
// Store into it.
// FIXME: Volatility!
CGF.EmitStoreOfComplex(Val.first, Val.second, LHS.getAddress());
EmitStoreOfComplex(Val, LHS.getAddress());
return Val;
}

30
clang/CodeGen/CGExpr.cpp
View File

@@ -40,36 +40,6 @@ llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
return ConvertScalarValueToBool(EmitExpr(E), E->getType());
}
/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
/// load the real and imaginary pieces, returning them as Real/Imag.
void CodeGenFunction::EmitLoadOfComplex(llvm::Value *SrcPtr,
llvm::Value *&Real, llvm::Value *&Imag){
llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
llvm::Constant *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
// FIXME: It would be nice to make this "Ptr->getName()+realp"
llvm::Value *RealPtr = Builder.CreateGEP(SrcPtr, Zero, Zero, "realp");
llvm::Value *ImagPtr = Builder.CreateGEP(SrcPtr, Zero, One, "imagp");
// FIXME: Handle volatility.
// FIXME: It would be nice to make this "Ptr->getName()+real"
Real = Builder.CreateLoad(RealPtr, "real");
Imag = Builder.CreateLoad(ImagPtr, "imag");
}
/// EmitStoreOfComplex - Store the specified real/imag parts into the
/// specified value pointer.
void CodeGenFunction::EmitStoreOfComplex(llvm::Value *Real, llvm::Value *Imag,
llvm::Value *ResPtr) {
llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
llvm::Constant *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
llvm::Value *RealPtr = Builder.CreateGEP(ResPtr, Zero, Zero, "real");
llvm::Value *ImagPtr = Builder.CreateGEP(ResPtr, Zero, One, "imag");
// FIXME: Handle volatility.
Builder.CreateStore(Real, RealPtr);
Builder.CreateStore(Imag, ImagPtr);
}
//===--------------------------------------------------------------------===//
// Conversions
//===--------------------------------------------------------------------===//

10
clang/CodeGen/CodeGenFunction.h
View File

@@ -248,16 +248,6 @@ public:
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(llvm::Value *SrcPtr, 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
//===--------------------------------------------------------------------===//