llvm.org GIT mirror llvm / dc4dcca
Remove getDataLayout() from TargetSelectionDAGInfo (had no users) Summary: Remove empty subclass in the process. This change is part of a series of commits dedicated to have a single DataLayout during compilation by using always the one owned by the module. Reviewers: echristo Subscribers: jholewinski, llvm-commits, rafael, yaron.keren, ted Differential Revision: http://reviews.llvm.org/D11045 From: Mehdi Amini <mehdi.amini@apple.com> git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@241780 91177308-0d34-0410-b5e6-96231b3b80d8 Mehdi Amini 5 years ago
42 changed file(s) with 28 addition(s) and 306 deletion(s). Raw diff Collapse all Expand all
1919
2020 namespace llvm {
2121
22 class DataLayout;
23
2422 //===----------------------------------------------------------------------===//
2523 /// TargetSelectionDAGInfo - Targets can subclass this to parameterize the
2624 /// SelectionDAG lowering and instruction selection process.
2927 TargetSelectionDAGInfo(const TargetSelectionDAGInfo &) = delete;
3028 void operator=(const TargetSelectionDAGInfo &) = delete;
3129
32 const DataLayout *DL;
33
34 protected:
35 const DataLayout *getDataLayout() const { return DL; }
36
3730 public:
38 explicit TargetSelectionDAGInfo(const DataLayout *DL);
31 explicit TargetSelectionDAGInfo() = default;
3932 virtual ~TargetSelectionDAGInfo();
4033
4134 /// EmitTargetCodeForMemcpy - Emit target-specific code that performs a
1414 #include "llvm/Target/TargetMachine.h"
1515 using namespace llvm;
1616
17 TargetSelectionDAGInfo::TargetSelectionDAGInfo(const DataLayout *DL)
18 : DL(DL) {
19 }
20
2117 TargetSelectionDAGInfo::~TargetSelectionDAGInfo() {
2218 }
1414 using namespace llvm;
1515
1616 #define DEBUG_TYPE "aarch64-selectiondag-info"
17
18 AArch64SelectionDAGInfo::AArch64SelectionDAGInfo(const DataLayout *DL)
19 : TargetSelectionDAGInfo(DL) {}
20
21 AArch64SelectionDAGInfo::~AArch64SelectionDAGInfo() {}
2217
2318 SDValue AArch64SelectionDAGInfo::EmitTargetCodeForMemset(
2419 SelectionDAG &DAG, SDLoc dl, SDValue Chain, SDValue Dst, SDValue Src,
1919
2020 class AArch64SelectionDAGInfo : public TargetSelectionDAGInfo {
2121 public:
22 explicit AArch64SelectionDAGInfo(const DataLayout *DL);
23 ~AArch64SelectionDAGInfo();
2422
2523 SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl, SDValue Chain,
2624 SDValue Dst, SDValue Src, SDValue Size,
4848 HasV8_1aOps(false), HasFPARMv8(false), HasNEON(false), HasCrypto(false),
4949 HasCRC(false), HasZeroCycleRegMove(false), HasZeroCycleZeroing(false),
5050 IsLittle(LittleEndian), CPUString(CPU), TargetTriple(TT), FrameLowering(),
51 InstrInfo(initializeSubtargetDependencies(FS)),
52 TSInfo(TM.getDataLayout()), TLInfo(TM, *this) {}
51 InstrInfo(initializeSubtargetDependencies(FS)), TSInfo(),
52 TLInfo(TM, *this) {}
5353
5454 /// ClassifyGlobalReference - Find the target operand flags that describe
5555 /// how a global value should be referenced for the current subtarget.
1616 using namespace llvm;
1717
1818 #define DEBUG_TYPE "arm-selectiondag-info"
19
20 ARMSelectionDAGInfo::ARMSelectionDAGInfo(const DataLayout &DL)
21 : TargetSelectionDAGInfo(&DL) {}
22
23 ARMSelectionDAGInfo::~ARMSelectionDAGInfo() {
24 }
2519
2620 // Emit, if possible, a specialized version of the given Libcall. Typically this
2721 // means selecting the appropriately aligned version, but we also convert memset
3636
3737 class ARMSelectionDAGInfo : public TargetSelectionDAGInfo {
3838 public:
39 explicit ARMSelectionDAGInfo(const DataLayout &DL);
40 ~ARMSelectionDAGInfo();
4139
4240 SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
4341 SDValue Chain,
111111 : ARMGenSubtargetInfo(TT, CPU, FS), ARMProcFamily(Others),
112112 ARMProcClass(None), stackAlignment(4), CPUString(CPU), IsLittle(IsLittle),
113113 TargetTriple(TT), Options(TM.Options), TM(TM),
114 TSInfo(*TM.getDataLayout()),
115114 FrameLowering(initializeFrameLowering(CPU, FS)),
116115 // At this point initializeSubtargetDependencies has been called so
117116 // we can query directly.
2727 BPFSubtarget::BPFSubtarget(const Triple &TT, const std::string &CPU,
2828 const std::string &FS, const TargetMachine &TM)
2929 : BPFGenSubtargetInfo(TT, CPU, FS), InstrInfo(), FrameLowering(*this),
30 TLInfo(TM, *this), TSInfo(TM.getDataLayout()) {}
30 TLInfo(TM, *this) {}
1717
1818 bool llvm::flag_aligned_memcpy;
1919
20 HexagonSelectionDAGInfo::HexagonSelectionDAGInfo(const DataLayout &DL)
21 : TargetSelectionDAGInfo(&DL) {}
22
23 HexagonSelectionDAGInfo::~HexagonSelectionDAGInfo() {
24 }
25
2620 SDValue
2721 HexagonSelectionDAGInfo::
2822 EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl, SDValue Chain,
1919
2020 class HexagonSelectionDAGInfo : public TargetSelectionDAGInfo {
2121 public:
22 explicit HexagonSelectionDAGInfo(const DataLayout &DL);
23 ~HexagonSelectionDAGInfo();
2422
2523 SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
2624 SDValue Chain,
7373 StringRef FS, const TargetMachine &TM)
7474 : HexagonGenSubtargetInfo(TT, CPU, FS), CPUString(CPU),
7575 InstrInfo(initializeSubtargetDependencies(CPU, FS)), TLInfo(TM, *this),
76 TSInfo(*TM.getDataLayout()), FrameLowering() {
76 FrameLowering() {
7777
7878 // Initialize scheduling itinerary for the specified CPU.
7979 InstrItins = getInstrItineraryForCPU(CPUString);
1717 MSP430RegisterInfo.cpp
1818 MSP430Subtarget.cpp
1919 MSP430TargetMachine.cpp
20 MSP430SelectionDAGInfo.cpp
2120 MSP430AsmPrinter.cpp
2221 MSP430MCInstLower.cpp
2322 )
+0
-23
lib/Target/MSP430/MSP430SelectionDAGInfo.cpp less more
None //===-- MSP430SelectionDAGInfo.cpp - MSP430 SelectionDAG Info -------------===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the MSP430SelectionDAGInfo class.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "MSP430TargetMachine.h"
14 using namespace llvm;
15
16 #define DEBUG_TYPE "msp430-selectiondag-info"
17
18 MSP430SelectionDAGInfo::MSP430SelectionDAGInfo(const DataLayout &DL)
19 : TargetSelectionDAGInfo(&DL) {}
20
21 MSP430SelectionDAGInfo::~MSP430SelectionDAGInfo() {
22 }
+0
-31
lib/Target/MSP430/MSP430SelectionDAGInfo.h less more
None //===-- MSP430SelectionDAGInfo.h - MSP430 SelectionDAG Info -----*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the MSP430 subclass for TargetSelectionDAGInfo.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef LLVM_LIB_TARGET_MSP430_MSP430SELECTIONDAGINFO_H
14 #define LLVM_LIB_TARGET_MSP430_MSP430SELECTIONDAGINFO_H
15
16 #include "llvm/Target/TargetSelectionDAGInfo.h"
17
18 namespace llvm {
19
20 class MSP430TargetMachine;
21
22 class MSP430SelectionDAGInfo : public TargetSelectionDAGInfo {
23 public:
24 explicit MSP430SelectionDAGInfo(const DataLayout &DL);
25 ~MSP430SelectionDAGInfo();
26 };
27
28 }
29
30 #endif
3333 MSP430Subtarget::MSP430Subtarget(const Triple &TT, const std::string &CPU,
3434 const std::string &FS, const TargetMachine &TM)
3535 : MSP430GenSubtargetInfo(TT, CPU, FS), FrameLowering(),
36 InstrInfo(initializeSubtargetDependencies(CPU, FS)), TLInfo(TM, *this),
37 TSInfo(*TM.getDataLayout()) {}
36 InstrInfo(initializeSubtargetDependencies(CPU, FS)), TLInfo(TM, *this) {}
1717 #include "MSP430ISelLowering.h"
1818 #include "MSP430InstrInfo.h"
1919 #include "MSP430RegisterInfo.h"
20 #include "MSP430SelectionDAGInfo.h"
2120 #include "llvm/IR/DataLayout.h"
21 #include "llvm/Target/TargetSelectionDAGInfo.h"
2222 #include "llvm/Target/TargetSubtargetInfo.h"
2323 #include
2424
3434 MSP430FrameLowering FrameLowering;
3535 MSP430InstrInfo InstrInfo;
3636 MSP430TargetLowering TLInfo;
37 MSP430SelectionDAGInfo TSInfo;
37 TargetSelectionDAGInfo TSInfo;
3838
3939 public:
4040 /// This constructor initializes the data members to match that
5959 const MSP430TargetLowering *getTargetLowering() const override {
6060 return &TLInfo;
6161 }
62 const MSP430SelectionDAGInfo *getSelectionDAGInfo() const override {
62 const TargetSelectionDAGInfo *getSelectionDAGInfo() const override {
6363 return &TSInfo;
6464 }
6565 };
4545 MipsSubtarget.cpp
4646 MipsTargetMachine.cpp
4747 MipsTargetObjectFile.cpp
48 MipsSelectionDAGInfo.cpp
4948 )
5049
5150 add_subdirectory(InstPrinter)
+0
-23
lib/Target/Mips/MipsSelectionDAGInfo.cpp less more
None //===-- MipsSelectionDAGInfo.cpp - Mips SelectionDAG Info -----------------===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the MipsSelectionDAGInfo class.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "MipsTargetMachine.h"
14 using namespace llvm;
15
16 #define DEBUG_TYPE "mips-selectiondag-info"
17
18 MipsSelectionDAGInfo::MipsSelectionDAGInfo(const DataLayout &DL)
19 : TargetSelectionDAGInfo(&DL) {}
20
21 MipsSelectionDAGInfo::~MipsSelectionDAGInfo() {
22 }
+0
-31
lib/Target/Mips/MipsSelectionDAGInfo.h less more
None //===-- MipsSelectionDAGInfo.h - Mips SelectionDAG Info ---------*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the Mips subclass for TargetSelectionDAGInfo.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef LLVM_LIB_TARGET_MIPS_MIPSSELECTIONDAGINFO_H
14 #define LLVM_LIB_TARGET_MIPS_MIPSSELECTIONDAGINFO_H
15
16 #include "llvm/Target/TargetSelectionDAGInfo.h"
17
18 namespace llvm {
19
20 class MipsTargetMachine;
21
22 class MipsSelectionDAGInfo : public TargetSelectionDAGInfo {
23 public:
24 explicit MipsSelectionDAGInfo(const DataLayout &DL);
25 ~MipsSelectionDAGInfo();
26 };
27
28 }
29
30 #endif
6969 HasMips4_32r2(false), HasMips5_32r2(false), InMips16Mode(false),
7070 InMips16HardFloat(Mips16HardFloat), InMicroMipsMode(false), HasDSP(false),
7171 HasDSPR2(false), AllowMixed16_32(Mixed16_32 | Mips_Os16), Os16(Mips_Os16),
72 HasMSA(false), TM(TM), TargetTriple(TT), TSInfo(*TM.getDataLayout()),
72 HasMSA(false), TM(TM), TargetTriple(TT), TSInfo(),
7373 InstrInfo(
7474 MipsInstrInfo::create(initializeSubtargetDependencies(CPU, FS, TM))),
7575 FrameLowering(MipsFrameLowering::create(*this)),
1717 #include "MipsFrameLowering.h"
1818 #include "MipsISelLowering.h"
1919 #include "MipsInstrInfo.h"
20 #include "MipsSelectionDAGInfo.h"
2120 #include "llvm/IR/DataLayout.h"
2221 #include "llvm/MC/MCInstrItineraries.h"
2322 #include "llvm/Support/ErrorHandling.h"
23 #include "llvm/Target/TargetSelectionDAGInfo.h"
2424 #include "llvm/Target/TargetSubtargetInfo.h"
2525 #include
2626
139139
140140 Triple TargetTriple;
141141
142 const MipsSelectionDAGInfo TSInfo;
142 const TargetSelectionDAGInfo TSInfo;
143143 std::unique_ptr InstrInfo;
144144 std::unique_ptr FrameLowering;
145145 std::unique_ptr TLInfo;
274274 void setHelperClassesMips16();
275275 void setHelperClassesMipsSE();
276276
277 const MipsSelectionDAGInfo *getSelectionDAGInfo() const override {
277 const TargetSelectionDAGInfo *getSelectionDAGInfo() const override {
278278 return &TSInfo;
279279 }
280280 const MipsInstrInfo *getInstrInfo() const override { return InstrInfo.get(); }
4747 const NVPTXTargetMachine &TM)
4848 : NVPTXGenSubtargetInfo(TT, CPU, FS), PTXVersion(0), SmVersion(20), TM(TM),
4949 InstrInfo(), TLInfo(TM, initializeSubtargetDependencies(CPU, FS)),
50 TSInfo(TM.getDataLayout()), FrameLowering() {}
50 FrameLowering() {}
5151
5252 bool NVPTXSubtarget::hasImageHandles() const {
5353 // Enable handles for Kepler+, where CUDA supports indirect surfaces and
3232 PPCTargetObjectFile.cpp
3333 PPCTargetTransformInfo.cpp
3434 PPCTOCRegDeps.cpp
35 PPCSelectionDAGInfo.cpp
3635 PPCTLSDynamicCall.cpp
3736 PPCVSXCopy.cpp
3837 PPCVSXFMAMutate.cpp
+0
-22
lib/Target/PowerPC/PPCSelectionDAGInfo.cpp less more
None //===-- PPCSelectionDAGInfo.cpp - PowerPC SelectionDAG Info ---------------===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the PPCSelectionDAGInfo class.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "PPCTargetMachine.h"
14 using namespace llvm;
15
16 #define DEBUG_TYPE "powerpc-selectiondag-info"
17
18 PPCSelectionDAGInfo::PPCSelectionDAGInfo(const DataLayout *DL)
19 : TargetSelectionDAGInfo(DL) {}
20
21 PPCSelectionDAGInfo::~PPCSelectionDAGInfo() {}
+0
-31
lib/Target/PowerPC/PPCSelectionDAGInfo.h less more
None //===-- PPCSelectionDAGInfo.h - PowerPC SelectionDAG Info -------*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the PowerPC subclass for TargetSelectionDAGInfo.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef LLVM_LIB_TARGET_POWERPC_PPCSELECTIONDAGINFO_H
14 #define LLVM_LIB_TARGET_POWERPC_PPCSELECTIONDAGINFO_H
15
16 #include "llvm/Target/TargetSelectionDAGInfo.h"
17
18 namespace llvm {
19
20 class PPCTargetMachine;
21
22 class PPCSelectionDAGInfo : public TargetSelectionDAGInfo {
23 public:
24 explicit PPCSelectionDAGInfo(const DataLayout *DL);
25 ~PPCSelectionDAGInfo();
26 };
27
28 }
29
30 #endif
5252 IsPPC64(TargetTriple.getArch() == Triple::ppc64 ||
5353 TargetTriple.getArch() == Triple::ppc64le),
5454 TM(TM), FrameLowering(initializeSubtargetDependencies(CPU, FS)),
55 InstrInfo(*this), TLInfo(TM, *this), TSInfo(TM.getDataLayout()) {}
55 InstrInfo(*this), TLInfo(TM, *this) {}
5656
5757 void PPCSubtarget::initializeEnvironment() {
5858 StackAlignment = 16;
1616 #include "PPCFrameLowering.h"
1717 #include "PPCISelLowering.h"
1818 #include "PPCInstrInfo.h"
19 #include "PPCSelectionDAGInfo.h"
2019 #include "llvm/ADT/Triple.h"
2120 #include "llvm/IR/DataLayout.h"
2221 #include "llvm/MC/MCInstrItineraries.h"
22 #include "llvm/Target/TargetSelectionDAGInfo.h"
2323 #include "llvm/Target/TargetSubtargetInfo.h"
2424 #include
2525
128128 PPCFrameLowering FrameLowering;
129129 PPCInstrInfo InstrInfo;
130130 PPCTargetLowering TLInfo;
131 PPCSelectionDAGInfo TSInfo;
131 TargetSelectionDAGInfo TSInfo;
132132
133133 public:
134134 /// This constructor initializes the data members to match that
163163 const PPCTargetLowering *getTargetLowering() const override {
164164 return &TLInfo;
165165 }
166 const PPCSelectionDAGInfo *getSelectionDAGInfo() const override {
166 const TargetSelectionDAGInfo *getSelectionDAGInfo() const override {
167167 return &TSInfo;
168168 }
169169 const PPCRegisterInfo *getRegisterInfo() const override {
2121 SparcRegisterInfo.cpp
2222 SparcSubtarget.cpp
2323 SparcTargetMachine.cpp
24 SparcSelectionDAGInfo.cpp
2524 SparcMCInstLower.cpp
2625 SparcTargetObjectFile.cpp
2726 )
+0
-24
lib/Target/Sparc/SparcSelectionDAGInfo.cpp less more
None //===-- SparcSelectionDAGInfo.cpp - Sparc SelectionDAG Info ---------------===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the SparcSelectionDAGInfo class.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "SparcSelectionDAGInfo.h"
14 using namespace llvm;
15
16 #define DEBUG_TYPE "sparc-selectiondag-info"
17
18 SparcSelectionDAGInfo::SparcSelectionDAGInfo(const DataLayout &DL)
19 : TargetSelectionDAGInfo(&DL) {
20 }
21
22 SparcSelectionDAGInfo::~SparcSelectionDAGInfo() {
23 }
+0
-31
lib/Target/Sparc/SparcSelectionDAGInfo.h less more
None //===-- SparcSelectionDAGInfo.h - Sparc SelectionDAG Info -------*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the Sparc subclass for TargetSelectionDAGInfo.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef LLVM_LIB_TARGET_SPARC_SPARCSELECTIONDAGINFO_H
14 #define LLVM_LIB_TARGET_SPARC_SPARCSELECTIONDAGINFO_H
15
16 #include "llvm/Target/TargetSelectionDAGInfo.h"
17
18 namespace llvm {
19
20 class SparcTargetMachine;
21
22 class SparcSelectionDAGInfo : public TargetSelectionDAGInfo {
23 public:
24 explicit SparcSelectionDAGInfo(const DataLayout &DL);
25 ~SparcSelectionDAGInfo() override;
26 };
27
28 }
29
30 #endif
5353 bool is64Bit)
5454 : SparcGenSubtargetInfo(TT, CPU, FS), Is64Bit(is64Bit),
5555 InstrInfo(initializeSubtargetDependencies(CPU, FS)), TLInfo(TM, *this),
56 TSInfo(*TM.getDataLayout()), FrameLowering(*this) {}
56 FrameLowering(*this) {}
5757
5858 int SparcSubtarget::getAdjustedFrameSize(int frameSize) const {
5959
1616 #include "SparcFrameLowering.h"
1717 #include "SparcInstrInfo.h"
1818 #include "SparcISelLowering.h"
19 #include "SparcSelectionDAGInfo.h"
2019 #include "llvm/IR/DataLayout.h"
2120 #include "llvm/Target/TargetFrameLowering.h"
21 #include "llvm/Target/TargetSelectionDAGInfo.h"
2222 #include "llvm/Target/TargetSubtargetInfo.h"
2323 #include
2424
3838 bool UsePopc;
3939 SparcInstrInfo InstrInfo;
4040 SparcTargetLowering TLInfo;
41 SparcSelectionDAGInfo TSInfo;
41 TargetSelectionDAGInfo TSInfo;
4242 SparcFrameLowering FrameLowering;
4343
4444 public:
5555 const SparcTargetLowering *getTargetLowering() const override {
5656 return &TLInfo;
5757 }
58 const SparcSelectionDAGInfo *getSelectionDAGInfo() const override {
58 const TargetSelectionDAGInfo *getSelectionDAGInfo() const override {
5959 return &TSInfo;
6060 }
6161
1616 using namespace llvm;
1717
1818 #define DEBUG_TYPE "systemz-selectiondag-info"
19
20 SystemZSelectionDAGInfo::SystemZSelectionDAGInfo(const DataLayout &DL)
21 : TargetSelectionDAGInfo(&DL) {}
22
23 SystemZSelectionDAGInfo::~SystemZSelectionDAGInfo() {
24 }
2519
2620 // Decide whether it is best to use a loop or straight-line code for
2721 // a block operation of Size bytes with source address Src and destination
2121
2222 class SystemZSelectionDAGInfo : public TargetSelectionDAGInfo {
2323 public:
24 explicit SystemZSelectionDAGInfo(const DataLayout &DL);
25 ~SystemZSelectionDAGInfo();
24 explicit SystemZSelectionDAGInfo() = default;
2625
2726 SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc DL, SDValue Chain,
2827 SDValue Dst, SDValue Src,
4141 HasTransactionalExecution(false), HasProcessorAssist(false),
4242 HasVector(false), TargetTriple(TT),
4343 InstrInfo(initializeSubtargetDependencies(CPU, FS)), TLInfo(TM, *this),
44 TSInfo(*TM.getDataLayout()), FrameLowering() {}
44 TSInfo(), FrameLowering() {}
4545
4646 // Return true if GV binds locally under reloc model RM.
4747 static bool bindsLocally(const GlobalValue *GV, Reloc::Model RM) {
2222 using namespace llvm;
2323
2424 #define DEBUG_TYPE "x86-selectiondag-info"
25
26 X86SelectionDAGInfo::X86SelectionDAGInfo(const DataLayout &DL)
27 : TargetSelectionDAGInfo(&DL) {}
28
29 X86SelectionDAGInfo::~X86SelectionDAGInfo() {}
3025
3126 bool X86SelectionDAGInfo::isBaseRegConflictPossible(
3227 SelectionDAG &DAG, ArrayRef ClobberSet) const {
2828 ArrayRef ClobberSet) const;
2929
3030 public:
31 explicit X86SelectionDAGInfo(const DataLayout &DL);
32 ~X86SelectionDAGInfo();
31 explicit X86SelectionDAGInfo() = default;
3332
3433 SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl,
3534 SDValue Chain,
296296 TargetTriple.getEnvironment() != Triple::CODE16),
297297 In16BitMode(TargetTriple.getArch() == Triple::x86 &&
298298 TargetTriple.getEnvironment() == Triple::CODE16),
299 TSInfo(*TM.getDataLayout()),
300 InstrInfo(initializeSubtargetDependencies(CPU, FS)), TLInfo(TM, *this),
301 FrameLowering(*this, getStackAlignment()) {
299 TSInfo(), InstrInfo(initializeSubtargetDependencies(CPU, FS)),
300 TLInfo(TM, *this), FrameLowering(*this, getStackAlignment()) {
302301 // Determine the PICStyle based on the target selected.
303302 if (TM.getRelocationModel() == Reloc::Static) {
304303 // Unless we're in PIC or DynamicNoPIC mode, set the PIC style to None.
1414 using namespace llvm;
1515
1616 #define DEBUG_TYPE "xcore-selectiondag-info"
17
18 XCoreSelectionDAGInfo::XCoreSelectionDAGInfo(const DataLayout &DL)
19 : TargetSelectionDAGInfo(&DL) {}
20
21 XCoreSelectionDAGInfo::~XCoreSelectionDAGInfo() {
22 }
2317
2418 SDValue XCoreSelectionDAGInfo::
2519 EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl, SDValue Chain,
2121
2222 class XCoreSelectionDAGInfo : public TargetSelectionDAGInfo {
2323 public:
24 explicit XCoreSelectionDAGInfo(const DataLayout &DL);
25 ~XCoreSelectionDAGInfo();
2624
2725 SDValue
2826 EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
2727 XCoreSubtarget::XCoreSubtarget(const Triple &TT, const std::string &CPU,
2828 const std::string &FS, const TargetMachine &TM)
2929 : XCoreGenSubtargetInfo(TT, CPU, FS), InstrInfo(), FrameLowering(*this),
30 TLInfo(TM, *this), TSInfo(*TM.getDataLayout()) {}
30 TLInfo(TM, *this), TSInfo() {}