1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
|
#ifndef _MAGIC_ANALYSIS_H
#define _MAGIC_ANALYSIS_H
#include <magic.h>
#include <magic_mem.h>
/* Special convenience types. */
#define MAGIC_TYPE_SPECIAL_INIT(STR) { 0, STR, NULL, 0, STR, 0, 0, 0, 0, 0, 0, \
0, MAGIC_TYPE_FUNCTION, MAGIC_TYPE_EXTERNAL, 0, NULL }
EXTERN char magic_ne_str[];
EXTERN char magic_enf_str[];
EXTERN char magic_bo_str[];
EXTERN char magic_be_str[];
EXTERN char magic_bv_str[];
EXTERN char magic_vf_str[];
EXTERN const struct _magic_type magic_NULL_ENTRY_TYPE;
EXTERN const struct _magic_type magic_ENTRY_NOT_FOUND_TYPE;
EXTERN const struct _magic_type magic_BAD_OFFSET_TYPE;
EXTERN const struct _magic_type magic_BAD_ENTRY_TYPE;
EXTERN const struct _magic_type magic_BAD_VALUE_TYPE;
EXTERN const struct _magic_type magic_VALUE_FOUND;
#define MAGIC_TYPE_NULL_ENTRY (&magic_NULL_ENTRY_TYPE)
#define MAGIC_TYPE_ENTRY_NOT_FOUND (&magic_ENTRY_NOT_FOUND_TYPE)
#define MAGIC_TYPE_BAD_OFFSET (&magic_BAD_OFFSET_TYPE)
#define MAGIC_TYPE_BAD_ENTRY (&magic_BAD_ENTRY_TYPE)
#define MAGIC_TYPE_BAD_VALUE (&magic_BAD_VALUE_TYPE)
#define MAGIC_TYPE_VALUE_FOUND (&magic_VALUE_FOUND)
#define MAGIC_TYPE_IS_SPECIAL(T) (T == MAGIC_TYPE_NULL_ENTRY \
|| T == MAGIC_TYPE_ENTRY_NOT_FOUND || T == MAGIC_TYPE_BAD_OFFSET \
|| T == MAGIC_TYPE_BAD_ENTRY || T == MAGIC_TYPE_BAD_VALUE \
|| T == MAGIC_TYPE_VALUE_FOUND)
/* Magic state element macros. */
#define MAGIC_SEL_ANALYZE_POINTERS 0x00001
#define MAGIC_SEL_ANALYZE_NONPOINTERS 0x00002
#define MAGIC_SEL_ANALYZE_LIKELYPOINTERS 0x00004
#define MAGIC_SEL_ANALYZE_DATA 0x00008
#define MAGIC_SEL_ANALYZE_INVARIANTS 0x00010
#define MAGIC_SEL_ANALYZE_VIOLATIONS 0x00020
#define MAGIC_SEL_ANALYZE_WALKABLE 0x00040
#define MAGIC_SEL_ANALYZE_DYNAMIC 0x00080
#define MAGIC_SEL_ANALYZE_OUT_OF_BAND 0x00100
#define MAGIC_SEL_ANALYZE_LIB_SRC 0x00200
#define MAGIC_SEL_ANALYZE_ALL \
(MAGIC_SEL_ANALYZE_POINTERS | MAGIC_SEL_ANALYZE_NONPOINTERS \
| MAGIC_SEL_ANALYZE_DATA | MAGIC_SEL_ANALYZE_INVARIANTS \
| MAGIC_SEL_ANALYZE_VIOLATIONS | MAGIC_SEL_ANALYZE_WALKABLE \
| MAGIC_SEL_ANALYZE_DYNAMIC | MAGIC_SEL_ANALYZE_OUT_OF_BAND \
| MAGIC_SEL_ANALYZE_LIB_SRC)
#define MAGIC_SEL_SKIP_UNIONS 0x00400
#define MAGIC_SEL_SKIP_INTEGERS 0x00800
#define MAGIC_SEL_ANALYZE_NONPTRS_AS_PTRS 0x01000
#define MAGIC_SEL_ANALYZE_RETURN_TRG_PTRS 0x02000
#define MAGIC_SEL_FOUND_DATA 0x04000
#define MAGIC_SEL_FOUND_INVARIANTS 0x08000
#define MAGIC_SEL_FOUND_VIOLATIONS 0X10000
#define MAGIC_SEL_FOUND_WALKABLE 0x20000
/* Magic state element analyzed. */
typedef enum {
_ptr_type_found,
_other_types_found,
_void_type_found,
_comp_trg_types_found,
_badentry_found
} _magic_trg_stats_t;
struct _magic_sel_analyzed_s {
unsigned type_id, contained_type_id;
int flags;
int num;
union {
struct {
void *value;
union {
struct _magic_dsentry dsentry;
struct _magic_dfunction dfunction;
} trg;
struct {
struct _magic_dsentry *dsentry;
struct _magic_dfunction *dfunction;
} trg_p;
int trg_flags;
int trg_offset;
_magic_selement_t trg_selements[MAGIC_MAX_RECURSIVE_TYPES + 1];
_magic_trg_stats_t trg_stats[MAGIC_MAX_RECURSIVE_TYPES + 1];
int first_legal_trg_type;
unsigned num_legal_trg_types;
unsigned num_trg_types;
} ptr;
struct {
int value;
int trg_flags;
} nonptr;
} u;
};
typedef struct _magic_sel_analyzed_s _magic_sel_analyzed_t;
#define MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E) \
(((E)->u.ptr.trg_flags & MAGIC_STATE_TEXT) != 0)
#define MAGIC_SEL_ANALYZED_PTR_HAS_TRG_SENTRY(E) \
((E)->u.ptr.trg_flags && !MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E))
#define MAGIC_SEL_ANALYZED_PTR_SENTRY(E) \
((E)->u.ptr.trg_flags & MAGIC_SEL_ANALYZE_RETURN_TRG_PTRS) \
? (E)->u.ptr.trg_p.dsentry->sentry \
: (E)->u.ptr.trg.dsentry.sentry
#define MAGIC_SEL_ANALYZED_PTR_SENTRY_ADDRESS(E) \
((E)->u.ptr.trg_flags & MAGIC_SEL_ANALYZE_RETURN_TRG_PTRS) \
? &((E)->u.ptr.trg_p.dsentry->sentry) \
: &((E)->u.ptr.trg.dsentry.sentry)
#define MAGIC_SEL_ANALYZED_PTR_FUNCTION(E) \
((E)->u.ptr.trg_flags & MAGIC_SEL_ANALYZE_RETURN_TRG_PTRS) \
? (E)->u.ptr.trg_p.dfunction->function \
: (E)->u.ptr.trg.dfunction.function
#define MAGIC_SEL_ANALYZED_PTR_TRG_NAME(E) \
(MAGIC_SEL_ANALYZED_PTR_HAS_SPECIAL_TRG_TYPE(E) ? "" \
: MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E) \
? (MAGIC_SEL_ANALYZED_PTR_FUNCTION(E)).name \
: (MAGIC_SEL_ANALYZED_PTR_HAS_TRG_SENTRY(E) \
? (MAGIC_SEL_ANALYZED_PTR_SENTRY(E)).name : "?"))
#define MAGIC_SEL_ANALYZED_PTR_TRG_ADDRESS(E) \
(MAGIC_SEL_ANALYZED_PTR_HAS_SPECIAL_TRG_TYPE(E) ? NULL \
: MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E) \
? (MAGIC_SEL_ANALYZED_PTR_FUNCTION(E)).address \
: (MAGIC_SEL_ANALYZED_PTR_SENTRY(E)).address)
#define MAGIC_SEL_ANALYZED_PTR_PRINT_TRG_ABS_NAME(E) \
do { \
if (MAGIC_SEL_ANALYZED_PTR_HAS_SPECIAL_TRG_TYPE(E) \
|| MAGIC_SEL_ANALYZED_PTR_HAS_TRG_FUNCTION(E)) { \
_magic_printf(MAGIC_SEL_ANALYZED_PTR_TRG_NAME(E)); \
} else { \
magic_print_sentry_abs_name( \
MAGIC_SEL_ANALYZED_PTR_SENTRY_ADDRESS(E)); \
} \
} while(0)
#define MAGIC_SEL_ANALYZED_PTR_FIRST_TRG_TYPE(E) \
((E)->u.ptr.trg_selements[0].type)
#define MAGIC_SEL_ANALYZED_PTR_HAS_SPECIAL_TRG_TYPE(E) \
(MAGIC_TYPE_IS_SPECIAL(MAGIC_SEL_ANALYZED_PTR_FIRST_TRG_TYPE(E)))
#define MAGIC_SEL_ANALYZED_PTR_SET_SPECIAL_TRG_TYPE(E,T) \
do { \
(E)->u.ptr.trg_selements[0].type = T; \
(E)->u.ptr.num_trg_types = 1; \
(E)->u.ptr.num_legal_trg_types = 0; \
(E)->u.ptr.first_legal_trg_type = -1; \
} while(0)
#define MAGIC_SEL_ANALYZED_TRG_FLAGS(E) \
((E)->type_id == MAGIC_TYPE_POINTER ? (E)->u.ptr.trg_flags \
: (E)->u.nonptr.trg_flags)
#define MAGIC_SEL_ANALYZED_FLAG(E,F) (((E)->flags & F) != 0)
#define MAGIC_SEL_ANALYZED_TRG_STATS_HAS_VIOLATIONS(E) \
((E) == _other_types_found || (E) == _badentry_found)
#define MAGIC_SEL_ANALYZED_TRG_STATS_C(E) \
((E) == _ptr_type_found ? 'p' : (E) == _other_types_found ? 'o' \
: (E) == _void_type_found ? 'v' : (E) == _comp_trg_types_found ? 'c' \
: (E) == _badentry_found ? 'b' : '?')
#define MAGIC_SEL_ANALYZED_PRINT(E, FLAGS) do { \
_magic_printf("SEL_ANALYZED: (num=%d, type=%s, flags(DIVW)=%d%d%d%d", \
(E)->num, (E)->type_id == MAGIC_TYPE_POINTER ? "ptr" : "nonptr", \
MAGIC_SEL_ANALYZED_FLAG(E, MAGIC_SEL_FOUND_DATA), \
MAGIC_SEL_ANALYZED_FLAG(E, MAGIC_SEL_FOUND_INVARIANTS), \
MAGIC_SEL_ANALYZED_FLAG(E, MAGIC_SEL_FOUND_VIOLATIONS), \
MAGIC_SEL_ANALYZED_FLAG(E, MAGIC_SEL_FOUND_WALKABLE)); \
if((E)->type_id == MAGIC_TYPE_POINTER) { \
_magic_printf(", value=0x%08x, trg_name=", (E)->u.ptr.value); \
MAGIC_SEL_ANALYZED_PTR_PRINT_TRG_ABS_NAME(E); \
_magic_printf(", trg_offset=%d, trg_flags(RL)=%c%c", \
(E)->u.ptr.trg_offset, \
(E)->u.ptr.trg_flags \
? MAGIC_STATE_FLAGS_REGION_C((E)->u.ptr.trg_flags) : 0, \
(E)->u.ptr.trg_flags \
? MAGIC_STATE_FLAGS_LIBSPEC_C((E)->u.ptr.trg_flags) : 0); \
if((E)->u.ptr.num_trg_types > 0) { \
_magic_printf(", trg_selements=("); \
magic_sel_analyzed_trg_selements_print(E, FLAGS); \
_magic_printf(")"); \
} \
} else { \
_magic_printf(", value=%d/0x%08x", \
(E)->u.nonptr.value, (E)->u.nonptr.value); \
if((E)->u.nonptr.trg_flags) { \
_magic_printf(", trg_flags(RL)=%c%c", \
MAGIC_STATE_FLAGS_REGION_C((E)->u.nonptr.trg_flags), \
MAGIC_STATE_FLAGS_LIBSPEC_C((E)->u.nonptr.trg_flags)); \
} \
} \
_magic_printf(")"); \
} while(0)
/* Magic state element stats. */
struct _magic_sel_stats_s {
unsigned ptr_found;
unsigned nonptr_found;
unsigned nonptr_unconstrained_found;
int trg_flags;
int ptr_type_found;
int other_types_found;
int null_type_found;
int badoffset_found;
int unknown_found;
int void_type_found;
int comp_trg_types_found;
int value_found;
int badvalue_found;
int badentry_found;
};
typedef struct _magic_sel_stats_s _magic_sel_stats_t;
/* Magic state element stats. */
#define MAGIC_SEL_STAT_INCR(S,I,F) ((S)->F += (I)->F)
#define MAGIC_SEL_STATS_INCR(S,I) do { \
MAGIC_SEL_STAT_INCR(S,I, ptr_found); \
MAGIC_SEL_STAT_INCR(S,I, nonptr_found); \
MAGIC_SEL_STAT_INCR(S,I, nonptr_unconstrained_found); \
S->trg_flags |= I->trg_flags; \
MAGIC_SEL_STAT_INCR(S,I, ptr_type_found); \
MAGIC_SEL_STAT_INCR(S,I, other_types_found); \
MAGIC_SEL_STAT_INCR(S,I, null_type_found); \
MAGIC_SEL_STAT_INCR(S,I, badoffset_found); \
MAGIC_SEL_STAT_INCR(S,I, unknown_found); \
MAGIC_SEL_STAT_INCR(S,I, void_type_found); \
MAGIC_SEL_STAT_INCR(S,I, comp_trg_types_found); \
MAGIC_SEL_STAT_INCR(S,I, value_found); \
MAGIC_SEL_STAT_INCR(S,I, badvalue_found); \
MAGIC_SEL_STAT_INCR(S,I, badentry_found); \
} while(0)
#define MAGIC_SEL_STATS_HAS_VIOLATIONS(S) \
(MAGIC_SEL_STATS_NUM_VIOLATIONS(S) > 0)
#define MAGIC_SEL_STATS_NUM_VIOLATIONS(S) \
((S)->ptr_found ? MAGIC_SEL_PTR_STATS_NUM_VIOLATIONS(S) \
: MAGIC_SEL_NONPTR_STATS_NUM_VIOLATIONS(S))
#define MAGIC_SEL_PTR_STATS_NUM_VIOLATIONS(S) ((S)->other_types_found \
+ (S)->badoffset_found + (S)->unknown_found + (S)->badvalue_found \
+ (S)->badentry_found)
#define MAGIC_SEL_NONPTR_STATS_NUM_VIOLATIONS(S) ((S)->badvalue_found)
#define MAGIC_SEL_STATS_PRINT(E) do { \
_magic_printf("SEL_STATS: (type=%s", \
(E)->ptr_found ? "ptr" : "nonptr"); \
if((E)->trg_flags) { \
_magic_printf(", trg_flags(RL)=%c%c", \
MAGIC_STATE_FLAGS_REGION_C((E)->trg_flags), \
MAGIC_STATE_FLAGS_LIBSPEC_C((E)->trg_flags)); \
} \
if((E)->ptr_found) _magic_printf(", ptr_found=%d", (E)->ptr_found); \
if((E)->nonptr_found) \
_magic_printf(", nonptr_found=%d", (E)->nonptr_found); \
if((E)->nonptr_unconstrained_found) \
_magic_printf(", nonptr_unconstrained_found=%d", \
(E)->nonptr_unconstrained_found); \
if((E)->ptr_type_found) \
_magic_printf(", ptr_type_found=%d", (E)->ptr_type_found); \
if((E)->other_types_found) \
_magic_printf(", other_types_found=%d", (E)->other_types_found); \
if((E)->null_type_found) \
_magic_printf(", null_type_found=%d", (E)->null_type_found); \
if((E)->badoffset_found) \
_magic_printf(", badoffset_found=%d", (E)->badoffset_found); \
if((E)->unknown_found) \
_magic_printf(", unknown_found=%d", (E)->unknown_found); \
if((E)->void_type_found) \
_magic_printf(", void_type_found=%d", (E)->void_type_found); \
if((E)->comp_trg_types_found) \
_magic_printf(", comp_trg_types_found=%d", \
(E)->comp_trg_types_found); \
if((E)->value_found) \
_magic_printf(", value_found=%d", (E)->value_found); \
if((E)->badvalue_found) \
_magic_printf(", badvalue_found=%d", (E)->badvalue_found); \
if((E)->badentry_found) \
_magic_printf(", badentry_found=%d", (E)->badentry_found); \
_magic_printf(", violations=%d", MAGIC_SEL_STATS_NUM_VIOLATIONS(E)); \
_magic_printf(")"); \
} while(0)
/* Magic sentry macros. */
#define MAGIC_SENTRY_ANALYZE_STOP 1
#define MAGIC_SENTRY_ANALYZE_CONTINUE 2
#define MAGIC_SENTRY_ANALYZE_SKIP_PATH 3
#define MAGIC_SENTRY_ANALYZE_IS_VALID_RET(R) \
((R)>=MAGIC_SENTRY_ANALYZE_STOP && (R)<=MAGIC_SENTRY_ANALYZE_SKIP_PATH)
#ifndef __MINIX
#define MAGIC_PTR_LIKELY_INTS_START 0xFFFFF000
#else
#define MAGIC_PTR_LIKELY_INTS_START 0xE0000000
#endif
#define MAGIC_PTR_LIKELY_INTS_END 0xFFF
#define MAGIC_PTR_IS_LIKELY_INT(V) \
((V) && ((unsigned)(V)>=MAGIC_PTR_LIKELY_INTS_START \
|| (unsigned)(V)<=MAGIC_PTR_LIKELY_INTS_END))
#define MAGIC_INT_IS_LIKELY_PTR(V) \
((V) && !MAGIC_PTR_IS_LIKELY_INT((void*)V))
/* Magic callbacks. */
typedef int (*magic_cb_sentries_analyze_pre_t)(void);
PUBLIC void magic_setcb_sentries_analyze_pre(magic_cb_sentries_analyze_pre_t cb);
/* Magic state entry functions. */
typedef int (*magic_sentry_analyze_cb_t)(_magic_selement_t* selement,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
void* cb_args);
PUBLIC int magic_sentry_print_ptr_types(struct _magic_sentry* entry);
PUBLIC int magic_sentry_extract_ptrs(struct _magic_sentry* entry,
void ****ptr_map, const struct _magic_type ***ptr_type_map, int *ptr_num);
PUBLIC int magic_sentry_analyze(struct _magic_sentry* sentry, int flags,
const magic_sentry_analyze_cb_t cb, void* cb_args,
_magic_sel_stats_t *sentry_stats);
PUBLIC int magic_sentries_analyze(int flags, const magic_sentry_analyze_cb_t cb,
void* cb_args, _magic_sel_stats_t *sentries_stats);
PUBLIC int magic_sentry_print_selements(struct _magic_sentry* sentry);
PUBLIC int magic_sentry_print_ptr_selements(struct _magic_sentry* sentry,
int skip_null_ptrs, int max_target_recusions);
/* Magic dynamic state entry functions. */
PUBLIC int magic_dsentries_analyze(int flags,
const magic_sentry_analyze_cb_t cb, void* cb_args,
_magic_sel_stats_t *dsentries_stats);
/* Magic sentry analyze callbacks. */
PUBLIC int magic_sentry_print_el_cb(_magic_selement_t* selement,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
void* cb_args);
PUBLIC int magic_sentry_print_ptr_el_cb(_magic_selement_t* selement,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
void* cb_args);
PUBLIC int magic_sentry_print_el_with_trg_reg_cb(_magic_selement_t* selement,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
void* cb_args);
PUBLIC int magic_sentry_print_el_with_trg_cb(_magic_selement_t* selement,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats,
void* cb_args);
/* Magic sentry analyze helpers. */
#define magic_sentry_analyze_invariants(sentry, cb, cb_args, sentry_stats) \
magic_sentry_analyze(sentry, MAGIC_SEL_ANALYZE_POINTERS \
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_INVARIANTS, cb, \
cb_args, sentry_stats)
#define magic_sentries_analyze_invariants(cb, cb_args, sentries_stats) \
magic_sentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_INVARIANTS, cb, \
cb_args, sentries_stats)
#define magic_dsentries_analyze_invariants(cb, cb_args, dsentries_stats) \
magic_dsentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_INVARIANTS, cb, \
cb_args, dsentries_stats)
#define magic_allsentries_analyze_invariants(cb, cb_args, sentries_stats) \
magic_sentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_INVARIANTS \
| MAGIC_SEL_ANALYZE_DYNAMIC, cb, cb_args, sentries_stats)
#define magic_sentry_analyze_violations(sentry, cb, cb_args, sentry_stats) \
magic_sentry_analyze(sentry, MAGIC_SEL_ANALYZE_POINTERS \
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_VIOLATIONS, cb, \
cb_args, sentry_stats)
#define magic_sentries_analyze_violations(cb, cb_args, sentries_stats) \
magic_sentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_VIOLATIONS, cb, \
cb_args, sentries_stats)
#define magic_dsentries_analyze_violations(cb, cb_args, dsentries_stats) \
magic_dsentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_VIOLATIONS, cb, \
cb_args, dsentries_stats)
#define magic_allsentries_analyze_violations(cb, cb_args, sentries_stats) \
magic_sentries_analyze(MAGIC_SEL_ANALYZE_POINTERS \
| MAGIC_SEL_ANALYZE_NONPOINTERS | MAGIC_SEL_ANALYZE_VIOLATIONS \
| MAGIC_SEL_ANALYZE_DYNAMIC, cb, cb_args, sentries_stats)
#define magic_sentry_analyze_likely_pointers(sentry, cb, cb_args, sentry_stats)\
magic_sentry_analyze(sentry, MAGIC_SEL_ANALYZE_LIKELYPOINTERS \
| MAGIC_SEL_ANALYZE_DATA, cb, cb_args, sentry_stats)
#define magic_sentries_analyze_likely_pointers(cb, cb_args, sentries_stats) \
magic_sentries_analyze(MAGIC_SEL_ANALYZE_LIKELYPOINTERS \
| MAGIC_SEL_ANALYZE_DATA, cb, cb_args, sentries_stats)
#define magic_dsentries_analyze_likely_pointers(cb, cb_args, dsentries_stats) \
magic_dsentries_analyze(MAGIC_SEL_ANALYZE_LIKELYPOINTERS \
| MAGIC_SEL_ANALYZE_DATA, cb, cb_args, dsentries_stats)
#define magic_allsentries_analyze_likely_pointers(cb, cb_args, sentries_stats) \
magic_sentries_analyze(MAGIC_SEL_ANALYZE_LIKELYPOINTERS \
| MAGIC_SEL_ANALYZE_DATA | MAGIC_SEL_ANALYZE_DYNAMIC, cb, cb_args, \
sentries_stats)
/* Magic state type functions. */
PUBLIC int magic_type_count_ptrs(const struct _magic_type* type, int *ptr_num);
/* Magic type walk callbacks. */
PUBLIC int magic_type_examine_ptr_cb(const struct _magic_type* parent_type,
const unsigned parent_offset, int child_num, const struct _magic_type* type,
const unsigned offset, int depth, void* cb_args);
PUBLIC int magic_type_extract_ptr_cb(const struct _magic_type* parent_type,
const unsigned parent_offset, int child_num, const struct _magic_type* type,
const unsigned offset, int depth, void* cb_args);
PUBLIC int magic_type_analyzer_cb(const struct _magic_type* parent_type,
const unsigned parent_offset, int child_num, const struct _magic_type* type,
const unsigned offset, int depth, void* cb_args);
/* Magic state element functions. */
PUBLIC int magic_selement_analyze(_magic_selement_t *selement, int flags,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
PUBLIC int magic_selement_analyze_ptr(_magic_selement_t *selement, int flags,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
PUBLIC int magic_selement_analyze_nonptr(_magic_selement_t *selement, int flags,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
PUBLIC int magic_selement_analyze_ptr_value_invs(_magic_selement_t *selement,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
PUBLIC int magic_selement_analyze_ptr_trg_invs(_magic_selement_t *selement,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
PUBLIC _magic_trg_stats_t
magic_selement_analyze_ptr_target(const struct _magic_type *ptr_type,
const struct _magic_type *trg_type, int trg_flags);
PUBLIC int magic_selement_analyze_ptr_type_invs(_magic_selement_t *selement,
_magic_sel_analyzed_t *sel_analyzed, _magic_sel_stats_t *sel_stats);
PUBLIC int magic_selement_recurse_ptr(_magic_selement_t *selement,
_magic_selement_t *new_selement, int max_steps);
PUBLIC void
magic_sel_analyzed_trg_selements_print(_magic_sel_analyzed_t *sel_analyzed,
int flags);
PUBLIC _magic_selement_t*
magic_selement_type_cast(_magic_selement_t *selement, int flags,
const struct _magic_type* type, _magic_sel_analyzed_t *sel_analyzed,
_magic_sel_stats_t *sel_stats);
#endif /* _MAGIC_ANALYSIS_H */
|
