Coverage Report

Created: 2023-09-25 06:24

/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
112k
{
36
  /*
37
     if (((cs_struct *)ud)->detail != CS_OPT_ON)
38
     return;
39
   */
40
112k
}
41
42
static void printAddress(MCInst *MI, unsigned Base, int64_t Disp, unsigned Index, SStream *O)
43
43.8k
{
44
43.8k
  printInt64(O, Disp);
45
46
43.8k
  if (Base) {
47
37.5k
    SStream_concat0(O, "(");
48
37.5k
    if (Index)
49
14.3k
      SStream_concat(O, "%%%s, ", getRegisterName(Index));
50
37.5k
    SStream_concat(O, "%%%s)", getRegisterName(Base));
51
52
37.5k
    if (MI->csh->detail) {
53
37.5k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM;
54
37.5k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base);
55
37.5k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.index = (uint8_t)SystemZ_map_register(Index);
56
37.5k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = Disp;
57
37.5k
      MI->flat_insn->detail->sysz.op_count++;
58
37.5k
    }
59
37.5k
  } else if (!Index) {
60
4.65k
    if (MI->csh->detail) {
61
4.65k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
62
4.65k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Disp;
63
4.65k
      MI->flat_insn->detail->sysz.op_count++;
64
4.65k
    }
65
4.65k
  } else {
66
1.66k
    SStream_concat(O, "(%%%s)", getRegisterName(Index));
67
1.66k
    if (MI->csh->detail) {
68
1.66k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM;
69
1.66k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base);
70
1.66k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.index = (uint8_t)SystemZ_map_register(Index);
71
1.66k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = Disp;
72
1.66k
      MI->flat_insn->detail->sysz.op_count++;
73
1.66k
    }
74
1.66k
  }
75
43.8k
}
76
77
static void _printOperand(MCInst *MI, MCOperand *MO, SStream *O)
78
158k
{
79
158k
  if (MCOperand_isReg(MO)) {
80
158k
    unsigned reg;
81
82
158k
    reg = MCOperand_getReg(MO);
83
158k
    SStream_concat(O, "%%%s", getRegisterName(reg));
84
158k
    reg = SystemZ_map_register(reg);
85
86
158k
    if (MI->csh->detail) {
87
158k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_REG;
88
158k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].reg = reg;
89
158k
      MI->flat_insn->detail->sysz.op_count++;
90
158k
    }
91
158k
  } 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
158k
}
103
104
static void printU1ImmOperand(MCInst *MI, int OpNum, SStream *O)
105
263
{
106
263
  int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum));
107
  // assert(isUInt<1>(Value) && "Invalid u1imm argument");
108
263
  printInt64(O, Value);
109
110
263
  if (MI->csh->detail) {
111
263
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
112
263
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value;
113
263
    MI->flat_insn->detail->sysz.op_count++;
114
263
  }
115
263
}
116
117
static void printU2ImmOperand(MCInst *MI, int OpNum, SStream *O)
118
288
{
119
288
  int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum));
120
  // assert(isUInt<2>(Value) && "Invalid u2imm argument");
121
288
  printInt64(O, Value);
122
123
288
  if (MI->csh->detail) {
124
288
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
125
288
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value;
126
288
    MI->flat_insn->detail->sysz.op_count++;
127
288
  }
128
288
}
129
130
static void printU3ImmOperand(MCInst *MI, int OpNum, SStream *O)
131
160
{
132
160
  int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum));
133
  // assert(isUInt<3>(Value) && "Invalid u4imm argument");
134
160
  printInt64(O, Value);
135
136
160
  if (MI->csh->detail) {
137
160
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
138
160
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value;
139
160
    MI->flat_insn->detail->sysz.op_count++;
140
160
  }
141
160
}
142
143
static void printU4ImmOperand(MCInst *MI, int OpNum, SStream *O)
144
24.6k
{
145
24.6k
  int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum));
146
  // assert(isUInt<4>(Value) && "Invalid u4imm argument");
147
24.6k
  printInt64(O, Value);
148
149
24.6k
  if (MI->csh->detail) {
150
24.6k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
151
24.6k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value;
152
24.6k
    MI->flat_insn->detail->sysz.op_count++;
153
24.6k
  }
