/src/capstonev5/arch/SystemZ/SystemZInstPrinter.c
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- SystemZInstPrinter.cpp - Convert SystemZ MCInst to assembly syntax --------===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // This class prints an SystemZ MCInst to a .s file. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | /* Capstone Disassembly Engine */ |
15 | | /* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2015 */ |
16 | | |
17 | | #ifdef CAPSTONE_HAS_SYSZ |
18 | | |
19 | | #include <stdio.h> |
20 | | #include <stdlib.h> |
21 | | #include <string.h> |
22 | | #include <capstone/platform.h> |
23 | | |
24 | | #include "SystemZInstPrinter.h" |
25 | | #include "../../MCInst.h" |
26 | | #include "../../utils.h" |
27 | | #include "../../SStream.h" |
28 | | #include "../../MCRegisterInfo.h" |
29 | | #include "../../MathExtras.h" |
30 | | #include "SystemZMapping.h" |
31 | | |
32 | | static const char *getRegisterName(unsigned RegNo); |
33 | | |
34 | | void SystemZ_post_printer(csh ud, cs_insn *insn, char *insn_asm, MCInst *mci) |
35 | 136k | { |
36 | | /* |
37 | | if (((cs_struct *)ud)->detail != CS_OPT_ON) |
38 | | return; |
39 | | */ |
40 | 136k | } |
41 | | |
42 | | static void printAddress(MCInst *MI, unsigned Base, int64_t Disp, unsigned Index, SStream *O) |
43 | 63.7k | { |
44 | 63.7k | printInt64(O, Disp); |
45 | | |
46 | 63.7k | if (Base) { |
47 | 56.5k | SStream_concat0(O, "("); |
48 | 56.5k | if (Index) |
49 | 21.9k | SStream_concat(O, "%%%s, ", getRegisterName(Index)); |
50 | 56.5k | SStream_concat(O, "%%%s)", getRegisterName(Base)); |
51 | | |
52 | 56.5k | if (MI->csh->detail) { |
53 | 56.5k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM; |
54 | 56.5k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base); |
55 | 56.5k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.index = (uint8_t)SystemZ_map_register(Index); |
56 | 56.5k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = Disp; |
57 | 56.5k | MI->flat_insn->detail->sysz.op_count++; |
58 | 56.5k | } |
59 | 56.5k | } else if (!Index) { |
60 | 4.35k | if (MI->csh->detail) { |
61 | 4.35k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
62 | 4.35k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Disp; |
63 | 4.35k | MI->flat_insn->detail->sysz.op_count++; |
64 | 4.35k | } |
65 | 4.35k | } else { |
66 | 2.92k | SStream_concat(O, "(%%%s)", getRegisterName(Index)); |
67 | 2.92k | if (MI->csh->detail) { |
68 | 2.92k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM; |
69 | 2.92k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base); |
70 | 2.92k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.index = (uint8_t)SystemZ_map_register(Index); |
71 | 2.92k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = Disp; |
72 | 2.92k | MI->flat_insn->detail->sysz.op_count++; |
73 | 2.92k | } |
74 | 2.92k | } |
75 | 63.7k | } |
76 | | |
77 | | static void _printOperand(MCInst *MI, MCOperand *MO, SStream *O) |
78 | 176k | { |
79 | 176k | if (MCOperand_isReg(MO)) { |
80 | 176k | unsigned reg; |
81 | | |
82 | 176k | reg = MCOperand_getReg(MO); |
83 | 176k | SStream_concat(O, "%%%s", getRegisterName(reg)); |
84 | 176k | reg = SystemZ_map_register(reg); |
85 | | |
86 | 176k | if (MI->csh->detail) { |
87 | 176k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_REG; |
88 | 176k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].reg = reg; |
89 | 176k | MI->flat_insn->detail->sysz.op_count++; |
90 | 176k | } |
91 | 176k | } else if (MCOperand_isImm(MO)) { |
92 | 0 | int64_t Imm = MCOperand_getImm(MO); |
93 | |
|
94 | 0 | printInt64(O, Imm); |
95 | |
|
96 | 0 | if (MI->csh->detail) { |
97 | 0 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
98 | 0 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Imm; |
99 | 0 | MI->flat_insn->detail->sysz.op_count++; |
100 | 0 | } |
101 | 0 | } |
102 | 176k | } |
103 | | |
104 | | static void printU1ImmOperand(MCInst *MI, int OpNum, SStream *O) |
105 | 552 | { |
106 | 552 | int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
107 | | // assert(isUInt<1>(Value) && "Invalid u1imm argument"); |
108 | 552 | printInt64(O, Value); |
109 | | |
110 | 552 | if (MI->csh->detail) { |
111 | 552 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
112 | 552 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value; |
113 | 552 | MI->flat_insn->detail->sysz.op_count++; |
114 | 552 | } |
115 | 552 | } |
116 | | |
117 | | static void printU2ImmOperand(MCInst *MI, int OpNum, SStream *O) |
118 | 874 | { |
119 | 874 | int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
120 | | // assert(isUInt<2>(Value) && "Invalid u2imm argument"); |
121 | 874 | printInt64(O, Value); |
122 | | |
123 | 874 | if (MI->csh->detail) { |
124 | 874 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
125 | 874 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value; |
126 | 874 | MI->flat_insn->detail->sysz.op_count++; |
127 | 874 | } |
128 | 874 | } |
129 | | |
130 | | static void printU3ImmOperand(MCInst *MI, int OpNum, SStream *O) |
131 | 401 | { |
132 | 401 | int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
133 | | // assert(isUInt<3>(Value) && "Invalid u4imm argument"); |
134 | 401 | printInt64(O, Value); |
135 | | |
136 | 401 | if (MI->csh->detail) { |
137 | 401 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
138 | 401 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value; |
139 | 401 | MI->flat_insn->detail->sysz.op_count++; |
140 | 401 | } |
141 | 401 | } |
142 | | |
143 | | static void printU4ImmOperand(MCInst *MI, int OpNum, SStream *O) |
144 | 27.6k | { |
145 | 27.6k | int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
146 | | // assert(isUInt<4>(Value) && "Invalid u4imm argument"); |
147 | 27.6k | printInt64(O, Value); |
148 | | |
149 | 27.6k | if (MI->csh->detail) { |
150 | 27.6k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
151 | 27.6k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value; |
152 | 27.6k | MI->flat_insn->detail->sysz.op_count++; |
153 | 27.6k | } |
154 | 27.6k | } |
155 | | |
156 | | static void printU6ImmOperand(MCInst *MI, int OpNum, SStream *O) |
157 | 121 | { |
158 | 121 | uint32_t Value = (uint32_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
159 | | // assert(isUInt<6>(Value) && "Invalid u6imm argument"); |
160 | | |
161 | 121 | printUInt32(O, Value); |
162 | | |
163 | 121 | if (MI->csh->detail) { |
164 | 121 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
165 | 121 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value; |
166 | 121 | MI->flat_insn->detail->sysz.op_count++; |
167 | 121 | } |
168 | 121 | } |
169 | | |
170 | | static void printS8ImmOperand(MCInst *MI, int OpNum, SStream *O) |
171 | 2.93k | { |
172 | 2.93k | int8_t Value = (int8_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
173 | | // assert(isInt<8>(Value) && "Invalid s8imm argument"); |
174 | | |
175 | 2.93k | if (Value >= 0) { |
176 | 1.30k | if (Value > HEX_THRESHOLD) |
177 | 500 | SStream_concat(O, "0x%x", Value); |
178 | 809 | else |
179 | 809 | SStream_concat(O, "%u", Value); |
180 | 1.62k | } else { |
181 | 1.62k | if (Value < -HEX_THRESHOLD) |
182 | 1.48k | SStream_concat(O, "-0x%x", -Value); |
183 | 138 | else |
184 | 138 | SStream_concat(O, "-%u", -Value); |
185 | 1.62k | } |
186 | | |
187 | 2.93k | if (MI->csh->detail) { |
188 | 2.93k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
189 | 2.93k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value; |
190 | 2.93k | MI->flat_insn->detail->sysz.op_count++; |
191 | 2.93k | } |
192 | 2.93k | } |
193 | | |
194 | | static void printU8ImmOperand(MCInst *MI, int OpNum, SStream *O) |
195 | 10.2k | { |
196 | 10.2k | uint8_t Value = (uint8_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
197 | | // assert(isUInt<8>(Value) && "Invalid u8imm argument"); |
198 | | |
199 | 10.2k | if (Value > HEX_THRESHOLD) |
200 | 9.66k | SStream_concat(O, "0x%x", Value); |
201 | 580 | else |
202 | 580 | SStream_concat(O, "%u", Value); |
203 | | |
204 | 10.2k | if (MI->csh->detail) { |
205 | 10.2k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
206 | 10.2k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value; |
207 | 10.2k | MI->flat_insn->detail->sysz.op_count++; |
208 | 10.2k | } |
209 | 10.2k | } |
210 | | |
211 | | static void printU12ImmOperand(MCInst *MI, int OpNum, SStream *O) |
212 | 171 | { |
213 | 171 | int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
214 | | // assert(isUInt<12>(Value) && "Invalid u12imm argument"); |
215 | 171 | printInt64(O, Value); |
216 | | |
217 | 171 | if (MI->csh->detail) { |
218 | 171 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
219 | 171 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value; |
220 | 171 | MI->flat_insn->detail->sysz.op_count++; |
221 | 171 | } |
222 | 171 | } |
223 | | |
224 | | static void printS16ImmOperand(MCInst *MI, int OpNum, SStream *O) |
225 | 2.44k | { |
226 | 2.44k | int16_t Value = (int16_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
227 | | // assert(isInt<16>(Value) && "Invalid s16imm argument"); |
228 | | |
229 | 2.44k | if (Value >= 0) { |
230 | 1.22k | if (Value > HEX_THRESHOLD) |
231 | 1.13k | SStream_concat(O, "0x%x", Value); |
232 | 93 | else |
233 | 93 | SStream_concat(O, "%u", Value); |
234 | 1.22k | } else { |
235 | 1.21k | if (Value < -HEX_THRESHOLD) |
236 | 1.17k | SStream_concat(O, "-0x%x", -Value); |
237 | 38 | else |
238 | 38 | SStream_concat(O, "-%u", -Value); |
239 | 1.21k | } |
240 | | |
241 | 2.44k | if (MI->csh->detail) { |
242 | 2.44k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
243 | 2.44k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value; |
244 | 2.44k | MI->flat_insn->detail->sysz.op_count++; |
245 | 2.44k | } |
246 | 2.44k | } |
247 | | |
248 | | static void printU16ImmOperand(MCInst *MI, int OpNum, SStream *O) |
249 | 2.91k | { |
250 | 2.91k | uint16_t Value = (uint16_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
251 | | // assert(isUInt<16>(Value) && "Invalid u16imm argument"); |
252 | | |
253 | 2.91k | if (Value > HEX_THRESHOLD) |
254 | 2.83k | SStream_concat(O, "0x%x", Value); |
255 | 80 | else |
256 | 80 | SStream_concat(O, "%u", Value); |
257 | | |
258 | 2.91k | if (MI->csh->detail) { |
259 | 2.91k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
260 | 2.91k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value; |
261 | 2.91k | MI->flat_insn->detail->sysz.op_count++; |
262 | 2.91k | } |
263 | 2.91k | } |
264 | | |
265 | | static void printS32ImmOperand(MCInst *MI, int OpNum, SStream *O) |
266 | 1.33k | { |
267 | 1.33k | int32_t Value = (int32_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
268 | | // assert(isInt<32>(Value) && "Invalid s32imm argument"); |
269 | | |
270 | 1.33k | printInt32(O, Value); |
271 | | |
272 | 1.33k | if (MI->csh->detail) { |
273 | 1.33k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
274 | 1.33k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value; |
275 | 1.33k | MI->flat_insn->detail->sysz.op_count++; |
276 | 1.33k | } |
277 | 1.33k | } |
278 | | |
279 | | static void printU32ImmOperand(MCInst *MI, int OpNum, SStream *O) |
280 | 1.56k | { |
281 | 1.56k | uint32_t Value = (uint32_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
282 | | // assert(isUInt<32>(Value) && "Invalid u32imm argument"); |
283 | | |
284 | 1.56k | printUInt32(O, Value); |
285 | | |
286 | 1.56k | if (MI->csh->detail) { |
287 | 1.56k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
288 | 1.56k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value; |
289 | 1.56k | MI->flat_insn->detail->sysz.op_count++; |
290 | 1.56k | } |
291 | 1.56k | } |
292 | | |
293 | | static void printU48ImmOperand(MCInst *MI, int OpNum, SStream *O) |
294 | 0 | { |
295 | 0 | int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
296 | | // assert(isUInt<48>(Value) && "Invalid u48imm argument"); |
297 | 0 | printInt64(O, Value); |
298 | |
|
299 | 0 | if (MI->csh->detail) { |
300 | 0 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
301 | 0 | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value; |
302 | 0 | MI->flat_insn->detail->sysz.op_count++; |
303 | 0 | } |
304 | 0 | } |
305 | | |
306 | | static void printPCRelOperand(MCInst *MI, int OpNum, SStream *O) |
307 | 9.40k | { |
308 | 9.40k | MCOperand *MO = MCInst_getOperand(MI, OpNum); |
309 | | |
310 | 9.40k | if (MCOperand_isImm(MO)) { |
311 | 9.40k | int64_t imm = (int64_t)MCOperand_getImm(MO); |
312 | | |
313 | 9.40k | printInt64(O, imm); |
314 | | |
315 | 9.40k | if (MI->csh->detail) { |
316 | 9.40k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM; |
317 | 9.40k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = imm; |
318 | 9.40k | MI->flat_insn->detail->sysz.op_count++; |
319 | 9.40k | } |
320 | 9.40k | } |
321 | 9.40k | } |
322 | | |
323 | | static void printPCRelTLSOperand(MCInst *MI, int OpNum, SStream *O) |
324 | 333 | { |
325 | | // Output the PC-relative operand. |
326 | 333 | printPCRelOperand(MI, OpNum, O); |
327 | 333 | } |
328 | | |
329 | | static void printOperand(MCInst *MI, int OpNum, SStream *O) |
330 | 176k | { |
331 | 176k | _printOperand(MI, MCInst_getOperand(MI, OpNum), O); |
332 | 176k | } |
333 | | |
334 | | static void printBDAddrOperand(MCInst *MI, int OpNum, SStream *O) |
335 | 30.3k | { |
336 | 30.3k | printAddress(MI, MCOperand_getReg(MCInst_getOperand(MI, OpNum)), |
337 | 30.3k | MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1)), 0, O); |
338 | 30.3k | } |
339 | | |
340 | | static void printBDXAddrOperand(MCInst *MI, int OpNum, SStream *O) |
341 | 32.4k | { |
342 | 32.4k | printAddress(MI, MCOperand_getReg(MCInst_getOperand(MI, OpNum)), |
343 | 32.4k | MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1)), |
344 | 32.4k | MCOperand_getReg(MCInst_getOperand(MI, OpNum + 2)), O); |
345 | 32.4k | } |
346 | | |
347 | | static void printBDLAddrOperand(MCInst *MI, int OpNum, SStream *O) |
348 | 12.0k | { |
349 | 12.0k | unsigned Base = MCOperand_getReg(MCInst_getOperand(MI, OpNum)); |
350 | 12.0k | uint64_t Disp = (uint64_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1)); |
351 | 12.0k | uint64_t Length = (uint64_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum + 2)); |
352 | | |
353 | 12.0k | if (Disp > HEX_THRESHOLD) |
354 | 11.5k | SStream_concat(O, "0x%"PRIx64, Disp); |
355 | 468 | else |
356 | 468 | SStream_concat(O, "%"PRIu64, Disp); |
357 | | |
358 | 12.0k | if (Length > HEX_THRESHOLD) |
359 | 8.80k | SStream_concat(O, "(0x%"PRIx64, Length); |
360 | 3.24k | else |
361 | 3.24k | SStream_concat(O, "(%"PRIu64, Length); |
362 | | |
363 | 12.0k | if (Base) |
364 | 10.3k | SStream_concat(O, ", %%%s", getRegisterName(Base)); |
365 | 12.0k | SStream_concat0(O, ")"); |
366 | | |
367 | 12.0k | if (MI->csh->detail) { |
368 | 12.0k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM; |
369 | 12.0k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base); |
370 | 12.0k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.length = Length; |
371 | 12.0k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = (int64_t)Disp; |
372 | 12.0k | MI->flat_insn->detail->sysz.op_count++; |
373 | 12.0k | } |
374 | 12.0k | } |
375 | | |
376 | | static void printBDRAddrOperand(MCInst *MI, int OpNum, SStream *O) |
377 | 1.08k | { |
378 | 1.08k | unsigned Base = MCOperand_getReg(MCInst_getOperand(MI, OpNum)); |
379 | 1.08k | uint64_t Disp = (uint64_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1)); |
380 | 1.08k | uint64_t Length = MCOperand_getReg(MCInst_getOperand(MI, OpNum + 2)); |
381 | | |
382 | 1.08k | if (Disp > HEX_THRESHOLD) |
383 | 938 | SStream_concat(O, "0x%"PRIx64, Disp); |
384 | 142 | else |
385 | 142 | SStream_concat(O, "%"PRIu64, Disp); |
386 | | |
387 | 1.08k | SStream_concat0(O, "("); |
388 | 1.08k | SStream_concat(O, "%%%s", getRegisterName(Length)); |
389 | | |
390 | 1.08k | if (Base) |
391 | 884 | SStream_concat(O, ", %%%s", getRegisterName(Base)); |
392 | 1.08k | SStream_concat0(O, ")"); |
393 | | |
394 | 1.08k | if (MI->csh->detail) { |
395 | 1.08k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM; |
396 | 1.08k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base); |
397 | 1.08k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.length = (uint8_t)SystemZ_map_register(Length); |
398 | 1.08k | MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = (int64_t)Disp; |
399 | 1.08k | MI->flat_insn->detail->sysz.op_count++; |
400 | 1.08k | } |
401 | 1.08k | } |
402 | | |
403 | | static void printBDVAddrOperand(MCInst *MI, int OpNum, SStream *O) |
404 | 937 | { |
405 | 937 | printAddress(MI, MCOperand_getReg(MCInst_getOperand(MI, OpNum)), |
406 | 937 | MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1)), |
407 | 937 | MCOperand_getReg(MCInst_getOperand(MI, OpNum + 2)), O); |
408 | 937 | } |
409 | | |
410 | | static void printCond4Operand(MCInst *MI, int OpNum, SStream *O) |
411 | 0 | { |
412 | 0 | static const char *const CondNames[] = { |
413 | 0 | "o", "h", "nle", "l", "nhe", "lh", "ne", |
414 | 0 | "e", "nlh", "he", "nl", "le", "nh", "no" |
415 | 0 | }; |
416 | |
|
417 | 0 | uint64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, OpNum)); |
418 | | // assert(Imm > 0 && Imm < 15 && "Invalid condition"); |
419 | 0 | SStream_concat0(O, CondNames[Imm - 1]); |
420 | |
|
421 | 0 | if (MI->csh->detail) |
422 | 0 | MI->flat_insn->detail->sysz.cc = (sysz_cc)Imm; |
423 | 0 | } |
424 | | |
425 | | #define PRINT_ALIAS_INSTR |
426 | | #include "SystemZGenAsmWriter.inc" |
427 | | |
428 | | void SystemZ_printInst(MCInst *MI, SStream *O, void *Info) |
429 | 136k | { |
430 | 136k | printInstruction(MI, O, Info); |
431 | 136k | } |
432 | | |
433 | | #endif |