Coverage Report

Created: 2025-10-12 06:32

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/capstonenext/MCInstPrinter.c
Line
Count
Source
1
/* Capstone Disassembly Engine */
2
/* By Rot127 <unisono@quyllur.org>, 2023 */
3
4
#include "MCInstPrinter.h"
5
#include "cs_priv.h"
6
#include <capstone/platform.h>
7
8
extern bool ARM_getFeatureBits(unsigned int mode, unsigned int feature);
9
extern bool PPC_getFeatureBits(unsigned int mode, unsigned int feature);
10
extern bool Mips_getFeatureBits(unsigned int mode, unsigned int feature);
11
extern bool AArch64_getFeatureBits(unsigned int mode, unsigned int feature);
12
extern bool TriCore_getFeatureBits(unsigned int mode, unsigned int feature);
13
extern bool Sparc_getFeatureBits(unsigned int mode, unsigned int feature);
14
15
static bool testFeatureBits(const MCInst *MI, uint32_t Value)
16
58.5k
{
17
58.5k
  assert(MI && MI->csh);
18
58.5k
  switch (MI->csh->arch) {
19
0
  default:
20
0
    assert(0 && "Not implemented for current arch.");
21
0
    return false;
22
0
#ifdef CAPSTONE_HAS_ARM
23
6.58k
  case CS_ARCH_ARM:
24
6.58k
    return ARM_getFeatureBits(MI->csh->mode, Value);
25
0
#endif
26
0
#ifdef CAPSTONE_HAS_POWERPC
27
727
  case CS_ARCH_PPC:
28
727
    return PPC_getFeatureBits(MI->csh->mode, Value);
29
0
#endif
30
0
#ifdef CAPSTONE_HAS_MIPS
31
7.39k
  case CS_ARCH_MIPS:
32
7.39k
    return Mips_getFeatureBits(MI->csh->mode, Value);
33
0
#endif
34
0
#ifdef CAPSTONE_HAS_AARCH64
35
42.5k
  case CS_ARCH_AARCH64:
36
42.5k
    return AArch64_getFeatureBits(MI->csh->mode, Value);
37
0
#endif
38
0
#ifdef CAPSTONE_HAS_TRICORE
39
0
  case CS_ARCH_TRICORE:
40
0
    return TriCore_getFeatureBits(MI->csh->mode, Value);
41
0
#endif
42
0
#ifdef CAPSTONE_HAS_SPARC
43
1.21k
  case CS_ARCH_SPARC:
44
1.21k
    return Sparc_getFeatureBits(MI->csh->mode, Value);
45
58.5k
#endif
46
58.5k
  }
47
58.5k
}
48
49
static bool matchAliasCondition(MCInst *MI, const MCRegisterInfo *MRI,
50
        unsigned *OpIdx, const AliasMatchingData *M,
51
        const AliasPatternCond *C,
52
        bool *OrPredicateResult)