154
24.6k
}
155
156
static void printU6ImmOperand(MCInst *MI, int OpNum, SStream *O)
157
450
{
158
450
  uint32_t Value = (uint32_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
159
  // assert(isUInt<6>(Value) && "Invalid u6imm argument");
160
161
450
  printUInt32(O, Value);
162
163
450
  if (MI->csh->detail) {
164
450
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
165
450
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value;
166
450
    MI->flat_insn->detail->sysz.op_count++;
167
450
  }
168
450
}
169
170
static void printS8ImmOperand(MCInst *MI, int OpNum, SStream *O)
171
1.77k
{
172
1.77k
  int8_t Value = (int8_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
173
  // assert(isInt<8>(Value) && "Invalid s8imm argument");
174
175
1.77k
  if (Value >= 0) {
176
353
    if (Value > HEX_THRESHOLD)
177
213
      SStream_concat(O, "0x%x", Value);
178
140
    else
179
140
      SStream_concat(O, "%u", Value);
180
1.42k
  } else {
181
1.42k
    if (Value < -HEX_THRESHOLD)
182
669
      SStream_concat(O, "-0x%x", -Value);
183
755
    else
184
755
      SStream_concat(O, "-%u", -Value);
185
1.42k
  }
186
187
1.77k
  if (MI->csh->detail) {
188
1.77k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
189
1.77k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value;
190
1.77k
    MI->flat_insn->detail->sysz.op_count++;
191
1.77k
  }
192
1.77k
}
193
194
static void printU8ImmOperand(MCInst *MI, int OpNum, SStream *O)
195
6.34k
{
196
6.34k
  uint8_t Value = (uint8_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
197
  // assert(isUInt<8>(Value) && "Invalid u8imm argument");
198
199
6.34k
  if (Value > HEX_THRESHOLD)
200
4.52k
    SStream_concat(O, "0x%x", Value);
201
1.81k
  else
202
1.81k
    SStream_concat(O, "%u", Value);
203
204
6.34k
  if (MI->csh->detail) {
205
6.34k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
206
6.34k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value;
207
6.34k
    MI->flat_insn->detail->sysz.op_count++;
208
6.34k
  }
209
6.34k
}
210
211
static void printU12ImmOperand(MCInst *MI, int OpNum, SStream *O)
212
1.11k
{
213
1.11k
  int64_t Value = MCOperand_getImm(MCInst_getOperand(MI, OpNum));
214
  // assert(isUInt<12>(Value) && "Invalid u12imm argument");
215
1.11k
  printInt64(O, Value);
216
217
1.11k
  if (MI->csh->detail) {
218
1.11k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
219
1.11k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Value;
220
1.11k
    MI->flat_insn->detail->sysz.op_count++;
221
1.11k
  }
222
1.11k
}
223
224
static void printS16ImmOperand(MCInst *MI, int OpNum, SStream *O)
225
4.42k
{
226
4.42k
  int16_t Value = (int16_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
227
  // assert(isInt<16>(Value) && "Invalid s16imm argument");
228
229
4.42k
  if (Value >= 0) {
230
3.27k
    if (Value > HEX_THRESHOLD)
231
2.16k
      SStream_concat(O, "0x%x", Value);
232
1.10k
    else
233
1.10k
      SStream_concat(O, "%u", Value);
234
3.27k
  } else {
235
1.15k
    if (Value < -HEX_THRESHOLD)
236
1.04k
      SStream_concat(O, "-0x%x", -Value);
237
102
    else
238
102
      SStream_concat(O, "-%u", -Value);
239
1.15k
  }
240
241
4.42k
  if (MI->csh->detail) {
242
4.42k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
243
4.42k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value;
244
4.42k
    MI->flat_insn->detail->sysz.op_count++;
245
4.42k
  }
246
4.42k
}
247
248
static void printU16ImmOperand(MCInst *MI, int OpNum, SStream *O)
249
3.17k
{
250
3.17k
  uint16_t Value = (uint16_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
251
  // assert(isUInt<16>(Value) && "Invalid u16imm argument");
252
253
3.17k
  if (Value > HEX_THRESHOLD)
254
2.78k
    SStream_concat(O, "0x%x", Value);
255
392
  else
256
392
    SStream_concat(O, "%u", Value);
257
258
3.17k
  if (MI->csh->detail) {
259
3.17k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
260
3.17k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value;
261
3.17k
    MI->flat_insn->detail->sysz.op_count++;
262
3.17k
  }
263
3.17k
}
264
265
static void printS32ImmOperand(MCInst *MI, int OpNum, SStream *O)
266
1.17k
{
267
1.17k
  int32_t Value = (int32_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
268
  // assert(isInt<32>(Value) && "Invalid s32imm argument");
269
270
1.17k
  printInt32(O, Value);
271
272
1.17k
  if (MI->csh->detail) {
273
1.17k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
274
1.17k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value;
275
1.17k
    MI->flat_insn->detail->sysz.op_count++;
276
1.17k
  }
277
1.17k
}
278
279
static void printU32ImmOperand(MCInst *MI, int OpNum, SStream *O)
280
2.00k
{
281
2.00k
  uint32_t Value = (uint32_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
282
  // assert(isUInt<32>(Value) && "Invalid u32imm argument");
283
284
2.00k
  printUInt32(O, Value);
285
286
2.00k
  if (MI->csh->detail) {
287
2.00k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
288
2.00k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = (int64_t)Value;
289
2.00k
    MI->flat_insn->detail->sysz.op_count++;
290
2.00k
  }
291
2.00k
}
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
7.06k
{
308
7.06k
  MCOperand *MO = MCInst_getOperand(MI, OpNum);
309
310
7.06k
  if (MCOperand_isImm(MO)) {
311
7.06k
    int64_t imm = (int64_t)MCOperand_getImm(MO);
312
313
7.06k
    printInt64(O, imm);
314
315
7.06k
    if (MI->csh->detail) {
316
7.06k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
317
7.06k
      MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = imm;
318
7.06k
      MI->flat_insn->detail->sysz.op_count++;
319
7.06k
    }
320
7.06k
  }
321
7.06k
}
322
323
static void printPCRelTLSOperand(MCInst *MI, int OpNum, SStream *O)
324
330
{
325
  // Output the PC-relative operand.
326
330
  printPCRelOperand(MI, OpNum, O);
327
330
}
328
329
static void printOperand(MCInst *MI, int OpNum, SStream *O)
330
158k
{
331
158k
  _printOperand(MI, MCInst_getOperand(MI, OpNum), O);
332
158k
}
333
334
static void printBDAddrOperand(MCInst *MI, int OpNum, SStream *O)
335
22.8k
{
336
22.8k
  printAddress(MI, MCOperand_getReg(MCInst_getOperand(MI, OpNum)),
337
22.8k
      MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1)), 0, O);
338
22.8k
}
339
340
static void printBDXAddrOperand(MCInst *MI, int OpNum, SStream *O)
341
20.6k
{
342
20.6k
  printAddress(MI, MCOperand_getReg(MCInst_getOperand(MI, OpNum)),
343
20.6k
      MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1)),
344
20.6k
      MCOperand_getReg(MCInst_getOperand(MI, OpNum + 2)), O);
345
20.6k
}
346
347
static void printBDLAddrOperand(MCInst *MI, int OpNum, SStream *O)
348
9.47k
{
349
9.47k
  unsigned Base = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
350
9.47k
  uint64_t Disp = (uint64_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1));
351
9.47k
  uint64_t Length = (uint64_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum + 2));
352
353
9.47k
  if (Disp > HEX_THRESHOLD)
354
9.20k
    SStream_concat(O, "0x%"PRIx64, Disp);
355
269
  else
356
269
    SStream_concat(O, "%"PRIu64, Disp);
357
358
9.47k
  if (Length > HEX_THRESHOLD)
359
7.20k
    SStream_concat(O, "(0x%"PRIx64, Length);
360
2.26k
  else
361
2.26k
    SStream_concat(O, "(%"PRIu64, Length);
362
363
9.47k
  if (Base)
364
8.39k
    SStream_concat(O, ", %%%s", getRegisterName(Base));
365
9.47k
  SStream_concat0(O, ")");
366
367
9.47k
  if (MI->csh->detail) {
368
9.47k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM;
369
9.47k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base);
370
9.47k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.length = Length;
371
9.47k
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = (int64_t)Disp;
372
9.47k
    MI->flat_insn->detail->sysz.op_count++;
373
9.47k
  }
374
9.47k
}
375
376
static void printBDRAddrOperand(MCInst *MI, int OpNum, SStream *O)
377
867
{
378
867
  unsigned Base = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
379
867
  uint64_t Disp = (uint64_t)MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1));
