OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [hppa-hpux-tdep.c] - Blame information for rev 827

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Target-dependent code for HP-UX on PA-RISC.
2
 
3
   Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008
4
   Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "arch-utils.h"
23
#include "gdbcore.h"
24
#include "osabi.h"
25
#include "frame.h"
26
#include "frame-unwind.h"
27
#include "trad-frame.h"
28
#include "symtab.h"
29
#include "objfiles.h"
30
#include "inferior.h"
31
#include "infcall.h"
32
#include "observer.h"
33
#include "hppa-tdep.h"
34
#include "solib-som.h"
35
#include "solib-pa64.h"
36
#include "regset.h"
37
#include "regcache.h"
38
#include "exceptions.h"
39
 
40
#include "gdb_string.h"
41
 
42
#define IS_32BIT_TARGET(_gdbarch) \
43
        ((gdbarch_tdep (_gdbarch))->bytes_per_address == 4)
44
 
45
/* Bit in the `ss_flag' member of `struct save_state' that indicates
46
   that the 64-bit register values are live.  From
47
   <machine/save_state.h>.  */
48
#define HPPA_HPUX_SS_WIDEREGS           0x40
49
 
50
/* Offsets of various parts of `struct save_state'.  From
51
   <machine/save_state.h>.  */
52
#define HPPA_HPUX_SS_FLAGS_OFFSET       0
53
#define HPPA_HPUX_SS_NARROW_OFFSET      4
54
#define HPPA_HPUX_SS_FPBLOCK_OFFSET     256
55
#define HPPA_HPUX_SS_WIDE_OFFSET        640
56
 
57
/* The size of `struct save_state.  */
58
#define HPPA_HPUX_SAVE_STATE_SIZE       1152
59
 
60
/* The size of `struct pa89_save_state', which corresponds to PA-RISC
61
   1.1, the lowest common denominator that we support.  */
62
#define HPPA_HPUX_PA89_SAVE_STATE_SIZE  512
63
 
64
 
65
/* Forward declarations.  */
66
extern void _initialize_hppa_hpux_tdep (void);
67
extern initialize_file_ftype _initialize_hppa_hpux_tdep;
68
 
69
static int
70
in_opd_section (CORE_ADDR pc)
71
{
72
  struct obj_section *s;
73
  int retval = 0;
74
 
75
  s = find_pc_section (pc);
76
 
77
  retval = (s != NULL
78
            && s->the_bfd_section->name != NULL
79
            && strcmp (s->the_bfd_section->name, ".opd") == 0);
80
  return (retval);
81
}
82
 
83
/* Return one if PC is in the call path of a trampoline, else return zero.
84
 
85
   Note we return one for *any* call trampoline (long-call, arg-reloc), not
86
   just shared library trampolines (import, export).  */
87
 
88
static int
89
hppa32_hpux_in_solib_call_trampoline (CORE_ADDR pc, char *name)
90
{
91
  struct minimal_symbol *minsym;
92
  struct unwind_table_entry *u;
93
 
94
  /* First see if PC is in one of the two C-library trampolines.  */
95
  if (pc == hppa_symbol_address("$$dyncall")
96
      || pc == hppa_symbol_address("_sr4export"))
97
    return 1;
98
 
99
  minsym = lookup_minimal_symbol_by_pc (pc);
100
  if (minsym && strcmp (DEPRECATED_SYMBOL_NAME (minsym), ".stub") == 0)
101
    return 1;
102
 
103
  /* Get the unwind descriptor corresponding to PC, return zero
104
     if no unwind was found.  */
105
  u = find_unwind_entry (pc);
106
  if (!u)
107
    return 0;
108
 
109
  /* If this isn't a linker stub, then return now.  */
110
  if (u->stub_unwind.stub_type == 0)
111
    return 0;
112
 
113
  /* By definition a long-branch stub is a call stub.  */
114
  if (u->stub_unwind.stub_type == LONG_BRANCH)
115
    return 1;
116
 
117
  /* The call and return path execute the same instructions within
118
     an IMPORT stub!  So an IMPORT stub is both a call and return
119
     trampoline.  */
120
  if (u->stub_unwind.stub_type == IMPORT)
121
    return 1;
122
 
123
  /* Parameter relocation stubs always have a call path and may have a
124
     return path.  */
125
  if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
126
      || u->stub_unwind.stub_type == EXPORT)
127
    {
128
      CORE_ADDR addr;
129
 
130
      /* Search forward from the current PC until we hit a branch
131
         or the end of the stub.  */
132
      for (addr = pc; addr <= u->region_end; addr += 4)
133
        {
134
          unsigned long insn;
135
 
136
          insn = read_memory_integer (addr, 4);
137
 
138
          /* Does it look like a bl?  If so then it's the call path, if
139
             we find a bv or be first, then we're on the return path.  */
140
          if ((insn & 0xfc00e000) == 0xe8000000)
141
            return 1;
142
          else if ((insn & 0xfc00e001) == 0xe800c000
143
                   || (insn & 0xfc000000) == 0xe0000000)
144
            return 0;
145
        }
146
 
147
      /* Should never happen.  */
148
      warning (_("Unable to find branch in parameter relocation stub."));
149
      return 0;
150
    }
151
 
152
  /* Unknown stub type.  For now, just return zero.  */
153
  return 0;
154
}
155
 
156
static int
157
hppa64_hpux_in_solib_call_trampoline (CORE_ADDR pc, char *name)
158
{
159
  /* PA64 has a completely different stub/trampoline scheme.  Is it
160
     better?  Maybe.  It's certainly harder to determine with any
161
     certainty that we are in a stub because we can not refer to the
162
     unwinders to help.
163
 
164
     The heuristic is simple.  Try to lookup the current PC value in th
165
     minimal symbol table.  If that fails, then assume we are not in a
166
     stub and return.
167
 
168
     Then see if the PC value falls within the section bounds for the
169
     section containing the minimal symbol we found in the first
170
     step.  If it does, then assume we are not in a stub and return.
171
 
172
     Finally peek at the instructions to see if they look like a stub.  */
173
  struct minimal_symbol *minsym;
174
  asection *sec;
175
  CORE_ADDR addr;
176
  int insn, i;
177
 
178
  minsym = lookup_minimal_symbol_by_pc (pc);
179
  if (! minsym)
180
    return 0;
181
 
182
  sec = SYMBOL_BFD_SECTION (minsym);
183
 
184
  if (bfd_get_section_vma (sec->owner, sec) <= pc
185
      && pc < (bfd_get_section_vma (sec->owner, sec)
186
                 + bfd_section_size (sec->owner, sec)))
187
      return 0;
188
 
189
  /* We might be in a stub.  Peek at the instructions.  Stubs are 3
190
     instructions long. */
191
  insn = read_memory_integer (pc, 4);
192
 
193
  /* Find out where we think we are within the stub.  */
194
  if ((insn & 0xffffc00e) == 0x53610000)
195
    addr = pc;
196
  else if ((insn & 0xffffffff) == 0xe820d000)
197
    addr = pc - 4;
198
  else if ((insn & 0xffffc00e) == 0x537b0000)
199
    addr = pc - 8;
200
  else
201
    return 0;
202
 
203
  /* Now verify each insn in the range looks like a stub instruction.  */
204
  insn = read_memory_integer (addr, 4);
205
  if ((insn & 0xffffc00e) != 0x53610000)
206
    return 0;
207
 
208
  /* Now verify each insn in the range looks like a stub instruction.  */
209
  insn = read_memory_integer (addr + 4, 4);
210
  if ((insn & 0xffffffff) != 0xe820d000)
211
    return 0;
212
 
213
  /* Now verify each insn in the range looks like a stub instruction.  */
214
  insn = read_memory_integer (addr + 8, 4);
215
  if ((insn & 0xffffc00e) != 0x537b0000)
216
    return 0;
217
 
218
  /* Looks like a stub.  */
219
  return 1;
220
}
221
 
