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 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 MachinePointerInfo SrcPtrInfo) const { 58 return SDValue(); 59 } 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 MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const { 71 return SDValue(); 72 } 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 MachinePointerInfo DstPtrInfo) const { 85 return SDValue(); 86 } 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 MachinePointerInfo Op2PtrInfo) const { 97 return std::make_pair(SDValue(), SDValue()); 98 } 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 MachinePointerInfo SrcPtrInfo) const { 108 return std::make_pair(SDValue(), SDValue()); 109 } 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 MachinePointerInfo SrcPtrInfo, bool isStpcpy) const { 122 return std::make_pair(SDValue(), SDValue()); 123 } 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 MachinePointerInfo Op2PtrInfo) const { 134 return std::make_pair(SDValue(), SDValue()); 135 } 136 137 virtual std::pair<SDValue, SDValue> 138 EmitTargetCodeForStrlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, 139 SDValue Src, MachinePointerInfo SrcPtrInfo) const { 140 return std::make_pair(SDValue(), SDValue()); 141 } 142 143 virtual std::pair<SDValue, SDValue> 144 EmitTargetCodeForStrnlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, 145 SDValue Src, SDValue MaxLength, 146 MachinePointerInfo SrcPtrInfo) const { 147 return std::make_pair(SDValue(), SDValue()); 148 } 149 150 virtual SDValue EmitTargetCodeForSetTag(SelectionDAG &DAG, const SDLoc &dl, 151 SDValue Chain, SDValue Addr, 152 SDValue Size, 153 MachinePointerInfo DstPtrInfo, 154 bool ZeroData) const { 155 return SDValue(); 156 } 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 virtual bool generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel) const { 161 return false; 162 } 163 }; 164 165 } // end namespace llvm 166 167 #endif // LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H 168