Coverage Report

Created: 2023-09-25 06:24

/src/capstonev5/MCInst.c
Line
Count
Source (jump to first uncovered line)
1
/* Capstone Disassembly Engine */
2
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
3
4
#if defined(CAPSTONE_HAS_OSXKERNEL)
5
#include <Availability.h>
6
#include <libkern/libkern.h>
7
#else
8
#include <stdio.h>
9
#include <stdlib.h>
10
#endif
11
#include <string.h>
12
#include <assert.h>
13
14
#include "MCInst.h"
15
#include "utils.h"
16
17
2.54M
#define MCINST_CACHE (ARR_SIZE(mcInst->Operands) - 1)
18
19
void MCInst_Init(MCInst *inst)
20
4.67M
{
21
  // unnecessary to initialize in loop . its expensive and inst->size shuold be honored
22
4.67M
  inst->Operands[0].Kind = kInvalid;
23
4.67M
  inst->Operands[0].ImmVal = 0;
24
25
4.67M
  inst->Opcode = 0;
26
4.67M
  inst->OpcodePub = 0;
27
4.67M
  inst->size = 0;
28
4.67M
  inst->has_imm = false;
29
4.67M
  inst->op1_size = 0;
30
4.67M
  inst->writeback = false;
31
4.67M
  inst->ac_idx = 0;
32
4.67M
  inst->popcode_adjust = 0;
33
4.67M
  inst->assembly[0] = '\0';
34
4.67M
  inst->wasm_data.type = WASM_OP_INVALID;
35
4.67M
  inst->xAcquireRelease = 0;
36
229M
  for (int i = 0; i < MAX_MC_OPS; ++i)
37
224M
    inst->tied_op_idx[i] = -1;
38
4.67M
}
39
40
void MCInst_clear(MCInst *inst)
41
4.32M
{
42
4.32M
  inst->size = 0;
43
4.32M
}
44
45
// does not free @Op
46
void MCInst_insert0(MCInst *inst, int index, MCOperand *Op)
47
2.56M
{
48
2.56M
  assert(index < MAX_MC_OPS);
49
2.56M
  int i;
50
51
4.24M
  for(i = inst->size; i > index; i--)
52
    //memcpy(&(inst->Operands[i]), &(inst->Operands[i-1]), sizeof(MCOperand));
53
1.68M
    inst->Operands[i] = inst->Operands[i-1];
54
55
2.56M
  inst->Operands[index] = *Op;
56
2.56M
  inst->size++;
57
2.56M
}
58
59
void MCInst_setOpcode(MCInst *inst, unsigned Op)
60
4.67M
{
61
4.67M
  inst->Opcode = Op;
62
4.67M
}
63
64
void MCInst_setOpcodePub(MCInst *inst, unsigned Op)
65
179k
{
66
179k
  inst->OpcodePub = Op;
67
179k
}
68
69
unsigned MCInst_getOpcode(const MCInst *inst)
70
38.4M
{
71
38.4M
  return inst->Opcode;
72
38.4M
}
73
74
unsigned MCInst_getOpcodePub(const MCInst *inst)
75
4.90M
{
76
4.90M
  return inst->OpcodePub;
77
4.90M
}
78
79
MCOperand *MCInst_getOperand(MCInst *inst, unsigned i)
80
25.3M
{
81
25.3M
  assert(i < MAX_MC_OPS);
82
25.3M
  return &inst->Operands[i];
83
25.3M
}
84
85
unsigned MCInst_getNumOperands(const MCInst *inst)
86
11.4M
{
87
11.4M
  return inst->size;
88
11.4M
}
89
90
// This addOperand2 function doesnt free Op
91
void MCInst_addOperand2(MCInst *inst, MCOperand *Op)
92
3.31k
{
93
3.31k
  assert(inst->size < MAX_MC_OPS);
94
3.31k
  inst->Operands[inst->size] = *Op;
95
96
3.31k
  inst->size++;
97
3.31k
}
98
99
bool MCOperand_isValid(const MCOperand *op)
100
0
{
101
0
  return op->Kind != kInvalid;
102
0
}
103
104
bool MCOperand_isReg(const MCOperand *op)
105
12.0M
{
106
12.0M
  return op->Kind == kRegister;
107
12.0M
}
108
109
bool MCOperand_isImm(const MCOperand *op)
110
4.01M
{
111
4.01M
  return op->Kind == kImmediate;
112
4.01M
}
113
114
bool MCOperand_isFPImm(const MCOperand *op)
115
3.66k
{
116
3.66k
  return op->Kind == kFPImmediate;
117
3.66k
}
118
119
bool MCOperand_isDFPImm(const MCOperand *op)
120
0
{
121
0
  return op->Kind == kDFPImmediate;
122
0
}
123
124
bool MCOperand_isExpr(const MCOperand *op)
125
116k
{
126
116k
  return op->Kind == kExpr;
127
116k
}
128
129
bool MCOperand_isInst(const MCOperand *op)
130
0
{
131
0
  return op->Kind == kInst;
132
0
}
133
134
/// getReg - Returns the register number.
135
unsigned MCOperand_getReg(const MCOperand *op)
136
15.9M
{
137
15.9M
  return op->RegVal;
138
15.9M
}
139
140
/// setReg - Set the register number.
141
void MCOperand_setReg(MCOperand *op, unsigned Reg)
142
17.7k
{
143
17.7k
  op->RegVal = Reg;
144
17.7k
}
145
146
int64_t MCOperand_getImm(MCOperand *op)
147
8.88M
{
148
8.88M
  return op->ImmVal;
149
8.88M
}
150
151
void MCOperand_setImm(MCOperand *op, int64_t Val)
152
22.5k
{
153
22.5k
  op->ImmVal = Val;
154
22.5k
}
155
156
double MCOperand_getFPImm(const MCOperand *op)
157
0
{
158
0
  return op->FPImmVal;
159
0
}
160
161
void MCOperand_setFPImm(MCOperand *op, double Val)
162
0
{
163
0
  op->FPImmVal = Val;
164
0
}
165
166
MCOperand *MCOperand_CreateReg1(MCInst *mcInst, unsigned Reg)
167
1.45M
{
168
1.45M
  MCOperand *op = &(mcInst->Operands[MCINST_CACHE]);
169
170
1.45M
  op->MachineOperandType = kRegister;
171
1.45M
  op->Kind = kRegister;
172
1.45M
  op->RegVal = Reg;
173
174
1.45M
  return op;
175
1.45M
}
176
177
void MCOperand_CreateReg0(MCInst *mcInst, unsigned Reg)
178
8.87M
{
179
8.87M
  MCOperand *op = &(mcInst->Operands[mcInst->size]);
180
8.87M
  mcInst->size++;
181
182
8.87M
  op->MachineOperandType = kRegister;
183
8.87M
  op->Kind = kRegister;
184
8.87M
  op->RegVal = Reg;
185
8.87M
}
186
187
MCOperand *MCOperand_CreateImm1(MCInst *mcInst, int64_t Val)
188
1.09M
{
189
1.09M
  MCOperand *op = &(mcInst->Operands[MCINST_CACHE]);
190
191
1.09M
  op->MachineOperandType = kImmediate;
192
1.09M
  op->Kind = kImmediate;
193
1.09M
  op->ImmVal = Val;
194
195
1.09M
  return op;
196
1.09M
}
197
198
void MCOperand_CreateImm0(MCInst *mcInst, int64_t Val)
199
4.18M
{
200
4.18M
  assert(mcInst->size < MAX_MC_OPS);
201
4.18M
  MCOperand *op = &(mcInst->Operands[mcInst->size]);
202
4.18M
  mcInst->size++;
203
204
4.18M
  op->MachineOperandType = kImmediate;
205
4.18M
  op->Kind = kImmediate;
206
4.18M
  op->ImmVal = Val;
207
4.18M
}
208
209
/// Check if any operand of the MCInstrDesc is predicable
210
bool MCInst_isPredicable(const MCInstrDesc *MIDesc)
211
1.06M
{
212
1.06M
  const MCOperandInfo *OpInfo = MIDesc->OpInfo;
213
1.06M
  unsigned NumOps = MIDesc->NumOperands;
214
4.78M
  for (unsigned i = 0; i < NumOps; ++i) {
215
4.71M
    if (MCOperandInfo_isPredicate(&OpInfo[i])) {
216
995k
      return true;
217
995k
    }
218
4.71M
  }
219
74.1k
  return false;
220
1.06M
}
221
222
/// Checks if tied operands exist in the instruction and sets
223
/// - The writeback flag in detail
224
/// - Saves the indices of the tied destination operands.
225
void MCInst_handleWriteback(MCInst *MI, const MCInstrDesc *InstDesc)
226
1.22M
{
227
1.22M
  const MCOperandInfo *OpInfo = InstDesc[MCInst_getOpcode(MI)].OpInfo;
228
1.22M
  unsigned short NumOps = InstDesc[MCInst_getOpcode(MI)].NumOperands;
229
230
1.22M
  unsigned i;
231
7.41M
  for (i = 0; i < NumOps; ++i) {
232
6.19M
    if (MCOperandInfo_isTiedToOp(&OpInfo[i])) {
233
258k
      int idx = MCOperandInfo_getOperandConstraint(
234
258k
        &InstDesc[MCInst_getOpcode(MI)], i,
235
258k
        MCOI_TIED_TO);
236
237
258k
      if (idx == -1)
238
0
        continue;
239
240
258k
      if (i >= MAX_MC_OPS) {
241
0
        assert(0 &&
242
0
               "Maximum number of MC operands reached.");
243
0
      }
244
258k
      MI->tied_op_idx[i] = idx;
245
246
258k
      if (MI->flat_insn->detail)
247
258k
        MI->flat_insn->detail->writeback = true;
248
258k
    }
249
6.19M
  }
250
1.22M
}
251
252
/// Check if operand with OpNum is tied by another operand
253
/// (operand is tying destination).
254
bool MCInst_opIsTied(const MCInst *MI, unsigned OpNum)
255
4.04M
{
256
4.04M
  assert(OpNum < MAX_MC_OPS && "Maximum number of MC operands exceeded.");
257
190M
  for (int i = 0; i < MAX_MC_OPS; ++i) {
258
186M
    if (MI->tied_op_idx[i] == OpNum)
259
168k
      return true;
260
186M
  }
261
3.87M
  return false;
262
4.04M
}
263
264
/// Check if operand with OpNum is tying another operand
265
/// (operand is tying src).
266
bool MCInst_opIsTying(const MCInst *MI, unsigned OpNum)
267
3.98M
{
268
3.98M
  assert(OpNum < MAX_MC_OPS && "Maximum number of MC operands exceeded.");
269
3.98M
  return MI->tied_op_idx[OpNum] != -1;
270
3.98M
}