222
/* Return one if PC is in the return path of a trampoline, else return zero.
223
 
224
   Note we return one for *any* call trampoline (long-call, arg-reloc), not
225
   just shared library trampolines (import, export).  */
226
 
227
static int
228
hppa_hpux_in_solib_return_trampoline (CORE_ADDR pc, char *name)
229
{
230
  struct unwind_table_entry *u;
231
 
232
  /* Get the unwind descriptor corresponding to PC, return zero
233
     if no unwind was found.  */
234
  u = find_unwind_entry (pc);
235
  if (!u)
236
    return 0;
237
 
238
  /* If this isn't a linker stub or it's just a long branch stub, then
239
     return zero.  */
240
  if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH)
241
    return 0;
242
 
243
  /* The call and return path execute the same instructions within
244
     an IMPORT stub!  So an IMPORT stub is both a call and return
245
     trampoline.  */
246
  if (u->stub_unwind.stub_type == IMPORT)
247
    return 1;
248
 
249
  /* Parameter relocation stubs always have a call path and may have a
250
     return path.  */
251
  if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
252
      || u->stub_unwind.stub_type == EXPORT)
253
    {
254
      CORE_ADDR addr;
255
 
256
      /* Search forward from the current PC until we hit a branch
257
         or the end of the stub.  */
258
      for (addr = pc; addr <= u->region_end; addr += 4)
259
        {
260
          unsigned long insn;
261
 
262
          insn = read_memory_integer (addr, 4);
263
 
264
          /* Does it look like a bl?  If so then it's the call path, if
265
             we find a bv or be first, then we're on the return path.  */
266
          if ((insn & 0xfc00e000) == 0xe8000000)
267
            return 0;
268
          else if ((insn & 0xfc00e001) == 0xe800c000
269
                   || (insn & 0xfc000000) == 0xe0000000)
270
            return 1;
271
        }
272
 
273
      /* Should never happen.  */
274
      warning (_("Unable to find branch in parameter relocation stub."));
275
      return 0;
276
    }
277
 
278
  /* Unknown stub type.  For now, just return zero.  */
279
  return 0;
280
 
281
}
282
 
283
/* Figure out if PC is in a trampoline, and if so find out where
284
   the trampoline will jump to.  If not in a trampoline, return zero.
285
 
286
   Simple code examination probably is not a good idea since the code
287
   sequences in trampolines can also appear in user code.
288
 
289
   We use unwinds and information from the minimal symbol table to
290
   determine when we're in a trampoline.  This won't work for ELF
291
   (yet) since it doesn't create stub unwind entries.  Whether or
292
   not ELF will create stub unwinds or normal unwinds for linker
293
   stubs is still being debated.
294
 
295
   This should handle simple calls through dyncall or sr4export,
296
   long calls, argument relocation stubs, and dyncall/sr4export
297
   calling an argument relocation stub.  It even handles some stubs
298
   used in dynamic executables.  */
299
 
