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   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.
EmitTargetCodeForMemcpy(SelectionDAG & DAG,const SDLoc & dl,SDValue Chain,SDValue Op1,SDValue Op2,SDValue Op3,unsigned Align,bool isVolatile,bool AlwaysInline,MachinePointerInfo DstPtrInfo,MachinePointerInfo SrcPtrInfo)49   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     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.
EmitTargetCodeForMemmove(SelectionDAG & DAG,const SDLoc & dl,SDValue Chain,SDValue Op1,SDValue Op2,SDValue Op3,unsigned Align,bool isVolatile,MachinePointerInfo DstPtrInfo,MachinePointerInfo SrcPtrInfo)65   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     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.
EmitTargetCodeForMemset(SelectionDAG & DAG,const SDLoc & dl,SDValue Chain,SDValue Op1,SDValue Op2,SDValue Op3,unsigned Align,bool isVolatile,MachinePointerInfo DstPtrInfo)78   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     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>
EmitTargetCodeForMemcmp(SelectionDAG & DAG,const SDLoc & dl,SDValue Chain,SDValue Op1,SDValue Op2,SDValue Op3,MachinePointerInfo Op1PtrInfo,MachinePointerInfo Op2PtrInfo)91   EmitTargetCodeForMemcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
92                           SDValue Op1, SDValue Op2, SDValue Op3,
93                           MachinePointerInfo Op1PtrInfo,
94                           MachinePointerInfo Op2PtrInfo) const {
95     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>
EmitTargetCodeForMemchr(SelectionDAG & DAG,const SDLoc & dl,SDValue Chain,SDValue Src,SDValue Char,SDValue Length,MachinePointerInfo SrcPtrInfo)103   EmitTargetCodeForMemchr(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
104                           SDValue Src, SDValue Char, SDValue Length,
105                           MachinePointerInfo SrcPtrInfo) const {
106     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>
EmitTargetCodeForStrcpy(SelectionDAG & DAG,const SDLoc & DL,SDValue Chain,SDValue Dest,SDValue Src,MachinePointerInfo DestPtrInfo,MachinePointerInfo SrcPtrInfo,bool isStpcpy)116   EmitTargetCodeForStrcpy(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
117                           SDValue Dest, SDValue Src,
118                           MachinePointerInfo DestPtrInfo,
119                           MachinePointerInfo SrcPtrInfo, bool isStpcpy) const {
120     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>
EmitTargetCodeForStrcmp(SelectionDAG & DAG,const SDLoc & dl,SDValue Chain,SDValue Op1,SDValue Op2,MachinePointerInfo Op1PtrInfo,MachinePointerInfo Op2PtrInfo)128   EmitTargetCodeForStrcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
129                           SDValue Op1, SDValue Op2,
130                           MachinePointerInfo Op1PtrInfo,
131                           MachinePointerInfo Op2PtrInfo) const {
132     return std::make_pair(SDValue(), SDValue());
133   }
134 
135   virtual std::pair<SDValue, SDValue>
EmitTargetCodeForStrlen(SelectionDAG & DAG,const SDLoc & DL,SDValue Chain,SDValue Src,MachinePointerInfo SrcPtrInfo)136   EmitTargetCodeForStrlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
137                           SDValue Src, MachinePointerInfo SrcPtrInfo) const {
138     return std::make_pair(SDValue(), SDValue());
139   }
140 
141   virtual std::pair<SDValue, SDValue>
EmitTargetCodeForStrnlen(SelectionDAG & DAG,const SDLoc & DL,SDValue Chain,SDValue Src,SDValue MaxLength,MachinePointerInfo SrcPtrInfo)142   EmitTargetCodeForStrnlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
143                            SDValue Src, SDValue MaxLength,
144                            MachinePointerInfo SrcPtrInfo) const {
145     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.
generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel)149   virtual bool generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel) const {
150     return false;
151   }
152 };
153 
154 } // end llvm namespace
155 
156 #endif
157