LCOV - code coverage report
Current view: top level - include/llvm/CodeGen - SelectionDAGTargetInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 22 22 100.0 %
Date: 2018-07-13 00:08:38 Functions: 11 12 91.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //==- llvm/CodeGen/SelectionDAGTargetInfo.h - SelectionDAG Info --*- 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 declares the SelectionDAGTargetInfo class, which targets can
      11             : // subclass to parameterize the SelectionDAG lowering and instruction
      12             : // selection process.
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H
      17             : #define LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H
      18             : 
      19             : #include "llvm/CodeGen/MachineMemOperand.h"
      20             : #include "llvm/CodeGen/SelectionDAGNodes.h"
      21             : #include "llvm/Support/CodeGen.h"
      22             : #include <utility>
      23             : 
      24             : namespace llvm {
      25             : 
      26             : class SelectionDAG;
      27             : 
      28             : //===----------------------------------------------------------------------===//
      29             : /// Targets can subclass this to parameterize the
      30             : /// SelectionDAG lowering and instruction selection process.
      31             : ///
      32       33149 : class SelectionDAGTargetInfo {
      33             : public:
      34       15205 :   explicit SelectionDAGTargetInfo() = default;
      35             :   SelectionDAGTargetInfo(const SelectionDAGTargetInfo &) = delete;
      36             :   SelectionDAGTargetInfo &operator=(const SelectionDAGTargetInfo &) = delete;
      37             :   virtual ~SelectionDAGTargetInfo();
      38             : 
      39             :   /// Emit target-specific code that performs a memcpy.
      40             :   /// This can be used by targets to provide code sequences for cases
      41             :   /// that don't fit the target's parameters for simple loads/stores and can be
      42             :   /// more efficient than using a library call. This function can return a null
      43             :   /// SDValue if the target declines to use custom code and a different
      44             :   /// lowering strategy should be used.
      45             :   ///
      46             :   /// If AlwaysInline is true, the size is constant and the target should not
      47             :   /// emit any calls and is strongly encouraged to attempt to emit inline code
      48             :   /// even if it is beyond the usual threshold because this intrinsic is being
      49             :   /// expanded in a place where calls are not feasible (e.g. within the prologue
      50             :   /// for another call). If the target chooses to decline an AlwaysInline
      51             :   /// request here, legalize will resort to using simple loads and stores.
      52          53 :   virtual SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, const SDLoc &dl,
      53             :                                           SDValue Chain, SDValue Op1,
      54             :                                           SDValue Op2, SDValue Op3,
      55             :                                           unsigned Align, bool isVolatile,
      56             :                                           bool AlwaysInline,
      57             :                                           MachinePointerInfo DstPtrInfo,
      58             :                                           MachinePointerInfo SrcPtrInfo) const {
      59          53 :     return SDValue();
      60             :   }
      61             : 
      62             :   /// Emit target-specific code that performs a memmove.
      63             :   /// This can be used by targets to provide code sequences for cases
      64             :   /// that don't fit the target's parameters for simple loads/stores and can be
      65             :   /// more efficient than using a library call. This function can return a null
      66             :   /// SDValue if the target declines to use custom code and a different
      67             :   /// lowering strategy should be used.
      68         229 :   virtual SDValue EmitTargetCodeForMemmove(
      69             :       SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Op1,
      70             :       SDValue Op2, SDValue Op3, unsigned Align, bool isVolatile,
      71             :       MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const {
      72         229 :     return SDValue();
      73             :   }
      74             : 
      75             :   /// Emit target-specific code that performs a memset.
      76             :   /// This can be used by targets to provide code sequences for cases
      77             :   /// that don't fit the target's parameters for simple stores and can be more
      78             :   /// efficient than using a library call. This function can return a null
      79             :   /// SDValue if the target declines to use custom code and a different
      80             :   /// lowering strategy should be used.
      81          27 :   virtual SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, const SDLoc &dl,
      82             :                                           SDValue Chain, SDValue Op1,
      83             :                                           SDValue Op2, SDValue Op3,
      84             :                                           unsigned Align, bool isVolatile,
      85             :                                           MachinePointerInfo DstPtrInfo) const {
      86          27 :     return SDValue();
      87             :   }
      88             : 
      89             :   /// Emit target-specific code that performs a memcmp, in cases where that is
      90             :   /// faster than a libcall. The first returned SDValue is the result of the
      91             :   /// memcmp and the second is the chain. Both SDValues can be null if a normal
      92             :   /// libcall should be used.
      93             :   virtual std::pair<SDValue, SDValue>
      94         245 :   EmitTargetCodeForMemcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
      95             :                           SDValue Op1, SDValue Op2, SDValue Op3,
      96             :                           MachinePointerInfo Op1PtrInfo,
      97             :                           MachinePointerInfo Op2PtrInfo) const {
      98         245 :     return std::make_pair(SDValue(), SDValue());
      99             :   }
     100             : 
     101             :   /// Emit target-specific code that performs a memchr, in cases where that is
     102             :   /// faster than a libcall. The first returned SDValue is the result of the
     103             :   /// memchr and the second is the chain. Both SDValues can be null if a normal
     104             :   /// libcall should be used.
     105             :   virtual std::pair<SDValue, SDValue>
     106           2 :   EmitTargetCodeForMemchr(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
     107             :                           SDValue Src, SDValue Char, SDValue Length,
     108             :                           MachinePointerInfo SrcPtrInfo) const {
     109           2 :     return std::make_pair(SDValue(), SDValue());
     110             :   }
     111             : 
     112             :   /// Emit target-specific code that performs a strcpy or stpcpy, in cases
     113             :   /// where that is faster than a libcall.
     114             :   /// The first returned SDValue is the result of the copy (the start
     115             :   /// of the destination string for strcpy, a pointer to the null terminator
     116             :   /// for stpcpy) and the second is the chain.  Both SDValues can be null
     117             :   /// if a normal libcall should be used.
     118             :   virtual std::pair<SDValue, SDValue>
     119         148 :   EmitTargetCodeForStrcpy(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
     120             :                           SDValue Dest, SDValue Src,
     121             :                           MachinePointerInfo DestPtrInfo,
     122             :                           MachinePointerInfo SrcPtrInfo, bool isStpcpy) const {
     123         148 :     return std::make_pair(SDValue(), SDValue());
     124             :   }
     125             : 
     126             :   /// Emit target-specific code that performs a strcmp, in cases where that is
     127             :   /// faster than a libcall.
     128             :   /// The first returned SDValue is the result of the strcmp and the second is
     129             :   /// the chain. Both SDValues can be null if a normal libcall should be used.
     130             :   virtual std::pair<SDValue, SDValue>
     131          50 :   EmitTargetCodeForStrcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
     132             :                           SDValue Op1, SDValue Op2,
     133             :                           MachinePointerInfo Op1PtrInfo,
     134             :                           MachinePointerInfo Op2PtrInfo) const {
     135          50 :     return std::make_pair(SDValue(), SDValue());
     136             :   }
     137             : 
     138             :   virtual std::pair<SDValue, SDValue>
     139         239 :   EmitTargetCodeForStrlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
     140             :                           SDValue Src, MachinePointerInfo SrcPtrInfo) const {
     141         239 :     return std::make_pair(SDValue(), SDValue());
     142             :   }
     143             : 
     144             :   virtual std::pair<SDValue, SDValue>
     145           1 :   EmitTargetCodeForStrnlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
     146             :                            SDValue Src, SDValue MaxLength,
     147             :                            MachinePointerInfo SrcPtrInfo) const {
     148           1 :     return std::make_pair(SDValue(), SDValue());
     149             :   }
     150             : 
     151             :   // Return true when the decision to generate FMA's (or FMS, FMLA etc) rather
     152             :   // than FMUL and ADD is delegated to the machine combiner.
     153        9095 :   virtual bool generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel) const {
     154        9095 :     return false;
     155             :   }
     156             : };
     157             : 
     158             : } // end namespace llvm
     159             : 
     160             : #endif // LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H

Generated by: LCOV version 1.13