Coverage Report

Created: 2023-09-25 06:24

/src/capstonev5/arch/SystemZ/SystemZDisassembler.c
Line
Count
Source
1
//===------ SystemZDisassembler.cpp - Disassembler for PowerPC ------*- C++ -*-===//
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
/* Capstone Disassembly Engine */
11
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2015 */
12
13
#ifdef CAPSTONE_HAS_SYSZ
14
15
#include <stdio.h>  // DEBUG
16
#include <stdlib.h>
17
#include <string.h>
18
19
#include "../../cs_priv.h"
20
#include "../../utils.h"
21
22
#include "SystemZDisassembler.h"
23
24
#include "../../MCInst.h"
25
#include "../../MCInstrDesc.h"
26
#include "../../MCFixedLenDisassembler.h"
27
#include "../../MCRegisterInfo.h"
28
#include "../../MCDisassembler.h"
29
#include "../../MathExtras.h"
30
31
#include "SystemZMCTargetDesc.h"
32
33
static uint64_t getFeatureBits(int mode)
34
113k
{
35
  // support everything
36
113k
  return (uint64_t)-1;
37
113k
}
38
39
static DecodeStatus decodeRegisterClass(MCInst *Inst, uint64_t RegNo, const unsigned *Regs)
40
195k
{
41
  //assert(RegNo < 16 && "Invalid register");
42
195k
  RegNo = Regs[RegNo];
43
195k
  if (RegNo == 0)
44
184
    return MCDisassembler_Fail;
45
46
194k
  MCOperand_CreateReg0(Inst, (unsigned)RegNo);
47
194k
  return MCDisassembler_Success;
48
195k
}
49
50
static DecodeStatus DecodeGR32BitRegisterClass(MCInst *Inst, uint64_t RegNo,
51
    uint64_t Address, const void *Decoder)
52
49.8k
{
53
49.8k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_GR32Regs);
54
49.8k
}
55
56
static DecodeStatus DecodeGRH32BitRegisterClass(MCInst *Inst, uint64_t RegNo,
57
    uint64_t Address, const void *Decoder)
58
6.38k
{
59
6.38k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_GRH32Regs);
60
6.38k
}
61
62
static DecodeStatus DecodeGR64BitRegisterClass(MCInst *Inst, uint64_t RegNo,
63
    uint64_t Address, const void *Decoder)
64
35.0k
{
65
35.0k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_GR64Regs);
66
35.0k
}
67
68
static DecodeStatus DecodeGR128BitRegisterClass(MCInst *Inst, uint64_t RegNo,
69
    uint64_t Address, const void *Decoder)
70
11.9k
{
71
11.9k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_GR128Regs);
72
11.9k
}
73
74
static DecodeStatus DecodeADDR64BitRegisterClass(MCInst *Inst, uint64_t RegNo,
75
    uint64_t Address, const void *Decoder)
76
5.30k
{
77
5.30k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_GR64Regs);
78
5.30k
}
79
80
static DecodeStatus DecodeFP32BitRegisterClass(MCInst *Inst, uint64_t RegNo,
81
    uint64_t Address, const void *Decoder) 
82
22.0k
{
83
22.0k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_FP32Regs);
84
22.0k
}
85
86
static DecodeStatus DecodeFP64BitRegisterClass(MCInst *Inst, uint64_t RegNo,
87
    uint64_t Address, const void *Decoder)
88
38.2k
{
89
38.2k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_FP64Regs);
90
38.2k
}
91
92
static DecodeStatus DecodeFP128BitRegisterClass(MCInst *Inst, uint64_t RegNo,
93
    uint64_t Address, const void *Decoder)
94
6.68k
{
95
6.68k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_FP128Regs);
96
6.68k
}
97
98
static DecodeStatus DecodeVR32BitRegisterClass(MCInst *Inst, uint64_t RegNo,
99
    uint64_t Address, const void *Decoder)
100
2.80k
{
101
2.80k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_VR32Regs);
102
2.80k
}
103
104
static DecodeStatus DecodeVR64BitRegisterClass(MCInst *Inst, uint64_t RegNo,
105
    uint64_t Address, const void *Decoder)
106
1.98k
{
107
1.98k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_VR64Regs);
108
1.98k
}
109
110
static DecodeStatus DecodeVR128BitRegisterClass(MCInst *Inst, uint64_t RegNo,
111
    uint64_t Address, const void *Decoder)
