← Back to branch summary

~ubuntu-branches/debian/jessie/gdb/jessie

« back to all changes in this revision

Viewing changes to gdb/gdbserver/linux-mips-low.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Jacobowitz
  • Date: 2010-03-20 01:21:29 UTC
  • mfrom: (1.3.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20100320012129-t7h25y8zgr8c2369
Tags: 7.1-1
http://bugs.debian.org/346409
http://bugs.debian.org/570875
http://bugs.debian.org/569551
http://bugs.debian.org/571132
http://bugs.debian.org/568489
* New upstream release, including:
  - PIE support (Closes: #346409).
  - C++ improvements, including static_cast<> et al, namespace imports,
    and bug fixes in printing virtual base classes.
  - Multi-program debugging.  One GDB can now debug multiple programs
    at the same time.
  - Python scripting improvements, including gdb.parse_and_eval.
  - Updated MIPS Linux signal frame layout (Closes: #570875).
  - No internal error stepping over _dl_debug_state (Closes: #569551).
* Update to Standards-Version: 3.8.4 (no changes required).
* Include more relevant (and smaller) docs in the gdbserver package
  (Closes: #571132).
* Do not duplicate documentation in gdb64, gdb-source, and libgdb-dev.
* Fix crash when switching into TUI mode (Closes: #568489).

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdb/gdbserver/linux-mips-low.c
1
1
/* GNU/Linux/MIPS specific low level interface, for the remote server for GDB.
2
2
   Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2005, 2006, 2007,
3
 
   2008, 2009 Free Software Foundation, Inc.
 
3
   2008, 2009, 2010 Free Software Foundation, Inc.
4
4
 
5
5
   This file is part of GDB.
6
6
 
115
115
}
116
116
 
117
117
static CORE_ADDR
118
 
mips_get_pc ()
 
118
mips_get_pc (struct regcache *regcache)
119
119
{
120
120
  union mips_register pc;
121
 
  collect_register_by_name ("pc", pc.buf);
 
121
  collect_register_by_name (regcache, "pc", pc.buf);
122
122
  return register_size (0) == 4 ? pc.reg32 : pc.reg64;
123
123
}
124
124
 
125
125
static void
126
 
mips_set_pc (CORE_ADDR pc)
 
126
mips_set_pc (struct regcache *regcache, CORE_ADDR pc)
127
127
{
128
128
  union mips_register newpc;
129
129
  if (register_size (0) == 4)
131
131
  else
132
132
    newpc.reg64 = pc;
133
133
 
134
 
  supply_register_by_name ("pc", newpc.buf);
 
134
  supply_register_by_name (regcache, "pc", newpc.buf);
135
135
}
136
136
 
137
137
/* Correct in either endianness.  */
142
142
   is outside of the function.  So rather than importing software single-step,
143
143
   we can just run until exit.  */
144
144
static CORE_ADDR
145
 
mips_reinsert_addr ()
 
145
mips_reinsert_addr (void)
146
146
{
 
147
  struct regcache *regcache = get_thread_regcache (current_inferior, 1);
147
148
  union mips_register ra;
148
 
  collect_register_by_name ("r31", ra.buf);
 
149
  collect_register_by_name (regcache, "r31", ra.buf);
149
150
  return register_size (0) == 4 ? ra.reg32 : ra.reg64;
150
151
}
151
152
 
183
184
#ifdef HAVE_PTRACE_GETREGS
184
185
 
185
186
static void
186
 
mips_collect_register (int use_64bit, int regno, union mips_register *reg)
 
187
mips_collect_register (struct regcache *regcache,
 
188
                       int use_64bit, int regno, union mips_register *reg)
187
189
{
188
190
  union mips_register tmp_reg;
189
191
 
190
192
  if (use_64bit)
191
193
    {
192
 
      collect_register (regno, &tmp_reg.reg64);
 
194
      collect_register (regcache, regno, &tmp_reg.reg64);
193
195
      *reg = tmp_reg;
194
196
    }
195
197
  else
196
198
    {
197
 
      collect_register (regno, &tmp_reg.reg32);
 
199
      collect_register (regcache, regno, &tmp_reg.reg32);
198
200
      reg->reg64 = tmp_reg.reg32;
199
201
    }
200
202
}
201
203
 
202
204
static void
203
 
mips_supply_register (int use_64bit, int regno, const union mips_register *reg)
 
205
mips_supply_register (struct regcache *regcache,
 
206
                      int use_64bit, int regno, const union mips_register *reg)
204
207
{
205
208
  int offset = 0;
206
209
 
209
212
  if (__BYTE_ORDER == __BIG_ENDIAN && !use_64bit)
210
213
    offset = 4;
211
214
 
212
 
  supply_register (regno, reg->buf + offset);
 
215
  supply_register (regcache, regno, reg->buf + offset);
213
216
}
214
217
 
215
218
static void
216
 
mips_collect_register_32bit (int use_64bit, int regno, unsigned char *buf)
 
219
mips_collect_register_32bit (struct regcache *regcache,
 
220
                             int use_64bit, int regno, unsigned char *buf)
217
221
{
218
222
  union mips_register tmp_reg;
219
223
  int reg32;
220
224
 
221
 
  mips_collect_register (use_64bit, regno, &tmp_reg);
 
225
  mips_collect_register (regcache, use_64bit, regno, &tmp_reg);
222
226
  reg32 = tmp_reg.reg64;
223
227
  memcpy (buf, &reg32, 4);
224
228
}
225
229
 
226
230
static void
227
 
mips_supply_register_32bit (int use_64bit, int regno, const unsigned char *buf)
 
231
mips_supply_register_32bit (struct regcache *regcache,
 
232
                            int use_64bit, int regno, const unsigned char *buf)
228
233
{
229
234
  union mips_register tmp_reg;
230
235
  int reg32;
231
236
 
232
237
  memcpy (&reg32, buf, 4);
233
238
  tmp_reg.reg64 = reg32;
234
 
  mips_supply_register (use_64bit, regno, &tmp_reg);
 
239
  mips_supply_register (regcache, use_64bit, regno, &tmp_reg);
235
240
}
236
241
 
237
242
static void
238
 
mips_fill_gregset (void *buf)
 
243
mips_fill_gregset (struct regcache *regcache, void *buf)
239
244
{
240
245
  union mips_register *regset = buf;
241
246
  int i, use_64bit;
243
248
  use_64bit = (register_size (0) == 8);
244
249
 
245
250
  for (i = 1; i < 32; i++)
246
 
    mips_collect_register (use_64bit, i, regset + i);
247
 
 
248
 
  mips_collect_register (use_64bit, find_regno ("lo"), regset + 32);
249
 
  mips_collect_register (use_64bit, find_regno ("hi"), regset + 33);
250
 
  mips_collect_register (use_64bit, find_regno ("pc"), regset + 34);
251
 
  mips_collect_register (use_64bit, find_regno ("badvaddr"), regset + 35);
252
 
  mips_collect_register (use_64bit, find_regno ("status"), regset + 36);
253
 
  mips_collect_register (use_64bit, find_regno ("cause"), regset + 37);
254
 
 
255
 
  mips_collect_register (use_64bit, find_regno ("restart"), regset + 0);
 
251
    mips_collect_register (regcache, use_64bit, i, regset + i);
 
252
 
 
253
  mips_collect_register (regcache, use_64bit,
 
254
                         find_regno ("lo"), regset + 32);
 
255
  mips_collect_register (regcache, use_64bit,
 
256
                         find_regno ("hi"), regset + 33);
 
257
  mips_collect_register (regcache, use_64bit,
 
258
                         find_regno ("pc"), regset + 34);
 
259
  mips_collect_register (regcache, use_64bit,
 
260
                         find_regno ("badvaddr"), regset + 35);
 
261
  mips_collect_register (regcache, use_64bit,
 
262
                         find_regno ("status"), regset + 36);
 
263
  mips_collect_register (regcache, use_64bit,
 
264
                         find_regno ("cause"), regset + 37);
 
265
 
 
266
  mips_collect_register (regcache, use_64bit,
 
267
                         find_regno ("restart"), regset + 0);
256
268
}
257
269
 
258
270
static void
259
 
mips_store_gregset (const void *buf)
 
271
mips_store_gregset (struct regcache *regcache, const void *buf)
260
272
{
261
273
  const union mips_register *regset = buf;
262
274
  int i, use_64bit;
264
276
  use_64bit = (register_size (0) == 8);
265
277
 
266
278
  for (i = 0; i < 32; i++)
267
 
    mips_supply_register (use_64bit, i, regset + i);
268
 
 
269
 
  mips_supply_register (use_64bit, find_regno ("lo"), regset + 32);
270
 
  mips_supply_register (use_64bit, find_regno ("hi"), regset + 33);
271
 
  mips_supply_register (use_64bit, find_regno ("pc"), regset + 34);
272
 
  mips_supply_register (use_64bit, find_regno ("badvaddr"), regset + 35);
273
 
  mips_supply_register (use_64bit, find_regno ("status"), regset + 36);
274
 
  mips_supply_register (use_64bit, find_regno ("cause"), regset + 37);
275
 
 
276
 
  mips_supply_register (use_64bit, find_regno ("restart"), regset + 0);
 
279
    mips_supply_register (regcache, use_64bit, i, regset + i);
 
280
 
 
281
  mips_supply_register (regcache, use_64bit, find_regno ("lo"), regset + 32);
 
282
  mips_supply_register (regcache, use_64bit, find_regno ("hi"), regset + 33);
 
283
  mips_supply_register (regcache, use_64bit, find_regno ("pc"), regset + 34);
 
284
  mips_supply_register (regcache, use_64bit,
 
285
                        find_regno ("badvaddr"), regset + 35);
 
286
  mips_supply_register (regcache, use_64bit,
 
287
                        find_regno ("status"), regset + 36);
 
288
  mips_supply_register (regcache, use_64bit,
 
289
                        find_regno ("cause"), regset + 37);
 
290
 
 
291
  mips_supply_register (regcache, use_64bit,
 
292
                        find_regno ("restart"), regset + 0);
277
293
}
278
294
 
279
295
static void
280
 
mips_fill_fpregset (void *buf)
 
296
mips_fill_fpregset (struct regcache *regcache, void *buf)
281
297
{
282
298
  union mips_register *regset = buf;
283
299
  int i, use_64bit, first_fp, big_endian;
289
305
  /* See GDB for a discussion of this peculiar layout.  */
290
306
  for (i = 0; i < 32; i++)
291
307
    if (use_64bit)
292
 
      collect_register (first_fp + i, regset[i].buf);
 
308
      collect_register (regcache, first_fp + i, regset[i].buf);
293
309
    else
294
 
      collect_register (first_fp + i,
 
310
      collect_register (regcache, first_fp + i,
295
311
                        regset[i & ~1].buf + 4 * (big_endian != (i & 1)));
296
312
 
297
 
  mips_collect_register_32bit (use_64bit, find_regno ("fcsr"), regset[32].buf);
298
 
  mips_collect_register_32bit (use_64bit, find_regno ("fir"),
 
313
  mips_collect_register_32bit (regcache, use_64bit,
 
314
                               find_regno ("fcsr"), regset[32].buf);
 
315
  mips_collect_register_32bit (regcache, use_64bit, find_regno ("fir"),
299
316
                               regset[32].buf + 4);
300
317
}
301
318
 
302
319
static void
303
 
mips_store_fpregset (const void *buf)
 
320
mips_store_fpregset (struct regcache *regcache, const void *buf)
304
321
{
305
322
  const union mips_register *regset = buf;
306
323
  int i, use_64bit, first_fp, big_endian;
312
329
  /* See GDB for a discussion of this peculiar layout.  */
313
330
  for (i = 0; i < 32; i++)
314
331
    if (use_64bit)
315
 
      supply_register (first_fp + i, regset[i].buf);
 
332
      supply_register (regcache, first_fp + i, regset[i].buf);
316
333
    else
317
 
      supply_register (first_fp + i,
 
334
      supply_register (regcache, first_fp + i,
318
335
                       regset[i & ~1].buf + 4 * (big_endian != (i & 1)));
319
336
 
320
 
  mips_supply_register_32bit (use_64bit, find_regno ("fcsr"), regset[32].buf);
321
 
  mips_supply_register_32bit (use_64bit, find_regno ("fir"),
 
337
  mips_supply_register_32bit (regcache, use_64bit,
 
338
                              find_regno ("fcsr"), regset[32].buf);
 
339
  mips_supply_register_32bit (regcache, use_64bit, find_regno ("fir"),
322
340
                              regset[32].buf + 4);
323
341
}
324
342
#endif /* HAVE_PTRACE_GETREGS */