[llvm-commits] [dragonegg] r95084 - in /dragonegg/trunk: llvm-convert.cpp llvm-internal.h
Duncan Sands
baldrick at free.fr
Tue Feb 2 03:25:08 PST 2010
Author: baldrick
Date: Tue Feb 2 05:25:08 2010
New Revision: 95084
URL: http://llvm.org/viewvc/llvm-project?rev=95084&view=rev
Log:
Logical operations can no longer be performed on floats. Handle the last
remaining users of EmitReg_BinOp directly, and remove this method.
Modified:
dragonegg/trunk/llvm-convert.cpp
dragonegg/trunk/llvm-internal.h
Modified: dragonegg/trunk/llvm-convert.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/llvm-convert.cpp?rev=95084&r1=95083&r2=95084&view=diff
==============================================================================
--- dragonegg/trunk/llvm-convert.cpp (original)
+++ dragonegg/trunk/llvm-convert.cpp Tue Feb 2 05:25:08 2010
@@ -2786,19 +2786,6 @@
return 0;
}
-/// getSuitableBitCastIntType - Given Ty is a floating point type or a vector
-/// type with floating point elements, return an integer type to bitcast to.
-/// e.g. 4 x float -> 4 x i32
-static const Type *getSuitableBitCastIntType(const Type *Ty) {
- if (const VectorType *VTy = dyn_cast<VectorType>(Ty)) {
- unsigned NumElements = VTy->getNumElements();
- const Type *EltTy = VTy->getElementType();
- return VectorType::get(
- IntegerType::get(Context, EltTy->getPrimitiveSizeInBits()), NumElements);
- }
- return IntegerType::get(Context, Ty->getPrimitiveSizeInBits());
-}
-
/// EmitEXC_PTR_EXPR - Handle EXC_PTR_EXPR.
Value *TreeToLLVM::EmitEXC_PTR_EXPR(tree exp) {
abort();
@@ -6063,45 +6050,6 @@
return Builder.CreateICmp(pred, LHS, RHS);
}
-// Binary expressions.
-/// EmitReg_BinOp - 'exp' is a binary operator.
-Value *TreeToLLVM::EmitReg_BinOp(tree type, tree_code code, tree op0, tree op1,
- unsigned Opc) {
- assert(TREE_CODE(type) != COMPLEX_TYPE && "Unexpected complex binop!");
-
- Value *LHS = EmitRegister(op0);
- Value *RHS = EmitRegister(op1);
-
- // GCC has no problem with things like "xor uint X, int 17", and X-Y, where
- // X and Y are pointer types, but the result is an integer. As such, convert
- // everything to the result type.
- bool LHSIsSigned = !TYPE_UNSIGNED(TREE_TYPE(op0));
- bool RHSIsSigned = !TYPE_UNSIGNED(TREE_TYPE(op1));
- bool TyIsSigned = !TYPE_UNSIGNED(type);
-
- const Type *Ty = GetRegType(type);
- LHS = CastToAnyType(LHS, LHSIsSigned, Ty, TyIsSigned);
- RHS = CastToAnyType(RHS, RHSIsSigned, Ty, TyIsSigned);
-
- // If it's And, Or, or Xor, make sure the operands are casted to the right
- // integer types first.
- bool isLogicalOp = Opc == Instruction::And || Opc == Instruction::Or ||
- Opc == Instruction::Xor;
- const Type *ResTy = Ty;
- if (isLogicalOp &&
- (Ty->isFloatingPoint() ||
- (isa<VectorType>(Ty) &&
- cast<VectorType>(Ty)->getElementType()->isFloatingPoint()))) {
- Ty = getSuitableBitCastIntType(Ty);
- LHS = UselesslyTypeConvert(LHS, Ty);
- RHS = UselesslyTypeConvert(RHS, Ty);
- }
-
- Value *V = Builder.CreateBinOp((Instruction::BinaryOps)Opc, LHS, RHS);
-
- return UselesslyTypeConvert(V, ResTy);
-}
-
Value *TreeToLLVM::EmitReg_MinMaxExpr(tree type, tree op0, tree op1,
unsigned UIPred, unsigned SIPred,
unsigned FPPred, bool isMax) {
@@ -6248,6 +6196,18 @@
return Builder.CreateAdd(CDiv, Offset, "cdiv");
}
+Value *TreeToLLVM::EmitReg_BIT_AND_EXPR(tree op0, tree op1) {
+ return Builder.CreateAnd(EmitRegister(op0), EmitRegister(op1));
+}
+
+Value *TreeToLLVM::EmitReg_BIT_IOR_EXPR(tree op0, tree op1) {
+ return Builder.CreateOr(EmitRegister(op0), EmitRegister(op1));
+}
+
+Value *TreeToLLVM::EmitReg_BIT_XOR_EXPR(tree op0, tree op1) {
+ return Builder.CreateXor(EmitRegister(op0), EmitRegister(op1));
+}
+
Value *TreeToLLVM::EmitReg_COMPLEX_EXPR(tree op0, tree op1) {
return CreateComplex(EmitRegister(op0), EmitRegister(op1), TREE_TYPE(op1));
}
@@ -7304,11 +7264,11 @@
// Binary expressions.
case BIT_AND_EXPR:
- RHS = EmitReg_BinOp(type, code, rhs1, rhs2, Instruction::And); break;
+ RHS = EmitReg_BIT_AND_EXPR(rhs1, rhs2); break;
case BIT_IOR_EXPR:
- RHS = EmitReg_BinOp(type, code, rhs1, rhs2, Instruction::Or); break;
+ RHS = EmitReg_BIT_IOR_EXPR(rhs1, rhs2); break;
case BIT_XOR_EXPR:
- RHS = EmitReg_BinOp(type, code, rhs1, rhs2, Instruction::Xor); break;
+ RHS = EmitReg_BIT_XOR_EXPR(rhs1, rhs2); break;
case CEIL_DIV_EXPR:
RHS = EmitReg_CEIL_DIV_EXPR(type, rhs1, rhs2); break;
case COMPLEX_EXPR:
Modified: dragonegg/trunk/llvm-internal.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/llvm-internal.h?rev=95084&r1=95083&r2=95084&view=diff
==============================================================================
--- dragonegg/trunk/llvm-internal.h (original)
+++ dragonegg/trunk/llvm-internal.h Tue Feb 2 05:25:08 2010
@@ -640,8 +640,6 @@
Value *EmitCompare(tree_node *lhs, tree_node *rhs, tree_code code);
// Binary expressions.
- Value *EmitReg_BinOp(tree_node *type, tree_code code, tree_node *op0,
- tree_node *op1, unsigned Opc);
Value *EmitReg_MinMaxExpr(tree_node *type, tree_node *op0, tree_node* op1,
unsigned UIPred, unsigned SIPred, unsigned Opc,
bool isMax);
@@ -650,6 +648,9 @@
Value *EmitReg_ShiftOp(tree_node *op0, tree_node* op1, unsigned Opc);
Value *EmitReg_TruthOp(tree_node *type, tree_node *op0, tree_node *op1,
unsigned Opc);
+ Value *EmitReg_BIT_AND_EXPR(tree_node *op0, tree_node *op1);
+ Value *EmitReg_BIT_IOR_EXPR(tree_node *op0, tree_node *op1);
+ Value *EmitReg_BIT_XOR_EXPR(tree_node *op0, tree_node *op1);
Value *EmitReg_CEIL_DIV_EXPR(tree_node *type, tree_node *op0, tree_node *op1);
Value *EmitReg_COMPLEX_EXPR(tree_node *op0, tree_node *op1);
Value *EmitReg_FLOOR_DIV_EXPR(tree_node *type, tree_node *op0,
More information about the llvm-commits
mailing list