112
11.2k
{
113
11.2k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_VR128Regs);
114
11.2k
}
115
116
static DecodeStatus DecodeAR32BitRegisterClass(MCInst *Inst, uint64_t RegNo,
117
    uint64_t Address, const void *Decoder)
118
1.32k
{
119
1.32k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_AR32Regs);
120
1.32k
}
121
122
static DecodeStatus DecodeCR64BitRegisterClass(MCInst *Inst, uint64_t RegNo,
123
    uint64_t Address, const void *Decoder)
124
2.22k
{
125
2.22k
  return decodeRegisterClass(Inst, RegNo, SystemZMC_CR64Regs);
126
2.22k
}
127
128
static DecodeStatus decodeUImmOperand(MCInst *Inst, uint64_t Imm)
129
38.4k
{
130
  //assert(isUInt<N>(Imm) && "Invalid immediate");
131
38.4k
  MCOperand_CreateImm0(Inst, Imm);
132
38.4k
  return MCDisassembler_Success;
133
38.4k
}
134
135
static DecodeStatus decodeSImmOperand(MCInst *Inst, uint64_t Imm, unsigned N)
136
7.36k
{
137
  //assert(isUInt<N>(Imm) && "Invalid immediate");
138
7.36k
  MCOperand_CreateImm0(Inst, SignExtend64(Imm, N));
139
7.36k
  return MCDisassembler_Success;
140
7.36k
}
141
142
static DecodeStatus decodeU1ImmOperand(MCInst *Inst, uint64_t Imm,
143
    uint64_t Address, const void *Decoder)
144
263
{
145
263
  return decodeUImmOperand(Inst, Imm);
146
263
}
147
148
static DecodeStatus decodeU2ImmOperand(MCInst *Inst, uint64_t Imm,
149
    uint64_t Address, const void *Decoder)
150
288
{
151
288
  return decodeUImmOperand(Inst, Imm);
152
288
}
153
154
static DecodeStatus decodeU3ImmOperand(MCInst *Inst, uint64_t Imm,
155
    uint64_t Address, const void *Decoder)
156
160
{
157
160
  return decodeUImmOperand(Inst, Imm);
158
160
}
159
160
static DecodeStatus decodeU4ImmOperand(MCInst *Inst, uint64_t Imm,
161
    uint64_t Address, const void *Decoder)
162
24.6k
{
163
24.6k
  return decodeUImmOperand(Inst, Imm);
164
24.6k
}
165
166
static DecodeStatus decodeU6ImmOperand(MCInst *Inst, uint64_t Imm,
167
    uint64_t Address, const void *Decoder)
168
450
{
169
450
  return decodeUImmOperand(Inst, Imm);
170
450
}
171
172
static DecodeStatus decodeU8ImmOperand(MCInst *Inst, uint64_t Imm,
173
    uint64_t Address, const void *Decoder)
174
6.34k
{
175
6.34k
  return decodeUImmOperand(Inst, Imm);
176
6.34k
}
177
178
static DecodeStatus decodeU12ImmOperand(MCInst *Inst, uint64_t Imm,
179
    uint64_t Address, const void *Decoder)
180
1.11k
{
181
1.11k
  return decodeUImmOperand(Inst, Imm);
182
1.11k
}
183
184
static DecodeStatus decodeU16ImmOperand(MCInst *Inst, uint64_t Imm,
185
    uint64_t Address, const void *Decoder)
186
3.17k
{
187
3.17k
  return decodeUImmOperand(Inst, Imm);
188
3.17k
}
189
190
static DecodeStatus decodeU32ImmOperand(MCInst *Inst, uint64_t Imm,
191
    uint64_t Address, const void *Decoder)
192
2.00k
{
193
2.00k
  return decodeUImmOperand(Inst, Imm);
194
2.00k
}
195
196
static DecodeStatus decodeS8ImmOperand(MCInst *Inst, uint64_t Imm,
197
    uint64_t Address, const void *Decoder)
198
1.77k
{
199
1.77k
  return decodeSImmOperand(Inst, Imm, 8);
200
1.77k
}
201
202
static DecodeStatus decodeS16ImmOperand(MCInst *Inst, uint64_t Imm,
203
    uint64_t Address, const void *Decoder) 
204
4.42k
{
205
4.42k
  return decodeSImmOperand(Inst, Imm, 16);
206
4.42k
}
207
208
static DecodeStatus decodeS32ImmOperand(MCInst *Inst, uint64_t Imm,
209
    uint64_t Address, const void *Decoder)
