1//===-- RISCVInsertReadWriteCSR.cpp - Insert Read/Write of RISC-V CSR -----===//
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// This file implements the machine function pass to insert read/write of CSR-s
9// of the RISC-V instructions.
10//
11// Currently the pass implements:
12// -Writing and saving frm before an RVV floating-point instruction with a
13// static rounding mode and restores the value after.
14//
15//===----------------------------------------------------------------------===//
16
17#include "MCTargetDesc/RISCVBaseInfo.h"
18#include "RISCV.h"
19#include "RISCVSubtarget.h"
20#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
21#include "llvm/CodeGen/MachineFunctionPass.h"
22#include "llvm/CodeGen/MachinePassManager.h"
23#include "llvm/IR/Analysis.h"
24using namespace llvm;
25
26#define DEBUG_TYPE "riscv-insert-read-write-csr"
27#define RISCV_INSERT_READ_WRITE_CSR_NAME "RISC-V Insert Read/Write CSR Pass"
28
29namespace {
30
31class RISCVInsertReadWriteCSRLegacy : public MachineFunctionPass {
32public:
33 static char ID;
34
35 RISCVInsertReadWriteCSRLegacy() : MachineFunctionPass(ID) {}
36
37 bool runOnMachineFunction(MachineFunction &MF) override;
38
39 void getAnalysisUsage(AnalysisUsage &AU) const override {
40 AU.setPreservesCFG();
41 MachineFunctionPass::getAnalysisUsage(AU);
42 }
43
44 StringRef getPassName() const override {
45 return RISCV_INSERT_READ_WRITE_CSR_NAME;
46 }
47};
48
49} // end anonymous namespace
50
51char RISCVInsertReadWriteCSRLegacy::ID = 0;
52
53INITIALIZE_PASS(RISCVInsertReadWriteCSRLegacy, DEBUG_TYPE,
54 RISCV_INSERT_READ_WRITE_CSR_NAME, false, false)
55
56// TODO: Use more accurate rounding mode at the start of MBB.
57static bool emitWriteRoundingModeOpt(MachineBasicBlock &MBB,
58 const TargetInstrInfo *TII) {
59 bool Changed = false;
60 MachineInstr *LastFRMChanger = nullptr;
61 unsigned CurrentRM = RISCVFPRndMode::DYN;
62 Register SavedFRM;
63
64 for (MachineInstr &MI : MBB) {
65 if (MI.getOpcode() == RISCV::SwapFRMImm ||
66 MI.getOpcode() == RISCV::WriteFRMImm) {
67 CurrentRM = MI.getOperand(i: 0).getImm();
68 SavedFRM = Register();
69 continue;
70 }
71
72 if (MI.getOpcode() == RISCV::WriteFRM) {
73 CurrentRM = RISCVFPRndMode::DYN;
74 SavedFRM = Register();
75 continue;
76 }
77
78 if (MI.isCall() || MI.isInlineAsm() ||
79 MI.readsRegister(Reg: RISCV::FRM, /*TRI=*/nullptr)) {
80 // Restore FRM before unknown operations.
81 if (SavedFRM.isValid())
82 BuildMI(BB&: MBB, I&: MI, MIMD: MI.getDebugLoc(), MCID: TII->get(Opcode: RISCV::WriteFRM))
83 .addReg(RegNo: SavedFRM);
84 CurrentRM = RISCVFPRndMode::DYN;
85 SavedFRM = Register();
86 continue;
87 }
88
89 assert(!MI.modifiesRegister(RISCV::FRM, /*TRI=*/nullptr) &&
90 "Expected that MI could not modify FRM.");
91
92 int FRMIdx = RISCVII::getFRMOpNum(Desc: MI.getDesc());
93 if (FRMIdx < 0)
94 continue;
95 unsigned InstrRM = MI.getOperand(i: FRMIdx).getImm();
96
97 LastFRMChanger = &MI;
98
99 // Make MI implicit use FRM.
100 MI.addOperand(Op: MachineOperand::CreateReg(Reg: RISCV::FRM, /*IsDef*/ isDef: false,
101 /*IsImp*/ isImp: true));
102 Changed = true;
103
104 // Skip if MI uses same rounding mode as FRM.
105 if (InstrRM == CurrentRM)
106 continue;
107
108 if (!SavedFRM.isValid()) {
109 // Save current FRM value to SavedFRM.
110 MachineRegisterInfo *MRI = &MBB.getParent()->getRegInfo();
111 SavedFRM = MRI->createVirtualRegister(RegClass: &RISCV::GPRRegClass);
112 BuildMI(BB&: MBB, I&: MI, MIMD: MI.getDebugLoc(), MCID: TII->get(Opcode: RISCV::SwapFRMImm), DestReg: SavedFRM)
113 .addImm(Val: InstrRM);
114 } else {
115 // Don't need to save current FRM when SavedFRM having value.
116 BuildMI(BB&: MBB, I&: MI, MIMD: MI.getDebugLoc(), MCID: TII->get(Opcode: RISCV::WriteFRMImm))
117 .addImm(Val: InstrRM);
118 }
119 CurrentRM = InstrRM;
120 }
121
122 // Restore FRM if needed.
123 if (SavedFRM.isValid()) {
124 assert(LastFRMChanger && "Expected valid pointer.");
125 MachineInstrBuilder MIB =
126 BuildMI(MF&: *MBB.getParent(), MIMD: {}, MCID: TII->get(Opcode: RISCV::WriteFRM))
127 .addReg(RegNo: SavedFRM);
128 MBB.insertAfter(I: LastFRMChanger, MI: MIB);
129 }
130
131 return Changed;
132}
133
134// This function also swaps frm and restores it when encountering an RVV
135// floating point instruction with a static rounding mode.
136static bool emitWriteRoundingMode(MachineBasicBlock &MBB,
137 const TargetInstrInfo *TII) {
138 bool Changed = false;
139 for (MachineInstr &MI : MBB) {
140 int FRMIdx = RISCVII::getFRMOpNum(Desc: MI.getDesc());
141 if (FRMIdx < 0)
142 continue;
143
144 unsigned FRMImm = MI.getOperand(i: FRMIdx).getImm();
145
146 // The value is a hint to this pass to not alter the frm value.
147 if (FRMImm == RISCVFPRndMode::DYN)
148 continue;
149
150 Changed = true;
151
152 // Save
153 MachineRegisterInfo *MRI = &MBB.getParent()->getRegInfo();
154 Register SavedFRM = MRI->createVirtualRegister(RegClass: &RISCV::GPRRegClass);
155 BuildMI(BB&: MBB, I&: MI, MIMD: MI.getDebugLoc(), MCID: TII->get(Opcode: RISCV::SwapFRMImm),
156 DestReg: SavedFRM)
157 .addImm(Val: FRMImm);
158 MI.addOperand(Op: MachineOperand::CreateReg(Reg: RISCV::FRM, /*IsDef*/ isDef: false,
159 /*IsImp*/ isImp: true));
160 // Restore
161 MachineInstrBuilder MIB =
162 BuildMI(MF&: *MBB.getParent(), MIMD: {}, MCID: TII->get(Opcode: RISCV::WriteFRM))
163 .addReg(RegNo: SavedFRM);
164 MBB.insertAfter(I: MI, MI: MIB);
165 }
166 return Changed;
167}
168
169static bool insertReadWriteCSROnMachineFunction(MachineFunction &MF) {
170 // Skip if the vector extension is not enabled.
171 const RISCVSubtarget &ST = MF.getSubtarget<RISCVSubtarget>();
172 if (!ST.hasVInstructions())
173 return false;
174
175 const TargetInstrInfo *TII = ST.getInstrInfo();
176
177 bool Changed = false;
178
179 for (MachineBasicBlock &MBB : MF) {
180 if (!ST.getCLOpts().frm_insert_opt)
181 Changed |= emitWriteRoundingMode(MBB, TII);
182 else
183 Changed |= emitWriteRoundingModeOpt(MBB, TII);
184 }
185
186 return Changed;
187}
188
189FunctionPass *llvm::createRISCVInsertReadWriteCSRLegacyPass() {
190 return new RISCVInsertReadWriteCSRLegacy();
191}
192
193bool RISCVInsertReadWriteCSRLegacy::runOnMachineFunction(MachineFunction &MF) {
194 return insertReadWriteCSROnMachineFunction(MF);
195}
196
197PreservedAnalyses
198RISCVInsertReadWriteCSRPass::run(MachineFunction &MF,
199 MachineFunctionAnalysisManager &MFAM) {
200 return insertReadWriteCSROnMachineFunction(MF)
201 ? getMachineFunctionPassPreservedAnalyses()
202 .preserveSet<CFGAnalyses>()
203 : PreservedAnalyses::all();
204}
205