SparcSubtarget.cpp

Go to the documentation of this file.

1//===-- SparcSubtarget.cpp - SPARC Subtarget Information ------------------===//

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 implements the SPARC specific subclass of TargetSubtargetInfo.

10//

11//===----------------------------------------------------------------------===//

12

13#include "SparcSubtarget.h"

14#include "SparcSelectionDAGInfo.h"

15#include "llvm/ADT/StringRef.h"

16#include "llvm/MC/TargetRegistry.h"

17#include "llvm/Support/MathExtras.h"

18

19using namespace llvm;

20

21 #define DEBUG_TYPE "sparc-subtarget"

22

23 #define GET_SUBTARGETINFO_TARGET_DESC

24 #define GET_SUBTARGETINFO_CTOR

25#include "SparcGenSubtargetInfo.inc"

26

27void SparcSubtarget::anchor() { }

28

29 SparcSubtarget &SparcSubtarget::initializeSubtargetDependencies(

30 StringRef CPU, StringRef TuneCPU, StringRef FS) {

31 const Triple &TT = getTargetTriple();

32 // Determine default and user specified characteristics

33 std::string CPUName = std::string(CPU);

34 if (CPUName.empty())

35 CPUName = TT.isSPARC64() ? "v9" : "v8";

36

37 if (TuneCPU.empty())

38 TuneCPU = CPUName;

39

40 // Parse features string.

41 ParseSubtargetFeatures(CPUName, TuneCPU, FS);

42

43 if (!Is64Bit && TT.isSPARC64()) {

44 FeatureBitset Features = getFeatureBits();

45 setFeatureBits(Features.set(Sparc::Feature64Bit));

46 Is64Bit = true;

47 }

48

49 // Popc is a v9-only instruction.

50 if (!IsV9)

51 UsePopc = false;

52

53 return *this;

54}

55

56 SparcSubtarget::SparcSubtarget(const StringRef &CPU, const StringRef &TuneCPU,

57 const StringRef &FS, const TargetMachine &TM)

58 : SparcGenSubtargetInfo(TM.getTargetTriple(), CPU, TuneCPU, FS),

59 ReserveRegister(TM.getMCRegisterInfo()->getNumRegs()),

60 InstrInfo(initializeSubtargetDependencies(CPU, TuneCPU, FS)),

61 TLInfo(TM, *this), FrameLowering(*this) {

62 TSInfo = std::make_unique<SparcSelectionDAGInfo>();

63}

64

65SparcSubtarget::~SparcSubtarget() = default;

66

67 const SelectionDAGTargetInfo *SparcSubtarget::getSelectionDAGInfo() const {

68 return TSInfo.get();

69}

70

71 int SparcSubtarget::getAdjustedFrameSize(int frameSize) const {

72

73 if (is64Bit()) {

74 // All 64-bit stack frames must be 16-byte aligned, and must reserve space

75 // for spilling the 16 window registers at %sp+BIAS..%sp+BIAS+128.

76 frameSize += 128;

77 // Frames with calls must also reserve space for 6 outgoing arguments

78 // whether they are used or not. LowerCall_64 takes care of that.

79 frameSize = alignTo(frameSize, 16);

80 } else {

81 // Emit the correct save instruction based on the number of bytes in

82 // the frame. Minimum stack frame size according to V8 ABI is:

83 // 16 words for register window spill

84 // 1 word for address of returned aggregate-value

85 // + 6 words for passing parameters on the stack

86 // ----------

87 // 23 words * 4 bytes per word = 92 bytes

88 frameSize += 92;

89

90 // Round up to next doubleword boundary -- a double-word boundary

91 // is required by the ABI.

92 frameSize = alignTo(frameSize, 8);

93 }

94 return frameSize;

95}

96

97 bool SparcSubtarget::enableMachineScheduler() const {

98 return true;

99}

MathExtras.h

SparcSelectionDAGInfo.h

static bool is64Bit(const char *name)

Definition X86Disassembler.cpp:1082

SparcGenSubtargetInfo

llvm::FeatureBitset

Container class for subtarget features.

Definition SubtargetFeature.h:42

llvm::FeatureBitset::set

FeatureBitset & set()

Definition SubtargetFeature.h:58

llvm::SelectionDAGTargetInfo

Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process...

Definition SelectionDAGTargetInfo.h:33

llvm::SparcSubtarget::~SparcSubtarget

~SparcSubtarget() override

llvm::SparcSubtarget::getAdjustedFrameSize

int getAdjustedFrameSize(int stackSize) const

Given a actual stack size as determined by FrameInfo, this function returns adjusted framesize which ...

Definition SparcSubtarget.cpp:71

llvm::SparcSubtarget::enableMachineScheduler

bool enableMachineScheduler() const override

Definition SparcSubtarget.cpp:97

llvm::SparcSubtarget::SparcSubtarget

SparcSubtarget(const StringRef &CPU, const StringRef &TuneCPU, const StringRef &FS, const TargetMachine &TM)

Definition SparcSubtarget.cpp:56

llvm::SparcSubtarget::ParseSubtargetFeatures

void ParseSubtargetFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS)

ParseSubtargetFeatures - Parses features string setting specified subtarget options.

llvm::SparcSubtarget::initializeSubtargetDependencies

SparcSubtarget & initializeSubtargetDependencies(StringRef CPU, StringRef TuneCPU, StringRef FS)

Definition SparcSubtarget.cpp:29

llvm::SparcSubtarget::getSelectionDAGInfo

const SelectionDAGTargetInfo * getSelectionDAGInfo() const override

Definition SparcSubtarget.cpp:67

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition StringRef.h:55

llvm::StringRef::empty

constexpr bool empty() const

empty - Check if the string is empty.

Definition StringRef.h:143

llvm::TargetMachine

Primary interface to the complete machine description for the target machine.

Definition TargetMachine.h:83

llvm::Triple

Triple - Helper class for working with autoconf configuration names.

Definition Triple.h:47

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition AddressRanges.h:18

llvm::alignTo

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

Definition Alignment.h:144

Generated on for LLVM by doxygen 1.14.0

LLVM: lib/Target/Sparc/SparcSubtarget.cpp Source File