210
1.17k
{
211
1.17k
  return decodeSImmOperand(Inst, Imm, 32);
212
1.17k
}
213
214
static DecodeStatus decodePCDBLOperand(MCInst *Inst, uint64_t Imm,
215
    uint64_t Address, unsigned N)
216
7.06k
{
217
  //assert(isUInt<N>(Imm) && "Invalid PC-relative offset");
218
7.06k
  MCOperand_CreateImm0(Inst, SignExtend64(Imm, N) * 2 + Address);
219
7.06k
  return MCDisassembler_Success;
220
7.06k
}
221
222
static DecodeStatus decodePC12DBLBranchOperand(MCInst *Inst, uint64_t Imm,
223
    uint64_t Address,
224
    const void *Decoder)
225
372
{
226
372
  return decodePCDBLOperand(Inst, Imm, Address, 12);
227
372
}
228
229
static DecodeStatus decodePC16DBLBranchOperand(MCInst *Inst, uint64_t Imm,
230
    uint64_t Address,
231
    const void *Decoder)
232
4.02k
{
233
4.02k
  return decodePCDBLOperand(Inst, Imm, Address, 16);
234
4.02k
}
235
236
static DecodeStatus decodePC24DBLBranchOperand(MCInst *Inst, uint64_t Imm,
237
    uint64_t Address,
238
    const void *Decoder)
239
372
{
240
372
  return decodePCDBLOperand(Inst, Imm, Address, 24);
241
372
}
242
243
static DecodeStatus decodePC32DBLBranchOperand(MCInst *Inst, uint64_t Imm,
244
    uint64_t Address,
245
    const void *Decoder)
246
623
{
247
623
  return decodePCDBLOperand(Inst, Imm, Address, 32);
248
623
}
249
250
static DecodeStatus decodePC32DBLOperand(MCInst *Inst, uint64_t Imm,
251
    uint64_t Address,
252
    const void *Decoder)
253
1.67k
{
254
1.67k
  return decodePCDBLOperand(Inst, Imm, Address, 32);
255
1.67k
}
256
257
static DecodeStatus decodeBDAddr12Operand(MCInst *Inst, uint64_t Field,
258
    const unsigned *Regs)
259
19.2k
{
260
19.2k
  uint64_t Base = Field >> 12;
261
19.2k
  uint64_t Disp = Field & 0xfff;
262
  //assert(Base < 16 && "Invalid BDAddr12");
263
264
19.2k
  MCOperand_CreateReg0(Inst, Base == 0 ? 0 : Regs[Base]);
265
19.2k
  MCOperand_CreateImm0(Inst, Disp);
266
267
19.2k
  return MCDisassembler_Success;
268
19.2k
}
269
270
static DecodeStatus decodeBDAddr20Operand(MCInst *Inst, uint64_t Field,
271
    const unsigned *Regs)
272
3.57k
{
273
3.57k
  uint64_t Base = Field >> 20;
274
3.57k
  uint64_t Disp = ((Field << 12) & 0xff000) | ((Field >> 8) & 0xfff);
275
  //assert(Base < 16 && "Invalid BDAddr20");
276
277
3.57k
  MCOperand_CreateReg0(Inst, Base == 0 ? 0 : Regs[Base]);
278
3.57k
  MCOperand_CreateImm0(Inst, SignExtend64(Disp, 20));
279
3.57k
  return MCDisassembler_Success;
280
3.57k
}
281
282
static DecodeStatus decodeBDXAddr12Operand(MCInst *Inst, uint64_t Field,
283
    const unsigned *Regs)
284
18.0k
{
285
18.0k
  uint64_t Index = Field >> 16;
286
18.0k
  uint64_t Base = (Field >> 12) & 0xf;
287
18.0k
  uint64_t Disp = Field & 0xfff;
288
289
  //assert(Index < 16 && "Invalid BDXAddr12");
290
18.0k
  MCOperand_CreateReg0(Inst, Base == 0 ? 0 : Regs[Base]);
291
18.0k
  MCOperand_CreateImm0(Inst, Disp);
292
18.0k
  MCOperand_CreateReg0(Inst, Index == 0 ? 0 : Regs[Index]);
293
294
18.0k
  return MCDisassembler_Success;
295
18.0k
}
296
297
static DecodeStatus decodeBDXAddr20Operand(MCInst *Inst, uint64_t Field,
298
    const unsigned *Regs)
