[llvm-commits] [gcc-plugin] r82220 - /gcc-plugin/trunk/llvm-convert.cpp

Duncan Sands baldrick at free.fr
Fri Sep 18 07:24:15 PDT 2009


Author: baldrick
Date: Fri Sep 18 09:24:14 2009
New Revision: 82220

URL: http://llvm.org/viewvc/llvm-project?rev=82220&view=rev
Log:
Most of "Emit" is now dead code since these expressions
can only occur in a "binary" GIMPLE_ASSIGN expression,
and are handled elsewhere.

Modified:
    gcc-plugin/trunk/llvm-convert.cpp

Modified: gcc-plugin/trunk/llvm-convert.cpp
URL: http://llvm.org/viewvc/llvm-project/gcc-plugin/trunk/llvm-convert.cpp?rev=82220&r1=82219&r2=82220&view=diff

==============================================================================
--- gcc-plugin/trunk/llvm-convert.cpp (original)
+++ gcc-plugin/trunk/llvm-convert.cpp Fri Sep 18 09:24:14 2009
@@ -1086,184 +1086,13 @@
   case CALL_EXPR:       Result = EmitCALL_EXPR(exp, DestLoc); break;
   case INIT_EXPR:
   case MODIFY_EXPR:     Result = EmitMODIFY_EXPR(exp, DestLoc); break;
-  case NON_LVALUE_EXPR: Result = Emit(TREE_OPERAND(exp, 0), DestLoc); break;
 
     // Unary Operators
-  case NOP_EXPR:
-    Result = EmitNOP_EXPR(TREE_TYPE(exp), TREE_OPERAND(exp, 0), DestLoc);
-    break;
-  case FIX_TRUNC_EXPR:
-  case FLOAT_EXPR:
-  case CONVERT_EXPR:
-    Result = EmitCONVERT_EXPR(TREE_TYPE(exp), TREE_OPERAND(exp, 0));
-    break;
   case VIEW_CONVERT_EXPR: Result = EmitVIEW_CONVERT_EXPR(exp, DestLoc); break;