300
static CORE_ADDR
301
hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
302
{
303
  struct gdbarch *gdbarch = get_frame_arch (frame);
304
  long orig_pc = pc;
305
  long prev_inst, curr_inst, loc;
306
  struct minimal_symbol *msym;
307
  struct unwind_table_entry *u;
308
 
309
  /* Addresses passed to dyncall may *NOT* be the actual address
310
     of the function.  So we may have to do something special.  */
311
  if (pc == hppa_symbol_address("$$dyncall"))
312
    {
313
      pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
314
 
315
      /* If bit 30 (counting from the left) is on, then pc is the address of
316
         the PLT entry for this function, not the address of the function
317
         itself.  Bit 31 has meaning too, but only for MPE.  */
318
      if (pc & 0x2)
319
        pc = (CORE_ADDR) read_memory_integer
320
                           (pc & ~0x3, gdbarch_ptr_bit (gdbarch) / 8);
321
    }
322
  if (pc == hppa_symbol_address("$$dyncall_external"))
323
    {
324
      pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
325
      pc = (CORE_ADDR) read_memory_integer
326
                         (pc & ~0x3, gdbarch_ptr_bit (gdbarch) / 8);
327
    }
328
  else if (pc == hppa_symbol_address("_sr4export"))
329
    pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
330
 
331
  /* Get the unwind descriptor corresponding to PC, return zero
332
     if no unwind was found.  */
333
  u = find_unwind_entry (pc);
334
  if (!u)
335
    return 0;
336
 
337
  /* If this isn't a linker stub, then return now.  */
338
  /* elz: attention here! (FIXME) because of a compiler/linker
339
     error, some stubs which should have a non zero stub_unwind.stub_type
340
     have unfortunately a value of zero. So this function would return here
341
     as if we were not in a trampoline. To fix this, we go look at the partial
342
     symbol information, which reports this guy as a stub.
343
     (FIXME): Unfortunately, we are not that lucky: it turns out that the
344
     partial symbol information is also wrong sometimes. This is because
345
     when it is entered (somread.c::som_symtab_read()) it can happen that
346
     if the type of the symbol (from the som) is Entry, and the symbol is
347
     in a shared library, then it can also be a trampoline.  This would
348
     be OK, except that I believe the way they decide if we are ina shared library
349
     does not work. SOOOO..., even if we have a regular function w/o trampolines
350
     its minimal symbol can be assigned type mst_solib_trampoline.
351
     Also, if we find that the symbol is a real stub, then we fix the unwind
352
     descriptor, and define the stub type to be EXPORT.
353
     Hopefully this is correct most of the times. */
354
  if (u->stub_unwind.stub_type == 0)
355
    {
356
 
357
/* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
358
   we can delete all the code which appears between the lines */
359
/*--------------------------------------------------------------------------*/
360
      msym = lookup_minimal_symbol_by_pc (pc);
361
 
362
      if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
363
        return orig_pc == pc ? 0 : pc & ~0x3;
364
 
365
      else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
366
        {
367
          struct objfile *objfile;
368
          struct minimal_symbol *msymbol;
369
          int function_found = 0;
370
 
371
          /* go look if there is another minimal symbol with the same name as
372
             this one, but with type mst_text. This would happen if the msym
373
             is an actual trampoline, in which case there would be another
374
             symbol with the same name corresponding to the real function */
375
 
376
          ALL_MSYMBOLS (objfile, msymbol)
377
          {
378
            if (MSYMBOL_TYPE (msymbol) == mst_text
379
                && strcmp (DEPRECATED_SYMBOL_NAME (msymbol),
380
                            DEPRECATED_SYMBOL_NAME (msym)) == 0)
381
              {
382
                function_found = 1;
383
                break;
384
              }
385
          }
386
 
387
          if (function_found)
388
            /* the type of msym is correct (mst_solib_trampoline), but
389
               the unwind info is wrong, so set it to the correct value */
390
            u->stub_unwind.stub_type = EXPORT;
391
          else
392
            /* the stub type info in the unwind is correct (this is not a
393
               trampoline), but the msym type information is wrong, it
394
               should be mst_text. So we need to fix the msym, and also
395
               get out of this function */
396
            {
397
              MSYMBOL_TYPE (msym) = mst_text;
398
              return orig_pc == pc ? 0 : pc & ~0x3;
399
            }
400
        }
401
 
402
/*--------------------------------------------------------------------------*/
403
    }
404
 
405
  /* It's a stub.  Search for a branch and figure out where it goes.
406
     Note we have to handle multi insn branch sequences like ldil;ble.
407
     Most (all?) other branches can be determined by examining the contents
408
     of certain registers and the stack.  */
409
 
410
  loc = pc;
411
  curr_inst = 0;
412
  prev_inst = 0;
413
  while (1)
414
    {
415
      /* Make sure we haven't walked outside the range of this stub.  */
416
      if (u != find_unwind_entry (loc))
417
        {
418
          warning (_("Unable to find branch in linker stub"));
419
          return orig_pc == pc ? 0 : pc & ~0x3;
420
        }
421
 
422
      prev_inst = curr_inst;
423
      curr_inst = read_memory_integer (loc, 4);
424
 
425
      /* Does it look like a branch external using %r1?  Then it's the
426
         branch from the stub to the actual function.  */
427
      if ((curr_inst & 0xffe0e000) == 0xe0202000)
428
        {
429
          /* Yup.  See if the previous instruction loaded
430
             a value into %r1.  If so compute and return the jump address.  */
431
          if ((prev_inst & 0xffe00000) == 0x20200000)
432
            return (hppa_extract_21 (prev_inst) + hppa_extract_17 (curr_inst)) & ~0x3;
433
          else
434
            {
435
              warning (_("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1)."));
436
              return orig_pc == pc ? 0 : pc & ~0x3;
437
            }
438
        }
439
 
440
      /* Does it look like a be 0(sr0,%r21)? OR
441
         Does it look like a be, n 0(sr0,%r21)? OR
442
         Does it look like a bve (r21)? (this is on PA2.0)
443
         Does it look like a bve, n(r21)? (this is also on PA2.0)
444
         That's the branch from an
445
         import stub to an export stub.
446
 
447
         It is impossible to determine the target of the branch via
448
         simple examination of instructions and/or data (consider
449
         that the address in the plabel may be the address of the
450
         bind-on-reference routine in the dynamic loader).
451
 
452
         So we have try an alternative approach.
453
 
454
         Get the name of the symbol at our current location; it should
455
         be a stub symbol with the same name as the symbol in the
456
         shared library.
457
 
458
         Then lookup a minimal symbol with the same name; we should
459
         get the minimal symbol for the target routine in the shared
460
         library as those take precedence of import/export stubs.  */
461
      if ((curr_inst == 0xe2a00000) ||
462
          (curr_inst == 0xe2a00002) ||
463
          (curr_inst == 0xeaa0d000) ||
464
          (curr_inst == 0xeaa0d002))
465
        {
466
          struct minimal_symbol *stubsym, *libsym;
467
 
468
          stubsym = lookup_minimal_symbol_by_pc (loc);
469
          if (stubsym == NULL)
470
            {
471
              warning (_("Unable to find symbol for 0x%lx"), loc);
472
              return orig_pc == pc ? 0 : pc & ~0x3;
473
            }
474
 
475
          libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL);
476
          if (libsym == NULL)
477
            {
478
              warning (_("Unable to find library symbol for %s."),
479
                       DEPRECATED_SYMBOL_NAME (stubsym));
480
              return orig_pc == pc ? 0 : pc & ~0x3;
481
            }
482
 
483
          return SYMBOL_VALUE (libsym);
484
        }
485
 
486
      /* Does it look like bl X,%rp or bl X,%r0?  Another way to do a
487
         branch from the stub to the actual function.  */
488
      /*elz */
489
      else if ((curr_inst & 0xffe0e000) == 0xe8400000
490
               || (curr_inst & 0xffe0e000) == 0xe8000000
491
               || (curr_inst & 0xffe0e000) == 0xe800A000)
492
        return (loc + hppa_extract_17 (curr_inst) + 8) & ~0x3;
493
 
494
      /* Does it look like bv (rp)?   Note this depends on the
495
         current stack pointer being the same as the stack
496
         pointer in the stub itself!  This is a branch on from the
497
         stub back to the original caller.  */
498
      /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
499
      else if ((curr_inst & 0xffe0f000) == 0xe840c000)
500
        {
501
          /* Yup.  See if the previous instruction loaded
502
             rp from sp - 8.  */
503
          if (prev_inst == 0x4bc23ff1)
504
            {
505
              CORE_ADDR sp;
506
              sp = get_frame_register_unsigned (frame, HPPA_SP_REGNUM);
507
              return read_memory_integer (sp - 8, 4) & ~0x3;
508
            }
509
          else
510
            {
511
              warning (_("Unable to find restore of %%rp before bv (%%rp)."));
512
              return orig_pc == pc ? 0 : pc & ~0x3;
513
            }
514
        }
515
 
516
      /* elz: added this case to capture the new instruction
517
         at the end of the return part of an export stub used by
518
         the PA2.0: BVE, n (rp) */
519
      else if ((curr_inst & 0xffe0f000) == 0xe840d000)
520
        {
521
          return (read_memory_integer
522
                  (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
523
                   gdbarch_ptr_bit (gdbarch) / 8)) & ~0x3;
524
        }
525
 
526
      /* What about be,n 0(sr0,%rp)?  It's just another way we return to
527
         the original caller from the stub.  Used in dynamic executables.  */
528
      else if (curr_inst == 0xe0400002)
529
        {
530
          /* The value we jump to is sitting in sp - 24.  But that's
531
             loaded several instructions before the be instruction.
532
             I guess we could check for the previous instruction being
533
             mtsp %r1,%sr0 if we want to do sanity checking.  */
534
          return (read_memory_integer
535
                  (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
536
                   gdbarch_ptr_bit (gdbarch) / 8)) & ~0x3;
537
        }
538
 
539
      /* Haven't found the branch yet, but we're still in the stub.
540
         Keep looking.  */
541
      loc += 4;
542
    }
543
}
544
 
545
static void
546
hppa_skip_permanent_breakpoint (struct regcache *regcache)
547
{
548
  /* To step over a breakpoint instruction on the PA takes some
549
     fiddling with the instruction address queue.
550
 
551
     When we stop at a breakpoint, the IA queue front (the instruction
552
     we're executing now) points at the breakpoint instruction, and
553
     the IA queue back (the next instruction to execute) points to
554
     whatever instruction we would execute after the breakpoint, if it
555
     were an ordinary instruction.  This is the case even if the
556
     breakpoint is in the delay slot of a branch instruction.
557
 
558
     Clearly, to step past the breakpoint, we need to set the queue
559
     front to the back.  But what do we put in the back?  What
560
     instruction comes after that one?  Because of the branch delay
561
     slot, the next insn is always at the back + 4.  */
562
 
563
  ULONGEST pcoq_tail, pcsq_tail;
564
  regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, &pcoq_tail);
565
  regcache_cooked_read_unsigned (regcache, HPPA_PCSQ_TAIL_REGNUM, &pcsq_tail);
566
 
567
  regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pcoq_tail);
568
  regcache_cooked_write_unsigned (regcache, HPPA_PCSQ_HEAD_REGNUM, pcsq_tail);
569
 
570
  regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pcoq_tail + 4);
571
  /* We can leave the tail's space the same, since there's no jump.  */
572
}
573
 
574
 
575
/* Signal frames.  */
576
struct hppa_hpux_sigtramp_unwind_cache
577
{
578
  CORE_ADDR base;
579
  struct trad_frame_saved_reg *saved_regs;
580
};
581
 
