[llvm-commits] [dragonegg] r95084 - in /dragonegg/trunk: llvm-convert.cpp llvm-internal.h

[Duncan Sands]

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,