X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTarget%2FTargetSelectionDAGInfo.h;h=a7143ac3fa6689455c2a43042127515ac1d85704;hb=HEAD;hp=3474ee493eaed8c1b62b429c02cc4b2d662ad7fb;hpb=8c20158fb0e1e5d747077f065eb0170c5af1fbfa;p=oota-llvm.git diff --git a/include/llvm/Target/TargetSelectionDAGInfo.h b/include/llvm/Target/TargetSelectionDAGInfo.h index 3474ee493ea..a7143ac3fa6 100644 --- a/include/llvm/Target/TargetSelectionDAGInfo.h +++ b/include/llvm/Target/TargetSelectionDAGInfo.h @@ -20,33 +20,25 @@ namespace llvm { -class DataLayout; -class TargetMachine; - //===----------------------------------------------------------------------===// -/// TargetSelectionDAGInfo - Targets can subclass this to parameterize the +/// Targets can subclass this to parameterize the /// SelectionDAG lowering and instruction selection process. /// class TargetSelectionDAGInfo { - TargetSelectionDAGInfo(const TargetSelectionDAGInfo &) LLVM_DELETED_FUNCTION; - void operator=(const TargetSelectionDAGInfo &) LLVM_DELETED_FUNCTION; - - const DataLayout *TD; - -protected: - const DataLayout *getDataLayout() const { return TD; } + TargetSelectionDAGInfo(const TargetSelectionDAGInfo &) = delete; + void operator=(const TargetSelectionDAGInfo &) = delete; public: - explicit TargetSelectionDAGInfo(const TargetMachine &TM); + explicit TargetSelectionDAGInfo() = default; virtual ~TargetSelectionDAGInfo(); - /// EmitTargetCodeForMemcpy - Emit target-specific code that performs a - /// memcpy. This can be used by targets to provide code sequences for cases + /// Emit target-specific code that performs a memcpy. + /// This can be used by targets to provide code sequences for cases /// that don't fit the target's parameters for simple loads/stores and can be /// more efficient than using a library call. This function can return a null /// SDValue if the target declines to use custom code and a different /// lowering strategy should be used. - /// + /// /// If AlwaysInline is true, the size is constant and the target should not /// emit any calls and is strongly encouraged to attempt to emit inline code /// even if it is beyond the usual threshold because this intrinsic is being @@ -64,8 +56,8 @@ public: return SDValue(); } - /// EmitTargetCodeForMemmove - Emit target-specific code that performs a - /// memmove. This can be used by targets to provide code sequences for cases + /// Emit target-specific code that performs a memmove. + /// This can be used by targets to provide code sequences for cases /// that don't fit the target's parameters for simple loads/stores and can be /// more efficient than using a library call. This function can return a null /// SDValue if the target declines to use custom code and a different @@ -80,8 +72,8 @@ public: return SDValue(); } - /// EmitTargetCodeForMemset - Emit target-specific code that performs a - /// memset. This can be used by targets to provide code sequences for cases + /// Emit target-specific code that performs a memset. + /// This can be used by targets to provide code sequences for cases /// that don't fit the target's parameters for simple stores and can be more /// efficient than using a library call. This function can return a null /// SDValue if the target declines to use custom code and a different @@ -95,11 +87,10 @@ public: return SDValue(); } - /// EmitTargetCodeForMemcmp - Emit target-specific code that performs a - /// memcmp, in cases where that is faster than a libcall. The first - /// returned SDValue is the result of the memcmp and the second is - /// the chain. Both SDValues can be null if a normal libcall should - /// be used. + /// Emit target-specific code that performs a memcmp, in cases where that is + /// faster than a libcall. The first returned SDValue is the result of the + /// memcmp and the second is the chain. Both SDValues can be null if a normal + /// libcall should be used. virtual std::pair EmitTargetCodeForMemcmp(SelectionDAG &DAG, SDLoc dl, SDValue Chain, @@ -109,11 +100,10 @@ public: return std::make_pair(SDValue(), SDValue()); } - /// EmitTargetCodeForMemchr - Emit target-specific code that performs a - /// memchr, in cases where that is faster than a libcall. The first - /// returned SDValue is the result of the memchr and the second is - /// the chain. Both SDValues can be null if a normal libcall should - /// be used. + /// Emit target-specific code that performs a memchr, in cases where that is + /// faster than a libcall. The first returned SDValue is the result of the + /// memchr and the second is the chain. Both SDValues can be null if a normal + /// libcall should be used. virtual std::pair EmitTargetCodeForMemchr(SelectionDAG &DAG, SDLoc dl, SDValue Chain, SDValue Src, SDValue Char, SDValue Length, @@ -121,8 +111,8 @@ public: return std::make_pair(SDValue(), SDValue()); } - /// EmitTargetCodeForStrcpy - Emit target-specific code that performs a - /// strcpy or stpcpy, in cases where that is faster than a libcall. + /// Emit target-specific code that performs a strcpy or stpcpy, in cases + /// where that is faster than a libcall. /// The first returned SDValue is the result of the copy (the start /// of the destination string for strcpy, a pointer to the null terminator /// for stpcpy) and the second is the chain. Both SDValues can be null @@ -136,11 +126,10 @@ public: return std::make_pair(SDValue(), SDValue()); } - /// EmitTargetCodeForStrcmp - Emit target-specific code that performs a - /// strcmp, in cases where that is faster than a libcall. The first - /// returned SDValue is the result of the strcmp and the second is - /// the chain. Both SDValues can be null if a normal libcall should - /// be used. + /// Emit target-specific code that performs a strcmp, in cases where that is + /// faster than a libcall. + /// The first returned SDValue is the result of the strcmp and the second is + /// the chain. Both SDValues can be null if a normal libcall should be used. virtual std::pair EmitTargetCodeForStrcmp(SelectionDAG &DAG, SDLoc dl, SDValue Chain,