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

Generated by: LCOV version 1.13