582
static int hppa_hpux_tramp_reg[] = {
583
  HPPA_SAR_REGNUM,
584
  HPPA_PCOQ_HEAD_REGNUM,
585
  HPPA_PCSQ_HEAD_REGNUM,
586
  HPPA_PCOQ_TAIL_REGNUM,
587
  HPPA_PCSQ_TAIL_REGNUM,
588
  HPPA_EIEM_REGNUM,
589
  HPPA_IIR_REGNUM,
590
  HPPA_ISR_REGNUM,
591
  HPPA_IOR_REGNUM,
592
  HPPA_IPSW_REGNUM,
593
  -1,
594
  HPPA_SR4_REGNUM,
595
  HPPA_SR4_REGNUM + 1,
596
  HPPA_SR4_REGNUM + 2,
597
  HPPA_SR4_REGNUM + 3,
598
  HPPA_SR4_REGNUM + 4,
599
  HPPA_SR4_REGNUM + 5,
600
  HPPA_SR4_REGNUM + 6,
601
  HPPA_SR4_REGNUM + 7,
602
  HPPA_RCR_REGNUM,
603
  HPPA_PID0_REGNUM,
604
  HPPA_PID1_REGNUM,
605
  HPPA_CCR_REGNUM,
606
  HPPA_PID2_REGNUM,
607
  HPPA_PID3_REGNUM,
608
  HPPA_TR0_REGNUM,
609
  HPPA_TR0_REGNUM + 1,
610
  HPPA_TR0_REGNUM + 2,
611
  HPPA_CR27_REGNUM
612
};
613
 
614
static struct hppa_hpux_sigtramp_unwind_cache *
615
hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
616
                                       void **this_cache)
617
 
618
{
619
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
620
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
621
  struct hppa_hpux_sigtramp_unwind_cache *info;
622
  unsigned int flag;
623
  CORE_ADDR sp, scptr, off;
624
  int i, incr, szoff;
625
 
626
  if (*this_cache)
627
    return *this_cache;
628
 
629
  info = FRAME_OBSTACK_ZALLOC (struct hppa_hpux_sigtramp_unwind_cache);
630
  *this_cache = info;
631
  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
632
 
633
  sp = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
634
 
635
  if (IS_32BIT_TARGET (gdbarch))
636
    scptr = sp - 1352;
637
  else
638
    scptr = sp - 1520;
639
 
640
  off = scptr;
641
 
642
  /* See /usr/include/machine/save_state.h for the structure of the save_state_t
643
     structure. */
644
 
645
  flag = read_memory_unsigned_integer(scptr + HPPA_HPUX_SS_FLAGS_OFFSET, 4);
646
 
647
  if (!(flag & HPPA_HPUX_SS_WIDEREGS))
648
    {
649
      /* Narrow registers. */
650
      off = scptr + HPPA_HPUX_SS_NARROW_OFFSET;
651
      incr = 4;
652
      szoff = 0;
653
    }
654
  else
655
    {
656
      /* Wide registers. */
657
      off = scptr + HPPA_HPUX_SS_WIDE_OFFSET + 8;
658
      incr = 8;
659
      szoff = (tdep->bytes_per_address == 4 ? 4 : 0);
660
    }
661
 
662
  for (i = 1; i < 32; i++)
663
    {
664
      info->saved_regs[HPPA_R0_REGNUM + i].addr = off + szoff;
665
      off += incr;
666
    }
667
 
668
  for (i = 0; i < ARRAY_SIZE (hppa_hpux_tramp_reg); i++)
669
    {
670
      if (hppa_hpux_tramp_reg[i] > 0)
671
        info->saved_regs[hppa_hpux_tramp_reg[i]].addr = off + szoff;
672
 
673
      off += incr;
674
    }
675
 
676
  /* TODO: fp regs */
677
 
678
  info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
679
 
680
  return info;
681
}
682
 
683
static void
684
hppa_hpux_sigtramp_frame_this_id (struct frame_info *next_frame,
685
                                   void **this_prologue_cache,
686
                                   struct frame_id *this_id)
687
{
688
  struct hppa_hpux_sigtramp_unwind_cache *info
689
    = hppa_hpux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
690
  *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
691
}
692
 
693
static void
694
hppa_hpux_sigtramp_frame_prev_register (struct frame_info *next_frame,
695
                                        void **this_prologue_cache,
696
                                        int regnum, int *optimizedp,
697
                                        enum lval_type *lvalp,
698
                                        CORE_ADDR *addrp,
699
                                        int *realnump, gdb_byte *valuep)
700
{
701
  struct hppa_hpux_sigtramp_unwind_cache *info
702
    = hppa_hpux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
703
  hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
704
                                   optimizedp, lvalp, addrp, realnump, valuep);
705
}
706
 
707
static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind = {
708
  SIGTRAMP_FRAME,
709
  hppa_hpux_sigtramp_frame_this_id,
710
  hppa_hpux_sigtramp_frame_prev_register
711
};
712
 
713
static const struct frame_unwind *
714
hppa_hpux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
715
{
716
  struct unwind_table_entry *u;
717
  CORE_ADDR pc = frame_pc_unwind (next_frame);
718
 
719
  u = find_unwind_entry (pc);
720
 
721
  /* If this is an export stub, try to get the unwind descriptor for
722
     the actual function itself.  */
723
  if (u && u->stub_unwind.stub_type == EXPORT)
724
    {
725
      gdb_byte buf[HPPA_INSN_SIZE];
726
      unsigned long insn;
727
 
728
      if (!safe_frame_unwind_memory (next_frame, u->region_start,
729
                                     buf, sizeof buf))
730
        return NULL;
731
 
732
      insn = extract_unsigned_integer (buf, sizeof buf);
733
      if ((insn & 0xffe0e000) == 0xe8400000)
734
        u = find_unwind_entry(u->region_start + hppa_extract_17 (insn) + 8);
735
    }
736
 
737
  if (u && u->HP_UX_interrupt_marker)
738
    return &hppa_hpux_sigtramp_frame_unwind;
739
 
740
  return NULL;
741
}
742
 
743
static CORE_ADDR
744
hppa32_hpux_find_global_pointer (struct gdbarch *gdbarch,
745
                                 struct value *function)
746
{
747
  CORE_ADDR faddr;
748
 
749
  faddr = value_as_address (function);
750
 
751
  /* Is this a plabel? If so, dereference it to get the gp value.  */
752
  if (faddr & 2)
753
    {
754
      int status;
755
      char buf[4];
756
 
757
      faddr &= ~3;
758
 
759
      status = target_read_memory (faddr + 4, buf, sizeof (buf));
760
      if (status == 0)
761
        return extract_unsigned_integer (buf, sizeof (buf));
762
    }
763
 
764
  return gdbarch_tdep (gdbarch)->solib_get_got_by_pc (faddr);
765
}
766
 
767
static CORE_ADDR
768
hppa64_hpux_find_global_pointer (struct gdbarch *gdbarch,
769
                                 struct value *function)
770
{
771
  CORE_ADDR faddr;
772
  char buf[32];
773
 
774
  faddr = value_as_address (function);
775
 
776
  if (in_opd_section (faddr))
777
    {
778
      target_read_memory (faddr, buf, sizeof (buf));
779
      return extract_unsigned_integer (&buf[24], 8);
780
    }
781
  else
782
    {
783
      return gdbarch_tdep (gdbarch)->solib_get_got_by_pc (faddr);
784
    }
785
}
786
 
787
static unsigned int ldsid_pattern[] = {
788
  0x000010a0, /* ldsid (rX),rY */
789
  0x00001820, /* mtsp rY,sr0 */
790
  0xe0000000  /* be,n (sr0,rX) */
791
};
792
 
793
static CORE_ADDR
794
hppa_hpux_search_pattern (CORE_ADDR start, CORE_ADDR end,
795
                          unsigned int *patterns, int count)
