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
|
/* Chrysalide - Outil d'analyse de fichiers binaires
* processor.h - prototypes pour la gestion générique des architectures
*
* Copyright (C) 2008-2012 Cyrille Bagard
*
* This file is part of Chrysalide.
*
* Chrysalide is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* Chrysalide is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Foobar. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _ARCH_PROCESSOR_H
#define _ARCH_PROCESSOR_H
#include <glib-object.h>
#include "context.h"
#include "instruction.h"
#include "../common/endianness.h"
#include "../format/executable.h"
#define G_TYPE_ARCH_PROCESSOR g_arch_processor_get_type()
#define G_ARCH_PROCESSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_arch_processor_get_type(), GArchProcessor))
#define G_IS_ARCH_PROCESSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_arch_processor_get_type()))
#define G_ARCH_PROCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ARCH_PROCESSOR, GArchProcessorClass))
#define G_IS_ARCH_PROCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ARCH_PROCESSOR))
#define G_ARCH_PROCESSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ARCH_PROCESSOR, GArchProcessorClass))
/* Définition générique d'un processeur d'architecture (instance) */
typedef struct _GArchProcessor GArchProcessor;
/* Définition générique d'un processeur d'architecture (classe) */
typedef struct _GArchProcessorClass GArchProcessorClass;
/* Indique le type défini pour un processeur d'architecture. */
GType g_arch_processor_get_type(void);
/* Fournit un contexte propre au processeur d'une architecture. */
GProcContext *g_arch_processor_get_context(const GArchProcessor *);
/* Fournit un contexte lié au processeur pour une décompilation. */
//GDecContext *g_arch_processor_get_decomp_context(const GArchProcessor *);
/* Fournit le boustime du processeur d'une architecture. */
SourceEndian g_arch_processor_get_endianness(const GArchProcessor *);
/* Fournit la taille de l'espace mémoire d'une architecture. */
MemoryDataSize g_arch_processor_get_memory_size(const GArchProcessor *);
/* Fournit la taille min. des instructions d'une architecture. */
MemoryDataSize g_arch_processor_get_instruction_size(const GArchProcessor *);
/* Désassemble une instruction dans un flux de données. */
GArchInstruction *g_arch_processor_disassemble(const GArchProcessor *, GProcContext *, const GBinContent *, vmpa2t *, GExeFormat *);
/* ------------------ RASSEMBLEMENT DES INSTRUCTIONS DESASSEMBLEES ------------------ */
/* Protège ou lève la protection de l'accès aux instructions. */
void g_arch_processor_lock_unlock(GArchProcessor *, bool);
#define g_arch_processor_lock(p) g_arch_processor_lock_unlock(p, true)
#define g_arch_processor_unlock(p) g_arch_processor_lock_unlock(p, false)
/* Fournit la marque de dernière modification des instructions. */
unsigned int g_arch_processor_get_stamp(const GArchProcessor *);
/* ------------------ MANIPULATIONS DES INSTRUCTIONS DESASSEMBLEES ------------------ */
/* Couverture d'un groupe d'instructions */
typedef struct _instr_coverage instr_coverage;
/* Note les instructions désassemblées avec une architecture. */
void g_arch_processor_set_disassembled_instructions(GArchProcessor *, GArchInstruction *);
/* Fournit les instructions désassemblées pour une architecture. */
GArchInstruction *g_arch_processor_get_disassembled_instructions(const GArchProcessor *);
/* Fournit une instruction désassemblée pour une architecture. */
GArchInstruction *g_arch_processor_get_disassembled_instruction(const GArchProcessor *, size_t);
/* Compte le nombre d'instructions représentées. */
size_t g_arch_processor_count_disassembled_instructions(const GArchProcessor *);
/* Recherche un groupe d'instruction d'après son adresse. */
const instr_coverage *g_arch_processor_find_coverage_by_address(const GArchProcessor *, const vmpa2t *);
/* Recherche une instruction d'après son adresse. */
GArchInstruction *_g_arch_processor_find_instr_by_address(const GArchProcessor *, const vmpa2t *, bool);
/* Recherche rapidement une instruction d'après son adresse. */
GArchInstruction *_g_arch_processor_find_covered_instr_by_address(const GArchProcessor *, const instr_coverage *, const vmpa2t *, bool);
#define g_arch_processor_find_instr_by_address(proc, addr) \
_g_arch_processor_find_instr_by_address(proc, addr, false)
#define g_arch_processor_find_covered_instr_by_address(proc, coverage, addr) \
_g_arch_processor_find_covered_instr_by_address(proc, coverage, addr, false)
/* Fournit l'instruction qui en précède une autre. */
GArchInstruction *g_arch_processor_get_prev_instr(const GArchProcessor *, const GArchInstruction *);
/* Fournit l'instruction qui en suit une autre. */
GArchInstruction *g_arch_processor_get_next_instr(const GArchProcessor *, const GArchInstruction *);
#endif /* _ARCH_PROCESSOR_H */
|
