/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 | } |