299
2.53k
{
300
2.53k
  uint64_t Index = Field >> 24;
301
2.53k
  uint64_t Base = (Field >> 20) & 0xf;
302
2.53k
  uint64_t Disp = ((Field & 0xfff00) >> 8) | ((Field & 0xff) << 12);
303
304
  //assert(Index < 16 && "Invalid BDXAddr20");
305
2.53k
  MCOperand_CreateReg0(Inst, Base == 0 ? 0 : Regs[Base]);
306
2.53k
  MCOperand_CreateImm0(Inst, SignExtend64(Disp, 20));
307
2.53k
  MCOperand_CreateReg0(Inst, Index == 0 ? 0 : Regs[Index]);
308
309
2.53k
  return MCDisassembler_Success;
310
2.53k
}
311
312
static DecodeStatus decodeBDLAddr12Len8Operand(MCInst *Inst, uint64_t Field,
313
    const unsigned *Regs)
314
9.47k
{
315
9.47k
  uint64_t Length = Field >> 16;
316
9.47k
  uint64_t Base = (Field >> 12) & 0xf;
317
9.47k
  uint64_t Disp = Field & 0xfff;
318
  //assert(Length < 256 && "Invalid BDLAddr12Len8");
319
320
9.47k
  MCOperand_CreateReg0(Inst, Base == 0 ? 0 : Regs[Base]);
321
9.47k
  MCOperand_CreateImm0(Inst, Disp);
322
9.47k
  MCOperand_CreateImm0(Inst, Length + 1);
323
324
9.47k
  return MCDisassembler_Success;
325
9.47k
}
326
327
static DecodeStatus decodeBDRAddr12Operand(MCInst *Inst, uint64_t Field,
328
    const unsigned *Regs)
329
867
{
330
867
  uint64_t Length = Field >> 16;
331
867
  uint64_t Base = (Field >> 12) & 0xf;
332
867
  uint64_t Disp = Field & 0xfff;
333
  //assert(Length < 16 && "Invalid BDRAddr12");
334
335
867
  MCOperand_CreateReg0(Inst, Base == 0 ? 0 : Regs[Base]);
336
867
  MCOperand_CreateImm0(Inst, Disp);
337
867
  MCOperand_CreateReg0(Inst, Regs[Length]);
338
339
867
  return MCDisassembler_Success;
340
867
}
341
342
static DecodeStatus decodeBDVAddr12Operand(MCInst *Inst, uint64_t Field,
343
    const unsigned *Regs)
344
324
{
345
324
  uint64_t Index = Field >> 16;
346
324
  uint64_t Base = (Field >> 12) & 0xf;
347
324
  uint64_t Disp = Field & 0xfff;
348
  //assert(Index < 32 && "Invalid BDVAddr12");
349
350
324
  MCOperand_CreateReg0(Inst, Base == 0 ? 0 : Regs[Base]);
351
324
  MCOperand_CreateImm0(Inst, Disp);
352
324
  MCOperand_CreateReg0(Inst, SystemZMC_VR128Regs[Index]);
353
354
324
  return MCDisassembler_Success;
355
324
}
356
357
static DecodeStatus decodeBDAddr32Disp12Operand(MCInst *Inst, uint64_t Field,
358
    uint64_t Address, const void *Decoder)
359
2.19k
{
360
2.19k
  return decodeBDAddr12Operand(Inst, Field, SystemZMC_GR32Regs);
361
2.19k
}
362
363
static DecodeStatus decodeBDAddr32Disp20Operand(MCInst *Inst, uint64_t Field,
364
    uint64_t Address, const void *Decoder)
365
705
{
366
705
  return decodeBDAddr20Operand(Inst, Field, SystemZMC_GR32Regs);
367
705
}
368
369
static DecodeStatus decodeBDAddr64Disp12Operand(MCInst *Inst, uint64_t Field,
370
    uint64_t Address, const void *Decoder)
371
17.1k
{
372
17.1k
  return decodeBDAddr12Operand(Inst, Field, SystemZMC_GR64Regs);
373
17.1k
}
374
375
static DecodeStatus decodeBDAddr64Disp20Operand(MCInst *Inst, uint64_t Field,
376
    uint64_t Address, const void *Decoder)
377
2.86k
{
378
2.86k
  return decodeBDAddr20Operand(Inst, Field, SystemZMC_GR64Regs);
379
2.86k
}
380
381
static DecodeStatus decodeBDXAddr64Disp12Operand(MCInst *Inst, uint64_t Field,
382
    uint64_t Address, const void *Decoder)
