| 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 | |
| 18 | namespace llvm { |
| 19 | |
| 20 | namespace yaml { |
| 21 | struct HexagonFunctionInfo; |
| 22 | } // end namespace yaml |
| 23 | |
| 24 | namespace 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. |
| 32 | class 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 | |
| 53 | public: |
| 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 | |
| 129 | namespace yaml { |
| 130 | |
| 131 | /// Hexagon-specific MachineFunction properties for YAML serialization. |
| 132 | struct 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 | |
| 144 | template <> 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 | |