LCOV - code coverage report
Current view: top level - include/llvm/Analysis - TargetFolder.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 49 76 64.5 %
Date: 2017-09-14 15:23:50 Functions: 23 36 63.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //====- TargetFolder.h - Constant folding helper ---------------*- C++ -*-====//
       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 defines the TargetFolder class, a helper for IRBuilder.
      11             : // It provides IRBuilder with a set of methods for creating constants with
      12             : // target dependent folding, in addition to the same target-independent
      13             : // folding that the ConstantFolder class provides.  For general constant
      14             : // creation and folding, use ConstantExpr and the routines in
      15             : // llvm/Analysis/ConstantFolding.h.
      16             : //
      17             : //===----------------------------------------------------------------------===//
      18             : 
      19             : #ifndef LLVM_ANALYSIS_TARGETFOLDER_H
      20             : #define LLVM_ANALYSIS_TARGETFOLDER_H
      21             : 
      22             : #include "llvm/ADT/ArrayRef.h"
      23             : #include "llvm/Analysis/ConstantFolding.h"
      24             : #include "llvm/IR/Constants.h"
      25             : #include "llvm/IR/InstrTypes.h"
      26             : 
      27             : namespace llvm {
      28             : 
      29             : class DataLayout;
      30             : 
      31             : /// TargetFolder - Create constants with target dependent folding.
      32             : class TargetFolder {
      33             :   const DataLayout &DL;
      34             : 
      35             :   /// Fold - Fold the constant using target specific information.
      36             :   Constant *Fold(Constant *C) const {
      37      345103 :     if (Constant *CF = ConstantFoldConstant(C, DL))
      38             :       return CF;
      39             :     return C;
      40             :   }
      41             : 
      42             : public:
      43             :   explicit TargetFolder(const DataLayout &DL) : DL(DL) {}
      44             : 
      45             :   //===--------------------------------------------------------------------===//
      46             :   // Binary Operators
      47             :   //===--------------------------------------------------------------------===//
      48             : 
      49         574 :   Constant *CreateAdd(Constant *LHS, Constant *RHS,
      50             :                       bool HasNUW = false, bool HasNSW = false) const {
      51        1148 :     return Fold(ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW));
      52             :   }
      53           1 :   Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
      54           2 :     return Fold(ConstantExpr::getFAdd(LHS, RHS));
      55             :   }
      56          20 :   Constant *CreateSub(Constant *LHS, Constant *RHS,
      57             :                       bool HasNUW = false, bool HasNSW = false) const {
      58          40 :     return Fold(ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW));
      59             :   }
      60           2 :   Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
      61           4 :     return Fold(ConstantExpr::getFSub(LHS, RHS));
      62             :   }
      63         118 :   Constant *CreateMul(Constant *LHS, Constant *RHS,
      64             :                       bool HasNUW = false, bool HasNSW = false) const {
      65         236 :     return Fold(ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW));
      66             :   }
      67           1 :   Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
      68           2 :     return Fold(ConstantExpr::getFMul(LHS, RHS));
      69             :   }
      70           0 :   Constant *CreateUDiv(Constant *LHS, Constant *RHS, bool isExact = false)const{
      71           0 :     return Fold(ConstantExpr::getUDiv(LHS, RHS, isExact));
      72             :   }
      73           0 :   Constant *CreateSDiv(Constant *LHS, Constant *RHS, bool isExact = false)const{
      74           0 :     return Fold(ConstantExpr::getSDiv(LHS, RHS, isExact));
      75             :   }
      76           0 :   Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
      77           0 :     return Fold(ConstantExpr::getFDiv(LHS, RHS));
      78             :   }
      79           0 :   Constant *CreateURem(Constant *LHS, Constant *RHS) const {
      80           0 :     return Fold(ConstantExpr::getURem(LHS, RHS));
      81             :   }
      82             :   Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
      83             :     return Fold(ConstantExpr::getSRem(LHS, RHS));
      84             :   }
      85           0 :   Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
      86           0 :     return Fold(ConstantExpr::getFRem(LHS, RHS));
      87             :   }
      88          26 :   Constant *CreateShl(Constant *LHS, Constant *RHS,
      89             :                       bool HasNUW = false, bool HasNSW = false) const {
      90          52 :     return Fold(ConstantExpr::getShl(LHS, RHS, HasNUW, HasNSW));
      91             :   }
      92          16 :   Constant *CreateLShr(Constant *LHS, Constant *RHS, bool isExact = false)const{
      93          32 :     return Fold(ConstantExpr::getLShr(LHS, RHS, isExact));
      94             :   }
      95          19 :   Constant *CreateAShr(Constant *LHS, Constant *RHS, bool isExact = false)const{
      96          38 :     return Fold(ConstantExpr::getAShr(LHS, RHS, isExact));
      97             :   }
      98           0 :   Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
      99           0 :     return Fold(ConstantExpr::getAnd(LHS, RHS));
     100             :   }
     101          41 :   Constant *CreateOr(Constant *LHS, Constant *RHS) const {
     102          82 :     return Fold(ConstantExpr::getOr(LHS, RHS));
     103             :   }
     104           0 :   Constant *CreateXor(Constant *LHS, Constant *RHS) const {
     105           0 :     return Fold(ConstantExpr::getXor(LHS, RHS));
     106             :   }
     107             : 
     108          14 :   Constant *CreateBinOp(Instruction::BinaryOps Opc,
     109             :                         Constant *LHS, Constant *RHS) const {
     110          28 :     return Fold(ConstantExpr::get(Opc, LHS, RHS));
     111             :   }
     112             : 
     113             :   //===--------------------------------------------------------------------===//
     114             :   // Unary Operators
     115             :   //===--------------------------------------------------------------------===//
     116             : 
     117           0 :   Constant *CreateNeg(Constant *C,
     118             :                       bool HasNUW = false, bool HasNSW = false) const {
     119           0 :     return Fold(ConstantExpr::getNeg(C, HasNUW, HasNSW));
     120             :   }
     121           1 :   Constant *CreateFNeg(Constant *C) const {
     122           2 :     return Fold(ConstantExpr::getFNeg(C));
     123             :   }
     124          76 :   Constant *CreateNot(Constant *C) const {
     125         152 :     return Fold(ConstantExpr::getNot(C));
     126             :   }
     127             : 
     128             :   //===--------------------------------------------------------------------===//
     129             :   // Memory Instructions
     130             :   //===--------------------------------------------------------------------===//
     131             : 
     132             :   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
     133             :                                 ArrayRef<Constant *> IdxList) const {
     134             :     return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
     135             :   }
     136           0 :   Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
     137             :     // This form of the function only exists to avoid ambiguous overload
     138             :     // warnings about whether to convert Idx to ArrayRef<Constant *> or
     139             :     // ArrayRef<Value *>.
     140           0 :     return Fold(ConstantExpr::getGetElementPtr(Ty, C, Idx));
     141             :   }
     142         134 :   Constant *CreateGetElementPtr(Type *Ty, Constant *C,
     143             :                                 ArrayRef<Value *> IdxList) const {
     144         402 :     return Fold(ConstantExpr::getGetElementPtr(Ty, C, IdxList));
     145             :   }
     146             : 
     147             :   Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
     148             :                                         ArrayRef<Constant *> IdxList) const {
     149             :     return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList));
     150             :   }
     151           0 :   Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
     152             :                                         Constant *Idx) const {
     153             :     // This form of the function only exists to avoid ambiguous overload
     154             :     // warnings about whether to convert Idx to ArrayRef<Constant *> or
     155             :     // ArrayRef<Value *>.
     156           0 :     return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, Idx));
     157             :   }
     158      150918 :   Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
     159             :                                         ArrayRef<Value *> IdxList) const {
     160      301836 :     return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, C, IdxList));
     161             :   }
     162             : 
     163             :   //===--------------------------------------------------------------------===//
     164             :   // Cast/Conversion Operators
     165             :   //===--------------------------------------------------------------------===//
     166             : 
     167       12770 :   Constant *CreateCast(Instruction::CastOps Op, Constant *C,
     168             :                        Type *DestTy) const {
     169       12770 :     if (C->getType() == DestTy)
     170             :       return C; // avoid calling Fold
     171       12770 :     return Fold(ConstantExpr::getCast(Op, C, DestTy));
     172             :   }
     173       28473 :   Constant *CreateIntCast(Constant *C, Type *DestTy,
     174             :                           bool isSigned) const {
     175       28473 :     if (C->getType() == DestTy)
     176             :       return C; // avoid calling Fold
     177       28473 :     return Fold(ConstantExpr::getIntegerCast(C, DestTy, isSigned));
     178             :   }
     179           0 :   Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
     180           0 :     if (C->getType() == DestTy)
     181             :       return C; // avoid calling Fold
     182           0 :     return Fold(ConstantExpr::getPointerCast(C, DestTy));
     183             :   }
     184             :   Constant *CreateFPCast(Constant *C, Type *DestTy) const {
     185             :     if (C->getType() == DestTy)
     186             :       return C; // avoid calling Fold
     187             :     return Fold(ConstantExpr::getFPCast(C, DestTy));
     188             :   }
     189             :   Constant *CreateBitCast(Constant *C, Type *DestTy) const {
     190             :     return CreateCast(Instruction::BitCast, C, DestTy);
     191             :   }
     192             :   Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
     193             :     return CreateCast(Instruction::IntToPtr, C, DestTy);
     194             :   }
     195             :   Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
     196             :     return CreateCast(Instruction::PtrToInt, C, DestTy);
     197             :   }
     198             :   Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
     199             :     if (C->getType() == DestTy)
     200             :       return C; // avoid calling Fold
     201             :     return Fold(ConstantExpr::getZExtOrBitCast(C, DestTy));
     202             :   }
     203             :   Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
     204             :     if (C->getType() == DestTy)
     205             :       return C; // avoid calling Fold
     206             :     return Fold(ConstantExpr::getSExtOrBitCast(C, DestTy));
     207             :   }
     208             :   Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
     209             :     if (C->getType() == DestTy)
     210             :       return C; // avoid calling Fold
     211             :     return Fold(ConstantExpr::getTruncOrBitCast(C, DestTy));
     212             :   }
     213             : 
     214             :   Constant *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
     215             :                                                 Type *DestTy) const {
     216             :     if (C->getType() == DestTy)
     217             :       return C; // avoid calling Fold
     218             :     return Fold(ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy));
     219             :   }
     220             : 
     221             :   //===--------------------------------------------------------------------===//
     222             :   // Compare Instructions
     223             :   //===--------------------------------------------------------------------===//
     224             : 
     225         141 :   Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
     226             :                        Constant *RHS) const {
     227         282 :     return Fold(ConstantExpr::getCompare(P, LHS, RHS));
     228             :   }
     229           0 :   Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
     230             :                        Constant *RHS) const {
     231           0 :     return Fold(ConstantExpr::getCompare(P, LHS, RHS));
     232             :   }
     233             : 
     234             :   //===--------------------------------------------------------------------===//
     235             :   // Other Instructions
     236             :   //===--------------------------------------------------------------------===//
     237             : 
     238          62 :   Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
     239         124 :     return Fold(ConstantExpr::getSelect(C, True, False));
     240             :   }
     241             : 
     242          28 :   Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
     243          56 :     return Fold(ConstantExpr::getExtractElement(Vec, Idx));
     244             :   }
     245             : 
     246         517 :   Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
     247             :                                 Constant *Idx) const {
     248        1034 :     return Fold(ConstantExpr::getInsertElement(Vec, NewElt, Idx));
     249             :   }
     250             : 
     251         140 :   Constant *CreateShuffleVector(Constant *V1, Constant *V2,
     252             :                                 Constant *Mask) const {
     253         280 :     return Fold(ConstantExpr::getShuffleVector(V1, V2, Mask));
     254             :   }
     255             : 
     256      151011 :   Constant *CreateExtractValue(Constant *Agg,
     257             :                                ArrayRef<unsigned> IdxList) const {
     258      302022 :     return Fold(ConstantExpr::getExtractValue(Agg, IdxList));
     259             :   }
     260             : 
     261           0 :   Constant *CreateInsertValue(Constant *Agg, Constant *Val,
     262             :                               ArrayRef<unsigned> IdxList) const {
     263           0 :     return Fold(ConstantExpr::getInsertValue(Agg, Val, IdxList));
     264             :   }
     265             : };
     266             : 
     267             : }
     268             : 
     269             : #endif

Generated by: LCOV version 1.13