383
18.0k
{
384
18.0k
  return decodeBDXAddr12Operand(Inst, Field, SystemZMC_GR64Regs);
385
18.0k
}
386
387
static DecodeStatus decodeBDXAddr64Disp20Operand(MCInst *Inst, uint64_t Field,
388
    uint64_t Address, const void *Decoder)
389
2.53k
{
390
2.53k
  return decodeBDXAddr20Operand(Inst, Field, SystemZMC_GR64Regs);
391
2.53k
}
392
393
static DecodeStatus decodeBDLAddr64Disp12Len4Operand(MCInst *Inst, uint64_t Field,
394
    uint64_t Address, const void *Decoder)
395
5.64k
{
396
5.64k
  return decodeBDLAddr12Len8Operand(Inst, Field, SystemZMC_GR64Regs);
397
5.64k
}
398
399
static DecodeStatus decodeBDLAddr64Disp12Len8Operand(MCInst *Inst, uint64_t Field,
400
    uint64_t Address, const void *Decoder)
401
3.83k
{
402
3.83k
  return decodeBDLAddr12Len8Operand(Inst, Field, SystemZMC_GR64Regs);
403
3.83k
}
404
405
static DecodeStatus decodeBDRAddr64Disp12Operand(MCInst *Inst, uint64_t Field,
406
    uint64_t Address, const void *Decoder)
407
867
{
408
867
  return decodeBDRAddr12Operand(Inst, Field, SystemZMC_GR64Regs);
409
867
}
410
411
static DecodeStatus decodeBDVAddr64Disp12Operand(MCInst *Inst, uint64_t Field,
412
    uint64_t Address, const void *Decoder)
413
324
{
414
324
  return decodeBDVAddr12Operand(Inst, Field, SystemZMC_GR64Regs);
415
324
}
416
417
418
#define GET_SUBTARGETINFO_ENUM
419
#include "SystemZGenSubtargetInfo.inc"
420
#include "SystemZGenDisassemblerTables.inc"
421
bool SystemZ_getInstruction(csh ud, const uint8_t *code, size_t code_len, MCInst *MI,
422
    uint16_t *size, uint64_t address, void *info)
423
114k
{
424
114k
  uint64_t Inst;
425
114k
  const uint8_t *Table;
426
114k
  uint16_t I; 
427
428
  // The top 2 bits of the first byte specify the size.
429
114k
  if (*code < 0x40) {
430
30.9k
    *size = 2;
431
30.9k
    Table = DecoderTable16;
432
83.7k
  } else if (*code < 0xc0) {
433
48.1k
    *size = 4;
434
48.1k
    Table = DecoderTable32;
435
48.1k
  } else {
436
35.6k
    *size = 6;
437
35.6k
    Table = DecoderTable48;
438
35.6k
  }
439
440
114k
  if (code_len < *size)
441
    // short of input data
442
1.26k
    return false;
443
444
113k
  if (MI->flat_insn->detail) {
445
113k
    memset(MI->flat_insn->detail, 0, offsetof(cs_detail, sysz)+sizeof(cs_sysz));
446
113k
  }
447
448
  // Construct the instruction.
449
113k
  Inst = 0;
450
575k
  for (I = 0; I < *size; ++I)
451
462k
    Inst = (Inst << 8) | code[I];
452
453
113k
  return decodeInstruction(Table, MI, Inst, address, info, 0);
454
114k
}
455
456
#define GET_REGINFO_ENUM
457
#define GET_REGINFO_MC_DESC
458
#include "SystemZGenRegisterInfo.inc"
459
void SystemZ_init(MCRegisterInfo *MRI)
460
4.10k
{
461
  /*
462
  InitMCRegisterInfo(SystemZRegDesc, 98, RA, PC,
463
      SystemZMCRegisterClasses, 12,
464
      SystemZRegUnitRoots,
465
      49,
466
      SystemZRegDiffLists,
467
      SystemZRegStrings,
468
      SystemZSubRegIdxLists,
469
      7,
470
      SystemZSubRegIdxRanges,
471
      SystemZRegEncodingTable);
472
  */
473
474
4.10k
  MCRegisterInfo_InitMCRegisterInfo(MRI, SystemZRegDesc, 194,
475
4.10k
      0, 0,
476
4.10k
      SystemZMCRegisterClasses, 21,
477
4.10k
      0, 0,
478
4.10k
      SystemZRegDiffLists,
479
4.10k
      0,
480
4.10k
      SystemZSubRegIdxLists, 7,
481
4.10k
      0);
482
4.10k
}
483
484
#endif