796
{
797
  int num_insns = (end - start + HPPA_INSN_SIZE) / HPPA_INSN_SIZE;
798
  unsigned int *insns;
799
  gdb_byte *buf;
800
  int offset, i;
801
 
802
  buf = alloca (num_insns * HPPA_INSN_SIZE);
803
  insns = alloca (num_insns * sizeof (unsigned int));
804
 
805
  read_memory (start, buf, num_insns * HPPA_INSN_SIZE);
806
  for (i = 0; i < num_insns; i++, buf += HPPA_INSN_SIZE)
807
    insns[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE);
808
 
809
  for (offset = 0; offset <= num_insns - count; offset++)
810
    {
811
      for (i = 0; i < count; i++)
812
        {
813
          if ((insns[offset + i] & patterns[i]) != patterns[i])
814
            break;
815
        }
816
      if (i == count)
817
        break;
818
    }
819
 
820
  if (offset <= num_insns - count)
821
    return start + offset * HPPA_INSN_SIZE;
822
  else
823
    return 0;
824
}
825
 
826
static CORE_ADDR
827
hppa32_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
828
                                        int *argreg)
829
{
830
  struct objfile *obj;
831
  struct obj_section *sec;
832
  struct hppa_objfile_private *priv;
833
  struct frame_info *frame;
834
  struct unwind_table_entry *u;
835
  CORE_ADDR addr, rp;
836
  char buf[4];
837
  unsigned int insn;
838
 
839
  sec = find_pc_section (pc);
840
  obj = sec->objfile;
841
  priv = objfile_data (obj, hppa_objfile_priv_data);
842
 
843
  if (!priv)
844
    priv = hppa_init_objfile_priv_data (obj);
845
  if (!priv)
846
    error (_("Internal error creating objfile private data."));
847
 
848
  /* Use the cached value if we have one.  */
849
  if (priv->dummy_call_sequence_addr != 0)
850
    {
851
      *argreg = priv->dummy_call_sequence_reg;
852
      return priv->dummy_call_sequence_addr;
853
    }
854
 
855
  /* First try a heuristic; if we are in a shared library call, our return
856
     pointer is likely to point at an export stub.  */
857
  frame = get_current_frame ();
858
  rp = frame_unwind_register_unsigned (frame, 2);
859
  u = find_unwind_entry (rp);
860
  if (u && u->stub_unwind.stub_type == EXPORT)
861
    {
862
      addr = hppa_hpux_search_pattern (u->region_start, u->region_end,
863
                                       ldsid_pattern,
864
                                       ARRAY_SIZE (ldsid_pattern));
865
      if (addr)
866
        goto found_pattern;
867
    }
868
 
869
  /* Next thing to try is to look for an export stub.  */
870
  if (priv->unwind_info)
871
    {
872
      int i;
873
 
874
      for (i = 0; i < priv->unwind_info->last; i++)
875
        {
876
          struct unwind_table_entry *u;
877
          u = &priv->unwind_info->table[i];
878
          if (u->stub_unwind.stub_type == EXPORT)
879
            {
880
              addr = hppa_hpux_search_pattern (u->region_start, u->region_end,
881
                                               ldsid_pattern,
882
                                               ARRAY_SIZE (ldsid_pattern));
883
              if (addr)
884
                {
885
                  goto found_pattern;
886
                }
887
            }
888
        }
889
    }
890
 
891
  /* Finally, if this is the main executable, try to locate a sequence
892
     from noshlibs */
893
  addr = hppa_symbol_address ("noshlibs");
894
  sec = find_pc_section (addr);
895
 
896
  if (sec && sec->objfile == obj)
897
    {
898
      CORE_ADDR start, end;
899
 
900
      find_pc_partial_function (addr, NULL, &start, &end);
901
      if (start != 0 && end != 0)
902
        {
903
          addr = hppa_hpux_search_pattern (start, end, ldsid_pattern,
904
                                           ARRAY_SIZE (ldsid_pattern));
905
          if (addr)
906
            goto found_pattern;
907
        }
908
    }
909
 
910
  /* Can't find a suitable sequence.  */
911
  return 0;
912
 
913
found_pattern:
914
  target_read_memory (addr, buf, sizeof (buf));
915
  insn = extract_unsigned_integer (buf, sizeof (buf));
916
  priv->dummy_call_sequence_addr = addr;
917
  priv->dummy_call_sequence_reg = (insn >> 21) & 0x1f;
918
 
919
  *argreg = priv->dummy_call_sequence_reg;
920
  return priv->dummy_call_sequence_addr;
921
}
922
 
923
static CORE_ADDR
924
hppa64_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
925
                                        int *argreg)
926
{
927
  struct objfile *obj;
928
  struct obj_section *sec;
929
  struct hppa_objfile_private *priv;
930
  CORE_ADDR addr;
931
  struct minimal_symbol *msym;
932
  int i;
933
 
934
  sec = find_pc_section (pc);
935
  obj = sec->objfile;
936
  priv = objfile_data (obj, hppa_objfile_priv_data);
937
 
938
  if (!priv)
939
    priv = hppa_init_objfile_priv_data (obj);
940
  if (!priv)
941
    error (_("Internal error creating objfile private data."));
942
 
943
  /* Use the cached value if we have one.  */
944
  if (priv->dummy_call_sequence_addr != 0)
945
    {
946
      *argreg = priv->dummy_call_sequence_reg;
947
      return priv->dummy_call_sequence_addr;
948
    }
949
 
950
  /* FIXME: Without stub unwind information, locating a suitable sequence is
951
     fairly difficult.  For now, we implement a very naive and inefficient
952
     scheme; try to read in blocks of code, and look for a "bve,n (rp)"
953
     instruction.  These are likely to occur at the end of functions, so
954
     we only look at the last two instructions of each function.  */
955
  for (i = 0, msym = obj->msymbols; i < obj->minimal_symbol_count; i++, msym++)
956
    {
957
      CORE_ADDR begin, end;
958
      char *name;
959
      gdb_byte buf[2 * HPPA_INSN_SIZE];
960
      int offset;
961
 
962
      find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym), &name,
963
                                &begin, &end);
964
 
965
      if (name == NULL || begin == 0 || end == 0)
966
        continue;
967
 
968
      if (target_read_memory (end - sizeof (buf), buf, sizeof (buf)) == 0)
969
        {
970
          for (offset = 0; offset < sizeof (buf); offset++)
971
            {
972
              unsigned int insn;
973
 
974
              insn = extract_unsigned_integer (buf + offset, HPPA_INSN_SIZE);
975
              if (insn == 0xe840d002) /* bve,n (rp) */
976
                {
977
                  addr = (end - sizeof (buf)) + offset;
978
                  goto found_pattern;
979
                }
980
            }
981
        }
982
    }
983
 
984
  /* Can't find a suitable sequence.  */
985
  return 0;
986
 
987
found_pattern:
988
  priv->dummy_call_sequence_addr = addr;
989
  /* Right now we only look for a "bve,l (rp)" sequence, so the register is
990
     always HPPA_RP_REGNUM.  */
991
  priv->dummy_call_sequence_reg = HPPA_RP_REGNUM;
992
 
993
  *argreg = priv->dummy_call_sequence_reg;
994
  return priv->dummy_call_sequence_addr;
995
}
996
 
