lib/Analysis/InstructionSimplify.cpp

   1 //===- InstructionSimplify.cpp - Fold instruction operands ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements routines for folding instructions into simpler forms
  11 // that do not require creating new instructions.  For example, this does
  12 // constant folding, and can handle identities like (X&0)->0.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "llvm/Analysis/InstructionSimplify.h"
  17 #include "llvm/Analysis/ConstantFolding.h"
  18 #include "llvm/Instructions.h"
  19 using namespace llvm;
  20
  21
  22 /// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
  23 /// fold the result.  If not, this returns null.
  24 Value *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
  25                            const TargetData *TD) {
  26   if (Constant *CLHS = dyn_cast<Constant>(LHS))
  27     if (Constant *CRHS = dyn_cast<Constant>(RHS)) {
  28       Constant *COps[] = {CLHS, CRHS};
  29       return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, 2, TD);
  30     }
  31   return 0;
  32 }
  33
  34
  35 /// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
  36 /// fold the result.  If not, this returns null.
  37 Value *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
  38                               const TargetData *TD) {
  39   CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate;
  40   assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!");
  41
  42   if (Constant *CLHS = dyn_cast<Constant>(LHS))
  43     if (Constant *CRHS = dyn_cast<Constant>(RHS))
  44       return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD);
  45
  46   // If this is an integer compare and the LHS and RHS are the same, fold it.
  47   if (LHS == RHS)
  48     if (ICmpInst::isTrueWhenEqual(Pred))
  49       return ConstantInt::getTrue(LHS->getContext());
  50     else
  51       return ConstantInt::getFalse(LHS->getContext());
  52
  53   return 0;
  54 }
  55
  56 /// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
  57 /// fold the result.  If not, this returns null.
  58 Value *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
  59                               const TargetData *TD) {
  60   CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate;
  61   assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!");
  62
  63   if (Constant *CLHS = dyn_cast<Constant>(LHS))
  64     if (Constant *CRHS = dyn_cast<Constant>(RHS))
  65       return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD);
  66
  67   return 0;
  68 }
  69
  70
  71
  72 /// SimplifyCmpInst - Given operands for a CmpInst, see if we can
  73 /// fold the result.
  74 Value *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
  75                              const TargetData *TD) {
  76   if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate))
  77     return SimplifyICmpInst(Predicate, LHS, RHS, TD);
  78   return SimplifyFCmpInst(Predicate, LHS, RHS, TD);
  79 }
  80