/[pearpc]/src/debug/asm.cc
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /src/debug/asm.cc

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1 - (show annotations)
Wed Sep 5 17:11:21 2007 UTC (12 years, 3 months ago) by dpavlin
File size: 5667 byte(s)
import upstream CVS
1 /*
2 * HT Editor
3 * asm.cc
4 *
5 * Copyright (C) 1999-2002 Stefan Weyergraf
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include <cstring>
22 #include <cstdio>
23 #include <cstdarg>
24
25 #include "asm.h"
26 #include "tools/data.h"
27 #include "system/types.h"
28 #include "tools/atom.h"
29 #include "tools/debug.h"
30
31 /* FIX8
32 #include "alphadis.h"
33 #include "ia64dis.h"
34 #include "ildis.h"
35 #include "javadis.h"
36 #include "x86dis.h"
37 */
38
39 /*
40 * CLASS Assembler
41 */
42
43 Assembler::Assembler(bool b)
44 {
45 codes = 0;
46 bigendian = b;
47 }
48
49 Assembler::~Assembler()
50 {
51 }
52
53 asm_insn *Assembler::alloc_insn()
54 {
55 return NULL;
56 }
57
58 void Assembler::deletecode(asm_code *code)
59 {
60 asm_code **p=&codes, *c=codes;
61 while (c) {
62 if (c==code) {
63 *p=c->next;
64 delete c;
65 return;
66 }
67 c=c->next;
68 p=&(*p)->next;
69 }
70 }
71
72 asm_code *Assembler::encode(asm_insn *asm_insn, int _options, CPU_ADDR cur_address)
73 {
74 free_asm_codes();
75 error=0;
76 options=_options;
77 return 0;
78 }
79
80 void Assembler::clearcode()
81 {
82 code.size=0;
83 }
84
85 void Assembler::emitbyte(byte b)
86 {
87 code.data[code.size] = b;
88 code.size++;
89 }
90
91 void Assembler::emitword(uint16 w)
92 {
93 if (bigendian) {
94 code.data[code.size+1] = (byte)w;
95 code.data[code.size+0] = (byte)(w>>8);
96 } else {
97 code.data[code.size+0] = (byte)w;
98 code.data[code.size+1] = (byte)(w>>8);
99 }
100 code.size += 2;
101 }
102
103 void Assembler::emitdword(uint32 d)
104 {
105 if (bigendian) {
106 code.data[code.size+3] = (byte)d;
107 code.data[code.size+2] = (byte)(d>>8);
108 code.data[code.size+1] = (byte)(d>>16);
109 code.data[code.size+0] = (byte)(d>>24);
110 } else {
111 code.data[code.size+0] = (byte)d;
112 code.data[code.size+1] = (byte)(d>>8);
113 code.data[code.size+2] = (byte)(d>>16);
114 code.data[code.size+3] = (byte)(d>>24);
115 }
116 code.size += 4;
117 }
118
119 void Assembler::free_asm_codes()
120 {
121 while (codes) {
122 asm_code *t=codes->next;
123 delete codes;
124 codes=t;
125 }
126 }
127
128 char *Assembler::get_error_msg()
129 {
130 return error_msg;
131 }
132
133 char *Assembler::get_name()
134 {
135 return "generic asm";
136 }
137
138 void Assembler::newcode()
139 {
140 code.size=0;
141 }
142
143 asm_code *Assembler::shortest(asm_code *codes)
144 {
145 asm_code *best=0;
146 uint32 bestv=0xffffffff;
147 while (codes) {
148 if (codes->size<bestv) {
149 best=codes;
150 bestv=codes->size;
151 }
152 codes=codes->next;
153 };
154 return best;
155 }
156
157 void Assembler::pushcode()
158 {
159 asm_code **t=&codes;
160 while (*t) {
161 t=&(*t)->next;
162 }
163 *t=new asm_code;
164
165 memmove(*t, &code, sizeof code);
166 (*t)->next=0;
167 }
168
169 int Assembler::translate_str(asm_insn *asm_insn, const char *s)
170 {
171 return 0;
172 }
173
174 void Assembler::set_error_msg(char *format, ...)
175 {
176 va_list arg;
177 va_start(arg, format);
178 vsprintf(error_msg, format, arg);
179 va_end(arg);
180 error=1;
181 }
182
183 void Assembler::set_imm_eval_proc(int (*p)(void *context, char **s, uint32 *v), void *c)
184 {
185 imm_eval_proc=p;
186 imm_eval_context=c;
187 }
188
189 /*
190 * CLASS disassembler
191 */
192
193 Disassembler::Disassembler()
194 {
195 disable_highlighting();
196 }
197
198 Disassembler::~Disassembler()
199 {
200 }
201
202 char* (*addr_sym_func)(CPU_ADDR addr, int *symstrlen, void *context) = NULL;
203 void* addr_sym_func_context = NULL;
204
205 dis_insn *Disassembler::createInvalidInsn()
206 {
207 return NULL;
208 }
209
210 void Disassembler::hexd(char **s, int size, int options, int imm)
211 {
212 char ff[16];
213 char *f = (char*)&ff;
214 char *t = *s;
215 *f++ = '%';
216 if ((imm>=0) && (imm<=9)) {
217 *s += sprintf(*s, "%d", imm);
218 } else if (options & DIS_STYLE_SIGNED) {
219 if (!(options & DIS_STYLE_HEX_NOZEROPAD)) f += sprintf(f, "0%d", size);
220 *f++ = 'd';
221 *f = 0;
222 *s += sprintf(*s, ff, imm);
223 } else {
224 if (options & DIS_STYLE_HEX_CSTYLE) *f++ = '#';
225 if (!(options & DIS_STYLE_HEX_NOZEROPAD)) f += sprintf(f, "0%d", size);
226 if (options & DIS_STYLE_HEX_UPPERCASE) *f++ = 'X'; else
227 *f++ = 'x';
228 if (options & DIS_STYLE_HEX_ASMSTYLE) *f++ = 'h';
229 *f = 0;
230 *s += sprintf(*s, ff, imm);
231 if ((options & DIS_STYLE_HEX_NOZEROPAD) && (*t-'0'>9)) {
232 memmove(t+1, t, strlen(t)+1);
233 *t = '0';
234 (*s)++;
235 }
236 }
237 }
238
239 bool Disassembler::selectNext(dis_insn *disasm_insn)
240 {
241 return false;
242 }
243
244 char *Disassembler::str(dis_insn *disasm_insn, int style)
245 {
246 return strf(disasm_insn, style, DISASM_STRF_DEFAULT_FORMAT);
247 }
248
249 const char *Disassembler::get_cs(AsmSyntaxHighlightEnum style)
250 {
251 const char *highlights[] = {
252 ASM_SYNTAX_DEFAULT,
253 ASM_SYNTAX_COMMENT,
254 ASM_SYNTAX_NUMBER,
255 ASM_SYNTAX_SYMBOL,
256 ASM_SYNTAX_STRING
257 };
258 return (highlight) ? highlights[(int)style] : "";
259 }
260
261 void Disassembler::enable_highlighting()
262 {
263 highlight = true;
264 }
265
266 void Disassembler::disable_highlighting()
267 {
268 highlight = false;
269 }
270
271 /* FIX8
272 BUILDER(ATOM_DISASM_X86, x86dis)
273 BUILDER(ATOM_DISASM_X86_VXD, x86dis_vxd)
274 BUILDER(ATOM_DISASM_ALPHA, Alphadis)
275 BUILDER(ATOM_DISASM_JAVA, javadis)
276 BUILDER(ATOM_DISASM_IA64, IA64Disassembler)
277 */
278
279 bool init_asm()
280 {
281 /* FIX8
282 REGISTER(ATOM_DISASM_X86, x86dis)
283 REGISTER(ATOM_DISASM_X86_VXD, x86dis_vxd)
284 REGISTER(ATOM_DISASM_ALPHA, Alphadis)
285 REGISTER(ATOM_DISASM_JAVA, javadis)
286 REGISTER(ATOM_DISASM_IA64, IA64Disassembler)
287 */
288 return true;
289 }
290
291 void done_asm()
292 {
293 /* FIX8
294 UNREGISTER(ATOM_DISASM_IA64, IA64Disassembler)
295 UNREGISTER(ATOM_DISASM_JAVA, javadis)
296 UNREGISTER(ATOM_DISASM_ALPHA, Alphadis)
297 UNREGISTER(ATOM_DISASM_X86_VXD, x86dis_vxd)
298 UNREGISTER(ATOM_DISASM_X86, x86dis)
299 */
300 }
301

  ViewVC Help
Powered by ViewVC 1.1.26