LLVM  4.0.0
SelectionDAGTargetInfo.h
Go to the documentation of this file.
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 
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 ///
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.
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.
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.
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>
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>
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>
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>
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>
137  SDValue Src, MachinePointerInfo SrcPtrInfo) const {
138  return std::make_pair(SDValue(), SDValue());
139  }
140 
141  virtual std::pair<SDValue, SDValue>
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.
149  virtual bool generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel) const {
150  return false;
151  }
152 };
153 
154 } // end llvm namespace
155 
156 #endif
virtual SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Op1, SDValue Op2, SDValue Op3, unsigned Align, bool isVolatile, bool AlwaysInline, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const
Emit target-specific code that performs a memcpy.
virtual std::pair< SDValue, SDValue > EmitTargetCodeForStrcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Op1, SDValue Op2, MachinePointerInfo Op1PtrInfo, MachinePointerInfo Op2PtrInfo) const
Emit target-specific code that performs a strcmp, in cases where that is faster than a libcall...
virtual SDValue EmitTargetCodeForMemmove(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Op1, SDValue Op2, SDValue Op3, unsigned Align, bool isVolatile, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const
Emit target-specific code that performs a memmove.
virtual std::pair< SDValue, SDValue > EmitTargetCodeForMemcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Op1, SDValue Op2, SDValue Op3, MachinePointerInfo Op1PtrInfo, MachinePointerInfo Op2PtrInfo) const
Emit target-specific code that performs a memcmp, in cases where that is faster than a libcall...
virtual std::pair< SDValue, SDValue > EmitTargetCodeForStrlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, MachinePointerInfo SrcPtrInfo) const
virtual std::pair< SDValue, SDValue > EmitTargetCodeForStrnlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Src, SDValue MaxLength, MachinePointerInfo SrcPtrInfo) const
virtual bool generateFMAsInMachineCombiner(CodeGenOpt::Level OptLevel) const
Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process...
virtual std::pair< SDValue, SDValue > EmitTargetCodeForStrcpy(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain, SDValue Dest, SDValue Src, MachinePointerInfo DestPtrInfo, MachinePointerInfo SrcPtrInfo, bool isStpcpy) const
Emit target-specific code that performs a strcpy or stpcpy, in cases where that is faster than a libc...
This class contains a discriminated union of information about pointers in memory operands...
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Definition: SelectionDAG.h:166
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
virtual SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Op1, SDValue Op2, SDValue Op3, unsigned Align, bool isVolatile, MachinePointerInfo DstPtrInfo) const
Emit target-specific code that performs a memset.
static bool isVolatile(Instruction *Inst)
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
virtual std::pair< SDValue, SDValue > EmitTargetCodeForMemchr(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Src, SDValue Char, SDValue Length, MachinePointerInfo SrcPtrInfo) const
Emit target-specific code that performs a memchr, in cases where that is faster than a libcall...