380
867
  uint64_t Length = MCOperand_getReg(MCInst_getOperand(MI, OpNum + 2));
381
382
867
  if (Disp > HEX_THRESHOLD)
383
774
    SStream_concat(O, "0x%"PRIx64, Disp);
384
93
  else
385
93
    SStream_concat(O, "%"PRIu64, Disp);
386
387
867
  SStream_concat0(O, "(");
388
867
  SStream_concat(O, "%%%s", getRegisterName(Length));
389
390
867
  if (Base)
391
563
    SStream_concat(O, ", %%%s", getRegisterName(Base));
392
867
  SStream_concat0(O, ")");
393
394
867
  if (MI->csh->detail) {
395
867
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM;
396
867
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base);
397
867
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.length = (uint8_t)SystemZ_map_register(Length);
398
867
    MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = (int64_t)Disp;
399
867
    MI->flat_insn->detail->sysz.op_count++;
400
867
  }
401
867
}
402
403
static void printBDVAddrOperand(MCInst *MI, int OpNum, SStream *O)
404
324
{
405
324
  printAddress(MI, MCOperand_getReg(MCInst_getOperand(MI, OpNum)),
406
324
      MCOperand_getImm(MCInst_getOperand(MI, OpNum + 1)),
407
324
      MCOperand_getReg(MCInst_getOperand(MI, OpNum + 2)), O);
408
324
}
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
112k
{
430
112k
  printInstruction(MI, O, Info);
431
112k
}
432
433
#endif