Coverage Report

Created: 2023-09-25 06:24

/src/capstonev5/arch/Mips/MipsDisassembler.c
Line
Count
Source (jump to first uncovered line)
1
//===- MipsDisassembler.cpp - Disassembler for Mips -------------*- 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
// This file is part of the Mips Disassembler.
11
//
12
//===----------------------------------------------------------------------===//
13
14
/* Capstone Disassembly Engine */
15
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2015 */
16
17
#ifdef CAPSTONE_HAS_MIPS
18
19
#include <stdio.h>
20
#include <string.h>
21
22
#include "capstone/platform.h"
23
24
#include "MipsDisassembler.h"
25
26
#include "../../utils.h"
27
28
#include "../../MCRegisterInfo.h"
29
#include "../../SStream.h"
30
31
#include "../../MathExtras.h"
32
33
//#include "Mips.h"
34
//#include "MipsRegisterInfo.h"
35
//#include "MipsSubtarget.h"
36
#include "../../MCFixedLenDisassembler.h"
37
#include "../../MCInst.h"
38
//#include "llvm/MC/MCSubtargetInfo.h"
39
#include "../../MCRegisterInfo.h"
40
#include "../../MCDisassembler.h"
41
42
// Forward declare these because the autogenerated code will reference them.
43
// Definitions are further down.
44
static DecodeStatus DecodeGPR64RegisterClass(MCInst *Inst,
45
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
46
47
static DecodeStatus DecodeCPU16RegsRegisterClass(MCInst *Inst,
48
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
49
50
static DecodeStatus DecodeGPRMM16RegisterClass(MCInst *Inst,
51
    unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder);
52
53
static DecodeStatus DecodeGPRMM16ZeroRegisterClass(MCInst *Inst,
54
    unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder);
55
56
static DecodeStatus DecodeGPRMM16MovePRegisterClass(MCInst *Inst,
57
    unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder);
58
59
static DecodeStatus DecodeGPR32RegisterClass(MCInst *Inst,
60
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
61
62
static DecodeStatus DecodePtrRegisterClass(MCInst *Inst,
63
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
64
65
static DecodeStatus DecodeDSPRRegisterClass(MCInst *Inst,
66
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
67
68
static DecodeStatus DecodeFGR64RegisterClass(MCInst *Inst,
69
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
70
71
static DecodeStatus DecodeFGR32RegisterClass(MCInst *Inst,
72
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
73
74
static DecodeStatus DecodeCCRRegisterClass(MCInst *Inst,
75
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
76
77
static DecodeStatus DecodeFCCRegisterClass(MCInst *Inst,
78
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
79
80
static DecodeStatus DecodeCCRegisterClass(MCInst *Inst,
81
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
82
83
static DecodeStatus DecodeFGRCCRegisterClass(MCInst *Inst,
84
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
85
86
static DecodeStatus DecodeHWRegsRegisterClass(MCInst *Inst,
87
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
88
89
static DecodeStatus DecodeAFGR64RegisterClass(MCInst *Inst,
90
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
91
92
static DecodeStatus DecodeACC64DSPRegisterClass(MCInst *Inst,
93
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
94
95
static DecodeStatus DecodeHI32DSPRegisterClass(MCInst *Inst,
96
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
97
98
static DecodeStatus DecodeLO32DSPRegisterClass(MCInst *Inst,
99
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
100
101
static DecodeStatus DecodeMSA128BRegisterClass(MCInst *Inst,
102
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
103
104
static DecodeStatus DecodeMSA128HRegisterClass(MCInst *Inst,
105
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
106
107
static DecodeStatus DecodeMSA128WRegisterClass(MCInst *Inst,
108
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
109
110
static DecodeStatus DecodeMSA128DRegisterClass(MCInst *Inst,
111
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
112
113
static DecodeStatus DecodeMSACtrlRegisterClass(MCInst *Inst,
114
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
115
116
static DecodeStatus DecodeCOP2RegisterClass(MCInst *Inst,
117
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder);
118
119
static DecodeStatus DecodeBranchTarget(MCInst *Inst,
120
    unsigned Offset, uint64_t Address, const MCRegisterInfo *Decoder);
121
122
static DecodeStatus DecodeJumpTarget(MCInst *Inst,
123
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
124
125
static DecodeStatus DecodeBranchTarget21(MCInst *Inst,
126
    unsigned Offset, uint64_t Address, const MCRegisterInfo *Decoder);
127
128
static DecodeStatus DecodeBranchTarget26(MCInst *Inst,
129
    unsigned Offset, uint64_t Address, const MCRegisterInfo *Decoder);
130
131
// DecodeBranchTarget7MM - Decode microMIPS branch offset, which is
132
// shifted left by 1 bit.
133
static DecodeStatus DecodeBranchTarget7MM(MCInst *Inst,
134
    unsigned Offset, uint64_t Address, MCRegisterInfo *Decoder);
135
136
// DecodeBranchTarget10MM - Decode microMIPS branch offset, which is
137
// shifted left by 1 bit.
138
static DecodeStatus DecodeBranchTarget10MM(MCInst *Inst,
139
    unsigned Offset, uint64_t Address, MCRegisterInfo *Decoder);
140
141
// DecodeBranchTargetMM - Decode microMIPS branch offset, which is
142
// shifted left by 1 bit.
143
static DecodeStatus DecodeBranchTargetMM(MCInst *Inst,
144
    unsigned Offset, uint64_t Address, const MCRegisterInfo *Decoder);
145
146
// DecodeJumpTargetMM - Decode microMIPS jump target, which is
147
// shifted left by 1 bit.
148
static DecodeStatus DecodeJumpTargetMM(MCInst *Inst,
149
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
150
151
static DecodeStatus DecodeMem(MCInst *Inst,
152
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
153
154
static DecodeStatus DecodeCacheOp(MCInst *Inst,
155
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
156
157
static DecodeStatus DecodeCacheOpR6(MCInst *Inst,
158
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
159
160
static DecodeStatus DecodeCacheOpMM(MCInst *Inst,
161
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
162
163
static DecodeStatus DecodeSyncI(MCInst *Inst,
164
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
165
166
static DecodeStatus DecodeMSA128Mem(MCInst *Inst,
167
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
168
169
static DecodeStatus DecodeMemMMImm4(MCInst *Inst,
170
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
171
172
static DecodeStatus DecodeMemMMSPImm5Lsl2(MCInst *Inst,
173
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
174
175
static DecodeStatus DecodeMemMMGPImm7Lsl2(MCInst *Inst,
176
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
177
178
static DecodeStatus DecodeMemMMReglistImm4Lsl2(MCInst *Inst,
179
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
180
181
static DecodeStatus DecodeMemMMImm12(MCInst *Inst,
182
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
183
184
static DecodeStatus DecodeMemMMImm16(MCInst *Inst,
185
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
186
187
static DecodeStatus DecodeFMem(MCInst *Inst, unsigned Insn,
188
    uint64_t Address, const MCRegisterInfo *Decoder);
189
190
static DecodeStatus DecodeFMem2(MCInst *Inst, unsigned Insn,
191
    uint64_t Address, MCRegisterInfo *Decoder);
192
193
static DecodeStatus DecodeFMem3(MCInst *Inst, unsigned Insn,
194
    uint64_t Address, MCRegisterInfo *Decoder);
195
196
static DecodeStatus DecodeFMemCop2R6(MCInst *Inst, unsigned Insn,
197
    uint64_t Address, MCRegisterInfo *Decoder);
198
199
static DecodeStatus DecodeSpecial3LlSc(MCInst *Inst,
200
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
201
202
static DecodeStatus DecodeAddiur2Simm7(MCInst *Inst,
203
    unsigned Value, uint64_t Address, MCRegisterInfo *Decoder);
204
205
static DecodeStatus DecodeUImm6Lsl2(MCInst *Inst,
206
    unsigned Value, uint64_t Address, MCRegisterInfo *Decoder);
207
208
static DecodeStatus DecodeLiSimm7(MCInst *Inst,
209
    unsigned Value, uint64_t Address, MCRegisterInfo *Decoder);
210
211
static DecodeStatus DecodeSimm4(MCInst *Inst,
212
    unsigned Value, uint64_t Address, MCRegisterInfo *Decoder);
213
214
static DecodeStatus DecodeSimm16(MCInst *Inst,
215
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
216
217
// Decode the immediate field of an LSA instruction which
218
// is off by one.
219
static DecodeStatus DecodeLSAImm(MCInst *Inst,
220
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
221
222
static DecodeStatus DecodeInsSize(MCInst *Inst,
223
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
224
225
static DecodeStatus DecodeExtSize(MCInst *Inst,
226
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
227
228
static DecodeStatus DecodeSimm19Lsl2(MCInst *Inst,
229
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
230
231
static DecodeStatus DecodeSimm18Lsl3(MCInst *Inst,
232
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder);
233
234
static DecodeStatus DecodeSimm9SP(MCInst *Inst,
235
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
236
237
static DecodeStatus DecodeANDI16Imm(MCInst *Inst,
238
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
239
240
static DecodeStatus DecodeUImm5lsl2(MCInst *Inst,
241
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
242
243
static DecodeStatus DecodeSimm23Lsl2(MCInst *Inst,
244
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder);
245
246
/// INSVE_[BHWD] have an implicit operand that the generated decoder doesn't
247
/// handle.
248
static DecodeStatus DecodeINSVE_DF_4(MCInst *MI,
249
    uint32_t insn, uint64_t Address, const MCRegisterInfo *Decoder);
250
251
static DecodeStatus DecodeAddiGroupBranch_4(MCInst *MI,
252
    uint32_t insn, uint64_t Address, const MCRegisterInfo *Decoder);
253
254
static DecodeStatus DecodeDaddiGroupBranch_4(MCInst *MI,
255
    uint32_t insn, uint64_t Address, const MCRegisterInfo *Decoder);
256
257
static DecodeStatus DecodeBlezlGroupBranch_4(MCInst *MI,
258
    uint32_t insn, uint64_t Address, const MCRegisterInfo *Decoder);
259
260
static DecodeStatus DecodeBgtzlGroupBranch_4(MCInst *MI,
261
    uint32_t insn, uint64_t Address, const MCRegisterInfo *Decoder);
262
263
static DecodeStatus DecodeBgtzGroupBranch_4(MCInst *MI,
264
    uint32_t insn, uint64_t Address, const MCRegisterInfo *Decoder);
265
266
static DecodeStatus DecodeBlezGroupBranch_4(MCInst *MI,
267
    uint32_t insn, uint64_t Address, const MCRegisterInfo *Decoder);
268
269
static DecodeStatus DecodeRegListOperand(MCInst *Inst,
270
    uint32_t insn, uint64_t Address, const MCRegisterInfo *Decoder);
271
272
static DecodeStatus DecodeRegListOperand16(MCInst *Inst,
273
    uint32_t insn, uint64_t Address, MCRegisterInfo *Decoder);
274
275
static DecodeStatus DecodeMovePRegPair(MCInst *Inst,
276
    uint32_t insn, uint64_t Address, MCRegisterInfo *Decoder);
277
278
#define GET_SUBTARGETINFO_ENUM
279
#include "MipsGenSubtargetInfo.inc"
280
281
// Hacky: enable all features for disassembler
282
static uint64_t getFeatureBits(int mode)
283
62.2k
{
284
62.2k
  uint64_t Bits = (uint64_t)-1; // include every features at first
285
286
  // By default we do not support Mips1
287
62.2k
  Bits &= ~Mips_FeatureMips1;
288
289
  // No MicroMips
290
62.2k
  Bits &= ~Mips_FeatureMicroMips;
291
292
  // ref: MipsGenDisassemblerTables.inc::checkDecoderPredicate()
293
  // some features are mutually execlusive
294
62.2k
  if (mode & CS_MODE_16) {
295
    //Bits &= ~Mips_FeatureMips32r2;
296
    //Bits &= ~Mips_FeatureMips32;
297
    //Bits &= ~Mips_FeatureFPIdx;
298
    //Bits &= ~Mips_FeatureBitCount;
299
    //Bits &= ~Mips_FeatureSwap;
300
    //Bits &= ~Mips_FeatureSEInReg;
301
    //Bits &= ~Mips_FeatureMips64r2;
302
    //Bits &= ~Mips_FeatureFP64Bit;
303
62.2k
  } else if (mode & CS_MODE_32) {
304
14.5k
    Bits &= ~Mips_FeatureMips16;
305
14.5k
    Bits &= ~Mips_FeatureFP64Bit;
306
14.5k
    Bits &= ~Mips_FeatureMips64r2;
307
14.5k
    Bits &= ~Mips_FeatureMips32r6;
308
14.5k
    Bits &= ~Mips_FeatureMips64r6;
309
47.7k
  } else if (mode & CS_MODE_64) {
310
32.4k
    Bits &= ~Mips_FeatureMips16;
311
32.4k
    Bits &= ~Mips_FeatureMips64r6;
312
32.4k
    Bits &= ~Mips_FeatureMips32r6;
313
32.4k
  } else if (mode & CS_MODE_MIPS32R6) {
314
15.2k
    Bits |= Mips_FeatureMips32r6;
315
15.2k
    Bits &= ~Mips_FeatureMips16;
316
15.2k
    Bits &= ~Mips_FeatureFP64Bit;
317
15.2k
    Bits &= ~Mips_FeatureMips64r6;
318
15.2k
    Bits &= ~Mips_FeatureMips64r2;
319
15.2k
  }
320
321
62.2k
  if (mode & CS_MODE_MICRO) {
322
13.2k
    Bits |= Mips_FeatureMicroMips;
323
13.2k
    Bits &= ~Mips_FeatureMips4_32r2;
324
13.2k
    Bits &= ~Mips_FeatureMips2;
325
13.2k
  }
326
327
62.2k
  return Bits;
328
62.2k
}
329
330
#include "MipsGenDisassemblerTables.inc"
331
332
#define GET_REGINFO_ENUM
333
#include "MipsGenRegisterInfo.inc"
334
335
#define GET_REGINFO_MC_DESC
336
#include "MipsGenRegisterInfo.inc"
337
338
#define GET_INSTRINFO_ENUM
339
#include "MipsGenInstrInfo.inc"
340
341
void Mips_init(MCRegisterInfo *MRI)
342
1.36k
{
343
  // InitMCRegisterInfo(MipsRegDesc, 394, RA, PC,
344
  //    MipsMCRegisterClasses, 62,
345
  //    MipsRegUnitRoots,
346
  //    273,
347
  //    MipsRegDiffLists,
348
  //    MipsLaneMaskLists,
349
  //    MipsRegStrings,
350
  //    MipsRegClassStrings,
351
  //    MipsSubRegIdxLists,
352
  //    12,
353
  //    MipsSubRegIdxRanges,
354
  //    MipsRegEncodingTable);
355
356
357
1.36k
  MCRegisterInfo_InitMCRegisterInfo(MRI, MipsRegDesc, 394,
358
1.36k
      0, 0,
359
1.36k
      MipsMCRegisterClasses, 62,
360
1.36k
      0, 0,
361
1.36k
      MipsRegDiffLists,
362
1.36k
      0,
363
1.36k
      MipsSubRegIdxLists, 12,
364
1.36k
      0);
365
1.36k
}
366
367
/// Read two bytes from the ArrayRef and return 16 bit halfword sorted
368
/// according to the given endianess.
369
static void readInstruction16(unsigned char *code, uint32_t *insn,
370
    bool isBigEndian)
371
9.84k
{
372
  // We want to read exactly 2 Bytes of data.
373
9.84k
  if (isBigEndian)
374
4.62k
    *insn = (code[0] << 8) | code[1];
375
5.22k
  else
376
5.22k
    *insn = (code[1] << 8) | code[0];
377
9.84k
}
378
379
/// readInstruction - read four bytes from the MemoryObject
380
/// and return 32 bit word sorted according to the given endianess
381
static void readInstruction32(unsigned char *code, uint32_t *insn, bool isBigEndian, bool isMicroMips)
382
34.4k
{
383
  // High 16 bits of a 32-bit microMIPS instruction (where the opcode is)
384
  // always precede the low 16 bits in the instruction stream (that is, they
385
  // are placed at lower addresses in the instruction stream).
386
  //
387
  // microMIPS byte ordering:
388
  //   Big-endian:    0 | 1 | 2 | 3
389
  //   Little-endian: 1 | 0 | 3 | 2
390
391
  // We want to read exactly 4 Bytes of data.
392
34.4k
  if (isBigEndian) {
393
    // Encoded as a big-endian 32-bit word in the stream.
394
20.4k
    *insn =
395
20.4k
      (code[3] << 0) | (code[2] << 8) | (code[1] << 16) | ((uint32_t) code[0] << 24);
396
20.4k
  } else {
397
14.0k
    if (isMicroMips) {
398
2.04k
      *insn = (code[2] << 0) | (code[3] << 8) | (code[0] << 16) |
399
2.04k
        ((uint32_t) code[1] << 24);
400
11.9k
    } else {
401
11.9k
      *insn = (code[0] << 0) | (code[1] << 8) | (code[2] << 16) |
402
11.9k
        ((uint32_t) code[3] << 24);
403
11.9k
    }
404
14.0k
  }
405
34.4k
}
406
407
static DecodeStatus MipsDisassembler_getInstruction(int mode, MCInst *instr,
408
    const uint8_t *code, size_t code_len,
409
    uint16_t *Size,
410
    uint64_t Address, bool isBigEndian, MCRegisterInfo *MRI)
411
41.2k
{
412
41.2k
  uint32_t Insn;
413
41.2k
  DecodeStatus Result;
414
415
41.2k
  if (instr->flat_insn->detail) {
416
41.2k
    memset(instr->flat_insn->detail, 0, offsetof(cs_detail, mips)+sizeof(cs_mips));
417
41.2k
  }
418
419
41.2k
  if (mode & CS_MODE_MICRO) {
420
9.89k
    if (code_len < 2)
421
      // not enough data
422
45
      return MCDisassembler_Fail;
423
424
9.84k
    readInstruction16((unsigned char*)code, &Insn, isBigEndian);
425
426
    // Calling the auto-generated decoder function.
427
9.84k
    Result = decodeInstruction(DecoderTableMicroMips16, instr, Insn, Address, MRI, mode);
428
9.84k
    if (Result != MCDisassembler_Fail) {
429
6.38k
      *Size = 2;
430
6.38k
      return Result;
431
6.38k
    }
432
433
3.46k
    if (code_len < 4)
434
      // not enough data
435
41
      return MCDisassembler_Fail;
436
437
3.42k
    readInstruction32((unsigned char*)code, &Insn, isBigEndian, true);
438
439
    //DEBUG(dbgs() << "Trying MicroMips32 table (32-bit instructions):\n");
440
    // Calling the auto-generated decoder function.
441
3.42k
    Result = decodeInstruction(DecoderTableMicroMips32, instr, Insn, Address, MRI, mode);
442
3.42k
    if (Result != MCDisassembler_Fail) {
443
3.35k
      *Size = 4;
444
3.35k
      return Result;
445
3.35k
    }
446
71
    return MCDisassembler_Fail;
447
3.42k
  }
448
449
31.3k
  if (code_len < 4)
450
    // not enough data
451
324
    return MCDisassembler_Fail;
452
453
30.9k
  readInstruction32((unsigned char*)code, &Insn, isBigEndian, false);
454
455
30.9k
  if ((mode & CS_MODE_MIPS2) && ((mode & CS_MODE_MIPS3) == 0)) {
456
    // DEBUG(dbgs() << "Trying COP3_ table (32-bit opcodes):\n");
457
0
    Result = decodeInstruction(DecoderTableCOP3_32, instr, Insn, Address, MRI, mode);
458
0
    if (Result != MCDisassembler_Fail) {
459
0
      *Size = 4;
460
0
      return Result;
461
0
    }
462
0
  }
463
464
30.9k
  if ((mode & CS_MODE_MIPS32R6) && (mode & CS_MODE_MIPS64)) {
465
    // DEBUG(dbgs() << "Trying Mips32r6_64r6 (GPR64) table (32-bit opcodes):\n");
466
0
    Result = decodeInstruction(DecoderTableMips32r6_64r6_GP6432, instr, Insn,
467
0
        Address, MRI, mode);
468
0
    if (Result != MCDisassembler_Fail) {
469
0
      *Size = 4;
470
0
      return Result;
471
0
    }
472
0
  }
473
474
30.9k
  if (mode & CS_MODE_MIPS32R6) {
475
    // DEBUG(dbgs() << "Trying Mips32r6_64r6 table (32-bit opcodes):\n");
476
6.48k
    Result = decodeInstruction(DecoderTableMips32r6_64r632, instr, Insn,
477
6.48k
        Address, MRI, mode);
478
6.48k
    if (Result != MCDisassembler_Fail) {
479
2.81k
      *Size = 4;
480
2.81k
      return Result;
481
2.81k
    }
482
6.48k
  }
483
484
28.1k
  if (mode & CS_MODE_MIPS64) {
485
    // DEBUG(dbgs() << "Trying Mips64 (GPR64) table (32-bit opcodes):\n");
486
18.1k
    Result = decodeInstruction(DecoderTableMips6432, instr, Insn,
487
18.1k
        Address, MRI, mode);
488
18.1k
    if (Result != MCDisassembler_Fail) {
489
3.87k
      *Size = 4;
490
3.87k
      return Result;
491
3.87k
    }
492
18.1k
  }
493
494
  // DEBUG(dbgs() << "Trying Mips table (32-bit opcodes):\n");
495
  // Calling the auto-generated decoder function.
496
24.3k
  Result = decodeInstruction(DecoderTableMips32, instr, Insn, Address, MRI, mode);
497
24.3k
  if (Result != MCDisassembler_Fail) {
498
23.9k
    *Size = 4;
499
23.9k
    return Result;
500
23.9k
  }
501
502
307
  return MCDisassembler_Fail;
503
24.3k
}
504
505
bool Mips_getInstruction(csh ud, const uint8_t *code, size_t code_len, MCInst *instr,
506
    uint16_t *size, uint64_t address, void *info)
507
41.2k
{
508
41.2k
  cs_struct *handle = (cs_struct *)(uintptr_t)ud;
509
510
41.2k
  DecodeStatus status = MipsDisassembler_getInstruction(handle->mode, instr,
511
41.2k
      code, code_len,
512
41.2k
      size,
513
41.2k
      address, MODE_IS_BIG_ENDIAN(handle->mode), (MCRegisterInfo *)info);
514
515
41.2k
  return status == MCDisassembler_Success;
516
41.2k
}
517
518
static unsigned getReg(const MCRegisterInfo *MRI, unsigned RC, unsigned RegNo)
519
70.1k
{
520
70.1k
  const MCRegisterClass *rc = MCRegisterInfo_getRegClass(MRI, RC);
521
70.1k
  return rc->RegsBegin[RegNo];
522
70.1k
}
523
524
static DecodeStatus DecodeINSVE_DF_4(MCInst *MI, uint32_t insn,
525
    uint64_t Address, const MCRegisterInfo *Decoder)
526
164
{
527
164
  typedef DecodeStatus (*DecodeFN)(MCInst *, unsigned, uint64_t, const MCRegisterInfo *);
528
  // The size of the n field depends on the element size
529
  // The register class also depends on this.
530
164
  uint32_t tmp = fieldFromInstruction(insn, 17, 5);
531
164
  unsigned NSize = 0;
532
164
  DecodeFN RegDecoder = NULL;
533
534
164
  if ((tmp & 0x18) == 0x00) { // INSVE_B
535
129
    NSize = 4;
536
129
    RegDecoder = DecodeMSA128BRegisterClass;
537
129
  } else if ((tmp & 0x1c) == 0x10) { // INSVE_H
538
14
    NSize = 3;
539
14
    RegDecoder = DecodeMSA128HRegisterClass;
540
21
  } else if ((tmp & 0x1e) == 0x18) { // INSVE_W
541
17
    NSize = 2;
542
17
    RegDecoder = DecodeMSA128WRegisterClass;
543
17
  } else if ((tmp & 0x1f) == 0x1c) { // INSVE_D
544
4
    NSize = 1;
545
4
    RegDecoder = DecodeMSA128DRegisterClass;
546
4
  } //else llvm_unreachable("Invalid encoding");
547
548
  //assert(NSize != 0 && RegDecoder != nullptr);
549
164
  if (NSize == 0 || RegDecoder == NULL)
550
0
    return MCDisassembler_Fail;
551
552
  // $wd
553
164
  tmp = fieldFromInstruction(insn, 6, 5);
554
164
  if (RegDecoder(MI, tmp, Address, Decoder) == MCDisassembler_Fail)
555
0
    return MCDisassembler_Fail;
556
557
  // $wd_in
558
164
  if (RegDecoder(MI, tmp, Address, Decoder) == MCDisassembler_Fail)
559
0
    return MCDisassembler_Fail;
560
561
  // $n
562
164
  tmp = fieldFromInstruction(insn, 16, NSize);
563
164
  MCOperand_CreateImm0(MI, tmp);
564
565
  // $ws
566
164
  tmp = fieldFromInstruction(insn, 11, 5);
567
164
  if (RegDecoder(MI, tmp, Address, Decoder) == MCDisassembler_Fail)
568
0
    return MCDisassembler_Fail;
569
570
  // $n2
571
164
  MCOperand_CreateImm0(MI, 0);
572
573
164
  return MCDisassembler_Success;
574
164
}
575
576
static DecodeStatus DecodeAddiGroupBranch_4(MCInst *MI, uint32_t insn,
577
    uint64_t Address, const MCRegisterInfo *Decoder)
578
398
{
579
  // If we are called then we can assume that MIPS32r6/MIPS64r6 is enabled
580
  // (otherwise we would have matched the ADDI instruction from the earlier
581
  // ISA's instead).
582
  //
583
  // We have:
584
  //    0b001000 sssss ttttt iiiiiiiiiiiiiiii
585
  //      BOVC if rs >= rt
586
  //      BEQZALC if rs == 0 && rt != 0
587
  //      BEQC if rs < rt && rs != 0
588
589
398
  uint32_t Rs = fieldFromInstruction(insn, 21, 5);
590
398
  uint32_t Rt = fieldFromInstruction(insn, 16, 5);
591
398
  uint32_t Imm = (uint32_t)SignExtend64(fieldFromInstruction(insn, 0, 16), 16) * 4;
592
398
  bool HasRs = false;
593
594
398
  if (Rs >= Rt) {
595
204
    MCInst_setOpcode(MI, Mips_BOVC);
596
204
    HasRs = true;
597
204
  } else if (Rs != 0 && Rs < Rt) {
598
143
    MCInst_setOpcode(MI, Mips_BEQC);
599
143
    HasRs = true;
600
143
  } else
601
51
    MCInst_setOpcode(MI, Mips_BEQZALC);
602
603
398
  if (HasRs)
604
347
    MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rs));
605
606
398
  MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rt));
607
398
  MCOperand_CreateImm0(MI, Imm);
608
609
398
  return MCDisassembler_Success;
610
398
}
611
612
static DecodeStatus DecodeDaddiGroupBranch_4(MCInst *MI, uint32_t insn,
613
    uint64_t Address, const MCRegisterInfo *Decoder)
614
237
{
615
  // If we are called then we can assume that MIPS32r6/MIPS64r6 is enabled
616
  // (otherwise we would have matched the ADDI instruction from the earlier
617
  // ISA's instead).
618
  //
619
  // We have:
620
  //    0b011000 sssss ttttt iiiiiiiiiiiiiiii
621
  //      BNVC if rs >= rt
622
  //      BNEZALC if rs == 0 && rt != 0
623
  //      BNEC if rs < rt && rs != 0
624
625
237
  uint32_t Rs = fieldFromInstruction(insn, 21, 5);
626
237
  uint32_t Rt = fieldFromInstruction(insn, 16, 5);
627
237
  uint32_t Imm = (uint32_t)SignExtend64(fieldFromInstruction(insn, 0, 16), 16) * 4;
628
237
  bool HasRs = false;
629
630
237
  if (Rs >= Rt) {
631
56
    MCInst_setOpcode(MI, Mips_BNVC);
632
56
    HasRs = true;
633
181
  } else if (Rs != 0 && Rs < Rt) {
634
107
    MCInst_setOpcode(MI, Mips_BNEC);
635
107
    HasRs = true;
636
107
  } else
637
74
    MCInst_setOpcode(MI, Mips_BNEZALC);
638
639
237
  if (HasRs)
640
163
    MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rs));
641
642
237
  MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rt));
643
237
  MCOperand_CreateImm0(MI, Imm);
644
645
237
  return MCDisassembler_Success;
646
237
}
647
648
static DecodeStatus DecodeBlezlGroupBranch_4(MCInst *MI, uint32_t insn,
649
    uint64_t Address, const MCRegisterInfo *Decoder)
650
481
{
651
  // If we are called then we can assume that MIPS32r6/MIPS64r6 is enabled
652
  // (otherwise we would have matched the BLEZL instruction from the earlier
653
  // ISA's instead).
654
  //
655
  // We have:
656
  //    0b010110 sssss ttttt iiiiiiiiiiiiiiii
657
  //      Invalid if rs == 0
658
  //      BLEZC   if rs == 0  && rt != 0
659
  //      BGEZC   if rs == rt && rt != 0
660
  //      BGEC    if rs != rt && rs != 0  && rt != 0
661
662
481
  uint32_t Rs = fieldFromInstruction(insn, 21, 5);
663
481
  uint32_t Rt = fieldFromInstruction(insn, 16, 5);
664
481
  uint32_t Imm = (uint32_t)SignExtend64(fieldFromInstruction(insn, 0, 16), 16) * 4;
665
481
  bool HasRs = false;
666
667
481
  if (Rt == 0)
668
2
    return MCDisassembler_Fail;
669
479
  else if (Rs == 0)
670
231
    MCInst_setOpcode(MI, Mips_BLEZC);
671
248
  else if (Rs == Rt)
672
3
    MCInst_setOpcode(MI, Mips_BGEZC);
673
245
  else {
674
245
    HasRs = true;
675
245
    MCInst_setOpcode(MI, Mips_BGEC);
676
245
  }
677
678
479
  if (HasRs)
679
245
    MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rs));
680
681
479
  MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rt));
682
683
479
  MCOperand_CreateImm0(MI, Imm);
684
685
479
  return MCDisassembler_Success;
686
481
}
687
688
static DecodeStatus DecodeBgtzlGroupBranch_4(MCInst *MI, uint32_t insn,
689
    uint64_t Address, const MCRegisterInfo *Decoder)
690
114
{
691
  // If we are called then we can assume that MIPS32r6/MIPS64r6 is enabled
692
  // (otherwise we would have matched the BGTZL instruction from the earlier
693
  // ISA's instead).
694
  //
695
  // We have:
696
  //    0b010111 sssss ttttt iiiiiiiiiiiiiiii
697
  //      Invalid if rs == 0
698
  //      BGTZC   if rs == 0  && rt != 0
699
  //      BLTZC   if rs == rt && rt != 0
700
  //      BLTC    if rs != rt && rs != 0  && rt != 0
701
702
114
  bool HasRs = false;
703
704
114
  uint32_t Rs = fieldFromInstruction(insn, 21, 5);
705
114
  uint32_t Rt = fieldFromInstruction(insn, 16, 5);
706
114
  uint32_t Imm = (uint32_t)SignExtend64(fieldFromInstruction(insn, 0, 16), 16) * 4;
707
708
114
  if (Rt == 0)
709
1
    return MCDisassembler_Fail;
710
113
  else if (Rs == 0)
711
36
    MCInst_setOpcode(MI, Mips_BGTZC);
712
77
  else if (Rs == Rt)
713
22
    MCInst_setOpcode(MI, Mips_BLTZC);
714
55
  else {
715
55
    MCInst_setOpcode(MI, Mips_BLTC);
716
55
    HasRs = true;
717
55
  }
718
719
113
  if (HasRs)
720
55
    MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rs));
721
722
113
  MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rt));
723
113
  MCOperand_CreateImm0(MI, Imm);
724
725
113
  return MCDisassembler_Success;
726
114
}
727
728
static DecodeStatus DecodeBgtzGroupBranch_4(MCInst *MI, uint32_t insn,
729
    uint64_t Address, const MCRegisterInfo *Decoder)
730
340
{
731
  // If we are called then we can assume that MIPS32r6/MIPS64r6 is enabled
732
  // (otherwise we would have matched the BGTZ instruction from the earlier
733
  // ISA's instead).
734
  //
735
  // We have:
736
  //    0b000111 sssss ttttt iiiiiiiiiiiiiiii
737
  //      BGTZ    if rt == 0
738
  //      BGTZALC if rs == 0 && rt != 0
739
  //      BLTZALC if rs != 0 && rs == rt
740
  //      BLTUC   if rs != 0 && rs != rt
741
742
340
  uint32_t Rs = fieldFromInstruction(insn, 21, 5);
743
340
  uint32_t Rt = fieldFromInstruction(insn, 16, 5);
744
340
  uint32_t Imm = (uint32_t)SignExtend64(fieldFromInstruction(insn, 0, 16), 16) * 4;
745
340
  bool HasRs = false;
746
340
  bool HasRt = false;
747
748
340
  if (Rt == 0) {
749
8
    MCInst_setOpcode(MI, Mips_BGTZ);
750
8
    HasRs = true;
751
332
  } else if (Rs == 0) {
752
63
    MCInst_setOpcode(MI, Mips_BGTZALC);
753
63
    HasRt = true;
754
269
  } else if (Rs == Rt) {
755
44
    MCInst_setOpcode(MI, Mips_BLTZALC);
756
44
    HasRs = true;
757
225
  } else {
758
225
    MCInst_setOpcode(MI, Mips_BLTUC);
759
225
    HasRs = true;
760
225
    HasRt = true;
761
225
  }
762
763
340
  if (HasRs)
764
277
    MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rs));
765
766
340
  if (HasRt)
767
288
    MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rt));
768
769
340
  MCOperand_CreateImm0(MI, Imm);
770
771
340
  return MCDisassembler_Success;
772
340
}
773
774
static DecodeStatus DecodeBlezGroupBranch_4(MCInst *MI, uint32_t insn,
775
    uint64_t Address, const MCRegisterInfo *Decoder)
776
191
{
777
  // If we are called then we can assume that MIPS32r6/MIPS64r6 is enabled
778
  // (otherwise we would have matched the BLEZL instruction from the earlier
779
  // ISA's instead).
780
  //
781
  // We have:
782
  //    0b000110 sssss ttttt iiiiiiiiiiiiiiii
783
  //      Invalid   if rs == 0
784
  //      BLEZALC   if rs == 0  && rt != 0
785
  //      BGEZALC   if rs == rt && rt != 0
786
  //      BGEUC     if rs != rt && rs != 0  && rt != 0
787
788
191
  uint32_t Rs = fieldFromInstruction(insn, 21, 5);
789
191
  uint32_t Rt = fieldFromInstruction(insn, 16, 5);
790
191
  uint32_t Imm = (uint32_t)SignExtend64(fieldFromInstruction(insn, 0, 16), 16) * 4;
791
191
  bool HasRs = false;
792
793
191
  if (Rt == 0)
794
45
    return MCDisassembler_Fail;
795
146
  else if (Rs == 0)
796
39
    MCInst_setOpcode(MI, Mips_BLEZALC);
797
107
  else if (Rs == Rt)
798
6
    MCInst_setOpcode(MI, Mips_BGEZALC);
799
101
  else {
800
101
    HasRs = true;
801
101
    MCInst_setOpcode(MI, Mips_BGEUC);
802
101
  }
803
804
146
  if (HasRs)
805
101
    MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rs));
806
807
146
  MCOperand_CreateReg0(MI, getReg(Decoder, Mips_GPR32RegClassID, Rt));
808
809
146
  MCOperand_CreateImm0(MI, Imm);
810
811
146
  return MCDisassembler_Success;
812
191
}
813
814
static DecodeStatus DecodeCPU16RegsRegisterClass(MCInst *Inst,
815
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
816
0
{
817
0
  return MCDisassembler_Fail;
818
0
}
819
820
static DecodeStatus DecodeGPR64RegisterClass(MCInst *Inst,
821
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
822
3.68k
{
823
3.68k
  unsigned Reg;
824
825
3.68k
  if (RegNo > 31)
826
0
    return MCDisassembler_Fail;
827
828
3.68k
  Reg = getReg(Decoder, Mips_GPR64RegClassID, RegNo);
829
3.68k
  MCOperand_CreateReg0(Inst, Reg);
830
3.68k
  return MCDisassembler_Success;
831
3.68k
}
832
833
static DecodeStatus DecodeGPRMM16RegisterClass(MCInst *Inst,
834
    unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
835
7.06k
{
836
7.06k
  unsigned Reg;
837
838
7.06k
  if (RegNo > 7)
839
0
    return MCDisassembler_Fail;
840
841
7.06k
  Reg = getReg(Decoder, Mips_GPRMM16RegClassID, RegNo);
842
7.06k
  MCOperand_CreateReg0(Inst, Reg);
843
7.06k
  return MCDisassembler_Success;
844
7.06k
}
845
846
static DecodeStatus DecodeGPRMM16ZeroRegisterClass(MCInst *Inst,
847
    unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
848
428
{
849
428
  unsigned Reg;
850
851
428
  if (RegNo > 7)
852
0
    return MCDisassembler_Fail;
853
854
428
  Reg = getReg(Decoder, Mips_GPRMM16ZeroRegClassID, RegNo);
855
428
  MCOperand_CreateReg0(Inst, Reg);
856
428
  return MCDisassembler_Success;
857
428
}
858
859
static DecodeStatus DecodeGPRMM16MovePRegisterClass(MCInst *Inst,
860
    unsigned RegNo, uint64_t Address, MCRegisterInfo *Decoder)
861
540
{
862
540
  unsigned Reg;
863
864
540
  if (RegNo > 7)
865
0
    return MCDisassembler_Fail;
866
867
540
  Reg = getReg(Decoder, Mips_GPRMM16MovePRegClassID, RegNo);
868
540
  MCOperand_CreateReg0(Inst, Reg);
869
540
  return MCDisassembler_Success;
870
540
}
871
872
static DecodeStatus DecodeGPR32RegisterClass(MCInst *Inst,
873
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
874
26.2k
{
875
26.2k
  unsigned Reg;
876
877
26.2k
  if (RegNo > 31)
878
0
    return MCDisassembler_Fail;
879
880
26.2k
  Reg = getReg(Decoder, Mips_GPR32RegClassID, RegNo);
881
26.2k
  MCOperand_CreateReg0(Inst, Reg);
882
26.2k
  return MCDisassembler_Success;
883
26.2k
}
884
885
static DecodeStatus DecodePtrRegisterClass(MCInst *Inst,
886
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
887
396
{
888
  // if (static_cast<const MipsDisassembler *>(Decoder)->isGP64())
889
396
  if (Inst->csh->mode & CS_MODE_MIPS64)
890
234
    return DecodeGPR64RegisterClass(Inst, RegNo, Address, Decoder);
891
892
162
  return DecodeGPR32RegisterClass(Inst, RegNo, Address, Decoder);
893
396
}
894
895
static DecodeStatus DecodeDSPRRegisterClass(MCInst *Inst,
896
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
897
474
{
898
474
  return DecodeGPR32RegisterClass(Inst, RegNo, Address, Decoder);
899
474
}
900
901
static DecodeStatus DecodeFGR64RegisterClass(MCInst *Inst,
902
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
903
1.05k
{
904
1.05k
  unsigned Reg;
905
906
1.05k
  if (RegNo > 31)
907
0
    return MCDisassembler_Fail;
908
909
1.05k
  Reg = getReg(Decoder, Mips_FGR64RegClassID, RegNo);
910
1.05k
  MCOperand_CreateReg0(Inst, Reg);
911
1.05k
  return MCDisassembler_Success;
912
1.05k
}
913
914
static DecodeStatus DecodeFGR32RegisterClass(MCInst *Inst,
915
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
916
817
{
917
817
  unsigned Reg;
918
919
817
  if (RegNo > 31)
920
0
    return MCDisassembler_Fail;
921
922
817
  Reg = getReg(Decoder, Mips_FGR32RegClassID, RegNo);
923
817
  MCOperand_CreateReg0(Inst, Reg);
924
817
  return MCDisassembler_Success;
925
817
}
926
927
static DecodeStatus DecodeCCRRegisterClass(MCInst *Inst,
928
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
929
15
{
930
15
  unsigned Reg;
931
932
15
  if (RegNo > 31)
933
0
    return MCDisassembler_Fail;
934
935
15
  Reg = getReg(Decoder, Mips_CCRRegClassID, RegNo);
936
15
  MCOperand_CreateReg0(Inst, Reg);
937
15
  return MCDisassembler_Success;
938
15
}
939
940
static DecodeStatus DecodeFCCRegisterClass(MCInst *Inst,
941
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
942
500
{
943
500
  unsigned Reg;
944
945
500
  if (RegNo > 7)
946
0
    return MCDisassembler_Fail;
947
948
500
  Reg = getReg(Decoder, Mips_FCCRegClassID, RegNo);
949
500
  MCOperand_CreateReg0(Inst, Reg);
950
500
  return MCDisassembler_Success;
951
500
}
952
953
static DecodeStatus DecodeCCRegisterClass(MCInst *Inst,
954
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
955
1.56k
{
956
1.56k
  unsigned Reg;
957
958
1.56k
  if (RegNo > 7)
959
0
    return MCDisassembler_Fail;
960
961
1.56k
  Reg = getReg(Decoder, Mips_CCRegClassID, RegNo);
962
1.56k
  MCOperand_CreateReg0(Inst, Reg);
963
1.56k
  return MCDisassembler_Success;
964
1.56k
}
965
966
static DecodeStatus DecodeFGRCCRegisterClass(MCInst *Inst,
967
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
968
97
{
969
97
  unsigned Reg;
970
971
97
  if (RegNo > 31)
972
0
    return MCDisassembler_Fail;
973
974
97
  Reg = getReg(Decoder, Mips_FGRCCRegClassID, RegNo);
975
97
  MCOperand_CreateReg0(Inst, Reg);
976
97
  return MCDisassembler_Success;
977
97
}
978
979
static DecodeStatus DecodeMem(MCInst *Inst,
980
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
981
3.45k
{
982
3.45k
  int Offset = SignExtend32(Insn & 0xffff, 16);
983
3.45k
  unsigned Reg = fieldFromInstruction(Insn, 16, 5);
984
3.45k
  unsigned Base = fieldFromInstruction(Insn, 21, 5);
985
3.45k
  int opcode = MCInst_getOpcode(Inst);
986
987
3.45k
  Reg = getReg(Decoder, Mips_GPR32RegClassID, Reg);
988
3.45k
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
989
990
3.45k
  if (opcode == Mips_SC || opcode == Mips_SCD) {
991
474
    MCOperand_CreateReg0(Inst, Reg);
992
474
  }
993
994
3.45k
  MCOperand_CreateReg0(Inst, Reg);
995
3.45k
  MCOperand_CreateReg0(Inst, Base);
996
3.45k
  MCOperand_CreateImm0(Inst, Offset);
997
998
3.45k
  return MCDisassembler_Success;
999
3.45k
}
1000
1001
static DecodeStatus DecodeCacheOp(MCInst *Inst,
1002
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1003
299
{
1004
299
  int Offset = SignExtend32(Insn & 0xffff, 16);
1005
299
  unsigned Hint = fieldFromInstruction(Insn, 16, 5);
1006
299
  unsigned Base = fieldFromInstruction(Insn, 21, 5);
1007
1008
299
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1009
1010
299
  MCOperand_CreateReg0(Inst, Base);
1011
299
  MCOperand_CreateImm0(Inst, Offset);
1012
299
  MCOperand_CreateImm0(Inst, Hint);
1013
1014
299
  return MCDisassembler_Success;
1015
299
}
1016
1017
static DecodeStatus DecodeCacheOpMM(MCInst *Inst,
1018
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1019
10
{
1020
10
  int Offset = SignExtend32(Insn & 0xfff, 12);
1021
10
  unsigned Base = fieldFromInstruction(Insn, 16, 5);
1022
10
  unsigned Hint = fieldFromInstruction(Insn, 21, 5);
1023
1024
10
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1025
1026
10
  MCOperand_CreateReg0(Inst, Base);
1027
10
  MCOperand_CreateImm0(Inst, Offset);
1028
10
  MCOperand_CreateImm0(Inst, Hint);
1029
1030
10
  return MCDisassembler_Success;
1031
10
}
1032
1033
static DecodeStatus DecodeCacheOpR6(MCInst *Inst,
1034
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1035
3
{
1036
3
  int Offset = fieldFromInstruction(Insn, 7, 9);
1037
3
  unsigned Hint = fieldFromInstruction(Insn, 16, 5);
1038
3
  unsigned Base = fieldFromInstruction(Insn, 21, 5);
1039
1040
3
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1041
1042
3
  MCOperand_CreateReg0(Inst, Base);
1043
3
  MCOperand_CreateImm0(Inst, Offset);
1044
3
  MCOperand_CreateImm0(Inst, Hint);
1045
1046
3
  return MCDisassembler_Success;
1047
3
}
1048
1049
static DecodeStatus DecodeSyncI(MCInst *Inst,
1050
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1051
26
{
1052
26
  int Offset = SignExtend32(Insn & 0xffff, 16);
1053
26
  unsigned Base = fieldFromInstruction(Insn, 21, 5);
1054
1055
26
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1056
1057
26
  MCOperand_CreateReg0(Inst, Base);
1058
26
  MCOperand_CreateImm0(Inst, Offset);
1059
1060
26
  return MCDisassembler_Success;
1061
26
}
1062
1063
static DecodeStatus DecodeMSA128Mem(MCInst *Inst, unsigned Insn,
1064
    uint64_t Address, const MCRegisterInfo *Decoder)
1065
567
{
1066
567
  int Offset = SignExtend32(fieldFromInstruction(Insn, 16, 10), 10);
1067
567
  unsigned Reg = fieldFromInstruction(Insn, 6, 5);
1068
567
  unsigned Base = fieldFromInstruction(Insn, 11, 5);
1069
1070
567
  Reg = getReg(Decoder, Mips_MSA128BRegClassID, Reg);
1071
567
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1072
1073
567
  MCOperand_CreateReg0(Inst, Reg);
1074
567
  MCOperand_CreateReg0(Inst, Base);
1075
  // MCOperand_CreateImm0(Inst, Offset);
1076
1077
  // The immediate field of an LD/ST instruction is scaled which means it must
1078
  // be multiplied (when decoding) by the size (in bytes) of the instructions'
1079
  // data format.
1080
  // .b - 1 byte
1081
  // .h - 2 bytes
1082
  // .w - 4 bytes
1083
  // .d - 8 bytes
1084
567
  switch(MCInst_getOpcode(Inst)) {
1085
0
    default:
1086
      //assert (0 && "Unexpected instruction");
1087
0
      return MCDisassembler_Fail;
1088
0
      break;
1089
312
    case Mips_LD_B:
1090
337
    case Mips_ST_B:
1091
337
      MCOperand_CreateImm0(Inst, Offset);
1092
337
      break;
1093
101
    case Mips_LD_H:
1094
130
    case Mips_ST_H:
1095
130
      MCOperand_CreateImm0(Inst, Offset * 2);
1096
130
      break;
1097
19
    case Mips_LD_W:
1098
40
    case Mips_ST_W:
1099
40
      MCOperand_CreateImm0(Inst, Offset * 4);
1100
40
      break;
1101
26
    case Mips_LD_D:
1102
60
    case Mips_ST_D:
1103
60
      MCOperand_CreateImm0(Inst, Offset * 8);
1104
60
      break;
1105
567
  }
1106
1107
567
  return MCDisassembler_Success;
1108
567
}
1109
1110
static DecodeStatus DecodeMemMMImm4(MCInst *Inst,
1111
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1112
1.54k
{
1113
1.54k
  unsigned Offset = Insn & 0xf;
1114
1.54k
  unsigned Reg = fieldFromInstruction(Insn, 7, 3);
1115
1.54k
  unsigned Base = fieldFromInstruction(Insn, 4, 3);
1116
1117
1.54k
  switch (MCInst_getOpcode(Inst)) {
1118
407
    case Mips_LBU16_MM:
1119
896
    case Mips_LHU16_MM:
1120
1.11k
    case Mips_LW16_MM:
1121
1.11k
      if (DecodeGPRMM16RegisterClass(Inst, Reg, Address, Decoder)
1122
1.11k
          == MCDisassembler_Fail)
1123
0
        return MCDisassembler_Fail;
1124
1.11k
      break;
1125
1.11k
    case Mips_SB16_MM:
1126
401
    case Mips_SH16_MM:
1127
428
    case Mips_SW16_MM:
1128
428
      if (DecodeGPRMM16ZeroRegisterClass(Inst, Reg, Address, Decoder)
1129
428
          == MCDisassembler_Fail)
1130
0
        return MCDisassembler_Fail;
1131
428
      break;
1132
1.54k
  }
1133
1134
1.54k
  if (DecodeGPRMM16RegisterClass(Inst, Base, Address, Decoder)
1135
1.54k
      == MCDisassembler_Fail)
1136
0
    return MCDisassembler_Fail;
1137
1138
1.54k
  switch (MCInst_getOpcode(Inst)) {
1139
407
    case Mips_LBU16_MM:
1140
407
      if (Offset == 0xf)
1141
40
        MCOperand_CreateImm0(Inst, -1);
1142
367
      else
1143
367
        MCOperand_CreateImm0(Inst, Offset);
1144
407
      break;
1145
206
    case Mips_SB16_MM:
1146
206
      MCOperand_CreateImm0(Inst, Offset);
1147
206
      break;
1148
489
    case Mips_LHU16_MM:
1149
684
    case Mips_SH16_MM:
1150
684
      MCOperand_CreateImm0(Inst, Offset << 1);
1151
684
      break;
1152
218
    case Mips_LW16_MM:
1153
245
    case Mips_SW16_MM:
1154
245
      MCOperand_CreateImm0(Inst, Offset << 2);
1155
245
      break;
1156
1.54k
  }
1157
1158
1.54k
  return MCDisassembler_Success;
1159
1.54k
}
1160
1161
static DecodeStatus DecodeMemMMSPImm5Lsl2(MCInst *Inst,
1162
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1163
304
{
1164
304
  unsigned Offset = Insn & 0x1F;
1165
304
  unsigned Reg = fieldFromInstruction(Insn, 5, 5);
1166
1167
304
  Reg = getReg(Decoder, Mips_GPR32RegClassID, Reg);
1168
1169
304
  MCOperand_CreateReg0(Inst, Reg);
1170
304
  MCOperand_CreateReg0(Inst, Mips_SP);
1171
304
  MCOperand_CreateImm0(Inst, Offset << 2);
1172
1173
304
  return MCDisassembler_Success;
1174
304
}
1175
1176
static DecodeStatus DecodeMemMMGPImm7Lsl2(MCInst *Inst,
1177
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1178
225
{
1179
225
  unsigned Offset = Insn & 0x7F;
1180
225
  unsigned Reg = fieldFromInstruction(Insn, 7, 3);
1181
1182
225
  Reg = getReg(Decoder, Mips_GPR32RegClassID, Reg);
1183
1184
225
  MCOperand_CreateReg0(Inst, Reg);
1185
225
  MCOperand_CreateReg0(Inst, Mips_GP);
1186
225
  MCOperand_CreateImm0(Inst, Offset << 2);
1187
1188
225
  return MCDisassembler_Success;
1189
225
}
1190
1191
static DecodeStatus DecodeMemMMReglistImm4Lsl2(MCInst *Inst,
1192
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1193
262
{
1194
262
  int Offset = SignExtend32(Insn & 0xf, 4);
1195
1196
262
  if (DecodeRegListOperand16(Inst, Insn, Address, Decoder) == MCDisassembler_Fail)
1197
0
    return MCDisassembler_Fail;
1198
1199
262
  MCOperand_CreateReg0(Inst, Mips_SP);
1200
262
  MCOperand_CreateImm0(Inst, Offset * 4);
1201
1202
262
  return MCDisassembler_Success;
1203
262
}
1204
1205
static DecodeStatus DecodeMemMMImm12(MCInst *Inst,
1206
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1207
170
{
1208
170
  int Offset = SignExtend32(Insn & 0x0fff, 12);
1209
170
  unsigned Reg = fieldFromInstruction(Insn, 21, 5);
1210
170
  unsigned Base = fieldFromInstruction(Insn, 16, 5);
1211
1212
170
  Reg = getReg(Decoder, Mips_GPR32RegClassID, Reg);
1213
170
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1214
1215
170
  switch (MCInst_getOpcode(Inst)) {
1216
6
    case Mips_SWM32_MM:
1217
108
    case Mips_LWM32_MM:
1218
108
      if (DecodeRegListOperand(Inst, Insn, Address, Decoder)
1219
108
          == MCDisassembler_Fail)
1220
1
        return MCDisassembler_Fail;
1221
107
      MCOperand_CreateReg0(Inst, Base);
1222
107
      MCOperand_CreateImm0(Inst, Offset);
1223
107
      break;
1224
7
    case Mips_SC_MM:
1225
7
      MCOperand_CreateReg0(Inst, Reg);
1226
      // fallthrough
1227
62
    default:
1228
62
      MCOperand_CreateReg0(Inst, Reg);
1229
62
      if (MCInst_getOpcode(Inst) == Mips_LWP_MM || MCInst_getOpcode(Inst) == Mips_SWP_MM)
1230
17
        MCOperand_CreateReg0(Inst, Reg + 1);
1231
1232
62
      MCOperand_CreateReg0(Inst, Base);
1233
62
      MCOperand_CreateImm0(Inst, Offset);
1234
170
  }
1235
1236
169
  return MCDisassembler_Success;
1237
170
}
1238
1239
static DecodeStatus DecodeMemMMImm16(MCInst *Inst,
1240
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1241
1.06k
{
1242
1.06k
  int Offset = SignExtend32(Insn & 0xffff, 16);
1243
1.06k
  unsigned Reg = fieldFromInstruction(Insn, 21, 5);
1244
1.06k
  unsigned Base = fieldFromInstruction(Insn, 16, 5);
1245
1246
1.06k
  Reg = getReg(Decoder, Mips_GPR32RegClassID, Reg);
1247
1.06k
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1248
1249
1.06k
  MCOperand_CreateReg0(Inst, Reg);
1250
1.06k
  MCOperand_CreateReg0(Inst, Base);
1251
1.06k
  MCOperand_CreateImm0(Inst, Offset);
1252
1253
1.06k
  return MCDisassembler_Success;
1254
1.06k
}
1255
1256
static DecodeStatus DecodeFMem(MCInst *Inst,
1257
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1258
1.02k
{
1259
1.02k
  int Offset = SignExtend32(Insn & 0xffff, 16);
1260
1.02k
  unsigned Reg = fieldFromInstruction(Insn, 16, 5);
1261
1.02k
  unsigned Base = fieldFromInstruction(Insn, 21, 5);
1262
1263
1.02k
  Reg = getReg(Decoder, Mips_FGR64RegClassID, Reg);
1264
1.02k
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1265
1266
1.02k
  MCOperand_CreateReg0(Inst, Reg);
1267
1.02k
  MCOperand_CreateReg0(Inst, Base);
1268
1.02k
  MCOperand_CreateImm0(Inst, Offset);
1269
1270
1.02k
  return MCDisassembler_Success;
1271
1.02k
}
1272
1273
static DecodeStatus DecodeFMem2(MCInst *Inst,
1274
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1275
431
{
1276
431
  int Offset = SignExtend32(Insn & 0xffff, 16);
1277
431
  unsigned Reg = fieldFromInstruction(Insn, 16, 5);
1278
431
  unsigned Base = fieldFromInstruction(Insn, 21, 5);
1279
1280
431
  Reg = getReg(Decoder, Mips_COP2RegClassID, Reg);
1281
431
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1282
1283
431
  MCOperand_CreateReg0(Inst, Reg);
1284
431
  MCOperand_CreateReg0(Inst, Base);
1285
431
  MCOperand_CreateImm0(Inst, Offset);
1286
1287
431
  return MCDisassembler_Success;
1288
431
}
1289
1290
static DecodeStatus DecodeFMem3(MCInst *Inst,
1291
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1292
0
{
1293
0
  int Offset = SignExtend32(Insn & 0xffff, 16);
1294
0
  unsigned Reg = fieldFromInstruction(Insn, 16, 5);
1295
0
  unsigned Base = fieldFromInstruction(Insn, 21, 5);
1296
1297
0
  Reg = getReg(Decoder, Mips_COP3RegClassID, Reg);
1298
0
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1299
1300
0
  MCOperand_CreateReg0(Inst, Reg);
1301
0
  MCOperand_CreateReg0(Inst, Base);
1302
0
  MCOperand_CreateImm0(Inst, Offset);
1303
1304
0
  return MCDisassembler_Success;
1305
0
}
1306
1307
static DecodeStatus DecodeFMemCop2R6(MCInst *Inst,
1308
    unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
1309
182
{
1310
182
  int Offset = SignExtend32(Insn & 0x07ff, 11);
1311
182
  unsigned Reg = fieldFromInstruction(Insn, 16, 5);
1312
182
  unsigned Base = fieldFromInstruction(Insn, 11, 5);
1313
1314
182
  Reg = getReg(Decoder, Mips_COP2RegClassID, Reg);
1315
182
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1316
1317
182
  MCOperand_CreateReg0(Inst, Reg);
1318
182
  MCOperand_CreateReg0(Inst, Base);
1319
182
  MCOperand_CreateImm0(Inst, Offset);
1320
1321
182
  return MCDisassembler_Success;
1322
182
}
1323
1324
static DecodeStatus DecodeSpecial3LlSc(MCInst *Inst,
1325
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1326
116
{
1327
116
  int64_t Offset = SignExtend64((Insn >> 7) & 0x1ff, 9);
1328
116
  unsigned Rt = fieldFromInstruction(Insn, 16, 5);
1329
116
  unsigned Base = fieldFromInstruction(Insn, 21, 5);
1330
1331
116
  Rt = getReg(Decoder, Mips_GPR32RegClassID, Rt);
1332
116
  Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
1333
1334
116
  if (MCInst_getOpcode(Inst) == Mips_SC_R6 ||
1335
116
      MCInst_getOpcode(Inst) == Mips_SCD_R6) {
1336
102
    MCOperand_CreateReg0(Inst, Rt);
1337
102
  }
1338
1339
116
  MCOperand_CreateReg0(Inst, Rt);
1340
116
  MCOperand_CreateReg0(Inst, Base);
1341
116
  MCOperand_CreateImm0(Inst, Offset);
1342
1343
116
  return MCDisassembler_Success;
1344
116
}
1345
1346
static DecodeStatus DecodeHWRegsRegisterClass(MCInst *Inst,
1347
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1348
21
{
1349
  // Currently only hardware register 29 is supported.
1350
21
  if (RegNo != 29)
1351
0
    return  MCDisassembler_Fail;
1352
1353
21
  MCOperand_CreateReg0(Inst, Mips_HWR29);
1354
1355
21
  return MCDisassembler_Success;
1356
21
}
1357
1358
static DecodeStatus DecodeAFGR64RegisterClass(MCInst *Inst,
1359
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1360
262
{
1361
262
  unsigned Reg;
1362
1363
262
  if (RegNo > 30 || RegNo % 2)
1364
8
    return MCDisassembler_Fail;
1365
1366
254
  Reg = getReg(Decoder, Mips_AFGR64RegClassID, RegNo /2);
1367
254
  MCOperand_CreateReg0(Inst, Reg);
1368
1369
254
  return MCDisassembler_Success;
1370
262
}
1371
1372
static DecodeStatus DecodeACC64DSPRegisterClass(MCInst *Inst,
1373
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1374
272
{
1375
272
  unsigned Reg;
1376
1377
272
  if (RegNo >= 4)
1378
0
    return MCDisassembler_Fail;
1379
1380
272
  Reg = getReg(Decoder, Mips_ACC64DSPRegClassID, RegNo);
1381
272
  MCOperand_CreateReg0(Inst, Reg);
1382
272
  return MCDisassembler_Success;
1383
272
}
1384
1385
static DecodeStatus DecodeHI32DSPRegisterClass(MCInst *Inst,
1386
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1387
3
{
1388
3
  unsigned Reg;
1389
1390
3
  if (RegNo >= 4)
1391
0
    return MCDisassembler_Fail;
1392
1393
3
  Reg = getReg(Decoder, Mips_HI32DSPRegClassID, RegNo);
1394
3
  MCOperand_CreateReg0(Inst, Reg);
1395
1396
3
  return MCDisassembler_Success;
1397
3
}
1398
1399
static DecodeStatus DecodeLO32DSPRegisterClass(MCInst *Inst,
1400
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1401
33
{
1402
33
  unsigned Reg;
1403
1404
33
  if (RegNo >= 4)
1405
0
    return MCDisassembler_Fail;
1406
1407
33
  Reg = getReg(Decoder, Mips_LO32DSPRegClassID, RegNo);
1408
33
  MCOperand_CreateReg0(Inst, Reg);
1409
1410
33
  return MCDisassembler_Success;
1411
33
}
1412
1413
static DecodeStatus DecodeMSA128BRegisterClass(MCInst *Inst,
1414
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1415
4.54k
{
1416
4.54k
  unsigned Reg;
1417
1418
4.54k
  if (RegNo > 31)
1419
0
    return MCDisassembler_Fail;
1420
1421
4.54k
  Reg = getReg(Decoder, Mips_MSA128BRegClassID, RegNo);
1422
4.54k
  MCOperand_CreateReg0(Inst, Reg);
1423
1424
4.54k
  return MCDisassembler_Success;
1425
4.54k
}
1426
1427
static DecodeStatus DecodeMSA128HRegisterClass(MCInst *Inst,
1428
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1429
1.25k
{
1430
1.25k
  unsigned Reg;
1431
1432
1.25k
  if (RegNo > 31)
1433
0
    return MCDisassembler_Fail;
1434
1435
1.25k
  Reg = getReg(Decoder, Mips_MSA128HRegClassID, RegNo);
1436
1.25k
  MCOperand_CreateReg0(Inst, Reg);
1437
1438
1.25k
  return MCDisassembler_Success;
1439
1.25k
}
1440
1441
static DecodeStatus DecodeMSA128WRegisterClass(MCInst *Inst,
1442
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1443
1.71k
{
1444
1.71k
  unsigned Reg;
1445
1446
1.71k
  if (RegNo > 31)
1447
0
    return MCDisassembler_Fail;
1448
1449
1.71k
  Reg = getReg(Decoder, Mips_MSA128WRegClassID, RegNo);
1450
1.71k
  MCOperand_CreateReg0(Inst, Reg);
1451
1452
1.71k
  return MCDisassembler_Success;
1453
1.71k
}
1454
1455
static DecodeStatus DecodeMSA128DRegisterClass(MCInst *Inst,
1456
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1457
2.21k
{
1458
2.21k
  unsigned Reg;
1459
1460
2.21k
  if (RegNo > 31)
1461
0
    return MCDisassembler_Fail;
1462
1463
2.21k
  Reg = getReg(Decoder, Mips_MSA128DRegClassID, RegNo);
1464
2.21k
  MCOperand_CreateReg0(Inst, Reg);
1465
1466
2.21k
  return MCDisassembler_Success;
1467
2.21k
}
1468
1469
static DecodeStatus DecodeMSACtrlRegisterClass(MCInst *Inst,
1470
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1471
46
{
1472
46
  unsigned Reg;
1473
1474
46
  if (RegNo > 7)
1475
1
    return MCDisassembler_Fail;
1476
1477
45
  Reg = getReg(Decoder, Mips_MSACtrlRegClassID, RegNo);
1478
45
  MCOperand_CreateReg0(Inst, Reg);
1479
1480
45
  return MCDisassembler_Success;
1481
46
}
1482
1483
static DecodeStatus DecodeCOP2RegisterClass(MCInst *Inst,
1484
    unsigned RegNo, uint64_t Address, const MCRegisterInfo *Decoder)
1485
13
{
1486
13
  unsigned Reg;
1487
1488
13
  if (RegNo > 31)
1489
0
    return MCDisassembler_Fail;
1490
1491
13
  Reg = getReg(Decoder, Mips_COP2RegClassID, RegNo);
1492
13
  MCOperand_CreateReg0(Inst, Reg);
1493
1494
13
  return MCDisassembler_Success;
1495
13
}
1496
1497
static DecodeStatus DecodeBranchTarget(MCInst *Inst,
1498
    unsigned Offset, uint64_t Address, const MCRegisterInfo *Decoder)
1499
4.45k
{
1500
4.45k
  uint64_t TargetAddress = (SignExtend32(Offset, 16) * 4) + Address + 4;
1501
4.45k
  MCOperand_CreateImm0(Inst, TargetAddress);
1502
1503
4.45k
  return MCDisassembler_Success;
1504
4.45k
}
1505
1506
static DecodeStatus DecodeJumpTarget(MCInst *Inst,
1507
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1508
1.58k
{
1509
1.58k
  uint64_t TargetAddress = (fieldFromInstruction(Insn, 0, 26) << 2) | ((Address + 4) & ~0x0FFFFFFF);
1510
1.58k
  MCOperand_CreateImm0(Inst, TargetAddress);
1511
1512
1.58k
  return MCDisassembler_Success;
1513
1.58k
}
1514
1515
static DecodeStatus DecodeBranchTarget21(MCInst *Inst,
1516
    unsigned Offset, uint64_t Address, const MCRegisterInfo *Decoder)
1517
144
{
1518
144
  int32_t BranchOffset = SignExtend32(Offset, 21) * 4;
1519
1520
144
  MCOperand_CreateImm0(Inst, BranchOffset);
1521
1522
144
  return MCDisassembler_Success;
1523
144
}
1524
1525
static DecodeStatus DecodeBranchTarget26(MCInst *Inst,
1526
    unsigned Offset, uint64_t Address, const MCRegisterInfo *Decoder)
1527
282
{
1528
282
  int32_t BranchOffset = SignExtend32(Offset, 26) * 4;
1529
1530
282
  MCOperand_CreateImm0(Inst, BranchOffset);
1531
282
  return MCDisassembler_Success;
1532
282
}
1533
1534
static DecodeStatus DecodeBranchTarget7MM(MCInst *Inst,
1535
    unsigned Offset, uint64_t Address, MCRegisterInfo *Decoder)
1536
304
{
1537
304
  int32_t BranchOffset = SignExtend32(Offset, 7) * 2;
1538
304
  MCOperand_CreateImm0(Inst, BranchOffset);
1539
304
  return MCDisassembler_Success;
1540
304
}
1541
1542
static DecodeStatus DecodeBranchTarget10MM(MCInst *Inst,
1543
    unsigned Offset, uint64_t Address, MCRegisterInfo *Decoder)
1544
350
{
1545
350
  int32_t BranchOffset = SignExtend32(Offset, 10) * 2;
1546
350
  MCOperand_CreateImm0(Inst, BranchOffset);
1547
350
  return MCDisassembler_Success;
1548
350
}
1549
1550
static DecodeStatus DecodeBranchTargetMM(MCInst *Inst,
1551
    unsigned Offset, uint64_t Address, const MCRegisterInfo *Decoder)
1552
210
{
1553
210
  int32_t BranchOffset = SignExtend32(Offset, 16) * 2;
1554
210
  MCOperand_CreateImm0(Inst, BranchOffset);
1555
1556
210
  return MCDisassembler_Success;
1557
210
}
1558
1559
static DecodeStatus DecodeJumpTargetMM(MCInst *Inst,
1560
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1561
332
{
1562
332
  unsigned JumpOffset = fieldFromInstruction(Insn, 0, 26) << 1;
1563
332
  MCOperand_CreateImm0(Inst, JumpOffset);
1564
1565
332
  return MCDisassembler_Success;
1566
332
}
1567
1568
static DecodeStatus DecodeAddiur2Simm7(MCInst *Inst,
1569
    unsigned Value, uint64_t Address, MCRegisterInfo *Decoder)
1570
503
{
1571
503
  if (Value == 0)
1572
17
    MCOperand_CreateImm0(Inst, 1);
1573
486
  else if (Value == 0x7)
1574
43
    MCOperand_CreateImm0(Inst, -1);
1575
443
  else
1576
443
    MCOperand_CreateImm0(Inst, Value << 2);
1577
1578
503
  return MCDisassembler_Success;
1579
503
}
1580
1581
static DecodeStatus DecodeUImm6Lsl2(MCInst *Inst,
1582
    unsigned Value, uint64_t Address, MCRegisterInfo *Decoder)
1583
117
{
1584
117
  MCOperand_CreateImm0(Inst, Value << 2);
1585
1586
117
  return MCDisassembler_Success;
1587
117
}
1588
1589
static DecodeStatus DecodeLiSimm7(MCInst *Inst,
1590
    unsigned Value, uint64_t Address, MCRegisterInfo *Decoder)
1591
144
{
1592
144
  if (Value == 0x7F)
1593
9
    MCOperand_CreateImm0(Inst, -1);
1594
135
  else
1595
135
    MCOperand_CreateImm0(Inst, Value);
1596
1597
144
  return MCDisassembler_Success;
1598
144
}
1599
1600
static DecodeStatus DecodeSimm4(MCInst *Inst,
1601
    unsigned Value, uint64_t Address, MCRegisterInfo *Decoder)
1602
256
{
1603
256
  MCOperand_CreateImm0(Inst, SignExtend32(Value, 4));
1604
1605
256
  return MCDisassembler_Success;
1606
256
}
1607
1608
static DecodeStatus DecodeSimm16(MCInst *Inst,
1609
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1610
2.51k
{
1611
2.51k
  MCOperand_CreateImm0(Inst, SignExtend32(Insn, 16));
1612
1613
2.51k
  return MCDisassembler_Success;
1614
2.51k
}
1615
1616
static DecodeStatus DecodeLSAImm(MCInst *Inst,
1617
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1618
179
{
1619
  // We add one to the immediate field as it was encoded as 'imm - 1'.
1620
179
  MCOperand_CreateImm0(Inst, Insn + 1);
1621
1622
179
  return MCDisassembler_Success;
1623
179
}
1624
1625
static DecodeStatus DecodeInsSize(MCInst *Inst,
1626
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1627
239
{
1628
  // First we need to grab the pos(lsb) from MCInst.
1629
239
  int Pos = (int)MCOperand_getImm(MCInst_getOperand(Inst, 2));
1630
239
  int Size = (int) Insn - Pos + 1;
1631
239
  MCOperand_CreateImm0(Inst, SignExtend32(Size, 16));
1632
1633
239
  return MCDisassembler_Success;
1634
239
}
1635
1636
static DecodeStatus DecodeExtSize(MCInst *Inst,
1637
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1638
49
{
1639
49
  int Size = (int)Insn  + 1;
1640
1641
49
  MCOperand_CreateImm0(Inst, SignExtend32(Size, 16));
1642
1643
49
  return MCDisassembler_Success;
1644
49
}
1645
1646
static DecodeStatus DecodeSimm19Lsl2(MCInst *Inst,
1647
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1648
65
{
1649
65
  MCOperand_CreateImm0(Inst, SignExtend32(Insn, 19) * 4);
1650
1651
65
  return MCDisassembler_Success;
1652
65
}
1653
1654
static DecodeStatus DecodeSimm18Lsl3(MCInst *Inst,
1655
    unsigned Insn, uint64_t Address, const MCRegisterInfo *Decoder)
1656
0
{
1657
0
  MCOperand_CreateImm0(Inst, SignExtend32(Insn, 18) * 8);
1658
1659
0
  return MCDisassembler_Success;
1660
0
}
1661
1662
static DecodeStatus DecodeSimm9SP(MCInst *Inst, unsigned Insn,
1663
    uint64_t Address, MCRegisterInfo *Decoder)
1664
337
{
1665
337
  int32_t DecodedValue;
1666
1667
337
  switch (Insn) {
1668
25
    case 0: DecodedValue = 256; break;
1669
29
    case 1: DecodedValue = 257; break;
1670
20
    case 510: DecodedValue = -258; break;
1671
23
    case 511: DecodedValue = -257; break;
1672
240
    default: DecodedValue = SignExtend32(Insn, 9); break;
1673
337
  }
1674
337
  MCOperand_CreateImm0(Inst, DecodedValue * 4);
1675
1676
337
  return MCDisassembler_Success;
1677
337
}
1678
1679
static DecodeStatus DecodeANDI16Imm(MCInst *Inst, unsigned Insn,
1680
    uint64_t Address, MCRegisterInfo *Decoder)
1681
250
{
1682
  // Insn must be >= 0, since it is unsigned that condition is always true.
1683
  // assert(Insn < 16);
1684
250
  int32_t DecodedValues[] = {128, 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64,
1685
250
    255, 32768, 65535};
1686
1687
250
  if (Insn >= 16)
1688
0
    return MCDisassembler_Fail;
1689
1690
250
  MCOperand_CreateImm0(Inst, DecodedValues[Insn]);
1691
1692
250
  return MCDisassembler_Success;
1693
250
}
1694
1695
static DecodeStatus DecodeUImm5lsl2(MCInst *Inst, unsigned Insn,
1696
    uint64_t Address, MCRegisterInfo *Decoder)
1697
146
{
1698
146
  MCOperand_CreateImm0(Inst, Insn << 2);
1699
1700
146
  return MCDisassembler_Success;
1701
146
}
1702
1703
static DecodeStatus DecodeRegListOperand(MCInst *Inst, unsigned Insn,
1704
    uint64_t Address, const MCRegisterInfo *Decoder)
1705
108
{
1706
108
  unsigned Regs[] = {Mips_S0, Mips_S1, Mips_S2, Mips_S3, Mips_S4, Mips_S5,
1707
108
    Mips_S6, Mips_FP};
1708
108
  unsigned RegNum;
1709
108
  unsigned int i;
1710
1711
108
  unsigned RegLst = fieldFromInstruction(Insn, 21, 5);
1712
  // Empty register lists are not allowed.
1713
108
  if (RegLst == 0)
1714
1
    return MCDisassembler_Fail;
1715
1716
107
  RegNum = RegLst & 0xf;
1717
754
  for (i = 0; i < MIN(RegNum, ARR_SIZE(Regs)); i++)
1718
647
    MCOperand_CreateReg0(Inst, Regs[i]);
1719
1720
107
  if (RegLst & 0x10)
1721
38
    MCOperand_CreateReg0(Inst, Mips_RA);
1722
1723
107
  return MCDisassembler_Success;
1724
108
}
1725
1726
static DecodeStatus DecodeRegListOperand16(MCInst *Inst, unsigned Insn,
1727
    uint64_t Address, MCRegisterInfo *Decoder)
1728
262
{
1729
262
  unsigned Regs[] = {Mips_S0, Mips_S1, Mips_S2, Mips_S3};
1730
262
  unsigned RegLst = fieldFromInstruction(Insn, 4, 2);
1731
262
  unsigned RegNum = RegLst & 0x3;
1732
262
  unsigned int i;
1733
1734
906
  for (i = 0; i <= RegNum; i++)
1735
644
    MCOperand_CreateReg0(Inst, Regs[i]);
1736
1737
262
  MCOperand_CreateReg0(Inst, Mips_RA);
1738
1739
262
  return MCDisassembler_Success;
1740
262
}
1741
1742
static DecodeStatus DecodeMovePRegPair(MCInst *Inst, unsigned Insn,
1743
    uint64_t Address, MCRegisterInfo *Decoder)
1744
270
{
1745
270
  unsigned RegPair = fieldFromInstruction(Insn, 7, 3);
1746
1747
270
  switch (RegPair) {
1748
0
    default:
1749
0
      return MCDisassembler_Fail;
1750
270
    case 0:
1751
270
      MCOperand_CreateReg0(Inst, Mips_A1);
1752
270
      MCOperand_CreateReg0(Inst, Mips_A2);
1753
270
      break;
1754
0
    case 1:
1755
0
      MCOperand_CreateReg0(Inst, Mips_A1);
1756
0
      MCOperand_CreateReg0(Inst, Mips_A3);
1757
0
      break;
1758
0
    case 2:
1759
0
      MCOperand_CreateReg0(Inst, Mips_A2);
1760
0
      MCOperand_CreateReg0(Inst, Mips_A3);
1761
0
      break;
1762
0
    case 3:
1763
0
      MCOperand_CreateReg0(Inst, Mips_A0);
1764
0
      MCOperand_CreateReg0(Inst, Mips_S5);
1765
0
      break;
1766
0
    case 4:
1767
0
      MCOperand_CreateReg0(Inst, Mips_A0);
1768
0
      MCOperand_CreateReg0(Inst, Mips_S6);
1769
0
      break;
1770
0
    case 5:
1771
0
      MCOperand_CreateReg0(Inst, Mips_A0);
1772
0
      MCOperand_CreateReg0(Inst, Mips_A1);
1773
0
      break;
1774
0
    case 6:
1775
0
      MCOperand_CreateReg0(Inst, Mips_A0);
1776
0
      MCOperand_CreateReg0(Inst, Mips_A2);
1777
0
      break;
1778
0
    case 7:
1779
0
      MCOperand_CreateReg0(Inst, Mips_A0);
1780
0
      MCOperand_CreateReg0(Inst, Mips_A3);
1781
0
      break;
1782
270
  }
1783
1784
270
  return MCDisassembler_Success;
1785
270
}
1786
1787
static DecodeStatus DecodeSimm23Lsl2(MCInst *Inst, unsigned Insn,
1788
    uint64_t Address, MCRegisterInfo *Decoder)
1789
244
{
1790
244
  MCOperand_CreateImm0(Inst, SignExtend32(Insn, 23) * 4);
1791
244
  return MCDisassembler_Success;
1792
244
}
1793
1794
#endif