Coverage Report

Created: 2025-10-10 06:20

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
32.3k
{
17
32.3k
  assert(MI && MI->csh);
18
32.3k
  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
2.76k
  case CS_ARCH_ARM:
24
2.76k
    return ARM_getFeatureBits(MI->csh->mode, Value);
25
0
#endif
26
0
#ifdef CAPSTONE_HAS_POWERPC
27
542
  case CS_ARCH_PPC:
28
542
    return PPC_getFeatureBits(MI->csh->mode, Value);
29
0
#endif
30
0
#ifdef CAPSTONE_HAS_MIPS
31
3.66k
  case CS_ARCH_MIPS:
32
3.66k
    return Mips_getFeatureBits(MI->csh->mode, Value);
33
0
#endif
34
0
#ifdef CAPSTONE_HAS_AARCH64
35
24.8k
  case CS_ARCH_AARCH64:
36
24.8k
    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
551
  case CS_ARCH_SPARC:
44
551
    return Sparc_getFeatureBits(MI->csh->mode, Value);
45
32.3k
#endif
46
32.3k
  }
47
32.3k
}
48
49
static bool matchAliasCondition(MCInst *MI, const MCRegisterInfo *MRI,
50
        unsigned *OpIdx, const AliasMatchingData *M,
51
        const AliasPatternCond *C,
52
        bool *OrPredicateResult)