53
601k
{
54
  // Feature tests are special, they don't consume operands.
55
601k
  if (C->Kind == AliasPatternCond_K_Feature)
56
10.4k
    return testFeatureBits(MI, C->Value);
57
590k
  if (C->Kind == AliasPatternCond_K_NegFeature)
58
5.19k
    return !testFeatureBits(MI, C->Value);
59
  // For feature tests where just one feature is required in a list, set the
60
  // predicate result bit to whether the expression will return true, and only
61
  // return the real result at the end of list marker.
62
585k
  if (C->Kind == AliasPatternCond_K_OrFeature) {
63
42.7k
    *OrPredicateResult |= testFeatureBits(MI, C->Value);
64
42.7k
    return true;
65
42.7k
  }
66
542k
  if (C->Kind == AliasPatternCond_K_OrNegFeature) {
67
166
    *OrPredicateResult |= !(testFeatureBits(MI, C->Value));
68
166
    return true;
69
166
  }
70
542k
  if (C->Kind == AliasPatternCond_K_EndOrFeatures) {
71
17.9k
    bool Res = *OrPredicateResult;
72
17.9k
    *OrPredicateResult = false;
73
17.9k
    return Res;
74
17.9k
  }
75
76
  // Get and consume an operand.
77
524k
  MCOperand *Opnd = MCInst_getOperand(MI, *OpIdx);
78
524k
  ++(*OpIdx);
79
80
  // Check the specific condition for the operand.
81
524k
  switch (C->Kind) {
82
0
  default:
83
0
    assert(0 && "invalid kind");
84
190k
  case AliasPatternCond_K_Imm:
85
    // Operand must be a specific immediate.
86
190k
    return MCOperand_isImm(Opnd) &&
87
190k
           MCOperand_getImm(Opnd) == (int32_t)C->Value;
88
38.2k
  case AliasPatternCond_K_Reg:
89
    // Operand must be a specific register.
90
38.2k
    return MCOperand_isReg(Opnd) &&
91
38.2k
           MCOperand_getReg(Opnd) == C->Value;
92
2.58k
  case AliasPatternCond_K_TiedReg:
93
    // Operand must match the register of another operand.
94
2.58k
    return MCOperand_isReg(Opnd) &&
95
2.58k
           MCOperand_getReg(Opnd) ==
96
2.58k
             MCOperand_getReg(
97
2.58k
               MCInst_getOperand(MI, C->Value));
98
216k
  case AliasPatternCond_K_RegClass:
99
    // Operand must be a register in this class. Value is a register class
100
    // id.
101
216k
    return MCOperand_isReg(Opnd) &&
102
216k
           MCRegisterClass_contains(
103
216k
             MCRegisterInfo_getRegClass(MRI, C->Value),
104
216k
             MCOperand_getReg(Opnd));
105
12.6k
  case AliasPatternCond_K_Custom:
106
    // Operand must match some custom criteria.
107
12.6k
    assert(M->ValidateMCOperand &&
108
12.6k
           "A custom validator should be set but isn't.");
109
12.6k
    return M->ValidateMCOperand(Opnd, C->Value);
110
63.6k
  case AliasPatternCond_K_Ignore:
111
    // Operand can be anything.
112
63.6k
    return true;
113
0
  case AliasPatternCond_K_Feature:
114
0
  case AliasPatternCond_K_NegFeature:
115
0
  case AliasPatternCond_K_OrFeature:
116
0
  case AliasPatternCond_K_OrNegFeature:
117
0
  case AliasPatternCond_K_EndOrFeatures:
118
0
    assert(0 && "handled earlier");
119
524k
  }
120
0
  return false;
121
524k
}
122
123
/// Check if PatternsForOpcode is all zero.
124
static inline bool validOpToPatter(const PatternsForOpcode *P)
125
143M
{
126
143M
  return !(P->Opcode == 0 && P->PatternStart == 0 && P->NumPatterns == 0);
127
143M
}
128
129
const char *matchAliasPatterns(MCInst *MI, const AliasMatchingData *M)
130
1.25M
{
131
  // TODO Rewrite to C
132
133
  // auto It = lower_bound(M.OpToPatterns, MI->getOpcode(),
134
  //                       [](const PatternsForOpcode &L, unsigned Opcode) {
135
  //                         return L.Opcode < Opcode;
136
  //                       });
137
  // if (It == M.OpToPatterns.end() || It->Opcode != MI->getOpcode())
138
  //   return nullptr;
139
140
  // Binary search by opcode. Return false if there are no aliases for this
141
  // opcode.
142
1.25M
  unsigned MIOpcode = MI->Opcode;
143
1.25M
  size_t i = 0;
144
1.25M
  uint32_t PatternOpcode = M->OpToPatterns[i].Opcode;
145
143M
  while (PatternOpcode < MIOpcode && validOpToPatter(&M->OpToPatterns[i]))
146
142M
    PatternOpcode = M->OpToPatterns[++i].Opcode;
147
1.25M
  if (PatternOpcode != MI->Opcode ||
148
100k
      !validOpToPatter(&M->OpToPatterns[i]))
149
1.15M
    return NULL;
150
151
  // // Try all patterns for this opcode.
152
100k
  uint32_t AsmStrOffset = ~0U;
153
100k
  const AliasPattern *Patterns =
154
100k
    M->Patterns + M->OpToPatterns[i].PatternStart;
155
100k
  for (const AliasPattern *P = Patterns;
156
310k
       P != Patterns + M->OpToPatterns[i].NumPatterns; ++P) {
157
    // Check operand count first.
158
248k
    if (MCInst_getNumOperands(MI) != P->NumOperands)
159
0
      return NULL;
160
161
    // Test all conditions for this pattern.
162
248k
    const AliasPatternCond *Conds =
163
248k
      M->PatternConds + P->AliasCondStart;
164
248k
    unsigned OpIdx = 0;
165
248k
    bool OrPredicateResult = false;
166
248k
    bool allMatch = true;
167
248k
    for (const AliasPatternCond *C = Conds;
168
638k
         C != Conds + P->NumConds; ++C) {
169
601k
      if (!matchAliasCondition(MI, MI->MRI, &OpIdx, M, C,
170
601k
             &OrPredicateResult)) {
171
210k
        allMatch = false;
172
210k
        break;
173
210k
      }
174
601k
    }
175
248k
    if (allMatch) {
176
37.6k
      AsmStrOffset = P->AsmStrOffset;
177
37.6k
      break;
178
37.6k
    }
179
248k
  }
180
  // If no alias matched, don't print an alias.
181
100k
  if (AsmStrOffset == ~0U)
182
62.5k
    return NULL;
183
184
  // Go to offset AsmStrOffset and use the null terminated string there. The
185
  // offset should point to the beginning of an alias string, so it should
186
  // either be zero or be preceded by a null byte.
187
37.6k
  return M->AsmStrings + AsmStrOffset;
188
100k
}
189
190
// TODO Add functionality to toggle the flag.
191
bool getUseMarkup(void)
192
6.72M
{
193
6.72M
  return false;
194
6.72M
}
195
196
/// Utility functions to make adding mark ups simpler.
197
const char *markup(const char *s)
198
6.61M
{
199
6.61M
  static const char *no_markup = "";
200
6.61M
  if (getUseMarkup())
201
0
    return s;
202
6.61M
  else
203
6.61M
    return no_markup;
204
6.61M
}
205
206
// binary search for encoding in IndexType array
207
// return -1 if not found, or index if found
208
unsigned int binsearch_IndexTypeEncoding(const struct IndexType *index,
209
           size_t size, uint16_t encoding)