997
static CORE_ADDR
998
hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr)
999
{
1000
  struct objfile *objfile;
1001
  struct minimal_symbol *funsym, *stubsym;
1002
  CORE_ADDR stubaddr;
1003
 
1004
  funsym = lookup_minimal_symbol_by_pc (funcaddr);
1005
  stubaddr = 0;
1006
 
1007
  ALL_OBJFILES (objfile)
1008
    {
1009
      stubsym = lookup_minimal_symbol_solib_trampoline
1010
        (SYMBOL_LINKAGE_NAME (funsym), objfile);
1011
 
1012
      if (stubsym)
1013
        {
1014
          struct unwind_table_entry *u;
1015
 
1016
          u = find_unwind_entry (SYMBOL_VALUE (stubsym));
1017
          if (u == NULL
1018
              || (u->stub_unwind.stub_type != IMPORT
1019
                  && u->stub_unwind.stub_type != IMPORT_SHLIB))
1020
            continue;
1021
 
1022
          stubaddr = SYMBOL_VALUE (stubsym);
1023
 
1024
          /* If we found an IMPORT stub, then we can stop searching;
1025
             if we found an IMPORT_SHLIB, we want to continue the search
1026
             in the hopes that we will find an IMPORT stub.  */
1027
          if (u->stub_unwind.stub_type == IMPORT)
1028
            break;
1029
        }
1030
    }
1031
 
1032
  return stubaddr;
1033
}
1034
 
1035
static int
1036
hppa_hpux_sr_for_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
1037
{
1038
  int sr;
1039
  /* The space register to use is encoded in the top 2 bits of the address.  */
1040
  sr = addr >> (gdbarch_tdep (gdbarch)->bytes_per_address * 8 - 2);
1041
  return sr + 4;
1042
}
1043
 
1044
static CORE_ADDR
1045
hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr)
1046
{
1047
  /* In order for us to restore the space register to its starting state,
1048
     we need the dummy trampoline to return to the an instruction address in
1049
     the same space as where we started the call.  We used to place the
1050
     breakpoint near the current pc, however, this breaks nested dummy calls
1051
     as the nested call will hit the breakpoint address and terminate
1052
     prematurely.  Instead, we try to look for an address in the same space to
1053
     put the breakpoint.
1054
 
1055
     This is similar in spirit to putting the breakpoint at the "entry point"
1056
     of an executable.  */
1057
 
1058
  struct obj_section *sec;
1059
  struct unwind_table_entry *u;
1060
  struct minimal_symbol *msym;
1061
  CORE_ADDR func;
1062
  int i;
1063
 
1064
  sec = find_pc_section (addr);
1065
  if (sec)
1066
    {
1067
      /* First try the lowest address in the section; we can use it as long
1068
         as it is "regular" code (i.e. not a stub) */
1069
      u = find_unwind_entry (sec->addr);
1070
      if (!u || u->stub_unwind.stub_type == 0)
1071
        return sec->addr;
1072
 
1073
      /* Otherwise, we need to find a symbol for a regular function.  We
1074
         do this by walking the list of msymbols in the objfile.  The symbol
1075
         we find should not be the same as the function that was passed in.  */
1076
 
1077
      /* FIXME: this is broken, because we can find a function that will be
1078
         called by the dummy call target function, which will still not
1079
         work.  */
1080
 
1081
      find_pc_partial_function (addr, NULL, &func, NULL);
1082
      for (i = 0, msym = sec->objfile->msymbols;
1083
           i < sec->objfile->minimal_symbol_count;
1084
           i++, msym++)
1085
        {
1086
          u = find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym));
1087
          if (func != SYMBOL_VALUE_ADDRESS (msym)
1088
              && (!u || u->stub_unwind.stub_type == 0))
1089
            return SYMBOL_VALUE_ADDRESS (msym);
1090
        }
1091
    }
1092
 
1093
  warning (_("Cannot find suitable address to place dummy breakpoint; nested "
1094
             "calls may fail."));
1095
  return addr - 4;
1096
}
1097
 
1098
static CORE_ADDR
1099
hppa_hpux_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
1100
                           CORE_ADDR funcaddr,
1101
                           struct value **args, int nargs,
1102
                           struct type *value_type,
1103
                           CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
1104
                           struct regcache *regcache)
1105
{
1106
  CORE_ADDR pc, stubaddr;
1107
  int argreg = 0;
1108
 
1109
  pc = read_pc ();
1110
 
1111
  /* Note: we don't want to pass a function descriptor here; push_dummy_call
1112
     fills in the PIC register for us.  */
1113
  funcaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funcaddr, NULL);
1114
 
1115
  /* The simple case is where we call a function in the same space that we are
1116
     currently in; in that case we don't really need to do anything.  */
1117
  if (hppa_hpux_sr_for_addr (gdbarch, pc)
1118
      == hppa_hpux_sr_for_addr (gdbarch, funcaddr))
1119
    {
1120
      /* Intraspace call.  */
1121
      *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
1122
      *real_pc = funcaddr;
1123
      regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, *bp_addr);
1124
 
1125
      return sp;
1126
    }
1127
 
1128
  /* In order to make an interspace call, we need to go through a stub.
1129
     gcc supplies an appropriate stub called "__gcc_plt_call", however, if
1130
     an application is compiled with HP compilers then this stub is not
1131
     available.  We used to fallback to "__d_plt_call", however that stub
1132
     is not entirely useful for us because it doesn't do an interspace
1133
     return back to the caller.  Also, on hppa64-hpux, there is no
1134
     __gcc_plt_call available.  In order to keep the code uniform, we
1135
     instead don't use either of these stubs, but instead write our own
1136
     onto the stack.
1137
 
1138
     A problem arises since the stack is located in a different space than
1139
     code, so in order to branch to a stack stub, we will need to do an
1140
     interspace branch.  Previous versions of gdb did this by modifying code
1141
     at the current pc and doing single-stepping to set the pcsq.  Since this
1142
     is highly undesirable, we use a different scheme:
1143
 
1144
     All we really need to do the branch to the stub is a short instruction
1145
     sequence like this:
1146
 
1147
     PA1.1:
1148
                ldsid (rX),r1
1149
                mtsp r1,sr0
1150
                be,n (sr0,rX)
1151
 
1152
     PA2.0:
1153
                bve,n (sr0,rX)
1154
 
1155
     Instead of writing these sequences ourselves, we can find it in
1156
     the instruction stream that belongs to the current space.  While this
1157
     seems difficult at first, we are actually guaranteed to find the sequences
1158
     in several places:
1159
 
1160
     For 32-bit code:
1161
     - in export stubs for shared libraries
1162
     - in the "noshlibs" routine in the main module
1163
 
1164
     For 64-bit code:
1165
     - at the end of each "regular" function
1166
 
1167
     We cache the address of these sequences in the objfile's private data
1168
     since these operations can potentially be quite expensive.
1169
 
1170
     So, what we do is:
1171
     - write a stack trampoline
1172
     - look for a suitable instruction sequence in the current space
1173
     - point the sequence at the trampoline
1174
     - set the return address of the trampoline to the current space
1175
       (see hppa_hpux_find_dummy_call_bpaddr)
1176
     - set the continuing address of the "dummy code" as the sequence.
1177
 
1178
*/
1179
 
1180
  if (IS_32BIT_TARGET (gdbarch))
