GDB (xrefs)
/tmp/gdb-7.10/gdb/rs6000-lynx178-tdep.c
Go to the documentation of this file.
1 /* Copyright (C) 2012-2015 Free Software Foundation, Inc.
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
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. */
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  Always store the floating point value using the register's
106  floating-point format. */
107  const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
108  gdb_byte reg_val[MAX_REGISTER_SIZE];
109  struct type *reg_type = register_type (gdbarch, fp_regnum);
110 
111  gdb_assert (len <= 8);
112 
114  reg_val, reg_type);
115  regcache_cooked_write (regcache, fp_regnum, reg_val);
116  ++f_argno;
117  }
118 
119  if (len > reg_size)
120  {
121 
122  /* Argument takes more than one register. */
123  while (argbytes < len)
124  {
126  memset (word, 0, reg_size);
127  memcpy (word,
128  ((char *) value_contents (arg)) + argbytes,
129  (len - argbytes) > reg_size
130  ? reg_size : len - argbytes);
131  regcache_cooked_write (regcache,
132  tdep->ppc_gp0_regnum + 3 + ii,
133  word);
134  ++ii, argbytes += reg_size;
135 
136  if (ii >= 8)
137  goto ran_out_of_registers_for_arguments;
138  }
139  argbytes = 0;
140  --ii;
141  }
142  else
143  {
144  /* Argument can fit in one register. No problem. */
145  int adj = gdbarch_byte_order (gdbarch)
146  == BFD_ENDIAN_BIG ? reg_size - len : 0;
148 
149  memset (word, 0, reg_size);
150  memcpy (word, value_contents (arg), len);
151  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3 +ii, word);
152  }
153  ++argno;
154  }
155 
156 ran_out_of_registers_for_arguments:
157 
159  gdbarch_sp_regnum (gdbarch),
160  &saved_sp);
161 
162  /* Location for 8 parameters are always reserved. */
163  sp -= wordsize * 8;
164 
165  /* Another six words for back chain, TOC register, link register, etc. */
166  sp -= wordsize * 6;
167 
168  /* Stack pointer must be quadword aligned. */
169  sp = align_down (sp, 16);
170 
171  /* If there are more arguments, allocate space for them in
172  the stack, then push them starting from the ninth one. */
173 
174  if ((argno < nargs) || argbytes)
175  {
176  int space = 0, jj;
177 
178  if (argbytes)
179  {
180  space += align_up (len - argbytes, 4);
181  jj = argno + 1;
182  }
183  else
184  jj = argno;
185 
186  for (; jj < nargs; ++jj)
187  {
188  struct value *val = args[jj];
189 
190  space += align_up (TYPE_LENGTH (value_type (val)), 4);
191  }
192 
193  /* Add location required for the rest of the parameters. */
194  space = align_up (space, 16);
195  sp -= space;
196 
197  /* This is another instance we need to be concerned about
198  securing our stack space. If we write anything underneath %sp
199  (r1), we might conflict with the kernel who thinks he is free
200  to use this area. So, update %sp first before doing anything
201  else. */
202 
203  regcache_raw_write_signed (regcache,
204  gdbarch_sp_regnum (gdbarch), sp);
205 
206  /* If the last argument copied into the registers didn't fit there
207  completely, push the rest of it into stack. */
208 
209  if (argbytes)
210  {
211  write_memory (sp + 24 + (ii * 4),
212  value_contents (arg) + argbytes,
213  len - argbytes);
214  ++argno;
215  ii += align_up (len - argbytes, 4) / 4;
216  }
217 
218  /* Push the rest of the arguments into stack. */
219  for (; argno < nargs; ++argno)
220  {
221 
222  arg = args[argno];
223  type = check_typedef (value_type (arg));
224  len = TYPE_LENGTH (type);
225 
226 
227  /* Float types should be passed in fpr's, as well as in the
228  stack. */
229  if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13)
230  {
231 
232  gdb_assert (len <= 8);
233 
234  regcache_cooked_write (regcache,
235  tdep->ppc_fp0_regnum + 1 + f_argno,
236  value_contents (arg));
237  ++f_argno;
238  }
239 
240  write_memory (sp + 24 + (ii * 4), value_contents (arg), len);
241  ii += align_up (len, 4) / 4;
242  }
243  }
244 
245  /* Set the stack pointer. According to the ABI, the SP is meant to
246  be set _before_ the corresponding stack space is used. On AIX,
247  this even applies when the target has been completely stopped!
248  Not doing this can lead to conflicts with the kernel which thinks
249  that it still has control over this not-yet-allocated stack
250  region. */
251  regcache_raw_write_signed (regcache, gdbarch_sp_regnum (gdbarch), sp);
252 
253  /* Set back chain properly. */
254  store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
255  write_memory (sp, tmp_buffer, wordsize);
256 
257  /* Point the inferior function call's return address at the dummy's
258  breakpoint. */
259  regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
260 
261  target_store_registers (regcache, -1);
262  return sp;
263 }
264 
265 /* Implement the "return_value" gdbarch method. */
266 
267 static enum return_value_convention
269  struct type *valtype, struct regcache *regcache,
270  gdb_byte *readbuf, const gdb_byte *writebuf)
271 {
272  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
273  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
274 
275  /* The calling convention this function implements assumes the
276  processor has floating-point registers. We shouldn't be using it
277  on PowerPC variants that lack them. */
279 
280  /* AltiVec extension: Functions that declare a vector data type as a
281  return value place that return value in VR2. */
282  if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY && TYPE_VECTOR (valtype)
283  && TYPE_LENGTH (valtype) == 16)
284  {
285  if (readbuf)
286  regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
287  if (writebuf)
288  regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
289 
291  }
292 
293  /* If the called subprogram returns an aggregate, there exists an
294  implicit first argument, whose value is the address of a caller-
295  allocated buffer into which the callee is assumed to store its
296  return value. All explicit parameters are appropriately
297  relabeled. */
298  if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
299  || TYPE_CODE (valtype) == TYPE_CODE_UNION
300  || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
302 
303  /* Scalar floating-point values are returned in FPR1 for float or
304  double, and in FPR1:FPR2 for quadword precision. Fortran
305  complex*8 and complex*16 are returned in FPR1:FPR2, and
306  complex*32 is returned in FPR1:FPR4. */
307  if (TYPE_CODE (valtype) == TYPE_CODE_FLT
308  && (TYPE_LENGTH (valtype) == 4 || TYPE_LENGTH (valtype) == 8))
309  {
310  struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
311  gdb_byte regval[8];
312 
313  /* FIXME: kettenis/2007-01-01: Add support for quadword
314  precision and complex. */
315 
316  if (readbuf)
317  {
318  regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
319  convert_typed_floating (regval, regtype, readbuf, valtype);
320  }
321  if (writebuf)
322  {
323  convert_typed_floating (writebuf, valtype, regval, regtype);
324  regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
325  }
326 
328  }
329 
330  /* Values of the types int, long, short, pointer, and char (length
331  is less than or equal to four bytes), as well as bit values of
332  lengths less than or equal to 32 bits, must be returned right
333  justified in GPR3 with signed values sign extended and unsigned
334  values zero extended, as necessary. */
335  if (TYPE_LENGTH (valtype) <= tdep->wordsize)
336  {
337  if (readbuf)
338  {
339  ULONGEST regval;
340 
341  /* For reading we don't have to worry about sign extension. */
342  regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
343  &regval);
344  store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), byte_order,
345  regval);
346  }
347  if (writebuf)
348  {
349  /* For writing, use unpack_long since that should handle any
350  required sign extension. */
351  regcache_cooked_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3,
352  unpack_long (valtype, writebuf));
353  }
354 
356  }
357 
358  /* Eight-byte non-floating-point scalar values must be returned in
359  GPR3:GPR4. */
360 
361  if (TYPE_LENGTH (valtype) == 8)
362  {
363  gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_FLT);
364  gdb_assert (tdep->wordsize == 4);
365 
366  if (readbuf)
367  {
368  gdb_byte regval[8];
369 
370  regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, regval);
371  regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
372  regval + 4);
373  memcpy (readbuf, regval, 8);
374  }
375  if (writebuf)
376  {
377  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf);
378  regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
379  writebuf + 4);
380  }
381 
383  }
384 
386 }
387 
388 /* PowerPC Lynx178 OSABI sniffer. */
389 
390 static enum gdb_osabi
392 {
393  if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
394  return GDB_OSABI_UNKNOWN;
395 
396  /* The only noticeable difference between Lynx178 XCOFF files and
397  AIX XCOFF files comes from the fact that there are no shared
398  libraries on Lynx178. So if the number of import files is
399  different from zero, it cannot be a Lynx178 binary. */
400  if (xcoff_get_n_import_files (abfd) != 0)
401  return GDB_OSABI_UNKNOWN;
402 
403  return GDB_OSABI_LYNXOS178;
404 }
405 
406 /* Callback for powerpc-lynx178 initialization. */
407 
408 static void
410 {
414 }
415 
416 /* -Wmissing-prototypes. */
418 
419 void
421 {
422  gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
423  bfd_target_xcoff_flavour,
425  gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_LYNXOS178,
427 }
428 
bfd_vma CORE_ADDR
Definition: common-types.h:41
int ppc_lr_regnum
Definition: ppc-tdep.h:218
ULONGEST align_down(ULONGEST v, int n)
Definition: utils.c:2971
void convert_typed_floating(const void *from, const struct type *from_type, void *to, const struct type *to_type)
Definition: doublest.c:862
return_value_convention
Definition: defs.h:206
void gdbarch_register_osabi_sniffer(enum bfd_architecture arch, enum bfd_flavour flavour, enum gdb_osabi(*sniffer_fn)(bfd *))
Definition: osabi.c:225
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
static enum gdb_osabi rs6000_lynx178_osabi_sniffer(bfd *abfd)
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
void regcache_raw_write_signed(struct regcache *regcache, int regnum, LONGEST val)
Definition: regcache.c:710
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
void initialize_file_ftype(void)
Definition: defs.h:281
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition: gdbarch.c:1981
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:157
int ppc_gp0_regnum
Definition: ppc-tdep.h:214
struct_return
Definition: arm-tdep.h:148
#define TYPE_VECTOR(t)
Definition: gdbtypes.h:287
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
Definition: gdbtypes.h:749
const char * word
Definition: symtab.h:1448
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
initialize_file_ftype _initialize_rs6000_lynx178_tdep
static enum return_value_convention rs6000_lynx178_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2797
Definition: value.c:172
bfd_byte gdb_byte
Definition: common-types.h:38
int ppc_vr0_regnum
Definition: ppc-tdep.h:239
ULONGEST align_up(ULONGEST v, int n)
Definition: utils.c:2963
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
int wordsize
Definition: ppc-tdep.h:206
int xcoff_get_n_import_files(bfd *abfd)
Definition: xcoffread.c:3142
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type)
Definition: infcall.c:247
static void rs6000_lynx178_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:723
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
unsigned long long ULONGEST
Definition: common-types.h:53
void target_store_registers(struct regcache *regcache, int regno)
Definition: target.c:3427
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
static CORE_ADDR rs6000_lynx178_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1667
struct type * value_type(const struct value *value)
Definition: value.c:1021
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2216
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
int ppc_floating_point_unit_p(struct gdbarch *gdbarch)
Definition: rs6000-tdep.c:212
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition: osabi.c:148
int ppc_fp0_regnum
Definition: ppc-tdep.h:227
#define wordsize
gdb_osabi
Definition: defs.h:540
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:930
const ULONGEST const LONGEST len
Definition: target.h:309