210
74.6k
{
211
  // binary searching since the index is sorted in encoding order
212
74.6k
  size_t left, right, m;
213
214
74.6k
  right = size - 1;
215
216
74.6k
  if (encoding < index[0].encoding || encoding > index[right].encoding)
217
    // not found
218
13.1k
    return -1;
219
220
61.5k
  left = 0;
221
222
287k
  while (left <= right) {
223
270k
    m = (left + right) / 2;
224
270k
    if (encoding == index[m].encoding) {
225
      // LLVM actually uses lower_bound for the index table search
226
      // Here we need to check if a previous entry is of the same encoding
227
      // and return the first one.
228
44.8k
      while (m > 0 && encoding == index[m - 1].encoding)
229
0
        --m;
230
44.8k
      return m;
231
44.8k
    }
232
233
225k
    if (encoding < index[m].encoding)
234
97.1k
      right = m - 1;
235
128k
    else
236
128k
      left = m + 1;
237
225k
  }
238
239
  // not found
240
16.6k
  return -1;
241
61.5k
}
242
243
// binary search for encoding in IndexTypeStr array
244
// return -1 if not found, or index if found
245
unsigned int binsearch_IndexTypeStrEncoding(const struct IndexTypeStr *index,
246
              size_t size, const char *name)
247
1.85k
{
248
  // binary searching since the index is sorted in encoding order
249
1.85k
  size_t left, right, m;
250
251
1.85k
  right = size - 1;
252
253
1.85k
  int str_left_cmp = strcmp(name, index[0].name);
254
1.85k
  int str_right_cmp = strcmp(name, index[right].name);
255
1.85k
  if (str_left_cmp < 0 || str_right_cmp > 0)
256
    // not found
257
0
    return -1;
258
259
1.85k
  left = 0;
260
261
19.2k
  while (left <= right) {
262
19.2k
    m = (left + right) / 2;
263
19.2k
    if (strcmp(name, index[m].name) == 0) {
264
      // LLVM actually uses lower_bound for the index table search
265
      // Here we need to check if a previous entry is of the same encoding
266
      // and return the first one.
267
1.85k
      while (m > 0 && (strcmp(name, index[m - 1].name) == 0))
268
0
        --m;
269
1.85k
      return m;
270
1.85k
    }
271
272
17.4k
    if (strcmp(name, index[m].name) < 0)
273
7.48k
      right = m - 1;
274
9.96k
    else
275
9.96k
      left = m + 1;
276
17.4k
  }
277
278
  // not found
279
6
  return -1;
280
1.85k
}