1181
    {
1182
      static unsigned int hppa32_tramp[] = {
1183
        0x0fdf1291, /* stw r31,-8(,sp) */
1184
        0x02c010a1, /* ldsid (,r22),r1 */
1185
        0x00011820, /* mtsp r1,sr0 */
1186
        0xe6c00000, /* be,l 0(sr0,r22),%sr0,%r31 */
1187
        0x081f0242, /* copy r31,rp */
1188
        0x0fd11082, /* ldw -8(,sp),rp */
1189
        0x004010a1, /* ldsid (,rp),r1 */
1190
        0x00011820, /* mtsp r1,sr0 */
1191
        0xe0400000, /* be 0(sr0,rp) */
1192
        0x08000240  /* nop */
1193
      };
1194
 
1195
      /* for hppa32, we must call the function through a stub so that on
1196
         return it can return to the space of our trampoline.  */
1197
      stubaddr = hppa_hpux_find_import_stub_for_addr (funcaddr);
1198
      if (stubaddr == 0)
1199
        error (_("Cannot call external function not referenced by application "
1200
               "(no import stub).\n"));
1201
      regcache_cooked_write_unsigned (regcache, 22, stubaddr);
1202
 
1203
      write_memory (sp, (char *)&hppa32_tramp, sizeof (hppa32_tramp));
1204
 
1205
      *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
1206
      regcache_cooked_write_unsigned (regcache, 31, *bp_addr);
1207
 
1208
      *real_pc = hppa32_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
1209
      if (*real_pc == 0)
1210
        error (_("Cannot make interspace call from here."));
1211
 
1212
      regcache_cooked_write_unsigned (regcache, argreg, sp);
1213
 
1214
      sp += sizeof (hppa32_tramp);
1215
    }
1216
  else
1217
    {
1218
      static unsigned int hppa64_tramp[] = {
1219
        0xeac0f000, /* bve,l (r22),%r2 */
1220
        0x0fdf12d1, /* std r31,-8(,sp) */
1221
        0x0fd110c2, /* ldd -8(,sp),rp */
1222
        0xe840d002, /* bve,n (rp) */
1223
        0x08000240  /* nop */
1224
      };
1225
 
1226
      /* for hppa64, we don't need to call through a stub; all functions
1227
         return via a bve.  */
1228
      regcache_cooked_write_unsigned (regcache, 22, funcaddr);
1229
      write_memory (sp, (char *)&hppa64_tramp, sizeof (hppa64_tramp));
1230
 
1231
      *bp_addr = pc - 4;
1232
      regcache_cooked_write_unsigned (regcache, 31, *bp_addr);
1233
 
1234
      *real_pc = hppa64_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
1235
      if (*real_pc == 0)
1236
        error (_("Cannot make interspace call from here."));
1237
 
1238
      regcache_cooked_write_unsigned (regcache, argreg, sp);
1239
 
1240
      sp += sizeof (hppa64_tramp);
1241
    }
1242
 
1243
  sp = gdbarch_frame_align (gdbarch, sp);
1244
 
1245
  return sp;
1246
}
1247
 
1248
 
1249
 
1250
static void
1251
hppa_hpux_supply_ss_narrow (struct regcache *regcache,
1252
                            int regnum, const char *save_state)
1253
{
1254
  const char *ss_narrow = save_state + HPPA_HPUX_SS_NARROW_OFFSET;
1255
  int i, offset = 0;
1256
 
1257
  for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
1258
    {
1259
      if (regnum == i || regnum == -1)
1260
        regcache_raw_supply (regcache, i, ss_narrow + offset);
1261
 
1262
      offset += 4;
1263
    }
1264
}
1265
 
1266
static void
1267
hppa_hpux_supply_ss_fpblock (struct regcache *regcache,
1268
                             int regnum, const char *save_state)
1269
{
1270
  const char *ss_fpblock = save_state + HPPA_HPUX_SS_FPBLOCK_OFFSET;
1271
  int i, offset = 0;
1272
 
1273
  /* FIXME: We view the floating-point state as 64 single-precision
1274
     registers for 32-bit code, and 32 double-precision register for
1275
     64-bit code.  This distinction is artificial and should be
1276
     eliminated.  If that ever happens, we should remove the if-clause
1277
     below.  */
1278
 
1279
  if (register_size (get_regcache_arch (regcache), HPPA_FP0_REGNUM) == 4)
1280
    {
1281
      for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 64; i++)
1282
        {
1283
          if (regnum == i || regnum == -1)
1284
            regcache_raw_supply (regcache, i, ss_fpblock + offset);
1285
 
1286
          offset += 4;
1287
        }
1288
    }
1289
  else
1290
    {
1291
      for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32; i++)
1292
        {
1293
          if (regnum == i || regnum == -1)
1294
            regcache_raw_supply (regcache, i, ss_fpblock + offset);
1295
 
1296
          offset += 8;
1297
        }
1298
    }
1299
}
1300
 
1301
static void
1302
hppa_hpux_supply_ss_wide (struct regcache *regcache,
1303
                          int regnum, const char *save_state)
1304
{
1305
  const char *ss_wide = save_state + HPPA_HPUX_SS_WIDE_OFFSET;
1306
  int i, offset = 8;
1307
 
1308
  if (register_size (get_regcache_arch (regcache), HPPA_R1_REGNUM) == 4)
1309
    offset += 4;
1310
 
1311
  for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
1312
    {
1313
      if (regnum == i || regnum == -1)
1314
        regcache_raw_supply (regcache, i, ss_wide + offset);
1315
 
1316
      offset += 8;
1317
    }
1318
}
1319
 
1320
static void
1321
hppa_hpux_supply_save_state (const struct regset *regset,
1322
                             struct regcache *regcache,
1323
                             int regnum, const void *regs, size_t len)
1324
{
1325
  const char *proc_info = regs;
1326
  const char *save_state = proc_info + 8;
1327
  ULONGEST flags;
1328
 
1329
  flags = extract_unsigned_integer (save_state + HPPA_HPUX_SS_FLAGS_OFFSET, 4);
1330
  if (regnum == -1 || regnum == HPPA_FLAGS_REGNUM)
1331
    {
1332
      struct gdbarch *arch = get_regcache_arch (regcache);
1333
      size_t size = register_size (arch, HPPA_FLAGS_REGNUM);
1334
      char buf[8];
1335
 
1336
      store_unsigned_integer (buf, size, flags);
1337
      regcache_raw_supply (regcache, HPPA_FLAGS_REGNUM, buf);
1338
    }
1339
 
1340
  /* If the SS_WIDEREGS flag is set, we really do need the full
1341
     `struct save_state'.  */
1342
  if (flags & HPPA_HPUX_SS_WIDEREGS && len < HPPA_HPUX_SAVE_STATE_SIZE)
1343
    error (_("Register set contents too small"));
1344
 
1345
  if (flags & HPPA_HPUX_SS_WIDEREGS)
1346
    hppa_hpux_supply_ss_wide (regcache, regnum, save_state);
1347
  else
1348
    hppa_hpux_supply_ss_narrow (regcache, regnum, save_state);
1349
 
1350
  hppa_hpux_supply_ss_fpblock (regcache, regnum, save_state);
1351
}
1352
 
1353
/* HP-UX register set.  */
1354
 
1355
static struct regset hppa_hpux_regset =
1356
{
1357
  NULL,
1358
  hppa_hpux_supply_save_state
1359
};
1360
 
1361
static const struct regset *
1362
hppa_hpux_regset_from_core_section (struct gdbarch *gdbarch,
1363
                                    const char *sect_name, size_t sect_size)
1364
{
1365
  if (strcmp (sect_name, ".reg") == 0
1366
      && sect_size >= HPPA_HPUX_PA89_SAVE_STATE_SIZE + 8)
1367
    return &hppa_hpux_regset;
1368
 
1369
  return NULL;
1370
}
1371
 
1372
 
1373
/* Bit in the `ss_flag' member of `struct save_state' that indicates
1374
   the state was saved from a system call.  From
1375
   <machine/save_state.h>.  */
1376
#define HPPA_HPUX_SS_INSYSCALL  0x02
1377
 
