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