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
|
/* OpenIDA - Outil d'analyse de fichiers binaires
* routine.h - prototypes pour la manipulation des prototypes de fonctions et de variables
*
* Copyright (C) 2009-2010 Cyrille Bagard
*
* This file is part of OpenIDA.
*
* OpenIDA 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.
*
* OpenIDA 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 _ANALYSIS_ROUTINE_H
#define _ANALYSIS_ROUTINE_H
#include <glib-object.h>
#include <stdint.h>
#include <sys/types.h>
#include "block.h"
#include "variable.h"
#include "../arch/instruction.h"
#include "../decomp/instruction.h"
/* Type de routine traitée */
typedef enum _RoutineType
{
RTT_CLASSIC, /* Fonction ou méthode */
RTT_CONSTRUCTOR, /* Constructeur */
RTT_DESTRUCTOR /* Destructeur */
} RoutineType;
#define G_TYPE_BIN_ROUTINE g_bin_routine_get_type()
#define G_BIN_ROUTINE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_bin_routine_get_type(), GBinRoutine))
#define G_IS_BIN_ROUTINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_bin_routine_get_type()))
#define G_BIN_ROUTINE_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_bin_routine_get_type(), GBinRoutineIface))
/* Représentation générique de routine (instance) */
typedef struct _GBinRoutine GBinRoutine;
/* Représentation générique de routine (classe) */
typedef struct _GBinRoutineClass GBinRoutineClass;
/* Modalités de représentation en chaîne */
typedef enum _Routine2StringOptions
{
RSO_LONG_TYPE = (1 << 0), /* Type avec espace de noms */
RSO_NAMESPACE = (1 << 1) /* Affichage de l'appartenance */
} Routine2StringOptions;
#define RSO_ALL (RSO_LONG_TYPE | RSO_NAMESPACE)
/* Indique le type définit pour une représentation de routine. */
GType g_bin_routine_get_type(void);
/* Crée une représentation de routine. */
GBinRoutine *g_binary_routine_new(void);
/* Crée une représentation de routine construisant une instance. */
GBinRoutine *g_binary_routine_new_constructor(GDataType *);
/* Etablit la comparaison ascendante entre deux routines. */
int g_binary_routine_compare(const GBinRoutine **, const GBinRoutine **);
/* Etablit la comparaison descendante entre deux routines. */
int g_binary_routine_rcompare(const GBinRoutine **, const GBinRoutine **);
/* Définit la position physique / en mémoire d'une routine. */
void g_binary_routine_set_address(GBinRoutine *, vmpa_t);
/* Fournit la position physique / en mémoire d'une routine. */
vmpa_t g_binary_routine_get_address(const GBinRoutine *);
/* Définit la taille du code d'une routine. */
void g_binary_routine_set_size(GBinRoutine *, off_t);
/* Fournit la taille du code associé à une routine. */
off_t g_binary_routine_get_size(const GBinRoutine *);
/* Définit le type d'une routine. */
void g_binary_routine_set_type(GBinRoutine *, RoutineType);
/* Définit le groupe d'appartenance d'une routine donnée. */
void g_binary_routine_set_namespace(GBinRoutine *, GDataType *);
/* Fournit le groupe d'appartenance d'une routine donnée. */
GDataType *g_binary_routine_get_namespace(const GBinRoutine *);
/* Définit le nom humain d'une routine. */
void g_binary_routine_set_name(GBinRoutine *, char *);
/* Désignation humainement lisible ou NULL si non définie. */
const char *g_binary_routine_get_name(GBinRoutine *);
/* Fournit le nom long et humain d'une routine. */
const char *g_binary_routine_get_long_name(GBinRoutine *);
/* Définit de façon indirecte le nom humain d'une routine. */
void g_binary_routine_set_name_from_type(GBinRoutine *, GDataType *);
/* Fournit le type construisant le nom humain d'une routine. */
GDataType *g_binary_routine_get_type_from_name(const GBinRoutine *);
/* Définit le type de retour d'une routine. */
void g_binary_routine_set_return_type(GBinRoutine *, GDataType *);
/* Fournit le type de retour d'une routine. */
GDataType *g_binary_routine_get_return_type(const GBinRoutine *);
/* Ajoute un argument à une routine. */
void g_binary_routine_add_arg(GBinRoutine *, GBinVariable *);
/* Indique le nombre d'arguments associés à une routine. */
size_t g_binary_routine_get_args_count(const GBinRoutine *);
/* Fournit un argument d'une routine. */
GBinVariable *g_binary_routine_get_arg(GBinRoutine *, size_t);
/* Retire un argument d'une routine. */
void g_binary_routine_remove_arg(GBinRoutine *, size_t);
/* S'assure qu'une variable est bien associée à une routine. */
void g_binary_routine_register_if_needed(GBinRoutine *, size_t, bool);
/* Donne l'indice d'une variable dans la liste d'une routine. */
size_t g_binary_routine_get_var_index_from_offset(const GBinRoutine *, size_t, bool);
/* Fournit les instructions natives correspondantes. */
GArchInstruction *g_binary_routine_get_instructions(const GBinRoutine *);
/* Définit les instructions natives de la routine. */
void g_binary_routine_set_instructions(GBinRoutine *, GArchInstruction *);
/* Fournit les blocs basiques de la routine. */
GInstrBlock *g_binary_routine_get_basic_blocks(const GBinRoutine *);
/* Définit les blocs basiques de la routine. */
void g_binary_routine_set_basic_blocks(GBinRoutine *, GInstrBlock *);
/* Fournit les instructions décompilées correspondantes. */
GDecInstruction *g_binary_routine_get_decomp_instructions(const GBinRoutine *);
/* Définit les instructions décompilées de la routine. */
void g_binary_routine_set_decomp_instructions(GBinRoutine *, GDecInstruction *);
/* Décrit le prototype de la routine sous forme de caractères. */
char *_g_binary_routine_to_string(const GBinRoutine *, Routine2StringOptions);
#define g_binary_routine_to_string(r) _g_binary_routine_to_string((r), RSO_ALL)
/* Procède à l'impression de la description d'une routine. */
void g_binary_routine_output_info(const GBinRoutine *, GLangOutput *, GCodeBuffer *);
/* Procède à l'impression de la décompilation d'une routine. */
void g_binary_routine_print_code(const GBinRoutine *, GLangOutput *, GCodeBuffer *, bool);
#endif /* _ANALYSIS_ROUTINE_H */
|
