Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* Print VAX instructions. |
bbe6d95f | 2 | Copyright 1995, 1998, 2000, 2001 Free Software Foundation, Inc. |
252b5132 RH |
3 | Contributed by Pauline Middelink <middelin@polyware.iaf.nl> |
4 | ||
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 2 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the Free Software | |
17 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
18 | ||
0d8dfecf | 19 | #include "sysdep.h" |
252b5132 RH |
20 | #include "opcode/vax.h" |
21 | #include "dis-asm.h" | |
22 | ||
23 | /* Local function prototypes */ | |
24 | static int | |
25 | print_insn_arg PARAMS ((const char *, unsigned char *, bfd_vma, | |
26 | disassemble_info *)); | |
27 | ||
28 | static int | |
29 | print_insn_mode PARAMS ((int, unsigned char *, bfd_vma, disassemble_info *)); | |
30 | ||
31 | static char *reg_names[] = | |
32 | { | |
33 | "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", | |
34 | "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc" | |
35 | }; | |
36 | ||
37 | /* Sign-extend an (unsigned char). */ | |
38 | #if __STDC__ == 1 | |
39 | #define COERCE_SIGNED_CHAR(ch) ((signed char)(ch)) | |
40 | #else | |
41 | #define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128) | |
42 | #endif | |
43 | ||
44 | /* Get a 1 byte signed integer. */ | |
45 | #define NEXTBYTE(p) \ | |
46 | (p += 1, FETCH_DATA (info, p), \ | |
47 | COERCE_SIGNED_CHAR(p[-1])) | |
48 | ||
49 | /* Get a 2 byte signed integer. */ | |
50 | #define COERCE16(x) ((int) (((x) ^ 0x8000) - 0x8000)) | |
51 | #define NEXTWORD(p) \ | |
52 | (p += 2, FETCH_DATA (info, p), \ | |
53 | COERCE16 ((p[-1] << 8) + p[-2])) | |
54 | ||
55 | /* Get a 4 byte signed integer. */ | |
56 | #define COERCE32(x) ((int) (((x) ^ 0x80000000) - 0x80000000)) | |
57 | #define NEXTLONG(p) \ | |
58 | (p += 4, FETCH_DATA (info, p), \ | |
59 | (COERCE32 ((((((p[-1] << 8) + p[-2]) << 8) + p[-3]) << 8) + p[-4]))) | |
60 | ||
61 | /* Maximum length of an instruction. */ | |
62 | #define MAXLEN 25 | |
63 | ||
64 | #include <setjmp.h> | |
65 | ||
66 | struct private | |
67 | { | |
68 | /* Points to first byte not fetched. */ | |
69 | bfd_byte *max_fetched; | |
70 | bfd_byte the_buffer[MAXLEN]; | |
71 | bfd_vma insn_start; | |
72 | jmp_buf bailout; | |
73 | }; | |
74 | ||
75 | /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) | |
76 | to ADDR (exclusive) are valid. Returns 1 for success, longjmps | |
77 | on error. */ | |
78 | #define FETCH_DATA(info, addr) \ | |
79 | ((addr) <= ((struct private *)(info->private_data))->max_fetched \ | |
80 | ? 1 : fetch_data ((info), (addr))) | |
81 | ||
82 | static int | |
83 | fetch_data (info, addr) | |
84 | struct disassemble_info *info; | |
85 | bfd_byte *addr; | |
86 | { | |
87 | int status; | |
88 | struct private *priv = (struct private *) info->private_data; | |
89 | bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); | |
90 | ||
91 | status = (*info->read_memory_func) (start, | |
92 | priv->max_fetched, | |
93 | addr - priv->max_fetched, | |
94 | info); | |
95 | if (status != 0) | |
96 | { | |
97 | (*info->memory_error_func) (status, start, info); | |
98 | longjmp (priv->bailout, 1); | |
99 | } | |
100 | else | |
101 | priv->max_fetched = addr; | |
102 | ||
103 | return 1; | |
104 | } | |
105 | ||
106 | /* Print the vax instruction at address MEMADDR in debugged memory, | |
107 | on INFO->STREAM. Returns length of the instruction, in bytes. */ | |
108 | ||
109 | int | |
110 | print_insn_vax (memaddr, info) | |
111 | bfd_vma memaddr; | |
112 | disassemble_info *info; | |
113 | { | |
114 | const struct vot *votp; | |
115 | const char *argp = NULL; | |
116 | unsigned char *arg; | |
117 | struct private priv; | |
118 | bfd_byte *buffer = priv.the_buffer; | |
119 | ||
120 | info->private_data = (PTR) &priv; | |
121 | priv.max_fetched = priv.the_buffer; | |
122 | priv.insn_start = memaddr; | |
123 | if (setjmp (priv.bailout) != 0) | |
124 | { | |
125 | /* Error return. */ | |
126 | return -1; | |
127 | } | |
128 | ||
bbe6d95f AM |
129 | /* Check if the info buffer has more than one byte left since |
130 | the last opcode might be a single byte with no argument data. */ | |
131 | if (info->buffer_length - (memaddr - info->buffer_vma) > 1) | |
132 | { | |
133 | FETCH_DATA (info, buffer + 2); | |
134 | } | |
135 | else | |
136 | { | |
137 | FETCH_DATA (info, buffer + 1); | |
138 | buffer[1] = 0; | |
139 | } | |
140 | ||
252b5132 RH |
141 | for (votp = &votstrs[0]; votp->name[0]; votp++) |
142 | { | |
143 | register vax_opcodeT opcode = votp->detail.code; | |
144 | ||
145 | /* 2 byte codes match 2 buffer pos. */ | |
146 | if ((bfd_byte) opcode == buffer[0] | |
147 | && (opcode >> 8 == 0 || opcode >> 8 == buffer[1])) | |
148 | { | |
149 | argp = votp->detail.args; | |
150 | break; | |
151 | } | |
152 | } | |
153 | if (argp == NULL) | |
154 | { | |
155 | /* Handle undefined instructions. */ | |
156 | (*info->fprintf_func) (info->stream, ".word 0x%x", | |
157 | (buffer[0] << 8) + buffer[1]); | |
158 | return 2; | |
159 | } | |
160 | ||
161 | /* Point at first byte of argument data, and at descriptor for first | |
162 | argument. */ | |
163 | arg = buffer + ((votp->detail.code >> 8) ? 2 : 1); | |
164 | ||
165 | /* Make sure we have it in mem */ | |
166 | FETCH_DATA (info, arg); | |
167 | ||
168 | (*info->fprintf_func) (info->stream, "%s", votp->name); | |
169 | if (*argp) | |
170 | (*info->fprintf_func) (info->stream, " "); | |
171 | ||
172 | while (*argp) | |
173 | { | |
174 | arg += print_insn_arg (argp, arg, memaddr + arg - buffer, info); | |
175 | argp += 2; | |
176 | if (*argp) | |
177 | (*info->fprintf_func) (info->stream, ","); | |
178 | } | |
179 | ||
180 | return arg - buffer; | |
181 | } | |
182 | ||
183 | /* Returns number of bytes "eaten" by the operand, or return -1 if an | |
184 | invalid operand was found, or -2 if an opcode tabel error was | |
185 | found. */ | |
186 | ||
187 | static int | |
188 | print_insn_arg (d, p0, addr, info) | |
189 | const char *d; | |
190 | unsigned char *p0; | |
191 | bfd_vma addr; /* PC for this arg to be relative to */ | |
192 | disassemble_info *info; | |
193 | { | |
194 | int arg_len; | |
195 | ||
196 | /* check validity of addressing length */ | |
197 | switch (d[1]) | |
198 | { | |
199 | case 'b' : arg_len = 1; break; | |
200 | case 'd' : arg_len = 8; break; | |
201 | case 'f' : arg_len = 4; break; | |
202 | case 'g' : arg_len = 8; break; | |
203 | case 'h' : arg_len = 16; break; | |
204 | case 'l' : arg_len = 4; break; | |
205 | case 'o' : arg_len = 16; break; | |
206 | case 'w' : arg_len = 2; break; | |
207 | case 'q' : arg_len = 8; break; | |
208 | default : abort(); | |
209 | } | |
210 | ||
211 | /* branches have no mode byte */ | |
212 | if (d[0] == 'b') | |
213 | { | |
214 | unsigned char *p = p0; | |
215 | ||
216 | if (arg_len == 1) | |
217 | (*info->print_address_func) (addr + 1 + NEXTBYTE (p), info); | |
218 | else | |
219 | (*info->print_address_func) (addr + 2 + NEXTWORD (p), info); | |
220 | ||
221 | return p - p0; | |
222 | } | |
223 | ||
224 | return print_insn_mode (arg_len, p0, addr, info); | |
225 | } | |
226 | ||
227 | static int | |
228 | print_insn_mode (size, p0, addr, info) | |
229 | int size; | |
230 | unsigned char *p0; | |
231 | bfd_vma addr; /* PC for this arg to be relative to */ | |
232 | disassemble_info *info; | |
233 | { | |
234 | unsigned char *p = p0; | |
235 | unsigned char mode, reg; | |
236 | ||
237 | /* fetch and interpret mode byte */ | |
238 | mode = (unsigned char) NEXTBYTE (p); | |
239 | reg = mode & 0xF; | |
240 | switch (mode & 0xF0) | |
241 | { | |
242 | case 0x00: | |
243 | case 0x10: | |
244 | case 0x20: | |
245 | case 0x30: /* literal mode $number */ | |
246 | (*info->fprintf_func) (info->stream, "$0x%x", mode); | |
247 | break; | |
248 | case 0x40: /* index: base-addr[Rn] */ | |
249 | p += print_insn_mode (size, p0 + 1, addr + 1, info); | |
250 | (*info->fprintf_func) (info->stream, "[%s]", reg_names[reg]); | |
251 | break; | |
252 | case 0x50: /* register: Rn */ | |
253 | (*info->fprintf_func) (info->stream, "%s", reg_names[reg]); | |
254 | break; | |
255 | case 0x60: /* register deferred: (Rn) */ | |
256 | (*info->fprintf_func) (info->stream, "(%s)", reg_names[reg]); | |
257 | break; | |
258 | case 0x70: /* autodecrement: -(Rn) */ | |
259 | (*info->fprintf_func) (info->stream, "-(%s)", reg_names[reg]); | |
260 | break; | |
261 | case 0x80: /* autoincrement: (Rn)+ */ | |
262 | if (reg == 0xF) | |
263 | { /* immediate? */ | |
264 | int i; | |
265 | ||
266 | FETCH_DATA (info, p + size); | |
267 | (*info->fprintf_func) (info->stream, "$0x"); | |
268 | for (i = 0; i < size; i++) | |
269 | (*info->fprintf_func) (info->stream, "%02x", p[size - i - 1]); | |
270 | p += size; | |
271 | } | |
272 | else | |
273 | (*info->fprintf_func) (info->stream, "(%s)+", reg_names[reg]); | |
274 | break; | |
275 | case 0x90: /* autoincrement deferred: @(Rn)+ */ | |
276 | if (reg == 0xF) | |
277 | (*info->fprintf_func) (info->stream, "*0x%x", NEXTLONG (p)); | |
278 | else | |
279 | (*info->fprintf_func) (info->stream, "@(%s)+", reg_names[reg]); | |
280 | break; | |
281 | case 0xB0: /* displacement byte deferred: *displ(Rn) */ | |
282 | (*info->fprintf_func) (info->stream, "*"); | |
283 | case 0xA0: /* displacement byte: displ(Rn) */ | |
284 | if (reg == 0xF) | |
285 | (*info->print_address_func) (addr + 2 + NEXTBYTE (p), info); | |
286 | else | |
287 | (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTBYTE (p), | |
288 | reg_names[reg]); | |
289 | break; | |
290 | case 0xD0: /* displacement word deferred: *displ(Rn) */ | |
291 | (*info->fprintf_func) (info->stream, "*"); | |
292 | case 0xC0: /* displacement word: displ(Rn) */ | |
293 | if (reg == 0xF) | |
294 | (*info->print_address_func) (addr + 3 + NEXTWORD (p), info); | |
295 | else | |
296 | (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTWORD (p), | |
297 | reg_names[reg]); | |
298 | break; | |
299 | case 0xF0: /* displacement long deferred: *displ(Rn) */ | |
300 | (*info->fprintf_func) (info->stream, "*"); | |
301 | case 0xE0: /* displacement long: displ(Rn) */ | |
302 | if (reg == 0xF) | |
303 | (*info->print_address_func) (addr + 5 + NEXTLONG (p), info); | |
304 | else | |
305 | (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTLONG (p), | |
306 | reg_names[reg]); | |
307 | break; | |
308 | } | |
309 | ||
310 | return p - p0; | |
311 | } |