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
456k
#define MCINST_CACHE (ARR_SIZE(mcInst->Operands) - 1)
18
19
void MCInst_Init(MCInst *inst)
20
1.27M
{
21
  // unnecessary to initialize in loop . its expensive and inst->size shuold be honored
22
1.27M
  inst->Operands[0].Kind = kInvalid;
23
1.27M
  inst->Operands[0].ImmVal = 0;
24
25
1.27M
  inst->Opcode = 0;
26
1.27M
  inst->OpcodePub = 0;
27
1.27M
  inst->size = 0;
28
1.27M
  inst->has_imm = false;
29
1.27M
  inst->op1_size = 0;
30
1.27M
  inst->writeback = false;
31
1.27M
  inst->ac_idx = 0;
32
1.27M
  inst->popcode_adjust = 0;
33
1.27M
  inst->assembly[0] = '\0';
34
1.27M
  inst->wasm_data.type = WASM_OP_INVALID;
35
1.27M
  inst->xAcquireRelease = 0;
36
62.3M
  for (int i = 0; i < MAX_MC_OPS; ++i)
37
61.0M
    inst->tied_op_idx[i] = -1;
38
1.27M
}
39
40
void MCInst_clear(MCInst *inst)
41
1.41M
{
42
1.41M
  inst->size = 0;
43
1.41M
}
44
45
// does not free @Op
46
void MCInst_insert0(MCInst *inst, int index, MCOperand *Op)
47
457k
{
48
457k
  assert(index < MAX_MC_OPS);
49
457k
  int i;
50
51
770k
  for(i = inst->size; i > index; i--)
52
    //memcpy(&(inst->Operands[i]), &(inst->Operands[i-1]), sizeof(MCOperand));
53
312k
    inst->Operands[i] = inst->Operands[i-1];
54
55
457k
  inst->Operands[index] = *Op;
56
457k
  inst->size++;
57
457k
}
58
59
void MCInst_setOpcode(MCInst *inst, unsigned Op)
60
1.23M
{
61
1.23M
  inst->Opcode = Op;
62
1.23M
}
63
64
void MCInst_setOpcodePub(MCInst *inst, unsigned Op)
65
51.0k
{
66
51.0k
  inst->OpcodePub = Op;
67
51.0k
}
68
69
unsigned MCInst_getOpcode(const MCInst *inst)
70
6.36M
{
71
6.36M
  return inst->Opcode;
72
6.36M
}
73
74
unsigned MCInst_getOpcodePub(const MCInst *inst)
75
1.36M
{
76
1.36M
  return inst->OpcodePub;
77
1.36M
}
78
79
MCOperand *MCInst_getOperand(MCInst *inst, unsigned i)
80
4.77M
{
81
4.77M
  assert(i < MAX_MC_OPS);
82
4.77M
  return &inst->Operands[i];
83
4.77M
}
84
85
unsigned MCInst_getNumOperands(const MCInst *inst)
86
1.29M
{
87
1.29M
  return inst->size;
88
1.29M
}
89
90
// This addOperand2 function doesnt free Op
91
void MCInst_addOperand2(MCInst *inst, MCOperand *Op)
92
1.03k
{
93
1.03k
  assert(inst->size < MAX_MC_OPS);
94
1.03k
  inst->Operands[inst->size] = *Op;
95
96
1.03k
  inst->size++;
97
1.03k
}
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
1.86M
{
106
1.86M
  return op->Kind == kRegister;
107
1.86M
}
108
109
bool MCOperand_isImm(const MCOperand *op)
110
738k
{
111
738k
  return op->Kind == kImmediate;
112
738k
}
113
114
bool MCOperand_isFPImm(const MCOperand *op)
115
302
{
116
302
  return op->Kind == kFPImmediate;
117
302
}
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
0
{
126
0
  return op->Kind == kExpr;
127
0
}
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
3.43M
{
137
3.43M
  return op->RegVal;
138
3.43M
}
139
140
/// setReg - Set the register number.
141
void MCOperand_setReg(MCOperand *op, unsigned Reg)
142
3.59k
{
143
3.59k
  op->RegVal = Reg;
144
3.59k
}
145
146
int64_t MCOperand_getImm(MCOperand *op)
147
1.52M
{
148
1.52M
  return op->ImmVal;
149
1.52M
}
150
151
void MCOperand_setImm(MCOperand *op, int64_t Val)
152
7.86k
{
153
7.86k
  op->ImmVal = Val;
154
7.86k
}
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
257k
{
168
257k
  MCOperand *op = &(mcInst->Operands[MCINST_CACHE]);
169
170
257k
  op->MachineOperandType = kRegister;
171
257k
  op->Kind = kRegister;
172
257k
  op->RegVal = Reg;
173
174
257k
  return op;
175
257k
}
176
177
void MCOperand_CreateReg0(MCInst *mcInst, unsigned Reg)
178
2.18M
{
179
2.18M
  MCOperand *op = &(mcInst->Operands[mcInst->size]);
180
2.18M
  mcInst->size++;
181
182
2.18M
  op->MachineOperandType = kRegister;
183
2.18M
  op->Kind = kRegister;
184
2.18M
  op->RegVal = Reg;
185
2.18M
}
186
187
MCOperand *MCOperand_CreateImm1(MCInst *mcInst, int64_t Val)
188
199k
{
189
199k
  MCOperand *op = &(mcInst->Operands[MCINST_CACHE]);
190
191
199k
  op->MachineOperandType = kImmediate;
192
199k
  op->Kind = kImmediate;
193
199k
  op->ImmVal = Val;
194
195
199k
  return op;
196
199k
}
197
198
void MCOperand_CreateImm0(MCInst *mcInst, int64_t Val)
199
1.01M
{
200
1.01M
  assert(mcInst->size < MAX_MC_OPS);
201
1.01M
  MCOperand *op = &(mcInst->Operands[mcInst->size]);
202
1.01M
  mcInst->size++;
203
204
1.01M
  op->MachineOperandType = kImmediate;
205
1.01M
  op->Kind = kImmediate;
206
1.01M
  op->ImmVal = Val;
207
1.01M
}
208
209
/// Check if any operand of the MCInstrDesc is predicable
210
bool MCInst_isPredicable(const MCInstrDesc *MIDesc)
211
0
{
212
0
  const MCOperandInfo *OpInfo = MIDesc->OpInfo;
213
0
  unsigned NumOps = MIDesc->NumOperands;
214
0
  for (unsigned i = 0; i < NumOps; ++i) {
215
0
    if (MCOperandInfo_isPredicate(&OpInfo[i])) {
216
0
      return true;
217
0
    }
218
0
  }
219
0
  return false;
220
0
}
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
0
{
227
0
  const MCOperandInfo *OpInfo = InstDesc[MCInst_getOpcode(MI)].OpInfo;
228
0
  unsigned short NumOps = InstDesc[MCInst_getOpcode(MI)].NumOperands;
229
230
0
  unsigned i;
231
0
  for (i = 0; i < NumOps; ++i) {
232
0
    if (MCOperandInfo_isTiedToOp(&OpInfo[i])) {
233
0
      int idx = MCOperandInfo_getOperandConstraint(
234
0
        &InstDesc[MCInst_getOpcode(MI)], i,
235
0
        MCOI_TIED_TO);
236
237
0
      if (idx == -1)
238
0
        continue;
239
240
0
      if (i >= MAX_MC_OPS) {
241
0
        assert(0 &&
242
0
               "Maximum number of MC operands reached.");
243
0
      }
244
0
      MI->tied_op_idx[i] = idx;
245
246
0
      if (MI->flat_insn->detail)
247
0
        MI->flat_insn->detail->writeback = true;
248
0
    }
249
0
  }
250
0
}
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
0
{
256
0
  assert(OpNum < MAX_MC_OPS && "Maximum number of MC operands exceeded.");
257
0
  for (int i = 0; i < MAX_MC_OPS; ++i) {
258
0
    if (MI->tied_op_idx[i] == OpNum)
259
0
      return true;
260
0
  }
261
0
  return false;
262
0
}
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
0
{
268
0
  assert(OpNum < MAX_MC_OPS && "Maximum number of MC operands exceeded.");
269
0
  return MI->tied_op_idx[OpNum] != -1;
270
0
}