Debian Codegraph @

js/src/jit/riscv64/extension/base-riscv-i.h

raw
1 // Copyright 2022 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 #ifndef jit_riscv64_extension_Base_riscv_i_h_
5 #define jit_riscv64_extension_Base_riscv_i_h_
6 #include "mozilla/Assertions.h"
7
8 #include <stdint.h>
9
10 #include "jit/riscv64/constant/Constant-riscv64.h"
11 #include "jit/riscv64/extension/base-assembler-riscv.h"
12 namespace js {
13 namespace jit {
14
15 class AssemblerRISCVI : public AssemblerRiscvBase {
16 public:
17 void lui(Register rd, int32_t imm20);
18 void auipc(Register rd, int32_t imm20);
19
20 // Jumps
21 void jal(Register rd, int32_t imm20);
22 void jalr(Register rd, Register rs1, int16_t imm12);
23
24 // Branches
25 void beq(Register rs1, Register rs2, int16_t imm12);
26 void bne(Register rs1, Register rs2, int16_t imm12);
27 void blt(Register rs1, Register rs2, int16_t imm12);
28 void bge(Register rs1, Register rs2, int16_t imm12);
29 void bltu(Register rs1, Register rs2, int16_t imm12);
30 void bgeu(Register rs1, Register rs2, int16_t imm12);
31 // Loads
32 void lb(Register rd, Register rs1, int16_t imm12);
33 void lh(Register rd, Register rs1, int16_t imm12);
34 void lw(Register rd, Register rs1, int16_t imm12);
35 void lbu(Register rd, Register rs1, int16_t imm12);
36 void lhu(Register rd, Register rs1, int16_t imm12);
37
38 // Stores
39 void sb(Register source, Register base, int16_t imm12);
40 void sh(Register source, Register base, int16_t imm12);
41 void sw(Register source, Register base, int16_t imm12);
42
43 // Arithmetic with immediate
44 void addi(Register rd, Register rs1, int16_t imm12);
45 void slti(Register rd, Register rs1, int16_t imm12);
46 void sltiu(Register rd, Register rs1, int16_t imm12);
47 void xori(Register rd, Register rs1, int16_t imm12);
48 void ori(Register rd, Register rs1, int16_t imm12);
49 void andi(Register rd, Register rs1, int16_t imm12);
50 void slli(Register rd, Register rs1, uint8_t shamt);
51 void srli(Register rd, Register rs1, uint8_t shamt);
52 void srai(Register rd, Register rs1, uint8_t shamt);
53
54 // Arithmetic
55 void add(Register rd, Register rs1, Register rs2);
56 void sub(Register rd, Register rs1, Register rs2);
57 void sll(Register rd, Register rs1, Register rs2);
58 void slt(Register rd, Register rs1, Register rs2);
59 void sltu(Register rd, Register rs1, Register rs2);
60 void xor_(Register rd, Register rs1, Register rs2);
61 void srl(Register rd, Register rs1, Register rs2);
62 void sra(Register rd, Register rs1, Register rs2);
63 void or_(Register rd, Register rs1, Register rs2);
64 void and_(Register rd, Register rs1, Register rs2);
65
66 // Other pseudo instructions that are not part of RISCV pseudo assemly
67 void nor(Register rd, Register rs, Register rt) {
68 or_(rd, rs, rt);
69 not_(rd, rd);
70 }
71
72 // Memory fences
73 void fence(uint8_t pred, uint8_t succ);
74 void fence_tso();
75
76 // Environment call / break
77 void ecall();
78 void ebreak();
79
80 void sync() { fence(0b1111, 0b1111); }
81
82 // This is a de facto standard (as set by GNU binutils) 32-bit unimplemented
83 // instruction (i.e., it should always trap, if your implementation has
84 // invalid instruction traps).
85 void unimp();
86
87 static int JumpOffset(Instr instr);
88 static int AuipcOffset(Instr instr);
89 static int JalrOffset(Instr instr);
90 static int LoadOffset(Instr instr);
91 static int BranchOffset(Instr instr);
92 static int BrachlongOffset(Instr auipc, Instr instr_I);
93 static inline Instr SetBranchOffset(int32_t pos, int32_t target_pos,
94 Instr instr) {
95 int32_t imm = target_pos - pos;
96 MOZ_ASSERT((imm & 1) == 0);
97 MOZ_ASSERT(is_intn(imm, kBranchOffsetBits));
98
99 instr &= ~kBImm12Mask;
100 int32_t imm12 = ((imm & 0x800) >> 4) | // bit 11
101 ((imm & 0x1e) << 7) | // bits 4-1
102 ((imm & 0x7e0) << 20) | // bits 10-5
103 ((imm & 0x1000) << 19); // bit 12
104
105 return instr | (imm12 & kBImm12Mask);
106 }
107
108 static inline Instr SetJalOffset(int32_t pos, int32_t target_pos,
109 Instr instr) {
110 MOZ_ASSERT(IsJal(instr));
111 int32_t imm = target_pos - pos;
112 MOZ_ASSERT((imm & 1) == 0);
113 MOZ_ASSERT(is_intn(imm, kJumpOffsetBits));
114
115 instr &= ~kImm20Mask;
116 int32_t imm20 = (imm & 0xff000) | // bits 19-12
117 ((imm & 0x800) << 9) | // bit 11
118 ((imm & 0x7fe) << 20) | // bits 10-1
119 ((imm & 0x100000) << 11); // bit 20
120
121 return instr | (imm20 & kImm20Mask);
122 }
123
124 static inline Instr SetJalrOffset(int32_t offset, Instr instr) {
125 MOZ_ASSERT(IsJalr(instr));
126 MOZ_ASSERT(is_int12(offset));
127 instr &= ~kImm12Mask;
128 int32_t imm12 = offset << kImm12Shift;
129 MOZ_ASSERT(IsJalr(instr | (imm12 & kImm12Mask)));
130 MOZ_ASSERT(JalrOffset(instr | (imm12 & kImm12Mask)) == offset);
131 return instr | (imm12 & kImm12Mask);
132 }
133
134 static inline Instr SetLoadOffset(int32_t offset, Instr instr) {
135 #if JS_CODEGEN_RISCV64
136 MOZ_ASSERT(IsLd(instr));
137 #elif JS_CODEGEN_RISCV32
138 MOZ_ASSERT(IsLw(instr));
139 #endif
140 MOZ_ASSERT(is_int12(offset));
141 instr &= ~kImm12Mask;
142 int32_t imm12 = offset << kImm12Shift;
143 return instr | (imm12 & kImm12Mask);
144 }
145
146 static inline Instr SetAuipcOffset(int32_t offset, Instr instr) {
147 MOZ_ASSERT(IsAuipc(instr));
148 MOZ_ASSERT(is_int20(offset));
149 instr = (instr & ~kImm31_12Mask) | ((offset & kImm19_0Mask) << 12);
150 return instr;
151 }
152
153 // Check if an instruction is a branch of some kind.
154 static bool IsBranch(Instr instr);
155 static bool IsNop(Instr instr);
156 static bool IsJump(Instr instr);
157 static bool IsJal(Instr instr);
158 static bool IsJalr(Instr instr);
159 static bool IsLui(Instr instr);
160 static bool IsAuipc(Instr instr);
161 static bool IsAddi(Instr instr);
162 static bool IsOri(Instr instr);
163 static bool IsSlli(Instr instr);
164 static bool IsLw(Instr instr);
165
166 inline int32_t branch_offset(Label* L) {
167 return branch_offset_helper(L, OffsetSize::kOffset13);
168 }
169 inline int32_t jump_offset(Label* L) {
170 return branch_offset_helper(L, OffsetSize::kOffset21);
171 }
172
173 // Branches
174 void beq(Register rs1, Register rs2, Label* L) {
175 beq(rs1, rs2, branch_offset(L));
176 }
177 void bne(Register rs1, Register rs2, Label* L) {
178 bne(rs1, rs2, branch_offset(L));
179 }
180 void blt(Register rs1, Register rs2, Label* L) {
181 blt(rs1, rs2, branch_offset(L));
182 }
183 void bge(Register rs1, Register rs2, Label* L) {
184 bge(rs1, rs2, branch_offset(L));
185 }
186 void bltu(Register rs1, Register rs2, Label* L) {
187 bltu(rs1, rs2, branch_offset(L));
188 }
189 void bgeu(Register rs1, Register rs2, Label* L) {
190 bgeu(rs1, rs2, branch_offset(L));
191 }
192
193 void beqz(Register rs, int16_t imm13) { beq(rs, zero_reg, imm13); }
194 void beqz(Register rs1, Label* L) { beqz(rs1, branch_offset(L)); }
195 void bnez(Register rs, int16_t imm13) { bne(rs, zero_reg, imm13); }
196 void bnez(Register rs1, Label* L) { bnez(rs1, branch_offset(L)); }
197 void blez(Register rs, int16_t imm13) { bge(zero_reg, rs, imm13); }
198 void blez(Register rs1, Label* L) { blez(rs1, branch_offset(L)); }
199 void bgez(Register rs, int16_t imm13) { bge(rs, zero_reg, imm13); }
200 void bgez(Register rs1, Label* L) { bgez(rs1, branch_offset(L)); }
201 void bltz(Register rs, int16_t imm13) { blt(rs, zero_reg, imm13); }
202 void bltz(Register rs1, Label* L) { bltz(rs1, branch_offset(L)); }
203 void bgtz(Register rs, int16_t imm13) { blt(zero_reg, rs, imm13); }
204
205 void bgtz(Register rs1, Label* L) { bgtz(rs1, branch_offset(L)); }
206 void bgt(Register rs1, Register rs2, int16_t imm13) { blt(rs2, rs1, imm13); }
207 void bgt(Register rs1, Register rs2, Label* L) {
208 bgt(rs1, rs2, branch_offset(L));
209 }
210 void ble(Register rs1, Register rs2, int16_t imm13) { bge(rs2, rs1, imm13); }
211 void ble(Register rs1, Register rs2, Label* L) {
212 ble(rs1, rs2, branch_offset(L));
213 }
214 void bgtu(Register rs1, Register rs2, int16_t imm13) {
215 bltu(rs2, rs1, imm13);
216 }
217 void bgtu(Register rs1, Register rs2, Label* L) {
218 bgtu(rs1, rs2, branch_offset(L));
219 }
220 void bleu(Register rs1, Register rs2, int16_t imm13) {
221 bgeu(rs2, rs1, imm13);
222 }
223 void bleu(Register rs1, Register rs2, Label* L) {
224 bleu(rs1, rs2, branch_offset(L));
225 }
226
227 void j(int32_t imm21) { jal(zero_reg, imm21); }
228 void j(Label* L) { j(jump_offset(L)); }
229 void b(Label* L) { j(L); }
230 void jal(int32_t imm21) { jal(ra, imm21); }
231 void jal(Label* L) { jal(jump_offset(L)); }
232 void jr(Register rs) { jalr(zero_reg, rs, 0); }
233 void jr(Register rs, int32_t imm12) { jalr(zero_reg, rs, imm12); }
234 void jalr(Register rs, int32_t imm12) { jalr(ra, rs, imm12); }
235 void jalr(Register rs) { jalr(ra, rs, 0); }
236 void call(int32_t offset) {
237 auipc(ra, (offset >> 12) + ((offset & 0x800) >> 11));
238 jalr(ra, ra, offset << 20 >> 20);
239 }
240
241 void mv(Register rd, Register rs) { addi(rd, rs, 0); }
242 void not_(Register rd, Register rs) { xori(rd, rs, -1); }
243 void neg(Register rd, Register rs) { sub(rd, zero_reg, rs); }
244 void seqz(Register rd, Register rs) { sltiu(rd, rs, 1); }
245 void snez(Register rd, Register rs) { sltu(rd, zero_reg, rs); }
246 void sltz(Register rd, Register rs) { slt(rd, rs, zero_reg); }
247 void sgtz(Register rd, Register rs) { slt(rd, zero_reg, rs); }
248
249 #if JS_CODEGEN_RISCV64
250 void lwu(Register rd, Register rs1, int16_t imm12);
251 void ld(Register rd, Register rs1, int16_t imm12);
252 void sd(Register source, Register base, int16_t imm12);
253 void addiw(Register rd, Register rs1, int16_t imm12);
254 void slliw(Register rd, Register rs1, uint8_t shamt);
255 void srliw(Register rd, Register rs1, uint8_t shamt);
256 void sraiw(Register rd, Register rs1, uint8_t shamt);
257 void addw(Register rd, Register rs1, Register rs2);
258 void subw(Register rd, Register rs1, Register rs2);
259 void sllw(Register rd, Register rs1, Register rs2);
260 void srlw(Register rd, Register rs1, Register rs2);
261 void sraw(Register rd, Register rs1, Register rs2);
262 void negw(Register rd, Register rs) { subw(rd, zero_reg, rs); }
263 void sext_w(Register rd, Register rs) { addiw(rd, rs, 0); }
264
265 static bool IsAddiw(Instr instr);
266 static bool IsLd(Instr instr);
267 #endif
268 };
269
270 } // namespace jit
271 } // namespace js
272
273 #endif // jit_riscv64_extension_Base_riscv_I_h_