53
321k
{
54
  // Feature tests are special, they don't consume operands.
55
321k
  if (C->Kind == AliasPatternCond_K_Feature)
56
4.61k
    return testFeatureBits(MI, C->Value);
57
317k
  if (C->Kind == AliasPatternCond_K_NegFeature)
58
2.61k
    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
314k
  if (C->Kind == AliasPatternCond_K_OrFeature) {
63
24.9k
    *OrPredicateResult |= testFeatureBits(MI, C->Value);
64
24.9k
    return true;
65
24.9k
  }
66
289k
  if (C->Kind == AliasPatternCond_K_OrNegFeature) {
67
145
    *OrPredicateResult |= !(testFeatureBits(MI, C->Value));
68
145
    return true;
69
145
  }
70
289k
  if (C->Kind == AliasPatternCond_K_EndOrFeatures) {
71
10.6k
    bool Res = *OrPredicateResult;
72
10.6k
    *OrPredicateResult = false;
73
10.6k
    return Res;
74
10.6k
  }
75
76
  // Get and consume an operand.
77
278k
  MCOperand *Opnd = MCInst_getOperand(MI, *OpIdx);
78
278k
  ++(*OpIdx);
79
80
  // Check the specific condition for the operand.
81
278k
  switch (C->Kind) {
82
0
  default:
83
0
    assert(0 && "invalid kind");
84
105k
  case AliasPatternCond_K_Imm:
85
    // Operand must be a specific immediate.
86
105k
    return MCOperand_isImm(Opnd) &&
87
105k
           MCOperand_getImm(Opnd) == (int32_t)C->Value;
88
18.0k
  case AliasPatternCond_K_Reg:
89
    // Operand must be a specific register.
90
18.0k
    return MCOperand_isReg(Opnd) &&
91
18.0k
           MCOperand_getReg(Opnd) == C->Value;
92
946
  case AliasPatternCond_K_TiedReg:
93
    // Operand must match the register of another operand.
94
946
    return MCOperand_isReg(Opnd) &&
95
946
           MCOperand_getReg(Opnd) ==
96
946
             MCOperand_getReg(
97
946
               MCInst_getOperand(MI, C->Value));
98
113k
  case AliasPatternCond_K_RegClass:
99
    // Operand must be a register in this class. Value is a register class
100
    // id.
101
113k
    return MCOperand_isReg(Opnd) &&
102
113k
           MCRegisterClass_contains(
103
113k
             MCRegisterInfo_getRegClass(MRI, C->Value),
104
113k
             MCOperand_getReg(Opnd));
105
6.04k
  case AliasPatternCond_K_Custom:
106
    // Operand must match some custom criteria.
107
6.04k
    assert(M->ValidateMCOperand &&
108
6.04k
           "A custom validator should be set but isn't.");
109
6.04k
    return M->ValidateMCOperand(Opnd, C->Value);
110
34.8k
  case AliasPatternCond_K_Ignore:
111
    // Operand can be anything.
112
34.8k
    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
278k
  }
120
0
  return false;
121
278k
}
122
123
/// Check if PatternsForOpcode is all zero.
124
static inline bool validOpToPatter(const PatternsForOpcode *P)
125
75.9M
{
126
75.9M
  return !(P->Opcode == 0 && P->PatternStart == 0 && P->NumPatterns == 0);
127
75.9M
}
128
129
const char *matchAliasPatterns(MCInst *MI, const AliasMatchingData *M)
130
575k
{
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
575k
  unsigned MIOpcode = MI->Opcode;
143
575k
  size_t i = 0;
144
575k
  uint32_t PatternOpcode = M->OpToPatterns[i].Opcode;
145
76.3M
  while (PatternOpcode < MIOpcode && validOpToPatter(&M->OpToPatterns[i]))
146
75.7M
    PatternOpcode = M->OpToPatterns[++i].Opcode;
147
575k
  if (PatternOpcode != MI->Opcode ||
148
52.8k
      !validOpToPatter(&M->OpToPatterns[i]))
149
522k
    return NULL;
150
151
  // // Try all patterns for this opcode.
152
52.8k
  uint32_t AsmStrOffset = ~0U;
153
52.8k
  const AliasPattern *Patterns =
154
52.8k
    M->Patterns + M->OpToPatterns[i].PatternStart;
155
52.8k
  for (const AliasPattern *P = Patterns;
156
166k
       P != Patterns + M->OpToPatterns[i].NumPatterns; ++P) {
157
    // Check operand count first.
158
133k
    if (MCInst_getNumOperands(MI) != P->NumOperands)
159
0
      return NULL;
160
161
    // Test all conditions for this pattern.
162
133k
    const AliasPatternCond *Conds =
163
133k
      M->PatternConds + P->AliasCondStart;
164
133k
    unsigned OpIdx = 0;
165
133k
    bool OrPredicateResult = false;
166
133k
    bool allMatch = true;
167
133k
    for (const AliasPatternCond *C = Conds;
168
342k
         C != Conds + P->NumConds; ++C) {
169
321k
      if (!matchAliasCondition(MI, MI->MRI, &OpIdx, M, C,
170
321k
             &OrPredicateResult)) {
171
113k
        allMatch = false;
172
113k
        break;
173
113k
      }
174
321k
    }
175
133k
    if (allMatch) {
176
20.2k
      AsmStrOffset = P->AsmStrOffset;
177
20.2k
      break;
178
20.2k
    }
179
133k
  }
180
  // If no alias matched, don't print an alias.
181
52.8k
  if (AsmStrOffset == ~0U)
182
32.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
20.2k
  return M->AsmStrings + AsmStrOffset;
188
52.8k
}
189
190
// TODO Add functionality to toggle the flag.
191
bool getUseMarkup(void)
192
3.05M
{
193
3.05M
  return false;
194
3.05M
}
195
196
/// Utility functions to make adding mark ups simpler.
197
const char *markup(const char *s)
198
3.00M
{
199
3.00M
  static const char *no_markup = "";
200
3.00M
  if (getUseMarkup())
201
0
    return s;
202
3.00M
  else
203
3.00M
    return no_markup;
204
3.00M
}
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
48.5k
{
211
  // binary searching since the index is sorted in encoding order
212
48.5k
  size_t left, right, m;
213
214
48.5k
  right = size - 1;
215
216
48.5k
  if (encoding < index[0].encoding || encoding > index[right].encoding)
217
    // not found
218
9.17k
    return -1;
219
220
39.3k
  left = 0;
221
222
174k
  while (left <= right) {
223
164k
    m = (left + right) / 2;
224
164k
    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
28.7k
      while (m > 0 && encoding == index[m - 1].encoding)
229
0
        --m;
230
28.7k
      return m;
231
28.7k
    }
232
233
135k
    if (encoding < index[m].encoding)
234
55.5k
      right = m - 1;
235
79.7k
    else
236
79.7k
      left = m + 1;
237
135k
  }
238
239
  // not found
240
10.6k
  return -1;
241
39.3k
}
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.16k
{
248
  // binary searching since the index is sorted in encoding order
249
1.16k
  size_t left, right, m;
250
251
1.16k
  right = size - 1;
252
253
1.16k
  int str_left_cmp = strcmp(name, index[0].name);
254
1.16k
  int str_right_cmp = strcmp(name, index[right].name);
255
1.16k
  if (str_left_cmp < 0 || str_right_cmp > 0)
256
    // not found
257
0
    return -1;
258
259
1.16k
  left = 0;
260
261
12.0k
  while (left <= right) {
262
12.0k
    m = (left + right) / 2;
263
12.0k
    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.16k
      while (m > 0 && (strcmp(name, index[m - 1].name) == 0))
268
0
        --m;
269
1.16k
      return m;
270
1.16k
    }
271
272
10.9k
    if (strcmp(name, index[m].name) < 0)
273
4.78k
      right = m - 1;
274
6.14k
    else
275
6.14k
      left = m + 1;
276
10.9k
  }
277
278
  // not found
279
4
  return -1;
280
1.16k
}