1//=- HexagonMachineFunctionInfo.h - Hexagon machine function 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#ifndef LLVM_LIB_TARGET_HEXAGON_HEXAGONMACHINEFUNCTIONINFO_H
10#define LLVM_LIB_TARGET_HEXAGON_HEXAGONMACHINEFUNCTIONINFO_H
11
12#include "llvm/ADT/DenseMap.h"
13#include "llvm/CodeGen/MIRYamlMapping.h"
14#include "llvm/CodeGen/MachineFrameInfo.h"
15#include "llvm/CodeGen/MachineFunction.h"
16#include <map>
17
18namespace llvm {
19
20namespace yaml {
21struct HexagonFunctionInfo;
22} // end namespace yaml
23
24namespace Hexagon {
25
26 const unsigned int StartPacket = 0x1;
27 const unsigned int EndPacket = 0x2;
28
29} // end namespace Hexagon
30
31/// Hexagon target-specific information for each MachineFunction.
32class HexagonMachineFunctionInfo : public MachineFunctionInfo {
33 // SRetReturnReg - Some subtargets require that sret lowering includes
34 // returning the value of the returned struct in a register. This field
35 // holds the virtual register into which the sret argument is passed.
36 unsigned SRetReturnReg = 0;
37 Register StackAlignBaseReg = 0; // Aligned-stack base register
38 int VarArgsFrameIndex;
39 int RegSavedAreaStartFrameIndex;
40 int FirstNamedArgFrameIndex;
41 int LastNamedArgFrameIndex;
42 bool HasClobberLR = false;
43 bool HasEHReturn = false;
44 MachineFrameInfo VTCMFrameInfo{Align(2048), false, false};
45 DenseMap<int, int> VTCMMap;
46 // Size of the largest outgoing HLX argument area on the VTCM stack.
47 unsigned MaxVTCMCallFrameSize = 0;
48 // Scalar stack slot holding the caller's VSP, or -1.
49 int VSPFrameIndex = -1;
50 std::map<const MachineInstr*, unsigned> PacketInfo;
51 virtual void anchor();
52
53public:
54 HexagonMachineFunctionInfo() = default;
55
56 HexagonMachineFunctionInfo(const Function &F,
57 const TargetSubtargetInfo *STI) {}
58
59 HexagonMachineFunctionInfo(const HexagonMachineFunctionInfo &Other);
60
61 MachineFunctionInfo *
62 clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF,
63 const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB)
64 const override;
65
66 void initializeBaseYamlFields(const yaml::HexagonFunctionInfo &YamlMFI);
67
68 unsigned getSRetReturnReg() const { return SRetReturnReg; }
69 void setSRetReturnReg(unsigned Reg) { SRetReturnReg = Reg; }
70
71 void setVarArgsFrameIndex(int v) { VarArgsFrameIndex = v; }
72 int getVarArgsFrameIndex() { return VarArgsFrameIndex; }
73
74 void setRegSavedAreaStartFrameIndex(int v) { RegSavedAreaStartFrameIndex = v;}
75 int getRegSavedAreaStartFrameIndex() { return RegSavedAreaStartFrameIndex; }
76
77 void setFirstNamedArgFrameIndex(int v) { FirstNamedArgFrameIndex = v; }
78 int getFirstNamedArgFrameIndex() { return FirstNamedArgFrameIndex; }
79
80 void setLastNamedArgFrameIndex(int v) { LastNamedArgFrameIndex = v; }
81 int getLastNamedArgFrameIndex() { return LastNamedArgFrameIndex; }
82
83 void setStartPacket(MachineInstr* MI) {
84 PacketInfo[MI] |= Hexagon::StartPacket;
85 }
86 void setEndPacket(MachineInstr* MI) {
87 PacketInfo[MI] |= Hexagon::EndPacket;
88 }
89 bool isStartPacket(const MachineInstr* MI) const {
90 auto It = PacketInfo.find(x: MI);
91 return It != PacketInfo.end() && (It->second & Hexagon::StartPacket);
92 }
93 bool isEndPacket(const MachineInstr* MI) const {
94 auto It = PacketInfo.find(x: MI);
95 return It != PacketInfo.end() && (It->second & Hexagon::EndPacket);
96 }
97 void setHasClobberLR(bool v) { HasClobberLR = v; }
98 bool hasClobberLR() const { return HasClobberLR; }
99
100 bool hasEHReturn() const { return HasEHReturn; };
101 void setHasEHReturn(bool H = true) { HasEHReturn = H; };
102
103 void setStackAlignBaseReg(Register R) { StackAlignBaseReg = R; }
104 Register getStackAlignBaseReg() const { return StackAlignBaseReg; }
105
106 void setVSPFrameIndex(int FI) { VSPFrameIndex = FI; }
107 int getVSPFrameIndex() const { return VSPFrameIndex; }
108
109 MachineFrameInfo &getVTCMFrameInfo() { return VTCMFrameInfo; }
110 const MachineFrameInfo &getVTCMFrameInfo() const { return VTCMFrameInfo; }
111
112 void moveToVTCMStack(int From, int To) { VTCMMap.insert(KV: {From, To}); }
113 bool isVTCMStackIndex(int ObjectIdx) const {
114 return VTCMMap.contains(Val: ObjectIdx);
115 }
116 int getMappedVTCMObjectIndex(int ObjectIdx) const {
117 return VTCMMap.lookup(Val: ObjectIdx);
118 }
119 int64_t getMappedVTCMObjectOffset(int ObjectIdx) const {
120 return VTCMFrameInfo.getObjectOffset(ObjectIdx: getMappedVTCMObjectIndex(ObjectIdx));
121 }
122
123 unsigned getMaxVTCMCallFrameSize() const { return MaxVTCMCallFrameSize; }
124 void reserveVTCMCallFrame(unsigned Size) {
125 MaxVTCMCallFrameSize = std::max(a: MaxVTCMCallFrameSize, b: Size);
126 }
127};
128
129namespace yaml {
130
131/// Hexagon-specific MachineFunction properties for YAML serialization.
132struct HexagonFunctionInfo final : public yaml::MachineFunctionInfo {
133 StringValue StackAlignBaseReg;
134 unsigned MaxVTCMCallFrameSize = 0;
135
136 HexagonFunctionInfo() = default;
137 HexagonFunctionInfo(const llvm::HexagonMachineFunctionInfo &MFI,
138 const TargetRegisterInfo &TRI);
139
140 void mappingImpl(yaml::IO &YamlIO) override;
141 ~HexagonFunctionInfo() override = default;
142};
143
144template <> struct MappingTraits<HexagonFunctionInfo> {
145 static void mapping(IO &YamlIO, HexagonFunctionInfo &MFI) {
146 YamlIO.mapOptional(Key: "stackAlignBaseReg", Val&: MFI.StackAlignBaseReg);
147 YamlIO.mapOptional(Key: "maxVTCMCallFrameSize", Val&: MFI.MaxVTCMCallFrameSize, Default: 0u);
148 }
149};
150
151} // end namespace yaml
152
153} // end namespace llvm
154
155#endif // LLVM_LIB_TARGET_HEXAGON_HEXAGONMACHINEFUNCTIONINFO_H
156