Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

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

  1. //===- NoFolder.h - Constant 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 NoFolder class, a helper for IRBuilder.  It provides
  10. // IRBuilder with a set of methods for creating unfolded constants.  This is
  11. // useful for learners trying to understand how LLVM IR works, and who don't
  12. // want details to be hidden by the constant folder.  For general constant
  13. // creation and folding, use ConstantExpr and the routines in
  14. // llvm/Analysis/ConstantFolding.h.
  15. //
  16. // Note: since it is not actually possible to create unfolded constants, this
  17. // class returns instructions rather than constants.
  18. //
  19. //===----------------------------------------------------------------------===//
  20.  
  21. #ifndef LLVM_IR_NOFOLDER_H
  22. #define LLVM_IR_NOFOLDER_H
  23.  
  24. #include "llvm/ADT/ArrayRef.h"
  25. #include "llvm/IR/Constants.h"
  26. #include "llvm/IR/FMF.h"
  27. #include "llvm/IR/IRBuilderFolder.h"
  28. #include "llvm/IR/InstrTypes.h"
  29. #include "llvm/IR/Instruction.h"
  30. #include "llvm/IR/Instructions.h"
  31.  
  32. namespace llvm {
  33.  
  34. /// NoFolder - Create "constants" (actually, instructions) with no folding.
  35. class NoFolder final : public IRBuilderFolder {
  36.   virtual void anchor();
  37.  
  38. public:
  39.   explicit NoFolder() = default;
  40.  
  41.   //===--------------------------------------------------------------------===//
  42.   // Value-based folders.
  43.   //
  44.   // Return an existing value or a constant if the operation can be simplified.
  45.   // Otherwise return nullptr.
  46.   //===--------------------------------------------------------------------===//
  47.  
  48.   Value *FoldBinOp(Instruction::BinaryOps Opc, Value *LHS,
  49.                    Value *RHS) const override {
  50.     return nullptr;
  51.   }
  52.  
  53.   Value *FoldExactBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
  54.                         bool IsExact) const override {
  55.     return nullptr;
  56.   }
  57.  
  58.   Value *FoldNoWrapBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
  59.                          bool HasNUW, bool HasNSW) const override {
  60.     return nullptr;
  61.   }
  62.  
  63.   Value *FoldBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
  64.                       FastMathFlags FMF) const override {
  65.     return nullptr;
  66.   }
  67.  
  68.   Value *FoldUnOpFMF(Instruction::UnaryOps Opc, Value *V,
  69.                      FastMathFlags FMF) const override {
  70.     return nullptr;
  71.   }
  72.  
  73.   Value *FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override {
  74.     return nullptr;
  75.   }
  76.  
  77.   Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
  78.                  bool IsInBounds = false) const override {
  79.     return nullptr;
  80.   }
  81.  
  82.   Value *FoldSelect(Value *C, Value *True, Value *False) const override {
  83.     return nullptr;
  84.   }
  85.  
  86.   Value *FoldExtractValue(Value *Agg,
  87.                           ArrayRef<unsigned> IdxList) const override {
  88.     return nullptr;
  89.   }
  90.  
  91.   Value *FoldInsertValue(Value *Agg, Value *Val,
  92.                          ArrayRef<unsigned> IdxList) const override {
  93.     return nullptr;
  94.   }
  95.  
  96.   Value *FoldExtractElement(Value *Vec, Value *Idx) const override {
  97.     return nullptr;
  98.   }
  99.  
  100.   Value *FoldInsertElement(Value *Vec, Value *NewElt,
  101.                            Value *Idx) const override {
  102.     return nullptr;
  103.   }
  104.  
  105.   Value *FoldShuffleVector(Value *V1, Value *V2,
  106.                            ArrayRef<int> Mask) const override {
  107.     return nullptr;
  108.   }
  109.  
  110.   //===--------------------------------------------------------------------===//
  111.   // Cast/Conversion Operators
  112.   //===--------------------------------------------------------------------===//
  113.  
  114.   Instruction *CreateCast(Instruction::CastOps Op, Constant *C,
  115.                           Type *DestTy) const override {
  116.     return CastInst::Create(Op, C, DestTy);
  117.   }
  118.  
  119.   Instruction *CreatePointerCast(Constant *C, Type *DestTy) const override {
  120.     return CastInst::CreatePointerCast(C, DestTy);
  121.   }
  122.  
  123.   Instruction *CreatePointerBitCastOrAddrSpaceCast(
  124.       Constant *C, Type *DestTy) const override {
  125.     return CastInst::CreatePointerBitCastOrAddrSpaceCast(C, DestTy);
  126.   }
  127.  
  128.   Instruction *CreateIntCast(Constant *C, Type *DestTy,
  129.                              bool isSigned) const override {
  130.     return CastInst::CreateIntegerCast(C, DestTy, isSigned);
  131.   }
  132.  
  133.   Instruction *CreateFPCast(Constant *C, Type *DestTy) const override {
  134.     return CastInst::CreateFPCast(C, DestTy);
  135.   }
  136.  
  137.   Instruction *CreateBitCast(Constant *C, Type *DestTy) const override {
  138.     return CreateCast(Instruction::BitCast, C, DestTy);
  139.   }
  140.  
  141.   Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const override {
  142.     return CreateCast(Instruction::IntToPtr, C, DestTy);
  143.   }
  144.  
  145.   Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const override {
  146.     return CreateCast(Instruction::PtrToInt, C, DestTy);
  147.   }
  148.  
  149.   Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
  150.     return CastInst::CreateZExtOrBitCast(C, DestTy);
  151.   }
  152.  
  153.   Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override {
  154.     return CastInst::CreateSExtOrBitCast(C, DestTy);
  155.   }
  156.  
  157.   Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override {
  158.     return CastInst::CreateTruncOrBitCast(C, DestTy);
  159.   }
  160.  
  161.   //===--------------------------------------------------------------------===//
  162.   // Compare Instructions
  163.   //===--------------------------------------------------------------------===//
  164.  
  165.   Instruction *CreateFCmp(CmpInst::Predicate P,
  166.                           Constant *LHS, Constant *RHS) const override {
  167.     return new FCmpInst(P, LHS, RHS);
  168.   }
  169. };
  170.  
  171. } // end namespace llvm
  172.  
  173. #endif // LLVM_IR_NOFOLDER_H
  174.