-  case NEGATE_EXPR:
-    Result = EmitNEGATE_EXPR(TREE_OPERAND(exp, 0), DestLoc);
-    break;
-  case CONJ_EXPR:
-    Result = EmitCONJ_EXPR(TREE_OPERAND(exp, 0), DestLoc);
-    break;
-  case ABS_EXPR:       Result = EmitABS_EXPR(TREE_OPERAND(exp, 0)); break;
-  case BIT_NOT_EXPR:   Result = EmitBIT_NOT_EXPR(TREE_OPERAND(exp, 0)); break;
-  case TRUTH_NOT_EXPR:
-    Result = EmitTRUTH_NOT_EXPR(TREE_TYPE(exp), TREE_OPERAND(exp, 0));
-    break;
-
-  // Binary Operators
-  case LT_EXPR:
-  case LE_EXPR:
-  case GT_EXPR:
-  case GE_EXPR:
-  case EQ_EXPR:
-  case NE_EXPR:
-  case UNORDERED_EXPR:
-  case ORDERED_EXPR:
-  case UNLT_EXPR:
-  case UNLE_EXPR:
-  case UNGT_EXPR:
-  case UNGE_EXPR:
-  case UNEQ_EXPR:
-  case LTGT_EXPR:
-    Result = EmitCompare(TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),
-                         TREE_CODE(exp));
-    // The GCC result may be of any integer type.
-    Result = Builder.CreateZExt(Result, ConvertType(TREE_TYPE(exp)));
-    break;
-  case PLUS_EXPR:
-    Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                       TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                       FLOAT_TYPE_P(TREE_TYPE(exp)) ?
-                         Instruction::FAdd :
-                         Instruction::Add);
-    break;
-  case MINUS_EXPR:
-    Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                       TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                       FLOAT_TYPE_P(TREE_TYPE(exp)) ?
-                         Instruction::FSub :
-                         Instruction::Sub);
-    break;
-  case MULT_EXPR:
-    Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                       TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                       FLOAT_TYPE_P(TREE_TYPE(exp)) ?
-                         Instruction::FMul :
-                         Instruction::Mul);
-    break;
-  case EXACT_DIV_EXPR:
-    Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                       TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                       TYPE_UNSIGNED(TREE_TYPE(exp)) ?
-                       Instruction::UDiv : Instruction::SDiv);
-  case TRUNC_DIV_EXPR:
-    if (TYPE_UNSIGNED(TREE_TYPE(exp)))
-      Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                         TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                         Instruction::UDiv);
-    else
-      Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                         TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                         Instruction::SDiv);
-    break;
-  case RDIV_EXPR: Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                                     TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),
-                                     DestLoc, Instruction::FDiv); break;
-  case CEIL_DIV_EXPR:
-    Result = EmitCEIL_DIV_EXPR(TREE_TYPE(exp), TREE_OPERAND(exp, 0),
-                               TREE_OPERAND(exp, 1));
-    break;
-  case FLOOR_DIV_EXPR:
-    Result = EmitFLOOR_DIV_EXPR(TREE_TYPE(exp), TREE_OPERAND(exp, 0),
-                                TREE_OPERAND(exp, 1));
-    break;
-  case ROUND_DIV_EXPR:
-    Result = EmitROUND_DIV_EXPR(TREE_TYPE(exp), TREE_OPERAND(exp, 0),
-                                TREE_OPERAND(exp, 1));
-    break;
-  case TRUNC_MOD_EXPR:
-    if (TYPE_UNSIGNED(TREE_TYPE(exp)))
-      Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                         TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                         Instruction::URem);
-    else
-      Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                         TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                         Instruction::SRem);
-    break;
-  case FLOOR_MOD_EXPR:
-    Result = EmitFLOOR_MOD_EXPR(TREE_TYPE(exp), TREE_OPERAND(exp, 0),
-                                TREE_OPERAND(exp, 1));
-    break;
-  case BIT_AND_EXPR:
-    Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                       TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                       Instruction::And);
-    break;
-  case BIT_IOR_EXPR:
-    Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                       TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                       Instruction::Or);
-    break;
-  case BIT_XOR_EXPR:
-    Result = EmitBinOp(TREE_TYPE(exp), TREE_CODE(exp),
-                       TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc,
-                       Instruction::Xor);
-    break;
-  case TRUTH_AND_EXPR:
-    Result = EmitTruthOp(TREE_TYPE(exp), TREE_OPERAND(exp, 0),
-                         TREE_OPERAND(exp, 1), Instruction::And);
-    break;
-  case TRUTH_OR_EXPR:
-    Result = EmitTruthOp(TREE_TYPE(exp), TREE_OPERAND(exp, 0),
-                         TREE_OPERAND(exp, 1), Instruction::Or);
-    break;
-  case TRUTH_XOR_EXPR:
-    Result = EmitTruthOp(TREE_TYPE(exp), TREE_OPERAND(exp, 0),
-                         TREE_OPERAND(exp, 1), Instruction::Xor);
-    break;
-  case RSHIFT_EXPR:
-    Result = EmitShiftOp(TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),
-                         TYPE_UNSIGNED(TREE_TYPE(exp)) ?
-                         Instruction::LShr : Instruction::AShr);
-    break;
-  case LSHIFT_EXPR:
-    Result = EmitShiftOp(TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),
-                         Instruction::Shl);
-    break;
-  case RROTATE_EXPR:
-    Result = EmitRotateOp(TREE_TYPE(exp),
-                          TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),
-                          Instruction::LShr, Instruction::Shl);
-    break;
-  case LROTATE_EXPR:
-    Result = EmitRotateOp(TREE_TYPE(exp),
-                          TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),
-                          Instruction::Shl, Instruction::LShr);
-    break;
-  case MIN_EXPR:
-    Result = EmitMinMaxExpr(TREE_TYPE(exp),
-                            TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),
-                            ICmpInst::ICMP_ULE, ICmpInst::ICMP_SLE,
-                            FCmpInst::FCMP_OLE, false);
-    break;
-  case MAX_EXPR:
-    Result = EmitMinMaxExpr(TREE_TYPE(exp),
-                            TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),
-                            ICmpInst::ICMP_UGE, ICmpInst::ICMP_SGE,
-                            FCmpInst::FCMP_OGE, true);
-    break;
   case CONSTRUCTOR:       Result = EmitCONSTRUCTOR(exp, DestLoc); break;
-  case POINTER_PLUS_EXPR:
-    Result = EmitPOINTER_PLUS_EXPR(TREE_TYPE(exp), TREE_OPERAND(exp, 0),
-                                   TREE_OPERAND(exp, 1));
-    break;
 
   // Complex Math Expressions.
   case COMPLEX_CST:    EmitCOMPLEX_CST (exp, DestLoc); break;
-  case COMPLEX_EXPR:
-    EmitCOMPLEX_EXPR(TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), DestLoc);
-    break;
 
   // Constant Expressions
   case INTEGER_CST:





More information about the llvm-commits mailing list