Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- InstSimplifyFolder.h - InstSimplify folding helper --------*- C++-*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // This file defines the InstSimplifyFolder class, a helper for IRBuilder.
  10. // It provides IRBuilder with a set of methods for folding operations to
  11. // existing values using InstructionSimplify. At the moment, only a subset of
  12. // the implementation uses InstructionSimplify. The rest of the implementation
  13. // only folds constants.
  14. //
  15. // The folder also applies target-specific constant folding.
  16. //
  17. //===----------------------------------------------------------------------===//
  18.  
  19. #ifndef LLVM_ANALYSIS_INSTSIMPLIFYFOLDER_H
  20. #define LLVM_ANALYSIS_INSTSIMPLIFYFOLDER_H
  21.  
  22. #include "llvm/ADT/ArrayRef.h"
  23. #include "llvm/Analysis/InstructionSimplify.h"
  24. #include "llvm/Analysis/TargetFolder.h"
  25. #include "llvm/IR/IRBuilderFolder.h"
  26. #include "llvm/IR/Instruction.h"
  27.  
  28. namespace llvm {
  29. class Constant;
  30.  
  31. /// InstSimplifyFolder - Use InstructionSimplify to fold operations to existing
  32. /// values. Also applies target-specific constant folding when not using
  33. /// InstructionSimplify.
  34. class InstSimplifyFolder final : public IRBuilderFolder {
  35.   TargetFolder ConstFolder;
  36.   SimplifyQuery SQ;
  37.  
  38.   virtual void anchor();
  39.  
  40. public:
  41.   InstSimplifyFolder(const DataLayout &DL) : ConstFolder(DL), SQ(DL) {}
  42.  
  43.   //===--------------------------------------------------------------------===//
  44.   // Value-based folders.
  45.   //
  46.   // Return an existing value or a constant if the operation can be simplified.
  47.   // Otherwise return nullptr.
  48.   //===--------------------------------------------------------------------===//
  49.  
  50.   Value *FoldBinOp(Instruction::BinaryOps Opc, Value *LHS,
  51.                    Value *RHS) const override {
  52.     return simplifyBinOp(Opc, LHS, RHS, SQ);
  53.   }
  54.  
  55.   Value *FoldExactBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
  56.                         bool IsExact) const override {
  57.     return simplifyBinOp(Opc, LHS, RHS, SQ);
  58.   }
  59.  
  60.   Value *FoldNoWrapBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
  61.                          bool HasNUW, bool HasNSW) const override {
  62.     return simplifyBinOp(Opc, LHS, RHS, SQ);
  63.   }
  64.  
  65.   Value *FoldBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
  66.                       FastMathFlags FMF) const override {
  67.     return simplifyBinOp(Opc, LHS, RHS, FMF, SQ);
  68.   }
  69.  
  70.   Value *FoldUnOpFMF(Instruction::UnaryOps Opc, Value *V,
  71.                       FastMathFlags FMF) const override {
  72.     return simplifyUnOp(Opc, V, FMF, SQ);
  73.   }
  74.  
  75.   Value *FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override {
  76.     return simplifyICmpInst(P, LHS, RHS, SQ);
  77.   }
  78.  
  79.   Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
  80.                  bool IsInBounds = false) const override {
  81.     return simplifyGEPInst(Ty, Ptr, IdxList, IsInBounds, SQ);
  82.   }
  83.  
  84.   Value *FoldSelect(Value *C, Value *True, Value *False) const override {
  85.     return simplifySelectInst(C, True, False, SQ);
  86.   }
  87.  
  88.   Value *FoldExtractValue(Value *Agg,
  89.                           ArrayRef<unsigned> IdxList) const override {
  90.     return simplifyExtractValueInst(Agg, IdxList, SQ);
  91.   };
  92.  
  93.   Value *FoldInsertValue(Value *Agg, Value *Val,
  94.                          ArrayRef<unsigned> IdxList) const override {
  95.     return simplifyInsertValueInst(Agg, Val, IdxList, SQ);
  96.   }
  97.  
  98.   Value *FoldExtractElement(Value *Vec, Value *Idx) const override {
  99.     return simplifyExtractElementInst(Vec, Idx, SQ);
  100.   }
  101.  
  102.   Value *FoldInsertElement(Value *Vec, Value *NewElt,
  103.                            Value *Idx) const override {
  104.     return simplifyInsertElementInst(Vec, NewElt, Idx, SQ);
  105.   }
  106.  
  107.   Value *FoldShuffleVector(Value *V1, Value *V2,
  108.                            ArrayRef<int> Mask) const override {
  109.     Type *RetTy = VectorType::get(
  110.         cast<VectorType>(V1->getType())->getElementType(), Mask.size(),
  111.         isa<ScalableVectorType>(V1->getType()));
  112.     return simplifyShuffleVectorInst(V1, V2, Mask, RetTy, SQ);
  113.   }
  114.  
  115.   //===--------------------------------------------------------------------===//
  116.   // Cast/Conversion Operators
  117.   //===--------------------------------------------------------------------===//
  118.  
  119.   Value *CreateCast(Instruction::CastOps Op, Constant *C,
  120.                     Type *DestTy) const override {
  121.     if (C->getType() == DestTy)
  122.       return C; // avoid calling Fold
  123.     return ConstFolder.CreateCast(Op, C, DestTy);
  124.   }
  125.   Value *CreateIntCast(Constant *C, Type *DestTy,
  126.                        bool isSigned) const override {
  127.     if (C->getType() == DestTy)
  128.       return C; // avoid calling Fold
  129.     return ConstFolder.CreateIntCast(C, DestTy, isSigned);
  130.   }
  131.   Value *CreatePointerCast(Constant *C, Type *DestTy) const override {
  132.     if (C->getType() == DestTy)
  133.       return C; // avoid calling Fold
  134.     return ConstFolder.CreatePointerCast(C, DestTy);
  135.   }
  136.   Value *CreateFPCast(Constant *C, Type *DestTy) const override {
  137.     if (C->getType() == DestTy)
  138.       return C; // avoid calling Fold
  139.     return ConstFolder.CreateFPCast(C, DestTy);
  140.   }
  141.   Value *CreateBitCast(Constant *C, Type *DestTy) const override {
  142.     return ConstFolder.CreateBitCast(C, DestTy);
  143.   }
  144.   Value *CreateIntToPtr(Constant *C, Type *DestTy) const override {
  145.     return ConstFolder.CreateIntToPtr(C, DestTy);
  146.   }
  147.   Value *CreatePtrToInt(Constant *C, Type *DestTy) const override {
  148.     return ConstFolder.CreatePtrToInt(C, DestTy);
  149.   }
  150.   Value *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
  151.     if (C->getType() == DestTy)
  152.       return C; // avoid calling Fold
  153.     return ConstFolder.CreateZExtOrBitCast(C, DestTy);
  154.   }
  155.   Value *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
  156.     if (C->getType() == DestTy)
  157.       return C; // avoid calling Fold
  158.     return ConstFolder.CreateSExtOrBitCast(C, DestTy);
  159.   }
  160.   Value *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
  161.     if (C->getType() == DestTy)
  162.       return C; // avoid calling Fold
  163.     return ConstFolder.CreateTruncOrBitCast(C, DestTy);
  164.   }
  165.  
  166.   Value *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
  167.                                              Type *DestTy) const override {
  168.     if (C->getType() == DestTy)
  169.       return C; // avoid calling Fold
  170.     return ConstFolder.CreatePointerBitCastOrAddrSpaceCast(C, DestTy);
  171.   }
  172.  
  173.   //===--------------------------------------------------------------------===//
  174.   // Compare Instructions
  175.   //===--------------------------------------------------------------------===//
  176.  
  177.   Value *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
  178.                     Constant *RHS) const override {
  179.     return ConstFolder.CreateFCmp(P, LHS, RHS);
  180.   }
  181. };
  182.  
  183. } // end namespace llvm
  184.  
  185. #endif // LLVM_ANALYSIS_INSTSIMPLIFYFOLDER_H
  186.