1378
static CORE_ADDR
1379
hppa_hpux_read_pc (struct regcache *regcache)
1380
{
1381
  ULONGEST flags;
1382
 
1383
  /* If we're currently in a system call return the contents of %r31.  */
1384
  regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
1385
  if (flags & HPPA_HPUX_SS_INSYSCALL)
1386
    {
1387
      ULONGEST pc;
1388
      regcache_cooked_read_unsigned (regcache, HPPA_R31_REGNUM, &pc);
1389
      return pc & ~0x3;
1390
    }
1391
 
1392
  return hppa_read_pc (regcache);
1393
}
1394
 
1395
static void
1396
hppa_hpux_write_pc (struct regcache *regcache, CORE_ADDR pc)
1397
{
1398
  ULONGEST flags;
1399
 
1400
  /* If we're currently in a system call also write PC into %r31.  */
1401
  regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
1402
  if (flags & HPPA_HPUX_SS_INSYSCALL)
1403
    regcache_cooked_write_unsigned (regcache, HPPA_R31_REGNUM, pc | 0x3);
1404
 
1405
  return hppa_write_pc (regcache, pc);
1406
}
1407
 
1408
static CORE_ADDR
1409
hppa_hpux_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1410
{
1411
  ULONGEST flags;
1412
 
1413
  /* If we're currently in a system call return the contents of %r31.  */
1414
  flags = frame_unwind_register_unsigned (next_frame, HPPA_FLAGS_REGNUM);
1415
  if (flags & HPPA_HPUX_SS_INSYSCALL)
1416
    return frame_unwind_register_unsigned (next_frame, HPPA_R31_REGNUM) & ~0x3;
1417
 
1418
  return hppa_unwind_pc (gdbarch, next_frame);
1419
}
1420
 
1421
 
1422
/* Given the current value of the pc, check to see if it is inside a stub, and
1423
   if so, change the value of the pc to point to the caller of the stub.
1424
   NEXT_FRAME is the next frame in the current list of frames.
1425
   BASE contains to stack frame base of the current frame.
1426
   SAVE_REGS is the register file stored in the frame cache. */
1427
static void
1428
hppa_hpux_unwind_adjust_stub (struct frame_info *next_frame, CORE_ADDR base,
1429
                              struct trad_frame_saved_reg *saved_regs)
1430
{
1431
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
1432
  int optimized, realreg;
1433
  enum lval_type lval;
1434
  CORE_ADDR addr;
1435
  char buffer[sizeof(ULONGEST)];
1436
  ULONGEST val;
1437
  CORE_ADDR stubpc;
1438
  struct unwind_table_entry *u;
1439
 
1440
  trad_frame_get_prev_register (next_frame, saved_regs,
1441
                                HPPA_PCOQ_HEAD_REGNUM,
1442
                                &optimized, &lval, &addr, &realreg, buffer);
1443
  val = extract_unsigned_integer (buffer,
1444
                                  register_size (get_frame_arch (next_frame),
1445
                                                 HPPA_PCOQ_HEAD_REGNUM));
1446
 
1447
  u = find_unwind_entry (val);
1448
  if (u && u->stub_unwind.stub_type == EXPORT)
1449
    {
1450
      stubpc = read_memory_integer
1451
                 (base - 24, gdbarch_ptr_bit (gdbarch) / 8);
1452
      trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
1453
    }
1454
  else if (hppa_symbol_address ("__gcc_plt_call")
1455
           == get_pc_function_start (val))
1456
    {
1457
      stubpc = read_memory_integer
1458
                 (base - 8, gdbarch_ptr_bit (gdbarch) / 8);
1459
      trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
1460
    }
1461
}
1462
 
1463
static void
1464
hppa_hpux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1465
{
1466
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1467
 
1468
  if (IS_32BIT_TARGET (gdbarch))
1469
    tdep->in_solib_call_trampoline = hppa32_hpux_in_solib_call_trampoline;
1470
  else
1471
    tdep->in_solib_call_trampoline = hppa64_hpux_in_solib_call_trampoline;
1472
 
1473
  tdep->unwind_adjust_stub = hppa_hpux_unwind_adjust_stub;
1474
 
1475
  set_gdbarch_in_solib_return_trampoline
1476
    (gdbarch, hppa_hpux_in_solib_return_trampoline);
1477
  set_gdbarch_skip_trampoline_code (gdbarch, hppa_hpux_skip_trampoline_code);
1478
 
1479
  set_gdbarch_push_dummy_code (gdbarch, hppa_hpux_push_dummy_code);
1480
  set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
1481
 
1482
  set_gdbarch_read_pc (gdbarch, hppa_hpux_read_pc);
1483
  set_gdbarch_write_pc (gdbarch, hppa_hpux_write_pc);
1484
  set_gdbarch_unwind_pc (gdbarch, hppa_hpux_unwind_pc);
1485
  set_gdbarch_skip_permanent_breakpoint
1486
    (gdbarch, hppa_skip_permanent_breakpoint);
1487
 
1488
  set_gdbarch_regset_from_core_section
1489
    (gdbarch, hppa_hpux_regset_from_core_section);
1490
 
1491
  frame_unwind_append_sniffer (gdbarch, hppa_hpux_sigtramp_unwind_sniffer);
1492
}
1493
 
1494
static void
1495
hppa_hpux_som_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1496
{
1497
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1498
 
1499
  tdep->is_elf = 0;
1500
 
1501
  tdep->find_global_pointer = hppa32_hpux_find_global_pointer;
1502
 
1503
  hppa_hpux_init_abi (info, gdbarch);
1504
  som_solib_select (gdbarch);
1505
}
1506
 
1507
static void
1508
hppa_hpux_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1509
{
1510
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1511
 
1512
  tdep->is_elf = 1;
1513
  tdep->find_global_pointer = hppa64_hpux_find_global_pointer;
1514
 
1515
  hppa_hpux_init_abi (info, gdbarch);
1516
  pa64_solib_select (gdbarch);
1517
}
1518
 
1519
static enum gdb_osabi
1520
hppa_hpux_core_osabi_sniffer (bfd *abfd)
1521
{
1522
  if (strcmp (bfd_get_target (abfd), "hpux-core") == 0)
1523
    return GDB_OSABI_HPUX_SOM;
1524
  else if (strcmp (bfd_get_target (abfd), "elf64-hppa") == 0)
1525
    {
1526
      asection *section;
1527
 
1528
      section = bfd_get_section_by_name (abfd, ".kernel");
1529
      if (section)
1530
        {
1531
          bfd_size_type size;
1532
          char *contents;
1533
 
1534
          size = bfd_section_size (abfd, section);
1535
          contents = alloca (size);
1536
          if (bfd_get_section_contents (abfd, section, contents,
1537
                                        (file_ptr) 0, size)
1538
              && strcmp (contents, "HP-UX") == 0)
1539
            return GDB_OSABI_HPUX_ELF;
1540
        }
1541
    }
1542
 
1543
  return GDB_OSABI_UNKNOWN;
1544
}
1545
 
1546
void
1547
_initialize_hppa_hpux_tdep (void)
1548
{
1549
  /* BFD doesn't set a flavour for HP-UX style core files.  It doesn't
1550
     set the architecture either.  */
1551
  gdbarch_register_osabi_sniffer (bfd_arch_unknown,
1552
                                  bfd_target_unknown_flavour,
1553
                                  hppa_hpux_core_osabi_sniffer);
1554
  gdbarch_register_osabi_sniffer (bfd_arch_hppa,
1555
                                  bfd_target_elf_flavour,
1556
                                  hppa_hpux_core_osabi_sniffer);
1557
 
1558
  gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_HPUX_SOM,
1559
                          hppa_hpux_som_init_abi);
1560
  gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_HPUX_ELF,
1561
                          hppa_hpux_elf_init_abi);
1562
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.