Commit | Line | Data |
---|---|---|
c906108c SS |
1 | /* Print instructions for Tahoe target machines, for GDB. |
2 | Copyright 1986, 1989, 1991, 1992 Free Software Foundation, Inc. | |
3 | Contributed by the State University of New York at Buffalo, by the | |
4 | Distributed Computer Systems Lab, Department of Computer Science, 1991. | |
5 | ||
6 | This file is part of GDB. | |
7 | ||
8 | This program is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 2 of the License, or | |
11 | (at your option) any later version. | |
12 | ||
13 | This program is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with this program; if not, write to the Free Software | |
20 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
21 | ||
22 | #include "defs.h" | |
23 | #include "symtab.h" | |
24 | #include "opcode/tahoe.h" | |
25 | ||
26 | /* Tahoe instructions are never longer than this. */ | |
27 | #define MAXLEN 62 | |
28 | ||
29 | /* Number of elements in the opcode table. */ | |
30 | #define NOPCODES (sizeof votstrs / sizeof votstrs[0]) | |
31 | ||
32 | static unsigned char *print_insn_arg (); | |
33 | ||
b83266a0 SS |
34 | /* Advance PC across any function entry prologue instructions |
35 | to reach some "real" code. */ | |
36 | ||
37 | CORE_ADDR | |
38 | tahoe_skip_prologue (pc) | |
39 | CORE_ADDR pc; | |
40 | { | |
41 | register int op = (unsigned char) read_memory_integer (pc, 1); | |
42 | if (op == 0x11) | |
43 | pc += 2; /* skip brb */ | |
44 | if (op == 0x13) | |
45 | pc += 3; /* skip brw */ | |
46 | if (op == 0x2c | |
47 | && ((unsigned char) read_memory_integer (pc+2, 1)) == 0x5e) | |
48 | pc += 3; /* skip subl2 */ | |
49 | if (op == 0xe9 | |
50 | && ((unsigned char) read_memory_integer (pc+1, 1)) == 0xae | |
51 | && ((unsigned char) read_memory_integer(pc+3, 1)) == 0x5e) | |
52 | pc += 4; /* skip movab */ | |
53 | if (op == 0xe9 | |
54 | && ((unsigned char) read_memory_integer (pc+1, 1)) == 0xce | |
55 | && ((unsigned char) read_memory_integer(pc+4, 1)) == 0x5e) | |
56 | pc += 5; /* skip movab */ | |
57 | if (op == 0xe9 | |
58 | && ((unsigned char) read_memory_integer (pc+1, 1)) == 0xee | |
59 | && ((unsigned char) read_memory_integer(pc+6, 1)) == 0x5e) | |
60 | pc += 7; /* skip movab */ | |
61 | return pc; | |
62 | } | |
63 | ||
392a587b JM |
64 | /* Return number of args passed to a frame. |
65 | Can return -1, meaning no way to tell. */ | |
66 | ||
67 | int | |
68 | tahoe_frame_num_args (fi) | |
69 | struct frame_info *fi; | |
70 | { | |
71 | return (((0xffff & read_memory_integer(((fi)->frame-4),4)) - 4) >> 2); | |
72 | } | |
b83266a0 | 73 | |
c906108c SS |
74 | /* Print the Tahoe instruction at address MEMADDR in debugged memory, |
75 | on STREAM. Returns length of the instruction, in bytes. */ | |
76 | ||
77 | int | |
78 | tahoe_print_insn (memaddr, stream) | |
79 | CORE_ADDR memaddr; | |
80 | GDB_FILE *stream; | |
81 | { | |
82 | unsigned char buffer[MAXLEN]; | |
83 | register int i; | |
84 | register unsigned char *p; | |
85 | register char *d; | |
86 | ||
87 | read_memory (memaddr, buffer, MAXLEN); | |
88 | ||
89 | for (i = 0; i < NOPCODES; i++) | |
90 | if (votstrs[i].detail.code == buffer[0] | |
91 | || votstrs[i].detail.code == *(unsigned short *)buffer) | |
92 | break; | |
93 | ||
94 | /* Handle undefined instructions. */ | |
95 | if (i == NOPCODES) | |
96 | { | |
97 | fprintf_unfiltered (stream, "0%o", buffer[0]); | |
98 | return 1; | |
99 | } | |
100 | ||
101 | fprintf_unfiltered (stream, "%s", votstrs[i].name); | |
102 | ||
103 | /* Point at first byte of argument data, | |
104 | and at descriptor for first argument. */ | |
105 | p = buffer + 1 + (votstrs[i].detail.code >= 0x100); | |
106 | d = votstrs[i].detail.args; | |
107 | ||
108 | if (*d) | |
109 | fputc_unfiltered ('\t', stream); | |
110 | ||
111 | while (*d) | |
112 | { | |
113 | p = print_insn_arg (d, p, memaddr + (p - buffer), stream); | |
114 | d += 2; | |
115 | if (*d) | |
116 | fprintf_unfiltered (stream, ","); | |
117 | } | |
118 | return p - buffer; | |
119 | } | |
120 | /*******************************************************************/ | |
121 | static unsigned char * | |
122 | print_insn_arg (d, p, addr, stream) | |
123 | char *d; | |
124 | register char *p; | |
125 | CORE_ADDR addr; | |
126 | GDB_FILE *stream; | |
127 | { | |
128 | int temp1 = 0; | |
129 | register int regnum = *p & 0xf; | |
130 | float floatlitbuf; | |
131 | ||
132 | if (*d == 'b') | |
133 | { | |
134 | if (d[1] == 'b') | |
135 | fprintf_unfiltered (stream, "0x%x", addr + *p++ + 1); | |
136 | else | |
137 | { | |
138 | ||
139 | temp1 = *p; | |
140 | temp1 <<= 8; | |
141 | temp1 |= *(p + 1); | |
142 | fprintf_unfiltered (stream, "0x%x", addr + temp1 + 2); | |
143 | p += 2; | |
144 | } | |
145 | } | |
146 | else | |
147 | switch ((*p++ >> 4) & 0xf) | |
148 | { | |
149 | case 0: | |
150 | case 1: | |
151 | case 2: | |
152 | case 3: /* Literal (short immediate byte) mode */ | |
153 | if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h') | |
154 | { | |
155 | *(int *)&floatlitbuf = 0x4000 + ((p[-1] & 0x3f) << 4); | |
156 | fprintf_unfiltered (stream, "$%f", floatlitbuf); | |
157 | } | |
158 | else | |
159 | fprintf_unfiltered (stream, "$%d", p[-1] & 0x3f); | |
160 | break; | |
161 | ||
162 | case 4: /* Indexed */ | |
163 | p = (char *) print_insn_arg (d, p, addr + 1, stream); | |
164 | fprintf_unfiltered (stream, "[%s]", REGISTER_NAME (regnum)); | |
165 | break; | |
166 | ||
167 | case 5: /* Register */ | |
168 | fprintf_unfiltered (stream, REGISTER_NAME (regnum)); | |
169 | break; | |
170 | ||
171 | case 7: /* Autodecrement */ | |
172 | fputc_unfiltered ('-', stream); | |
173 | case 6: /* Register deferred */ | |
174 | fprintf_unfiltered (stream, "(%s)", REGISTER_NAME (regnum)); | |
175 | break; | |
176 | ||
177 | case 9: /* Absolute Address & Autoincrement deferred */ | |
178 | fputc_unfiltered ('*', stream); | |
179 | if (regnum == PC_REGNUM) | |
180 | { | |
181 | temp1 = *p; | |
182 | temp1 <<= 8; | |
183 | temp1 |= *(p +1); | |
184 | ||
185 | fputc_unfiltered ('$', stream); | |
186 | print_address (temp1, stream); | |
187 | p += 4; | |
188 | break; | |
189 | } | |
190 | case 8: /*Immediate & Autoincrement SP */ | |
191 | if (regnum == 8) /*88 is Immediate Byte Mode*/ | |
192 | fprintf_unfiltered (stream, "$%d", *p++); | |
193 | ||
194 | else if (regnum == 9) /*89 is Immediate Word Mode*/ | |
195 | { | |
196 | temp1 = *p; | |
197 | temp1 <<= 8; | |
198 | temp1 |= *(p +1); | |
199 | fprintf_unfiltered (stream, "$%d", temp1); | |
200 | p += 2; | |
201 | } | |
202 | ||
203 | else if (regnum == PC_REGNUM) /*8F is Immediate Long Mode*/ | |
204 | { | |
205 | temp1 = *p; | |
206 | temp1 <<=8; | |
207 | temp1 |= *(p +1); | |
208 | temp1 <<=8; | |
209 | temp1 |= *(p +2); | |
210 | temp1 <<= 8; | |
211 | temp1 |= *(p +3); | |
212 | fprintf_unfiltered (stream, "$%d", temp1); | |
213 | p += 4; | |
214 | } | |
215 | ||
216 | else /*8E is Autoincrement SP Mode*/ | |
217 | fprintf_unfiltered (stream, "(%s)+", REGISTER_NAME (regnum)); | |
218 | break; | |
219 | ||
220 | case 11: /* Register + Byte Displacement Deferred Mode*/ | |
221 | fputc_unfiltered ('*', stream); | |
222 | case 10: /* Register + Byte Displacement Mode*/ | |
223 | if (regnum == PC_REGNUM) | |
224 | print_address (addr + *p + 2, stream); | |
225 | else | |
226 | fprintf_unfiltered (stream, "%d(%s)", *p, REGISTER_NAME (regnum)); | |
227 | p += 1; | |
228 | break; | |
229 | ||
230 | case 13: /* Register + Word Displacement Deferred Mode*/ | |
231 | fputc_unfiltered ('*', stream); | |
232 | case 12: /* Register + Word Displacement Mode*/ | |
233 | temp1 = *p; | |
234 | temp1 <<= 8; | |
235 | temp1 |= *(p +1); | |
236 | if (regnum == PC_REGNUM) | |
237 | print_address (addr + temp1 + 3, stream); | |
238 | else | |
239 | fprintf_unfiltered (stream, "%d(%s)", temp1, REGISTER_NAME (regnum)); | |
240 | p += 2; | |
241 | break; | |
242 | ||
243 | case 15: /* Register + Long Displacement Deferred Mode*/ | |
244 | fputc_unfiltered ('*', stream); | |
245 | case 14: /* Register + Long Displacement Mode*/ | |
246 | temp1 = *p; | |
247 | temp1 <<= 8; | |
248 | temp1 |= *(p +1); | |
249 | temp1 <<= 8; | |
250 | temp1 |= *(p +2); | |
251 | temp1 <<= 8; | |
252 | temp1 |= *(p +3); | |
253 | if (regnum == PC_REGNUM) | |
254 | print_address (addr + temp1 + 5, stream); | |
255 | else | |
256 | fprintf_unfiltered (stream, "%d(%s)", temp1, REGISTER_NAME (regnum)); | |
257 | p += 4; | |
258 | } | |
259 | ||
260 | return (unsigned char *) p; | |
261 | } | |
262 | ||
263 | ||
264 | ||
265 | ||
266 | ||
267 | ||
268 | ||
269 | ||
270 | ||
271 | ||
272 | ||
273 | ||
274 |