Commit | Line | Data |
---|---|---|
28e7fd62 | 1 | /* Copyright (C) 2012-2013 Free Software Foundation, Inc. |
d5367fe1 JB |
2 | |
3 | This file is part of GDB. | |
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 3 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, see <http://www.gnu.org/licenses/>. */ | |
17 | ||
18 | #include "defs.h" | |
19 | #include "osabi.h" | |
20 | #include "regcache.h" | |
21 | #include "gdbcore.h" | |
22 | #include "gdbtypes.h" | |
23 | #include "infcall.h" | |
24 | #include "ppc-tdep.h" | |
25 | #include "value.h" | |
26 | #include "xcoffread.h" | |
27 | ||
28 | /* Implement the "push_dummy_call" gdbarch method. */ | |
29 | ||
30 | static CORE_ADDR | |
31 | rs6000_lynx178_push_dummy_call (struct gdbarch *gdbarch, | |
32 | struct value *function, | |
33 | struct regcache *regcache, CORE_ADDR bp_addr, | |
34 | int nargs, struct value **args, CORE_ADDR sp, | |
35 | int struct_return, CORE_ADDR struct_addr) | |
36 | { | |
37 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
38 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); | |
39 | int ii; | |
40 | int len = 0; | |
41 | int argno; /* current argument number */ | |
42 | int argbytes; /* current argument byte */ | |
43 | gdb_byte tmp_buffer[50]; | |
44 | int f_argno = 0; /* current floating point argno */ | |
45 | int wordsize = gdbarch_tdep (gdbarch)->wordsize; | |
46 | CORE_ADDR func_addr = find_function_addr (function, NULL); | |
47 | ||
48 | struct value *arg = 0; | |
49 | struct type *type; | |
50 | ||
51 | ULONGEST saved_sp; | |
52 | ||
53 | /* The calling convention this function implements assumes the | |
54 | processor has floating-point registers. We shouldn't be using it | |
55 | on PPC variants that lack them. */ | |
56 | gdb_assert (ppc_floating_point_unit_p (gdbarch)); | |
57 | ||
58 | /* The first eight words of ther arguments are passed in registers. | |
59 | Copy them appropriately. */ | |
60 | ii = 0; | |
61 | ||
62 | /* If the function is returning a `struct', then the first word | |
63 | (which will be passed in r3) is used for struct return address. | |
64 | In that case we should advance one word and start from r4 | |
65 | register to copy parameters. */ | |
66 | if (struct_return) | |
67 | { | |
68 | regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, | |
69 | struct_addr); | |
70 | ii++; | |
71 | } | |
72 | ||
73 | /* Effectively indirect call... gcc does... | |
74 | ||
75 | return_val example( float, int); | |
76 | ||
77 | eabi: | |
78 | float in fp0, int in r3 | |
79 | offset of stack on overflow 8/16 | |
80 | for varargs, must go by type. | |
81 | power open: | |
82 | float in r3&r4, int in r5 | |
83 | offset of stack on overflow different | |
84 | both: | |
85 | return in r3 or f0. If no float, must study how gcc emulates floats; | |
86 | pay attention to arg promotion. | |
87 | User may have to cast\args to handle promotion correctly | |
88 | since gdb won't know if prototype supplied or not. */ | |
89 | ||
90 | for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii) | |
91 | { | |
92 | int reg_size = register_size (gdbarch, ii + 3); | |
93 | ||
94 | arg = args[argno]; | |
95 | type = check_typedef (value_type (arg)); | |
96 | len = TYPE_LENGTH (type); | |
97 | ||
98 | if (TYPE_CODE (type) == TYPE_CODE_FLT) | |
99 | { | |
100 | ||
101 | /* Floating point arguments are passed in fpr's, as well as gpr's. | |
102 | There are 13 fpr's reserved for passing parameters. At this point | |
103 | there is no way we would run out of them. */ | |
104 | ||
105 | gdb_assert (len <= 8); | |
106 | ||
107 | regcache_cooked_write (regcache, | |
108 | tdep->ppc_fp0_regnum + 1 + f_argno, | |
109 | value_contents (arg)); | |
110 | ++f_argno; | |
111 | } | |
112 | ||
113 | if (len > reg_size) | |
114 | { | |
115 | ||
116 | /* Argument takes more than one register. */ | |
117 | while (argbytes < len) | |
118 | { | |
119 | gdb_byte word[MAX_REGISTER_SIZE]; | |
120 | memset (word, 0, reg_size); | |
121 | memcpy (word, | |
122 | ((char *) value_contents (arg)) + argbytes, | |
123 | (len - argbytes) > reg_size | |
124 | ? reg_size : len - argbytes); | |
125 | regcache_cooked_write (regcache, | |
126 | tdep->ppc_gp0_regnum + 3 + ii, | |
127 | word); | |
128 | ++ii, argbytes += reg_size; | |
129 | ||
130 | if (ii >= 8) | |
131 | goto ran_out_of_registers_for_arguments; | |
132 | } | |
133 | argbytes = 0; | |
134 | --ii; | |
135 | } | |
136 | else | |
137 | { | |
138 | /* Argument can fit in one register. No problem. */ | |
139 | int adj = gdbarch_byte_order (gdbarch) | |
140 | == BFD_ENDIAN_BIG ? reg_size - len : 0; | |
141 | gdb_byte word[MAX_REGISTER_SIZE]; | |
142 | ||
143 | memset (word, 0, reg_size); | |
144 | memcpy (word, value_contents (arg), len); | |
145 | regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word); | |
146 | } | |
147 | ++argno; | |
148 | } | |
149 | ||
150 | ran_out_of_registers_for_arguments: | |
151 | ||
152 | regcache_cooked_read_unsigned (regcache, | |
153 | gdbarch_sp_regnum (gdbarch), | |
154 | &saved_sp); | |
155 | ||
156 | /* Location for 8 parameters are always reserved. */ | |
157 | sp -= wordsize * 8; | |
158 | ||
159 | /* Another six words for back chain, TOC register, link register, etc. */ | |
160 | sp -= wordsize * 6; | |
161 | ||
162 | /* Stack pointer must be quadword aligned. */ | |
163 | sp = align_down (sp, 16); | |
164 | ||
165 | /* If there are more arguments, allocate space for them in | |
166 | the stack, then push them starting from the ninth one. */ | |
167 | ||
168 | if ((argno < nargs) || argbytes) | |
169 | { | |
170 | int space = 0, jj; | |
171 | ||
172 | if (argbytes) | |
173 | { | |
174 | space += align_up (len - argbytes, 4); | |
175 | jj = argno + 1; | |
176 | } | |
177 | else | |
178 | jj = argno; | |
179 | ||
180 | for (; jj < nargs; ++jj) | |
181 | { | |
182 | struct value *val = args[jj]; | |
183 | ||
184 | space += align_up (TYPE_LENGTH (value_type (val)), 4); | |
185 | } | |
186 | ||
187 | /* Add location required for the rest of the parameters. */ | |
188 | space = align_up (space, 16); | |
189 | sp -= space; | |
190 | ||
191 | /* This is another instance we need to be concerned about | |
192 | securing our stack space. If we write anything underneath %sp | |
193 | (r1), we might conflict with the kernel who thinks he is free | |
194 | to use this area. So, update %sp first before doing anything | |
195 | else. */ | |
196 | ||
197 | regcache_raw_write_signed (regcache, | |
198 | gdbarch_sp_regnum (gdbarch), sp); | |
199 | ||
200 | /* If the last argument copied into the registers didn't fit there | |
201 | completely, push the rest of it into stack. */ | |
202 | ||
203 | if (argbytes) | |
204 | { | |
205 | write_memory (sp + 24 + (ii * 4), | |
206 | value_contents (arg) + argbytes, | |
207 | len - argbytes); | |
208 | ++argno; | |
209 | ii += align_up (len - argbytes, 4) / 4; | |
210 | } | |
211 | ||
212 | /* Push the rest of the arguments into stack. */ | |
213 | for (; argno < nargs; ++argno) | |
214 | { | |
215 | ||
216 | arg = args[argno]; | |
217 | type = check_typedef (value_type (arg)); | |
218 | len = TYPE_LENGTH (type); | |
219 | ||
220 | ||
221 | /* Float types should be passed in fpr's, as well as in the | |
222 | stack. */ | |
223 | if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13) | |
224 | { | |
225 | ||
226 | gdb_assert (len <= 8); | |
227 | ||
228 | regcache_cooked_write (regcache, | |
229 | tdep->ppc_fp0_regnum + 1 + f_argno, | |
230 | value_contents (arg)); | |
231 | ++f_argno; | |
232 | } | |
233 | ||
234 | write_memory (sp + 24 + (ii * 4), value_contents (arg), len); | |
235 | ii += align_up (len, 4) / 4; | |
236 | } | |
237 | } | |
238 | ||
239 | /* Set the stack pointer. According to the ABI, the SP is meant to | |
240 | be set _before_ the corresponding stack space is used. On AIX, | |
241 | this even applies when the target has been completely stopped! | |
242 | Not doing this can lead to conflicts with the kernel which thinks | |
243 | that it still has control over this not-yet-allocated stack | |
244 | region. */ | |
245 | regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp); | |
246 | ||
247 | /* Set back chain properly. */ | |
248 | store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp); | |
249 | write_memory (sp, tmp_buffer, wordsize); | |
250 | ||
251 | /* Point the inferior function call's return address at the dummy's | |
252 | breakpoint. */ | |
253 | regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr); | |
254 | ||
255 | target_store_registers (regcache, -1); | |
256 | return sp; | |
257 | } | |
258 | ||
259 | /* Implement the "return_value" gdbarch method. */ | |
260 | ||
261 | static enum return_value_convention | |
262 | rs6000_lynx178_return_value (struct gdbarch *gdbarch, struct value *function, | |
263 | struct type *valtype, struct regcache *regcache, | |
264 | gdb_byte *readbuf, const gdb_byte *writebuf) | |
265 | { | |
266 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
267 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); | |
268 | ||
269 | /* The calling convention this function implements assumes the | |
270 | processor has floating-point registers. We shouldn't be using it | |
271 | on PowerPC variants that lack them. */ | |
272 | gdb_assert (ppc_floating_point_unit_p (gdbarch)); | |
273 | ||
274 | /* AltiVec extension: Functions that declare a vector data type as a | |
275 | return value place that return value in VR2. */ | |
276 | if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype) | |
277 | && TYPE_LENGTH (valtype) == 16) | |
278 | { | |
279 | if (readbuf) | |
280 | regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf); | |
281 | if (writebuf) | |
282 | regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf); | |
283 | ||
284 | return RETURN_VALUE_REGISTER_CONVENTION; | |
285 | } | |
286 | ||
287 | /* If the called subprogram returns an aggregate, there exists an | |
288 | implicit first argument, whose value is the address of a caller- | |
289 | allocated buffer into which the callee is assumed to store its | |
290 | return value. All explicit parameters are appropriately | |
291 | relabeled. */ | |
292 | if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT | |
293 | || TYPE_CODE (valtype) == TYPE_CODE_UNION | |
294 | || TYPE_CODE (valtype) == TYPE_CODE_ARRAY) | |
295 | return RETURN_VALUE_STRUCT_CONVENTION; | |
296 | ||
297 | /* Scalar floating-point values are returned in FPR1 for float or | |
298 | double, and in FPR1:FPR2 for quadword precision. Fortran | |
299 | complex*8 and complex*16 are returned in FPR1:FPR2, and | |
300 | complex*32 is returned in FPR1:FPR4. */ | |
301 | if (TYPE_CODE (valtype) == TYPE_CODE_FLT | |
302 | && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8)) | |
303 | { | |
304 | struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum); | |
305 | gdb_byte regval[8]; | |
306 | ||
307 | /* FIXME: kettenis/2007-01-01: Add support for quadword | |
308 | precision and complex. */ | |
309 | ||
310 | if (readbuf) | |
311 | { | |
312 | regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval); | |
313 | convert_typed_floating (regval, regtype, readbuf, valtype); | |
314 | } | |
315 | if (writebuf) | |
316 | { | |
317 | convert_typed_floating (writebuf, valtype, regval, regtype); | |
318 | regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval); | |
319 | } | |
320 | ||
321 | return RETURN_VALUE_REGISTER_CONVENTION; | |
322 | } | |
323 | ||
324 | /* Values of the types int, long, short, pointer, and char (length | |
325 | is less than or equal to four bytes), as well as bit values of | |
326 | lengths less than or equal to 32 bits, must be returned right | |
327 | justified in GPR3 with signed values sign extended and unsigned | |
328 | values zero extended, as necessary. */ | |
329 | if (TYPE_LENGTH (valtype) <= tdep->wordsize) | |
330 | { | |
331 | if (readbuf) | |
332 | { | |
333 | ULONGEST regval; | |
334 | ||
335 | /* For reading we don't have to worry about sign extension. */ | |
336 | regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3, | |
337 | ®val); | |
338 | store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order, | |
339 | regval); | |
340 | } | |
341 | if (writebuf) | |
342 | { | |
343 | /* For writing, use unpack_long since that should handle any | |
344 | required sign extension. */ | |
345 | regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, | |
346 | unpack_long (valtype, writebuf)); | |
347 | } | |
348 | ||
349 | return RETURN_VALUE_REGISTER_CONVENTION; | |
350 | } | |
351 | ||
352 | /* Eight-byte non-floating-point scalar values must be returned in | |
353 | GPR3:GPR4. */ | |
354 | ||
355 | if (TYPE_LENGTH (valtype) == 8) | |
356 | { | |
357 | gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT); | |
358 | gdb_assert (tdep->wordsize == 4); | |
359 | ||
360 | if (readbuf) | |
361 | { | |
362 | gdb_byte regval[8]; | |
363 | ||
364 | regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval); | |
365 | regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4, | |
366 | regval + 4); | |
367 | memcpy (readbuf, regval, 8); | |
368 | } | |
369 | if (writebuf) | |
370 | { | |
371 | regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf); | |
372 | regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, | |
373 | writebuf + 4); | |
374 | } | |
375 | ||
376 | return RETURN_VALUE_REGISTER_CONVENTION; | |
377 | } | |
378 | ||
379 | return RETURN_VALUE_STRUCT_CONVENTION; | |
380 | } | |
381 | ||
382 | /* PowerPC Lynx178 OSABI sniffer. */ | |
383 | ||
384 | static enum gdb_osabi | |
385 | rs6000_lynx178_osabi_sniffer (bfd *abfd) | |
386 | { | |
387 | if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour) | |
388 | return GDB_OSABI_UNKNOWN; | |
389 | ||
390 | /* The only noticeable difference between Lynx178 XCOFF files and | |
391 | AIX XCOFF files comes from the fact that there are no shared | |
392 | libraries on Lynx178. So if the number of import files is | |
393 | different from zero, it cannot be a Lynx178 binary. */ | |
394 | if (xcoff_get_n_import_files (abfd) != 0) | |
395 | return GDB_OSABI_UNKNOWN; | |
396 | ||
397 | return GDB_OSABI_LYNXOS178; | |
398 | } | |
399 | ||
400 | /* Callback for powerpc-lynx178 initialization. */ | |
401 | ||
402 | static void | |
403 | rs6000_lynx178_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
404 | { | |
405 | set_gdbarch_push_dummy_call (gdbarch, rs6000_lynx178_push_dummy_call); | |
406 | set_gdbarch_return_value (gdbarch, rs6000_lynx178_return_value); | |
407 | set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); | |
408 | } | |
409 | ||
410 | /* -Wmissing-prototypes. */ | |
411 | extern initialize_file_ftype _initialize_rs6000_lynx178_tdep; | |
412 | ||
413 | void | |
414 | _initialize_rs6000_lynx178_tdep (void) | |
415 | { | |
416 | gdbarch_register_osabi_sniffer (bfd_arch_rs6000, | |
417 | bfd_target_xcoff_flavour, | |
418 | rs6000_lynx178_osabi_sniffer); | |
419 | gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178, | |
420 | rs6000_lynx178_init_osabi); | |
421 | } | |
422 |