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
24namespace llvm {
25
26class SelectionDAG;
27
28//===----------------------------------------------------------------------===//
29/// Targets can subclass this to parameterize the
30/// SelectionDAG lowering and instruction selection process.
31///
32class SelectionDAGTargetInfo {
33public:
34  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  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    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  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    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  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    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  EmitTargetCodeForMemcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
95                          SDValue Op1, SDValue Op2, SDValue Op3,
96                          MachinePointerInfo Op1PtrInfo,
97                          MachinePointerInfo Op2PtrInfo) const {
98    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  EmitTargetCodeForMemchr(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
107                          SDValue Src, SDValue Char, SDValue Length,
108                          MachinePointerInfo SrcPtrInfo) const {
109    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  EmitTargetCodeForStrcpy(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
120                          SDValue Dest, SDValue Src,
121                          MachinePointerInfo DestPtrInfo,
122                          MachinePointerInfo SrcPtrInfo, bool isStpcpy) const {
123    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  EmitTargetCodeForStrcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
132                          SDValue Op1, SDValue Op2,
133                          MachinePointerInfo Op1PtrInfo,
134                          MachinePointerInfo Op2PtrInfo) const {
135    return std::make_pair(SDValue(), SDValue());
136  }
137
138  virtual std::pair<SDValue, SDValue>
139  EmitTargetCodeForStrlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
140                          SDValue Src, MachinePointerInfo SrcPtrInfo) const {
141    return std::make_pair(SDValue(), SDValue());
142  }
143
144  virtual std::pair<SDValue, SDValue>
145  EmitTargetCodeForStrnlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
146                           SDValue Src, SDValue MaxLength,
147                           MachinePointerInfo SrcPtrInfo) const {
148    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  virtual bool generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel) const {
154    return false;
155  }
156};
157
158} // end namespace llvm
159
160#endif // LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H
161