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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [hppa-tdep.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Target-dependent code for the HP PA architecture, for GDB.
2
   Copyright 1986, 1987, 1989-1996, 1999-2000 Free Software Foundation, Inc.
3
 
4
   Contributed by the Center for Software Science at the
5
   University of Utah (pa-gdb-bugs@cs.utah.edu).
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 2 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 59 Temple Place - Suite 330,
22
   Boston, MA 02111-1307, USA.  */
23
 
24
#include "defs.h"
25
#include "frame.h"
26
#include "bfd.h"
27
#include "inferior.h"
28
#include "value.h"
29
 
30
/* For argument passing to the inferior */
31
#include "symtab.h"
32
 
33
#ifdef USG
34
#include <sys/types.h>
35
#endif
36
 
37
#include <dl.h>
38
#include <sys/param.h>
39
#include <signal.h>
40
 
41
#include <sys/ptrace.h>
42
#include <machine/save_state.h>
43
 
44
#ifdef COFF_ENCAPSULATE
45
#include "a.out.encap.h"
46
#else
47
#endif
48
 
49
/*#include <sys/user.h>         After a.out.h  */
50
#include <sys/file.h>
51
#include "gdb_stat.h"
52
#include "gdb_wait.h"
53
 
54
#include "gdbcore.h"
55
#include "gdbcmd.h"
56
#include "target.h"
57
#include "symfile.h"
58
#include "objfiles.h"
59
 
60
/* To support detection of the pseudo-initial frame
61
   that threads have. */
62
#define THREAD_INITIAL_FRAME_SYMBOL  "__pthread_exit"
63
#define THREAD_INITIAL_FRAME_SYM_LEN  sizeof(THREAD_INITIAL_FRAME_SYMBOL)
64
 
65
static int extract_5_load PARAMS ((unsigned int));
66
 
67
static unsigned extract_5R_store PARAMS ((unsigned int));
68
 
69
static unsigned extract_5r_store PARAMS ((unsigned int));
70
 
71
static void find_dummy_frame_regs PARAMS ((struct frame_info *,
72
                                           struct frame_saved_regs *));
73
 
74
static int find_proc_framesize PARAMS ((CORE_ADDR));
75
 
76
static int find_return_regnum PARAMS ((CORE_ADDR));
77
 
78
struct unwind_table_entry *find_unwind_entry PARAMS ((CORE_ADDR));
79
 
80
static int extract_17 PARAMS ((unsigned int));
81
 
82
static unsigned deposit_21 PARAMS ((unsigned int, unsigned int));
83
 
84
static int extract_21 PARAMS ((unsigned));
85
 
86
static unsigned deposit_14 PARAMS ((int, unsigned int));
87
 
88
static int extract_14 PARAMS ((unsigned));
89
 
90
static void unwind_command PARAMS ((char *, int));
91
 
92
static int low_sign_extend PARAMS ((unsigned int, unsigned int));
93
 
94
static int sign_extend PARAMS ((unsigned int, unsigned int));
95
 
96
static int restore_pc_queue PARAMS ((struct frame_saved_regs *));
97
 
98
static int hppa_alignof PARAMS ((struct type *));
99
 
100
/* To support multi-threading and stepping. */
101
int hppa_prepare_to_proceed PARAMS (());
102
 
103
static int prologue_inst_adjust_sp PARAMS ((unsigned long));
104
 
105
static int is_branch PARAMS ((unsigned long));
106
 
107
static int inst_saves_gr PARAMS ((unsigned long));
108
 
109
static int inst_saves_fr PARAMS ((unsigned long));
110
 
111
static int pc_in_interrupt_handler PARAMS ((CORE_ADDR));
112
 
113
static int pc_in_linker_stub PARAMS ((CORE_ADDR));
114
 
115
static int compare_unwind_entries PARAMS ((const void *, const void *));
116
 
117
static void read_unwind_info PARAMS ((struct objfile *));
118
 
119
static void internalize_unwinds PARAMS ((struct objfile *,
120
                                         struct unwind_table_entry *,
121
                                         asection *, unsigned int,
122
                                         unsigned int, CORE_ADDR));
123
static void pa_print_registers PARAMS ((char *, int, int));
124
static void pa_strcat_registers (char *, int, int, struct ui_file *);
125
static void pa_register_look_aside PARAMS ((char *, int, long *));
126
static void pa_print_fp_reg PARAMS ((int));
127
static void pa_strcat_fp_reg (int, struct ui_file *, enum precision_type);
128
static void record_text_segment_lowaddr PARAMS ((bfd *, asection *, void *));
129
 
130
typedef struct
131
  {
132
    struct minimal_symbol *msym;
133
    CORE_ADDR solib_handle;
134
    CORE_ADDR return_val;
135
  }
136
args_for_find_stub;
137
 
138
static int cover_find_stub_with_shl_get (PTR);
139
 
140
static int is_pa_2 = 0;          /* False */
141
 
142
/* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
143
extern int hp_som_som_object_present;
144
 
145
/* In breakpoint.c */
146
extern int exception_catchpoints_are_fragile;
147
 
148
/* This is defined in valops.c. */
149
extern value_ptr
150
  find_function_in_inferior PARAMS ((char *));
151
 
152
/* Should call_function allocate stack space for a struct return?  */
153
int
154
hppa_use_struct_convention (gcc_p, type)
155
     int gcc_p;
156
     struct type *type;
157
{
158
  return (TYPE_LENGTH (type) > 2 * REGISTER_SIZE);
159
}
160
 
161
 
162
/* Routines to extract various sized constants out of hppa
163
   instructions. */
164
 
165
/* This assumes that no garbage lies outside of the lower bits of
166
   value. */
167
 
168
static int
169
sign_extend (val, bits)
170
     unsigned val, bits;
171
{
172
  return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
173
}
174
 
175
/* For many immediate values the sign bit is the low bit! */
176
 
177
static int
178
low_sign_extend (val, bits)
179
     unsigned val, bits;
180
{
181
  return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
182
}
183
 
184
/* extract the immediate field from a ld{bhw}s instruction */
185
 
186
static int
187
extract_5_load (word)
188
     unsigned word;
189
{
190
  return low_sign_extend (word >> 16 & MASK_5, 5);
191
}
192
 
193
/* extract the immediate field from a break instruction */
194
 
195
static unsigned
196
extract_5r_store (word)
197
     unsigned word;
198
{
199
  return (word & MASK_5);
200
}
201
 
202
/* extract the immediate field from a {sr}sm instruction */
203
 
204
static unsigned
205
extract_5R_store (word)
206
     unsigned word;
207
{
208
  return (word >> 16 & MASK_5);
209
}
210
 
211
/* extract a 14 bit immediate field */
212
 
213
static int
214
extract_14 (word)
215
     unsigned word;
216
{
217
  return low_sign_extend (word & MASK_14, 14);
218
}
219
 
220
/* deposit a 14 bit constant in a word */
221
 
222
static unsigned
223
deposit_14 (opnd, word)
224
     int opnd;
225
     unsigned word;
226
{
227
  unsigned sign = (opnd < 0 ? 1 : 0);
228
 
229
  return word | ((unsigned) opnd << 1 & MASK_14) | sign;
230
}
231
 
232
/* extract a 21 bit constant */
233
 
234
static int
235
extract_21 (word)
236
     unsigned word;
237
{
238
  int val;
239
 
240
  word &= MASK_21;
241
  word <<= 11;
242
  val = GET_FIELD (word, 20, 20);
243
  val <<= 11;
244
  val |= GET_FIELD (word, 9, 19);
245
  val <<= 2;
246
  val |= GET_FIELD (word, 5, 6);
247
  val <<= 5;
248
  val |= GET_FIELD (word, 0, 4);
249
  val <<= 2;
250
  val |= GET_FIELD (word, 7, 8);
251
  return sign_extend (val, 21) << 11;
252
}
253
 
254
/* deposit a 21 bit constant in a word. Although 21 bit constants are
255
   usually the top 21 bits of a 32 bit constant, we assume that only
256
   the low 21 bits of opnd are relevant */
257
 
258
static unsigned
259
deposit_21 (opnd, word)
260
     unsigned opnd, word;
261
{
262
  unsigned val = 0;
263
 
264
  val |= GET_FIELD (opnd, 11 + 14, 11 + 18);
265
  val <<= 2;
266
  val |= GET_FIELD (opnd, 11 + 12, 11 + 13);
267
  val <<= 2;
268
  val |= GET_FIELD (opnd, 11 + 19, 11 + 20);
269
  val <<= 11;
270
  val |= GET_FIELD (opnd, 11 + 1, 11 + 11);
271
  val <<= 1;
272
  val |= GET_FIELD (opnd, 11 + 0, 11 + 0);
273
  return word | val;
274
}
275
 
276
/* extract a 17 bit constant from branch instructions, returning the
277
   19 bit signed value. */
278
 
279
static int
280
extract_17 (word)
281
     unsigned word;
282
{
283
  return sign_extend (GET_FIELD (word, 19, 28) |
284
                      GET_FIELD (word, 29, 29) << 10 |
285
                      GET_FIELD (word, 11, 15) << 11 |
286
                      (word & 0x1) << 16, 17) << 2;
287
}
288
 
289
 
290
/* Compare the start address for two unwind entries returning 1 if
291
   the first address is larger than the second, -1 if the second is
292
   larger than the first, and zero if they are equal.  */
293
 
294
static int
295
compare_unwind_entries (arg1, arg2)
296
     const void *arg1;
297
     const void *arg2;
298
{
299
  const struct unwind_table_entry *a = arg1;
300
  const struct unwind_table_entry *b = arg2;
301
 
302
  if (a->region_start > b->region_start)
303
    return 1;
304
  else if (a->region_start < b->region_start)
305
    return -1;
306
  else
307
    return 0;
308
}
309
 
310
static CORE_ADDR low_text_segment_address;
311
 
312
static void
313
record_text_segment_lowaddr (abfd, section, ignored)
314
     bfd *abfd ATTRIBUTE_UNUSED;
315
     asection *section;
316
     PTR ignored ATTRIBUTE_UNUSED;
317
{
318
  if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
319
       == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
320
      && section->vma < low_text_segment_address)
321
    low_text_segment_address = section->vma;
322
}
323
 
324
static void
325
internalize_unwinds (objfile, table, section, entries, size, text_offset)
326
     struct objfile *objfile;
327
     struct unwind_table_entry *table;
328
     asection *section;
329
     unsigned int entries, size;
330
     CORE_ADDR text_offset;
331
{
332
  /* We will read the unwind entries into temporary memory, then
333
     fill in the actual unwind table.  */
334
  if (size > 0)
335
    {
336
      unsigned long tmp;
337
      unsigned i;
338
      char *buf = alloca (size);
339
 
340
      low_text_segment_address = -1;
341
 
342
      /* If addresses are 64 bits wide, then unwinds are supposed to
343
         be segment relative offsets instead of absolute addresses.
344
 
345
         Note that when loading a shared library (text_offset != 0) the
346
         unwinds are already relative to the text_offset that will be
347
         passed in.  */
348
      if (TARGET_PTR_BIT == 64 && text_offset == 0)
349
        {
350
          bfd_map_over_sections (objfile->obfd,
351
                                 record_text_segment_lowaddr, (PTR) NULL);
352
 
353
          /* ?!? Mask off some low bits.  Should this instead subtract
354
             out the lowest section's filepos or something like that?
355
             This looks very hokey to me.  */
356
          low_text_segment_address &= ~0xfff;
357
          text_offset += low_text_segment_address;
358
        }
359
 
360
      bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
361
 
362
      /* Now internalize the information being careful to handle host/target
363
         endian issues.  */
364
      for (i = 0; i < entries; i++)
365
        {
366
          table[i].region_start = bfd_get_32 (objfile->obfd,
367
                                              (bfd_byte *) buf);
368
          table[i].region_start += text_offset;
369
          buf += 4;
370
          table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
371
          table[i].region_end += text_offset;
372
          buf += 4;
373
          tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
374
          buf += 4;
375
          table[i].Cannot_unwind = (tmp >> 31) & 0x1;
376
          table[i].Millicode = (tmp >> 30) & 0x1;
377
          table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
378
          table[i].Region_description = (tmp >> 27) & 0x3;
379
          table[i].reserved1 = (tmp >> 26) & 0x1;
380
          table[i].Entry_SR = (tmp >> 25) & 0x1;
381
          table[i].Entry_FR = (tmp >> 21) & 0xf;
382
          table[i].Entry_GR = (tmp >> 16) & 0x1f;
383
          table[i].Args_stored = (tmp >> 15) & 0x1;
384
          table[i].Variable_Frame = (tmp >> 14) & 0x1;
385
          table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
386
          table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
387
          table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
388
          table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
389
          table[i].Ada_Region = (tmp >> 9) & 0x1;
390
          table[i].cxx_info = (tmp >> 8) & 0x1;
391
          table[i].cxx_try_catch = (tmp >> 7) & 0x1;
392
          table[i].sched_entry_seq = (tmp >> 6) & 0x1;
393
          table[i].reserved2 = (tmp >> 5) & 0x1;
394
          table[i].Save_SP = (tmp >> 4) & 0x1;
395
          table[i].Save_RP = (tmp >> 3) & 0x1;
396
          table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
397
          table[i].extn_ptr_defined = (tmp >> 1) & 0x1;
398
          table[i].Cleanup_defined = tmp & 0x1;
399
          tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
400
          buf += 4;
401
          table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
402
          table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
403
          table[i].Large_frame = (tmp >> 29) & 0x1;
404
          table[i].Pseudo_SP_Set = (tmp >> 28) & 0x1;
405
          table[i].reserved4 = (tmp >> 27) & 0x1;
406
          table[i].Total_frame_size = tmp & 0x7ffffff;
407
 
408
          /* Stub unwinds are handled elsewhere. */
409
          table[i].stub_unwind.stub_type = 0;
410
          table[i].stub_unwind.padding = 0;
411
        }
412
    }
413
}
414
 
415
/* Read in the backtrace information stored in the `$UNWIND_START$' section of
416
   the object file.  This info is used mainly by find_unwind_entry() to find
417
   out the stack frame size and frame pointer used by procedures.  We put
418
   everything on the psymbol obstack in the objfile so that it automatically
419
   gets freed when the objfile is destroyed.  */
420
 
421
static void
422
read_unwind_info (objfile)
423
     struct objfile *objfile;
424
{
425
  asection *unwind_sec, *stub_unwind_sec;
426
  unsigned unwind_size, stub_unwind_size, total_size;
427
  unsigned index, unwind_entries;
428
  unsigned stub_entries, total_entries;
429
  CORE_ADDR text_offset;
430
  struct obj_unwind_info *ui;
431
  obj_private_data_t *obj_private;
432
 
433
  text_offset = ANOFFSET (objfile->section_offsets, 0);
434
  ui = (struct obj_unwind_info *) obstack_alloc (&objfile->psymbol_obstack,
435
                                           sizeof (struct obj_unwind_info));
436
 
437
  ui->table = NULL;
438
  ui->cache = NULL;
439
  ui->last = -1;
440
 
441
  /* For reasons unknown the HP PA64 tools generate multiple unwinder
442
     sections in a single executable.  So we just iterate over every
443
     section in the BFD looking for unwinder sections intead of trying
444
     to do a lookup with bfd_get_section_by_name.
445
 
446
     First determine the total size of the unwind tables so that we
447
     can allocate memory in a nice big hunk.  */
448
  total_entries = 0;
449
  for (unwind_sec = objfile->obfd->sections;
450
       unwind_sec;
451
       unwind_sec = unwind_sec->next)
452
    {
453
      if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
454
          || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
455
        {
456
          unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
457
          unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
458
 
459
          total_entries += unwind_entries;
460
        }
461
    }
462
 
463
  /* Now compute the size of the stub unwinds.  Note the ELF tools do not
464
     use stub unwinds at the curren time.  */
465
  stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
466
 
467
  if (stub_unwind_sec)
468
    {
469
      stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
470
      stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
471
    }
472
  else
473
    {
474
      stub_unwind_size = 0;
475
      stub_entries = 0;
476
    }
477
 
478
  /* Compute total number of unwind entries and their total size.  */
479
  total_entries += stub_entries;
480
  total_size = total_entries * sizeof (struct unwind_table_entry);
481
 
482
  /* Allocate memory for the unwind table.  */
483
  ui->table = (struct unwind_table_entry *)
484
    obstack_alloc (&objfile->psymbol_obstack, total_size);
485
  ui->last = total_entries - 1;
486
 
487
  /* Now read in each unwind section and internalize the standard unwind
488
     entries.  */
489
  index = 0;
490
  for (unwind_sec = objfile->obfd->sections;
491
       unwind_sec;
492
       unwind_sec = unwind_sec->next)
493
    {
494
      if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
495
          || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
496
        {
497
          unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
498
          unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
499
 
500
          internalize_unwinds (objfile, &ui->table[index], unwind_sec,
501
                               unwind_entries, unwind_size, text_offset);
502
          index += unwind_entries;
503
        }
504
    }
505
 
506
  /* Now read in and internalize the stub unwind entries.  */
507
  if (stub_unwind_size > 0)
508
    {
509
      unsigned int i;
510
      char *buf = alloca (stub_unwind_size);
511
 
512
      /* Read in the stub unwind entries.  */
513
      bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
514
                                0, stub_unwind_size);
515
 
516
      /* Now convert them into regular unwind entries.  */
517
      for (i = 0; i < stub_entries; i++, index++)
518
        {
519
          /* Clear out the next unwind entry.  */
520
          memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
521
 
522
          /* Convert offset & size into region_start and region_end.
523
             Stuff away the stub type into "reserved" fields.  */
524
          ui->table[index].region_start = bfd_get_32 (objfile->obfd,
525
                                                      (bfd_byte *) buf);
526
          ui->table[index].region_start += text_offset;
527
          buf += 4;
528
          ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
529
                                                          (bfd_byte *) buf);
530
          buf += 2;
531
          ui->table[index].region_end
532
            = ui->table[index].region_start + 4 *
533
            (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
534
          buf += 2;
535
        }
536
 
537
    }
538
 
539
  /* Unwind table needs to be kept sorted.  */
540
  qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
541
         compare_unwind_entries);
542
 
543
  /* Keep a pointer to the unwind information.  */
544
  if (objfile->obj_private == NULL)
545
    {
546
      obj_private = (obj_private_data_t *)
547
        obstack_alloc (&objfile->psymbol_obstack,
548
                       sizeof (obj_private_data_t));
549
      obj_private->unwind_info = NULL;
550
      obj_private->so_info = NULL;
551
      obj_private->dp = 0;
552
 
553
      objfile->obj_private = (PTR) obj_private;
554
    }
555
  obj_private = (obj_private_data_t *) objfile->obj_private;
556
  obj_private->unwind_info = ui;
557
}
558
 
559
/* Lookup the unwind (stack backtrace) info for the given PC.  We search all
560
   of the objfiles seeking the unwind table entry for this PC.  Each objfile
561
   contains a sorted list of struct unwind_table_entry.  Since we do a binary
562
   search of the unwind tables, we depend upon them to be sorted.  */
563
 
564
struct unwind_table_entry *
565
find_unwind_entry (pc)
566
     CORE_ADDR pc;
567
{
568
  int first, middle, last;
569
  struct objfile *objfile;
570
 
571
  /* A function at address 0?  Not in HP-UX! */
572
  if (pc == (CORE_ADDR) 0)
573
    return NULL;
574
 
575
  ALL_OBJFILES (objfile)
576
  {
577
    struct obj_unwind_info *ui;
578
    ui = NULL;
579
    if (objfile->obj_private)
580
      ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
581
 
582
    if (!ui)
583
      {
584
        read_unwind_info (objfile);
585
        if (objfile->obj_private == NULL)
586
          error ("Internal error reading unwind information.");
587
        ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
588
      }
589
 
590
    /* First, check the cache */
591
 
592
    if (ui->cache
593
        && pc >= ui->cache->region_start
594
        && pc <= ui->cache->region_end)
595
      return ui->cache;
596
 
597
    /* Not in the cache, do a binary search */
598
 
599
    first = 0;
600
    last = ui->last;
601
 
602
    while (first <= last)
603
      {
604
        middle = (first + last) / 2;
605
        if (pc >= ui->table[middle].region_start
606
            && pc <= ui->table[middle].region_end)
607
          {
608
            ui->cache = &ui->table[middle];
609
            return &ui->table[middle];
610
          }
611
 
612
        if (pc < ui->table[middle].region_start)
613
          last = middle - 1;
614
        else
615
          first = middle + 1;
616
      }
617
  }                             /* ALL_OBJFILES() */
618
  return NULL;
619
}
620
 
621
/* Return the adjustment necessary to make for addresses on the stack
622
   as presented by hpread.c.
623
 
624
   This is necessary because of the stack direction on the PA and the
625
   bizarre way in which someone (?) decided they wanted to handle
626
   frame pointerless code in GDB.  */
627
int
628
hpread_adjust_stack_address (func_addr)
629
     CORE_ADDR func_addr;
630
{
631
  struct unwind_table_entry *u;
632
 
633
  u = find_unwind_entry (func_addr);
634
  if (!u)
635
    return 0;
636
  else
637
    return u->Total_frame_size << 3;
638
}
639
 
640
/* Called to determine if PC is in an interrupt handler of some
641
   kind.  */
642
 
643
static int
644
pc_in_interrupt_handler (pc)
645
     CORE_ADDR pc;
646
{
647
  struct unwind_table_entry *u;
648
  struct minimal_symbol *msym_us;
649
 
650
  u = find_unwind_entry (pc);
651
  if (!u)
652
    return 0;
653
 
654
  /* Oh joys.  HPUX sets the interrupt bit for _sigreturn even though
655
     its frame isn't a pure interrupt frame.  Deal with this.  */
656
  msym_us = lookup_minimal_symbol_by_pc (pc);
657
 
658
  return u->HP_UX_interrupt_marker && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us));
659
}
660
 
661
/* Called when no unwind descriptor was found for PC.  Returns 1 if it
662
   appears that PC is in a linker stub.
663
 
664
   ?!? Need to handle stubs which appear in PA64 code.  */
665
 
666
static int
667
pc_in_linker_stub (pc)
668
     CORE_ADDR pc;
669
{
670
  int found_magic_instruction = 0;
671
  int i;
672
  char buf[4];
673
 
674
  /* If unable to read memory, assume pc is not in a linker stub.  */
675
  if (target_read_memory (pc, buf, 4) != 0)
676
    return 0;
677
 
678
  /* We are looking for something like
679
 
680
     ; $$dyncall jams RP into this special spot in the frame (RP')
681
     ; before calling the "call stub"
682
     ldw     -18(sp),rp
683
 
684
     ldsid   (rp),r1         ; Get space associated with RP into r1
685
     mtsp    r1,sp           ; Move it into space register 0
686
     be,n    0(sr0),rp)      ; back to your regularly scheduled program */
687
 
688
  /* Maximum known linker stub size is 4 instructions.  Search forward
689
     from the given PC, then backward.  */
690
  for (i = 0; i < 4; i++)
691
    {
692
      /* If we hit something with an unwind, stop searching this direction.  */
693
 
694
      if (find_unwind_entry (pc + i * 4) != 0)
695
        break;
696
 
697
      /* Check for ldsid (rp),r1 which is the magic instruction for a
698
         return from a cross-space function call.  */
699
      if (read_memory_integer (pc + i * 4, 4) == 0x004010a1)
700
        {
701
          found_magic_instruction = 1;
702
          break;
703
        }
704
      /* Add code to handle long call/branch and argument relocation stubs
705
         here.  */
706
    }
707
 
708
  if (found_magic_instruction != 0)
709
    return 1;
710
 
711
  /* Now look backward.  */
712
  for (i = 0; i < 4; i++)
713
    {
714
      /* If we hit something with an unwind, stop searching this direction.  */
715
 
716
      if (find_unwind_entry (pc - i * 4) != 0)
717
        break;
718
 
719
      /* Check for ldsid (rp),r1 which is the magic instruction for a
720
         return from a cross-space function call.  */
721
      if (read_memory_integer (pc - i * 4, 4) == 0x004010a1)
722
        {
723
          found_magic_instruction = 1;
724
          break;
725
        }
726
      /* Add code to handle long call/branch and argument relocation stubs
727
         here.  */
728
    }
729
  return found_magic_instruction;
730
}
731
 
732
static int
733
find_return_regnum (pc)
734
     CORE_ADDR pc;
735
{
736
  struct unwind_table_entry *u;
737
 
738
  u = find_unwind_entry (pc);
739
 
740
  if (!u)
741
    return RP_REGNUM;
742
 
743
  if (u->Millicode)
744
    return 31;
745
 
746
  return RP_REGNUM;
747
}
748
 
749
/* Return size of frame, or -1 if we should use a frame pointer.  */
750
static int
751
find_proc_framesize (pc)
752
     CORE_ADDR pc;
753
{
754
  struct unwind_table_entry *u;
755
  struct minimal_symbol *msym_us;
756
 
757
  /* This may indicate a bug in our callers... */
758
  if (pc == (CORE_ADDR) 0)
759
    return -1;
760
 
761
  u = find_unwind_entry (pc);
762
 
763
  if (!u)
764
    {
765
      if (pc_in_linker_stub (pc))
766
        /* Linker stubs have a zero size frame.  */
767
        return 0;
768
      else
769
        return -1;
770
    }
771
 
772
  msym_us = lookup_minimal_symbol_by_pc (pc);
773
 
774
  /* If Save_SP is set, and we're not in an interrupt or signal caller,
775
     then we have a frame pointer.  Use it.  */
776
  if (u->Save_SP && !pc_in_interrupt_handler (pc)
777
      && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us)))
778
    return -1;
779
 
780
  return u->Total_frame_size << 3;
781
}
782
 
783
/* Return offset from sp at which rp is saved, or 0 if not saved.  */
784
static int rp_saved PARAMS ((CORE_ADDR));
785
 
786
static int
787
rp_saved (pc)
788
     CORE_ADDR pc;
789
{
790
  struct unwind_table_entry *u;
791
 
792
  /* A function at, and thus a return PC from, address 0?  Not in HP-UX! */
793
  if (pc == (CORE_ADDR) 0)
794
    return 0;
795
 
796
  u = find_unwind_entry (pc);
797
 
798
  if (!u)
799
    {
800
      if (pc_in_linker_stub (pc))
801
        /* This is the so-called RP'.  */
802
        return -24;
803
      else
804
        return 0;
805
    }
806
 
807
  if (u->Save_RP)
808
    return (TARGET_PTR_BIT == 64 ? -16 : -20);
809
  else if (u->stub_unwind.stub_type != 0)
810
    {
811
      switch (u->stub_unwind.stub_type)
812
        {
813
        case EXPORT:
814
        case IMPORT:
815
          return -24;
816
        case PARAMETER_RELOCATION:
817
          return -8;
818
        default:
819
          return 0;
820
        }
821
    }
822
  else
823
    return 0;
824
}
825
 
826
int
827
frameless_function_invocation (frame)
828
     struct frame_info *frame;
829
{
830
  struct unwind_table_entry *u;
831
 
832
  u = find_unwind_entry (frame->pc);
833
 
834
  if (u == 0)
835
    return 0;
836
 
837
  return (u->Total_frame_size == 0 && u->stub_unwind.stub_type == 0);
838
}
839
 
840
CORE_ADDR
841
saved_pc_after_call (frame)
842
     struct frame_info *frame;
843
{
844
  int ret_regnum;
845
  CORE_ADDR pc;
846
  struct unwind_table_entry *u;
847
 
848
  ret_regnum = find_return_regnum (get_frame_pc (frame));
849
  pc = read_register (ret_regnum) & ~0x3;
850
 
851
  /* If PC is in a linker stub, then we need to dig the address
852
     the stub will return to out of the stack.  */
853
  u = find_unwind_entry (pc);
854
  if (u && u->stub_unwind.stub_type != 0)
855
    return FRAME_SAVED_PC (frame);
856
  else
857
    return pc;
858
}
859
 
860
CORE_ADDR
861
hppa_frame_saved_pc (frame)
862
     struct frame_info *frame;
863
{
864
  CORE_ADDR pc = get_frame_pc (frame);
865
  struct unwind_table_entry *u;
866
  CORE_ADDR old_pc;
867
  int spun_around_loop = 0;
868
  int rp_offset = 0;
869
 
870
  /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
871
     at the base of the frame in an interrupt handler.  Registers within
872
     are saved in the exact same order as GDB numbers registers.  How
873
     convienent.  */
874
  if (pc_in_interrupt_handler (pc))
875
    return read_memory_integer (frame->frame + PC_REGNUM * 4,
876
                                TARGET_PTR_BIT / 8) & ~0x3;
877
 
878
  if ((frame->pc >= frame->frame
879
       && frame->pc <= (frame->frame
880
                        /* A call dummy is sized in words, but it is
881
                           actually a series of instructions.  Account
882
                           for that scaling factor.  */
883
                        + ((REGISTER_SIZE / INSTRUCTION_SIZE)
884
                           * CALL_DUMMY_LENGTH)
885
                        /* Similarly we have to account for 64bit
886
                           wide register saves.  */
887
                        + (32 * REGISTER_SIZE)
888
                        /* We always consider FP regs 8 bytes long.  */
889
                        + (NUM_REGS - FP0_REGNUM) * 8
890
                        /* Similarly we have to account for 64bit
891
                           wide register saves.  */
892
                        + (6 * REGISTER_SIZE))))
893
    {
894
      return read_memory_integer ((frame->frame
895
                                   + (TARGET_PTR_BIT == 64 ? -16 : -20)),
896
                                  TARGET_PTR_BIT / 8) & ~0x3;
897
    }
898
 
899
#ifdef FRAME_SAVED_PC_IN_SIGTRAMP
900
  /* Deal with signal handler caller frames too.  */
901
  if (frame->signal_handler_caller)
902
    {
903
      CORE_ADDR rp;
904
      FRAME_SAVED_PC_IN_SIGTRAMP (frame, &rp);
905
      return rp & ~0x3;
906
    }
907
#endif
908
 
909
  if (frameless_function_invocation (frame))
910
    {
911
      int ret_regnum;
912
 
913
      ret_regnum = find_return_regnum (pc);
914
 
915
      /* If the next frame is an interrupt frame or a signal
916
         handler caller, then we need to look in the saved
917
         register area to get the return pointer (the values
918
         in the registers may not correspond to anything useful).  */
919
      if (frame->next
920
          && (frame->next->signal_handler_caller
921
              || pc_in_interrupt_handler (frame->next->pc)))
922
        {
923
          struct frame_saved_regs saved_regs;
924
 
925
          get_frame_saved_regs (frame->next, &saved_regs);
926
          if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
927
                                   TARGET_PTR_BIT / 8) & 0x2)
928
            {
929
              pc = read_memory_integer (saved_regs.regs[31],
930
                                        TARGET_PTR_BIT / 8) & ~0x3;
931
 
932
              /* Syscalls are really two frames.  The syscall stub itself
933
                 with a return pointer in %rp and the kernel call with
934
                 a return pointer in %r31.  We return the %rp variant
935
                 if %r31 is the same as frame->pc.  */
936
              if (pc == frame->pc)
937
                pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
938
                                          TARGET_PTR_BIT / 8) & ~0x3;
939
            }
940
          else
941
            pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
942
                                      TARGET_PTR_BIT / 8) & ~0x3;
943
        }
944
      else
945
        pc = read_register (ret_regnum) & ~0x3;
946
    }
947
  else
948
    {
949
      spun_around_loop = 0;
950
      old_pc = pc;
951
 
952
    restart:
953
      rp_offset = rp_saved (pc);
954
 
955
      /* Similar to code in frameless function case.  If the next
956
         frame is a signal or interrupt handler, then dig the right
957
         information out of the saved register info.  */
958
      if (rp_offset == 0
959
          && frame->next
960
          && (frame->next->signal_handler_caller
961
              || pc_in_interrupt_handler (frame->next->pc)))
962
        {
963
          struct frame_saved_regs saved_regs;
964
 
965
          get_frame_saved_regs (frame->next, &saved_regs);
966
          if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
967
                                   TARGET_PTR_BIT / 8) & 0x2)
968
            {
969
              pc = read_memory_integer (saved_regs.regs[31],
970
                                        TARGET_PTR_BIT / 8) & ~0x3;
971
 
972
              /* Syscalls are really two frames.  The syscall stub itself
973
                 with a return pointer in %rp and the kernel call with
974
                 a return pointer in %r31.  We return the %rp variant
975
                 if %r31 is the same as frame->pc.  */
976
              if (pc == frame->pc)
977
                pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
978
                                          TARGET_PTR_BIT / 8) & ~0x3;
979
            }
980
          else
981
            pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
982
                                      TARGET_PTR_BIT / 8) & ~0x3;
983
        }
984
      else if (rp_offset == 0)
985
        {
986
          old_pc = pc;
987
          pc = read_register (RP_REGNUM) & ~0x3;
988
        }
989
      else
990
        {
991
          old_pc = pc;
992
          pc = read_memory_integer (frame->frame + rp_offset,
993
                                    TARGET_PTR_BIT / 8) & ~0x3;
994
        }
995
    }
996
 
997
  /* If PC is inside a linker stub, then dig out the address the stub
998
     will return to.
999
 
1000
     Don't do this for long branch stubs.  Why?  For some unknown reason
1001
     _start is marked as a long branch stub in hpux10.  */
1002
  u = find_unwind_entry (pc);
1003
  if (u && u->stub_unwind.stub_type != 0
1004
      && u->stub_unwind.stub_type != LONG_BRANCH)
1005
    {
1006
      unsigned int insn;
1007
 
1008
      /* If this is a dynamic executable, and we're in a signal handler,
1009
         then the call chain will eventually point us into the stub for
1010
         _sigreturn.  Unlike most cases, we'll be pointed to the branch
1011
         to the real sigreturn rather than the code after the real branch!.
1012
 
1013
         Else, try to dig the address the stub will return to in the normal
1014
         fashion.  */
1015
      insn = read_memory_integer (pc, 4);
1016
      if ((insn & 0xfc00e000) == 0xe8000000)
1017
        return (pc + extract_17 (insn) + 8) & ~0x3;
1018
      else
1019
        {
1020
          if (old_pc == pc)
1021
            spun_around_loop++;
1022
 
1023
          if (spun_around_loop > 1)
1024
            {
1025
              /* We're just about to go around the loop again with
1026
                 no more hope of success.  Die. */
1027
              error ("Unable to find return pc for this frame");
1028
            }
1029
          else
1030
            goto restart;
1031
        }
1032
    }
1033
 
1034
  return pc;
1035
}
1036
 
1037
/* We need to correct the PC and the FP for the outermost frame when we are
1038
   in a system call.  */
1039
 
1040
void
1041
init_extra_frame_info (fromleaf, frame)
1042
     int fromleaf;
1043
     struct frame_info *frame;
1044
{
1045
  int flags;
1046
  int framesize;
1047
 
1048
  if (frame->next && !fromleaf)
1049
    return;
1050
 
1051
  /* If the next frame represents a frameless function invocation
1052
     then we have to do some adjustments that are normally done by
1053
     FRAME_CHAIN.  (FRAME_CHAIN is not called in this case.)  */
1054
  if (fromleaf)
1055
    {
1056
      /* Find the framesize of *this* frame without peeking at the PC
1057
         in the current frame structure (it isn't set yet).  */
1058
      framesize = find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame)));
1059
 
1060
      /* Now adjust our base frame accordingly.  If we have a frame pointer
1061
         use it, else subtract the size of this frame from the current
1062
         frame.  (we always want frame->frame to point at the lowest address
1063
         in the frame).  */
1064
      if (framesize == -1)
1065
        frame->frame = TARGET_READ_FP ();
1066
      else
1067
        frame->frame -= framesize;
1068
      return;
1069
    }
1070
 
1071
  flags = read_register (FLAGS_REGNUM);
1072
  if (flags & 2)                /* In system call? */
1073
    frame->pc = read_register (31) & ~0x3;
1074
 
1075
  /* The outermost frame is always derived from PC-framesize
1076
 
1077
     One might think frameless innermost frames should have
1078
     a frame->frame that is the same as the parent's frame->frame.
1079
     That is wrong; frame->frame in that case should be the *high*
1080
     address of the parent's frame.  It's complicated as hell to
1081
     explain, but the parent *always* creates some stack space for
1082
     the child.  So the child actually does have a frame of some
1083
     sorts, and its base is the high address in its parent's frame.  */
1084
  framesize = find_proc_framesize (frame->pc);
1085
  if (framesize == -1)
1086
    frame->frame = TARGET_READ_FP ();
1087
  else
1088
    frame->frame = read_register (SP_REGNUM) - framesize;
1089
}
1090
 
1091
/* Given a GDB frame, determine the address of the calling function's frame.
1092
   This will be used to create a new GDB frame struct, and then
1093
   INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
1094
 
1095
   This may involve searching through prologues for several functions
1096
   at boundaries where GCC calls HP C code, or where code which has
1097
   a frame pointer calls code without a frame pointer.  */
1098
 
1099
CORE_ADDR
1100
frame_chain (frame)
1101
     struct frame_info *frame;
1102
{
1103
  int my_framesize, caller_framesize;
1104
  struct unwind_table_entry *u;
1105
  CORE_ADDR frame_base;
1106
  struct frame_info *tmp_frame;
1107
 
1108
  /* A frame in the current frame list, or zero.  */
1109
  struct frame_info *saved_regs_frame = 0;
1110
  /* Where the registers were saved in saved_regs_frame.
1111
     If saved_regs_frame is zero, this is garbage.  */
1112
  struct frame_saved_regs saved_regs;
1113
 
1114
  CORE_ADDR caller_pc;
1115
 
1116
  struct minimal_symbol *min_frame_symbol;
1117
  struct symbol *frame_symbol;
1118
  char *frame_symbol_name;
1119
 
1120
  /* If this is a threaded application, and we see the
1121
     routine "__pthread_exit", treat it as the stack root
1122
     for this thread. */
1123
  min_frame_symbol = lookup_minimal_symbol_by_pc (frame->pc);
1124
  frame_symbol = find_pc_function (frame->pc);
1125
 
1126
  if ((min_frame_symbol != 0) /* && (frame_symbol == 0) */ )
1127
    {
1128
      /* The test above for "no user function name" would defend
1129
         against the slim likelihood that a user might define a
1130
         routine named "__pthread_exit" and then try to debug it.
1131
 
1132
         If it weren't commented out, and you tried to debug the
1133
         pthread library itself, you'd get errors.
1134
 
1135
         So for today, we don't make that check. */
1136
      frame_symbol_name = SYMBOL_NAME (min_frame_symbol);
1137
      if (frame_symbol_name != 0)
1138
        {
1139
          if (0 == strncmp (frame_symbol_name,
1140
                            THREAD_INITIAL_FRAME_SYMBOL,
1141
                            THREAD_INITIAL_FRAME_SYM_LEN))
1142
            {
1143
              /* Pretend we've reached the bottom of the stack. */
1144
              return (CORE_ADDR) 0;
1145
            }
1146
        }
1147
    }                           /* End of hacky code for threads. */
1148
 
1149
  /* Handle HPUX, BSD, and OSF1 style interrupt frames first.  These
1150
     are easy; at *sp we have a full save state strucutre which we can
1151
     pull the old stack pointer from.  Also see frame_saved_pc for
1152
     code to dig a saved PC out of the save state structure.  */
1153
  if (pc_in_interrupt_handler (frame->pc))
1154
    frame_base = read_memory_integer (frame->frame + SP_REGNUM * 4,
1155
                                      TARGET_PTR_BIT / 8);
1156
#ifdef FRAME_BASE_BEFORE_SIGTRAMP
1157
  else if (frame->signal_handler_caller)
1158
    {
1159
      FRAME_BASE_BEFORE_SIGTRAMP (frame, &frame_base);
1160
    }
1161
#endif
1162
  else
1163
    frame_base = frame->frame;
1164
 
1165
  /* Get frame sizes for the current frame and the frame of the
1166
     caller.  */
1167
  my_framesize = find_proc_framesize (frame->pc);
1168
  caller_pc = FRAME_SAVED_PC (frame);
1169
 
1170
  /* If we can't determine the caller's PC, then it's not likely we can
1171
     really determine anything meaningful about its frame.  We'll consider
1172
     this to be stack bottom. */
1173
  if (caller_pc == (CORE_ADDR) 0)
1174
    return (CORE_ADDR) 0;
1175
 
1176
  caller_framesize = find_proc_framesize (FRAME_SAVED_PC (frame));
1177
 
1178
  /* If caller does not have a frame pointer, then its frame
1179
     can be found at current_frame - caller_framesize.  */
1180
  if (caller_framesize != -1)
1181
    {
1182
      return frame_base - caller_framesize;
1183
    }
1184
  /* Both caller and callee have frame pointers and are GCC compiled
1185
     (SAVE_SP bit in unwind descriptor is on for both functions.
1186
     The previous frame pointer is found at the top of the current frame.  */
1187
  if (caller_framesize == -1 && my_framesize == -1)
1188
    {
1189
      return read_memory_integer (frame_base, TARGET_PTR_BIT / 8);
1190
    }
1191
  /* Caller has a frame pointer, but callee does not.  This is a little
1192
     more difficult as GCC and HP C lay out locals and callee register save
1193
     areas very differently.
1194
 
1195
     The previous frame pointer could be in a register, or in one of
1196
     several areas on the stack.
1197
 
1198
     Walk from the current frame to the innermost frame examining
1199
     unwind descriptors to determine if %r3 ever gets saved into the
1200
     stack.  If so return whatever value got saved into the stack.
1201
     If it was never saved in the stack, then the value in %r3 is still
1202
     valid, so use it.
1203
 
1204
     We use information from unwind descriptors to determine if %r3
1205
     is saved into the stack (Entry_GR field has this information).  */
1206
 
1207
  for (tmp_frame = frame; tmp_frame; tmp_frame = tmp_frame->next)
1208
    {
1209
      u = find_unwind_entry (tmp_frame->pc);
1210
 
1211
      if (!u)
1212
        {
1213
          /* We could find this information by examining prologues.  I don't
1214
             think anyone has actually written any tools (not even "strip")
1215
             which leave them out of an executable, so maybe this is a moot
1216
             point.  */
1217
          /* ??rehrauer: Actually, it's quite possible to stepi your way into
1218
             code that doesn't have unwind entries.  For example, stepping into
1219
             the dynamic linker will give you a PC that has none.  Thus, I've
1220
             disabled this warning. */
1221
#if 0
1222
          warning ("Unable to find unwind for PC 0x%x -- Help!", tmp_frame->pc);
1223
#endif
1224
          return (CORE_ADDR) 0;
1225
        }
1226
 
1227
      if (u->Save_SP
1228
          || tmp_frame->signal_handler_caller
1229
          || pc_in_interrupt_handler (tmp_frame->pc))
1230
        break;
1231
 
1232
      /* Entry_GR specifies the number of callee-saved general registers
1233
         saved in the stack.  It starts at %r3, so %r3 would be 1.  */
1234
      if (u->Entry_GR >= 1)
1235
        {
1236
          /* The unwind entry claims that r3 is saved here.  However,
1237
             in optimized code, GCC often doesn't actually save r3.
1238
             We'll discover this if we look at the prologue.  */
1239
          get_frame_saved_regs (tmp_frame, &saved_regs);
1240
          saved_regs_frame = tmp_frame;
1241
 
1242
          /* If we have an address for r3, that's good.  */
1243
          if (saved_regs.regs[FP_REGNUM])
1244
            break;
1245
        }
1246
    }
1247
 
1248
  if (tmp_frame)
1249
    {
1250
      /* We may have walked down the chain into a function with a frame
1251
         pointer.  */
1252
      if (u->Save_SP
1253
          && !tmp_frame->signal_handler_caller
1254
          && !pc_in_interrupt_handler (tmp_frame->pc))
1255
        {
1256
          return read_memory_integer (tmp_frame->frame, TARGET_PTR_BIT / 8);
1257
        }
1258
      /* %r3 was saved somewhere in the stack.  Dig it out.  */
1259
      else
1260
        {
1261
          /* Sick.
1262
 
1263
             For optimization purposes many kernels don't have the
1264
             callee saved registers into the save_state structure upon
1265
             entry into the kernel for a syscall; the optimization
1266
             is usually turned off if the process is being traced so
1267
             that the debugger can get full register state for the
1268
             process.
1269
 
1270
             This scheme works well except for two cases:
1271
 
1272
             * Attaching to a process when the process is in the
1273
             kernel performing a system call (debugger can't get
1274
             full register state for the inferior process since
1275
             the process wasn't being traced when it entered the
1276
             system call).
1277
 
1278
             * Register state is not complete if the system call
1279
             causes the process to core dump.
1280
 
1281
 
1282
             The following heinous code is an attempt to deal with
1283
             the lack of register state in a core dump.  It will
1284
             fail miserably if the function which performs the
1285
             system call has a variable sized stack frame.  */
1286
 
1287
          if (tmp_frame != saved_regs_frame)
1288
            get_frame_saved_regs (tmp_frame, &saved_regs);
1289
 
1290
          /* Abominable hack.  */
1291
          if (current_target.to_has_execution == 0
1292
              && ((saved_regs.regs[FLAGS_REGNUM]
1293
                   && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
1294
                                            TARGET_PTR_BIT / 8)
1295
                       & 0x2))
1296
                  || (saved_regs.regs[FLAGS_REGNUM] == 0
1297
                      && read_register (FLAGS_REGNUM) & 0x2)))
1298
            {
1299
              u = find_unwind_entry (FRAME_SAVED_PC (frame));
1300
              if (!u)
1301
                {
1302
                  return read_memory_integer (saved_regs.regs[FP_REGNUM],
1303
                                              TARGET_PTR_BIT / 8);
1304
                }
1305
              else
1306
                {
1307
                  return frame_base - (u->Total_frame_size << 3);
1308
                }
1309
            }
1310
 
1311
          return read_memory_integer (saved_regs.regs[FP_REGNUM],
1312
                                      TARGET_PTR_BIT / 8);
1313
        }
1314
    }
1315
  else
1316
    {
1317
      /* Get the innermost frame.  */
1318
      tmp_frame = frame;
1319
      while (tmp_frame->next != NULL)
1320
        tmp_frame = tmp_frame->next;
1321
 
1322
      if (tmp_frame != saved_regs_frame)
1323
        get_frame_saved_regs (tmp_frame, &saved_regs);
1324
 
1325
      /* Abominable hack.  See above.  */
1326
      if (current_target.to_has_execution == 0
1327
          && ((saved_regs.regs[FLAGS_REGNUM]
1328
               && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
1329
                                        TARGET_PTR_BIT / 8)
1330
                   & 0x2))
1331
              || (saved_regs.regs[FLAGS_REGNUM] == 0
1332
                  && read_register (FLAGS_REGNUM) & 0x2)))
1333
        {
1334
          u = find_unwind_entry (FRAME_SAVED_PC (frame));
1335
          if (!u)
1336
            {
1337
              return read_memory_integer (saved_regs.regs[FP_REGNUM],
1338
                                          TARGET_PTR_BIT / 8);
1339
            }
1340
          else
1341
            {
1342
              return frame_base - (u->Total_frame_size << 3);
1343
            }
1344
        }
1345
 
1346
      /* The value in %r3 was never saved into the stack (thus %r3 still
1347
         holds the value of the previous frame pointer).  */
1348
      return TARGET_READ_FP ();
1349
    }
1350
}
1351
 
1352
 
1353
/* To see if a frame chain is valid, see if the caller looks like it
1354
   was compiled with gcc. */
1355
 
1356
int
1357
hppa_frame_chain_valid (chain, thisframe)
1358
     CORE_ADDR chain;
1359
     struct frame_info *thisframe;
1360
{
1361
  struct minimal_symbol *msym_us;
1362
  struct minimal_symbol *msym_start;
1363
  struct unwind_table_entry *u, *next_u = NULL;
1364
  struct frame_info *next;
1365
 
1366
  if (!chain)
1367
    return 0;
1368
 
1369
  u = find_unwind_entry (thisframe->pc);
1370
 
1371
  if (u == NULL)
1372
    return 1;
1373
 
1374
  /* We can't just check that the same of msym_us is "_start", because
1375
     someone idiotically decided that they were going to make a Ltext_end
1376
     symbol with the same address.  This Ltext_end symbol is totally
1377
     indistinguishable (as nearly as I can tell) from the symbol for a function
1378
     which is (legitimately, since it is in the user's namespace)
1379
     named Ltext_end, so we can't just ignore it.  */
1380
  msym_us = lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe));
1381
  msym_start = lookup_minimal_symbol ("_start", NULL, NULL);
1382
  if (msym_us
1383
      && msym_start
1384
      && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
1385
    return 0;
1386
 
1387
  /* Grrrr.  Some new idiot decided that they don't want _start for the
1388
     PRO configurations; $START$ calls main directly....  Deal with it.  */
1389
  msym_start = lookup_minimal_symbol ("$START$", NULL, NULL);
1390
  if (msym_us
1391
      && msym_start
1392
      && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
1393
    return 0;
1394
 
1395
  next = get_next_frame (thisframe);
1396
  if (next)
1397
    next_u = find_unwind_entry (next->pc);
1398
 
1399
  /* If this frame does not save SP, has no stack, isn't a stub,
1400
     and doesn't "call" an interrupt routine or signal handler caller,
1401
     then its not valid.  */
1402
  if (u->Save_SP || u->Total_frame_size || u->stub_unwind.stub_type != 0
1403
      || (thisframe->next && thisframe->next->signal_handler_caller)
1404
      || (next_u && next_u->HP_UX_interrupt_marker))
1405
    return 1;
1406
 
1407
  if (pc_in_linker_stub (thisframe->pc))
1408
    return 1;
1409
 
1410
  return 0;
1411
}
1412
 
1413
/*
1414
   These functions deal with saving and restoring register state
1415
   around a function call in the inferior. They keep the stack
1416
   double-word aligned; eventually, on an hp700, the stack will have
1417
   to be aligned to a 64-byte boundary. */
1418
 
1419
void
1420
push_dummy_frame (inf_status)
1421
     struct inferior_status *inf_status;
1422
{
1423
  CORE_ADDR sp, pc, pcspace;
1424
  register int regnum;
1425
  CORE_ADDR int_buffer;
1426
  double freg_buffer;
1427
 
1428
  /* Oh, what a hack.  If we're trying to perform an inferior call
1429
     while the inferior is asleep, we have to make sure to clear
1430
     the "in system call" bit in the flag register (the call will
1431
     start after the syscall returns, so we're no longer in the system
1432
     call!)  This state is kept in "inf_status", change it there.
1433
 
1434
     We also need a number of horrid hacks to deal with lossage in the
1435
     PC queue registers (apparently they're not valid when the in syscall
1436
     bit is set).  */
1437
  pc = target_read_pc (inferior_pid);
1438
  int_buffer = read_register (FLAGS_REGNUM);
1439
  if (int_buffer & 0x2)
1440
    {
1441
      unsigned int sid;
1442
      int_buffer &= ~0x2;
1443
      write_inferior_status_register (inf_status, 0, int_buffer);
1444
      write_inferior_status_register (inf_status, PCOQ_HEAD_REGNUM, pc + 0);
1445
      write_inferior_status_register (inf_status, PCOQ_TAIL_REGNUM, pc + 4);
1446
      sid = (pc >> 30) & 0x3;
1447
      if (sid == 0)
1448
        pcspace = read_register (SR4_REGNUM);
1449
      else
1450
        pcspace = read_register (SR4_REGNUM + 4 + sid);
1451
      write_inferior_status_register (inf_status, PCSQ_HEAD_REGNUM, pcspace);
1452
      write_inferior_status_register (inf_status, PCSQ_TAIL_REGNUM, pcspace);
1453
    }
1454
  else
1455
    pcspace = read_register (PCSQ_HEAD_REGNUM);
1456
 
1457
  /* Space for "arguments"; the RP goes in here. */
1458
  sp = read_register (SP_REGNUM) + 48;
1459
  int_buffer = read_register (RP_REGNUM) | 0x3;
1460
 
1461
  /* The 32bit and 64bit ABIs save the return pointer into different
1462
     stack slots.  */
1463
  if (REGISTER_SIZE == 8)
1464
    write_memory (sp - 16, (char *) &int_buffer, REGISTER_SIZE);
1465
  else
1466
    write_memory (sp - 20, (char *) &int_buffer, REGISTER_SIZE);
1467
 
1468
  int_buffer = TARGET_READ_FP ();
1469
  write_memory (sp, (char *) &int_buffer, REGISTER_SIZE);
1470
 
1471
  write_register (FP_REGNUM, sp);
1472
 
1473
  sp += 2 * REGISTER_SIZE;
1474
 
1475
  for (regnum = 1; regnum < 32; regnum++)
1476
    if (regnum != RP_REGNUM && regnum != FP_REGNUM)
1477
      sp = push_word (sp, read_register (regnum));
1478
 
1479
  /* This is not necessary for the 64bit ABI.  In fact it is dangerous.  */
1480
  if (REGISTER_SIZE != 8)
1481
    sp += 4;
1482
 
1483
  for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
1484
    {
1485
      read_register_bytes (REGISTER_BYTE (regnum), (char *) &freg_buffer, 8);
1486
      sp = push_bytes (sp, (char *) &freg_buffer, 8);
1487
    }
1488
  sp = push_word (sp, read_register (IPSW_REGNUM));
1489
  sp = push_word (sp, read_register (SAR_REGNUM));
1490
  sp = push_word (sp, pc);
1491
  sp = push_word (sp, pcspace);
1492
  sp = push_word (sp, pc + 4);
1493
  sp = push_word (sp, pcspace);
1494
  write_register (SP_REGNUM, sp);
1495
}
1496
 
1497
static void
1498
find_dummy_frame_regs (frame, frame_saved_regs)
1499
     struct frame_info *frame;
1500
     struct frame_saved_regs *frame_saved_regs;
1501
{
1502
  CORE_ADDR fp = frame->frame;
1503
  int i;
1504
 
1505
  /* The 32bit and 64bit ABIs save RP into different locations.  */
1506
  if (REGISTER_SIZE == 8)
1507
    frame_saved_regs->regs[RP_REGNUM] = (fp - 16) & ~0x3;
1508
  else
1509
    frame_saved_regs->regs[RP_REGNUM] = (fp - 20) & ~0x3;
1510
 
1511
  frame_saved_regs->regs[FP_REGNUM] = fp;
1512
 
1513
  frame_saved_regs->regs[1] = fp + (2 * REGISTER_SIZE);
1514
 
1515
  for (fp += 3 * REGISTER_SIZE, i = 3; i < 32; i++)
1516
    {
1517
      if (i != FP_REGNUM)
1518
        {
1519
          frame_saved_regs->regs[i] = fp;
1520
          fp += REGISTER_SIZE;
1521
        }
1522
    }
1523
 
1524
  /* This is not necessary or desirable for the 64bit ABI.  */
1525
  if (REGISTER_SIZE != 8)
1526
    fp += 4;
1527
 
1528
  for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
1529
    frame_saved_regs->regs[i] = fp;
1530
 
1531
  frame_saved_regs->regs[IPSW_REGNUM] = fp;
1532
  frame_saved_regs->regs[SAR_REGNUM] = fp + REGISTER_SIZE;
1533
  frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 2 * REGISTER_SIZE;
1534
  frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 3 * REGISTER_SIZE;
1535
  frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 4 * REGISTER_SIZE;
1536
  frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 5 * REGISTER_SIZE;
1537
}
1538
 
1539
void
1540
hppa_pop_frame ()
1541
{
1542
  register struct frame_info *frame = get_current_frame ();
1543
  register CORE_ADDR fp, npc, target_pc;
1544
  register int regnum;
1545
  struct frame_saved_regs fsr;
1546
  double freg_buffer;
1547
 
1548
  fp = FRAME_FP (frame);
1549
  get_frame_saved_regs (frame, &fsr);
1550
 
1551
#ifndef NO_PC_SPACE_QUEUE_RESTORE
1552
  if (fsr.regs[IPSW_REGNUM])    /* Restoring a call dummy frame */
1553
    restore_pc_queue (&fsr);
1554
#endif
1555
 
1556
  for (regnum = 31; regnum > 0; regnum--)
1557
    if (fsr.regs[regnum])
1558
      write_register (regnum, read_memory_integer (fsr.regs[regnum],
1559
                      REGISTER_SIZE));
1560
 
1561
  for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM; regnum--)
1562
    if (fsr.regs[regnum])
1563
      {
1564
        read_memory (fsr.regs[regnum], (char *) &freg_buffer, 8);
1565
        write_register_bytes (REGISTER_BYTE (regnum), (char *) &freg_buffer, 8);
1566
      }
1567
 
1568
  if (fsr.regs[IPSW_REGNUM])
1569
    write_register (IPSW_REGNUM,
1570
                    read_memory_integer (fsr.regs[IPSW_REGNUM],
1571
                                         REGISTER_SIZE));
1572
 
1573
  if (fsr.regs[SAR_REGNUM])
1574
    write_register (SAR_REGNUM,
1575
                    read_memory_integer (fsr.regs[SAR_REGNUM],
1576
                                         REGISTER_SIZE));
1577
 
1578
  /* If the PC was explicitly saved, then just restore it.  */
1579
  if (fsr.regs[PCOQ_TAIL_REGNUM])
1580
    {
1581
      npc = read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM],
1582
                                 REGISTER_SIZE);
1583
      write_register (PCOQ_TAIL_REGNUM, npc);
1584
    }
1585
  /* Else use the value in %rp to set the new PC.  */
1586
  else
1587
    {
1588
      npc = read_register (RP_REGNUM);
1589
      write_pc (npc);
1590
    }
1591
 
1592
  write_register (FP_REGNUM, read_memory_integer (fp, REGISTER_SIZE));
1593
 
1594
  if (fsr.regs[IPSW_REGNUM])    /* call dummy */
1595
    write_register (SP_REGNUM, fp - 48);
1596
  else
1597
    write_register (SP_REGNUM, fp);
1598
 
1599
  /* The PC we just restored may be inside a return trampoline.  If so
1600
     we want to restart the inferior and run it through the trampoline.
1601
 
1602
     Do this by setting a momentary breakpoint at the location the
1603
     trampoline returns to.
1604
 
1605
     Don't skip through the trampoline if we're popping a dummy frame.  */
1606
  target_pc = SKIP_TRAMPOLINE_CODE (npc & ~0x3) & ~0x3;
1607
  if (target_pc && !fsr.regs[IPSW_REGNUM])
1608
    {
1609
      struct symtab_and_line sal;
1610
      struct breakpoint *breakpoint;
1611
      struct cleanup *old_chain;
1612
 
1613
      /* Set up our breakpoint.   Set it to be silent as the MI code
1614
         for "return_command" will print the frame we returned to.  */
1615
      sal = find_pc_line (target_pc, 0);
1616
      sal.pc = target_pc;
1617
      breakpoint = set_momentary_breakpoint (sal, NULL, bp_finish);
1618
      breakpoint->silent = 1;
1619
 
1620
      /* So we can clean things up.  */
1621
      old_chain = make_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
1622
 
1623
      /* Start up the inferior.  */
1624
      clear_proceed_status ();
1625
      proceed_to_finish = 1;
1626
      proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
1627
 
1628
      /* Perform our cleanups.  */
1629
      do_cleanups (old_chain);
1630
    }
1631
  flush_cached_frames ();
1632
}
1633
 
1634
/* After returning to a dummy on the stack, restore the instruction
1635
   queue space registers. */
1636
 
1637
static int
1638
restore_pc_queue (fsr)
1639
     struct frame_saved_regs *fsr;
1640
{
1641
  CORE_ADDR pc = read_pc ();
1642
  CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM],
1643
                                          TARGET_PTR_BIT / 8);
1644
  struct target_waitstatus w;
1645
  int insn_count;
1646
 
1647
  /* Advance past break instruction in the call dummy. */
1648
  write_register (PCOQ_HEAD_REGNUM, pc + 4);
1649
  write_register (PCOQ_TAIL_REGNUM, pc + 8);
1650
 
1651
  /* HPUX doesn't let us set the space registers or the space
1652
     registers of the PC queue through ptrace. Boo, hiss.
1653
     Conveniently, the call dummy has this sequence of instructions
1654
     after the break:
1655
     mtsp r21, sr0
1656
     ble,n 0(sr0, r22)
1657
 
1658
     So, load up the registers and single step until we are in the
1659
     right place. */
1660
 
1661
  write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM],
1662
                                           REGISTER_SIZE));
1663
  write_register (22, new_pc);
1664
 
1665
  for (insn_count = 0; insn_count < 3; insn_count++)
1666
    {
1667
      /* FIXME: What if the inferior gets a signal right now?  Want to
1668
         merge this into wait_for_inferior (as a special kind of
1669
         watchpoint?  By setting a breakpoint at the end?  Is there
1670
         any other choice?  Is there *any* way to do this stuff with
1671
         ptrace() or some equivalent?).  */
1672
      resume (1, 0);
1673
      target_wait (inferior_pid, &w);
1674
 
1675
      if (w.kind == TARGET_WAITKIND_SIGNALLED)
1676
        {
1677
          stop_signal = w.value.sig;
1678
          terminal_ours_for_output ();
1679
          printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1680
                             target_signal_to_name (stop_signal),
1681
                             target_signal_to_string (stop_signal));
1682
          gdb_flush (gdb_stdout);
1683
          return 0;
1684
        }
1685
    }
1686
  target_terminal_ours ();
1687
  target_fetch_registers (-1);
1688
  return 1;
1689
}
1690
 
1691
 
1692
#ifdef PA20W_CALLING_CONVENTIONS
1693
 
1694
/* This function pushes a stack frame with arguments as part of the
1695
   inferior function calling mechanism.
1696
 
1697
   This is the version for the PA64, in which later arguments appear
1698
   at higher addresses.  (The stack always grows towards higher
1699
   addresses.)
1700
 
1701
   We simply allocate the appropriate amount of stack space and put
1702
   arguments into their proper slots.  The call dummy code will copy
1703
   arguments into registers as needed by the ABI.
1704
 
1705
   This ABI also requires that the caller provide an argument pointer
1706
   to the callee, so we do that too.  */
1707
 
1708
CORE_ADDR
1709
hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
1710
     int nargs;
1711
     value_ptr *args;
1712
     CORE_ADDR sp;
1713
     int struct_return;
1714
     CORE_ADDR struct_addr;
1715
{
1716
  /* array of arguments' offsets */
1717
  int *offset = (int *) alloca (nargs * sizeof (int));
1718
 
1719
  /* array of arguments' lengths: real lengths in bytes, not aligned to
1720
     word size */
1721
  int *lengths = (int *) alloca (nargs * sizeof (int));
1722
 
1723
  /* The value of SP as it was passed into this function after
1724
     aligning.  */
1725
  CORE_ADDR orig_sp = STACK_ALIGN (sp);
1726
 
1727
  /* The number of stack bytes occupied by the current argument.  */
1728
  int bytes_reserved;
1729
 
1730
  /* The total number of bytes reserved for the arguments.  */
1731
  int cum_bytes_reserved = 0;
1732
 
1733
  /* Similarly, but aligned.  */
1734
  int cum_bytes_aligned = 0;
1735
  int i;
1736
 
1737
  /* Iterate over each argument provided by the user.  */
1738
  for (i = 0; i < nargs; i++)
1739
    {
1740
      struct type *arg_type = VALUE_TYPE (args[i]);
1741
 
1742
      /* Integral scalar values smaller than a register are padded on
1743
         the left.  We do this by promoting them to full-width,
1744
         although the ABI says to pad them with garbage.  */
1745
      if (is_integral_type (arg_type)
1746
          && TYPE_LENGTH (arg_type) < REGISTER_SIZE)
1747
        {
1748
          args[i] = value_cast ((TYPE_UNSIGNED (arg_type)
1749
                                 ? builtin_type_unsigned_long
1750
                                 : builtin_type_long),
1751
                                args[i]);
1752
          arg_type = VALUE_TYPE (args[i]);
1753
        }
1754
 
1755
      lengths[i] = TYPE_LENGTH (arg_type);
1756
 
1757
      /* Align the size of the argument to the word size for this
1758
         target.  */
1759
      bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
1760
 
1761
      offset[i] = cum_bytes_reserved;
1762
 
1763
      /* Aggregates larger than eight bytes (the only types larger
1764
         than eight bytes we have) are aligned on a 16-byte boundary,
1765
         possibly padded on the right with garbage.  This may leave an
1766
         empty word on the stack, and thus an unused register, as per
1767
         the ABI.  */
1768
      if (bytes_reserved > 8)
1769
        {
1770
          /* Round up the offset to a multiple of two slots.  */
1771
          int new_offset = ((offset[i] + 2*REGISTER_SIZE-1)
1772
                            & -(2*REGISTER_SIZE));
1773
 
1774
          /* Note the space we've wasted, if any.  */
1775
          bytes_reserved += new_offset - offset[i];
1776
          offset[i] = new_offset;
1777
        }
1778
 
1779
      cum_bytes_reserved += bytes_reserved;
1780
    }
1781
 
1782
  /* CUM_BYTES_RESERVED already accounts for all the arguments
1783
     passed by the user.  However, the ABIs mandate minimum stack space
1784
     allocations for outgoing arguments.
1785
 
1786
     The ABIs also mandate minimum stack alignments which we must
1787
     preserve.  */
1788
  cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved);
1789
  sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
1790
 
1791
  /* Now write each of the args at the proper offset down the stack.  */
1792
  for (i = 0; i < nargs; i++)
1793
    write_memory (orig_sp + offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
1794
 
1795
  /* If a structure has to be returned, set up register 28 to hold its
1796
     address */
1797
  if (struct_return)
1798
    write_register (28, struct_addr);
1799
 
1800
  /* For the PA64 we must pass a pointer to the outgoing argument list.
1801
     The ABI mandates that the pointer should point to the first byte of
1802
     storage beyond the register flushback area.
1803
 
1804
     However, the call dummy expects the outgoing argument pointer to
1805
     be passed in register %r4.  */
1806
  write_register (4, orig_sp + REG_PARM_STACK_SPACE);
1807
 
1808
  /* ?!? This needs further work.  We need to set up the global data
1809
     pointer for this procedure.  This assumes the same global pointer
1810
     for every procedure.   The call dummy expects the dp value to
1811
     be passed in register %r6.  */
1812
  write_register (6, read_register (27));
1813
 
1814
  /* The stack will have 64 bytes of additional space for a frame marker.  */
1815
  return sp + 64;
1816
}
1817
 
1818
#else
1819
 
1820
/* This function pushes a stack frame with arguments as part of the
1821
   inferior function calling mechanism.
1822
 
1823
   This is the version of the function for the 32-bit PA machines, in
1824
   which later arguments appear at lower addresses.  (The stack always
1825
   grows towards higher addresses.)
1826
 
1827
   We simply allocate the appropriate amount of stack space and put
1828
   arguments into their proper slots.  The call dummy code will copy
1829
   arguments into registers as needed by the ABI. */
1830
 
1831
CORE_ADDR
1832
hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
1833
     int nargs;
1834
     value_ptr *args;
1835
     CORE_ADDR sp;
1836
     int struct_return;
1837
     CORE_ADDR struct_addr;
1838
{
1839
  /* array of arguments' offsets */
1840
  int *offset = (int *) alloca (nargs * sizeof (int));
1841
 
1842
  /* array of arguments' lengths: real lengths in bytes, not aligned to
1843
     word size */
1844
  int *lengths = (int *) alloca (nargs * sizeof (int));
1845
 
1846
  /* The number of stack bytes occupied by the current argument.  */
1847
  int bytes_reserved;
1848
 
1849
  /* The total number of bytes reserved for the arguments.  */
1850
  int cum_bytes_reserved = 0;
1851
 
1852
  /* Similarly, but aligned.  */
1853
  int cum_bytes_aligned = 0;
1854
  int i;
1855
 
1856
  /* Iterate over each argument provided by the user.  */
1857
  for (i = 0; i < nargs; i++)
1858
    {
1859
      lengths[i] = TYPE_LENGTH (VALUE_TYPE (args[i]));
1860
 
1861
      /* Align the size of the argument to the word size for this
1862
         target.  */
1863
      bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
1864
 
1865
      offset[i] = cum_bytes_reserved + lengths[i];
1866
 
1867
      /* If the argument is a double word argument, then it needs to be
1868
         double word aligned.  */
1869
      if ((bytes_reserved == 2 * REGISTER_SIZE)
1870
          && (offset[i] % 2 * REGISTER_SIZE))
1871
        {
1872
          int new_offset = 0;
1873
          /* BYTES_RESERVED is already aligned to the word, so we put
1874
             the argument at one word more down the stack.
1875
 
1876
             This will leave one empty word on the stack, and one unused
1877
             register as mandated by the ABI.  */
1878
          new_offset = ((offset[i] + 2 * REGISTER_SIZE - 1)
1879
                        & -(2 * REGISTER_SIZE));
1880
 
1881
          if ((new_offset - offset[i]) >= 2 * REGISTER_SIZE)
1882
            {
1883
              bytes_reserved += REGISTER_SIZE;
1884
              offset[i] += REGISTER_SIZE;
1885
            }
1886
        }
1887
 
1888
      cum_bytes_reserved += bytes_reserved;
1889
 
1890
    }
1891
 
1892
  /* CUM_BYTES_RESERVED already accounts for all the arguments passed
1893
     by the user.  However, the ABI mandates minimum stack space
1894
     allocations for outgoing arguments.
1895
 
1896
     The ABI also mandates minimum stack alignments which we must
1897
     preserve.  */
1898
  cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved);
1899
  sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
1900
 
1901
  /* Now write each of the args at the proper offset down the stack.
1902
     ?!? We need to promote values to a full register instead of skipping
1903
     words in the stack.  */
1904
  for (i = 0; i < nargs; i++)
1905
    write_memory (sp - offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
1906
 
1907
  /* If a structure has to be returned, set up register 28 to hold its
1908
     address */
1909
  if (struct_return)
1910
    write_register (28, struct_addr);
1911
 
1912
  /* The stack will have 32 bytes of additional space for a frame marker.  */
1913
  return sp + 32;
1914
}
1915
 
1916
#endif
1917
 
1918
/* elz: this function returns a value which is built looking at the given address.
1919
   It is called from call_function_by_hand, in case we need to return a
1920
   value which is larger than 64 bits, and it is stored in the stack rather than
1921
   in the registers r28 and r29 or fr4.
1922
   This function does the same stuff as value_being_returned in values.c, but
1923
   gets the value from the stack rather than from the buffer where all the
1924
   registers were saved when the function called completed. */
1925
value_ptr
1926
hppa_value_returned_from_stack (valtype, addr)
1927
     register struct type *valtype;
1928
     CORE_ADDR addr;
1929
{
1930
  register value_ptr val;
1931
 
1932
  val = allocate_value (valtype);
1933
  CHECK_TYPEDEF (valtype);
1934
  target_read_memory (addr, VALUE_CONTENTS_RAW (val), TYPE_LENGTH (valtype));
1935
 
1936
  return val;
1937
}
1938
 
1939
 
1940
 
1941
/* elz: Used to lookup a symbol in the shared libraries.
1942
   This function calls shl_findsym, indirectly through a
1943
   call to __d_shl_get. __d_shl_get is in end.c, which is always
1944
   linked in by the hp compilers/linkers.
1945
   The call to shl_findsym cannot be made directly because it needs
1946
   to be active in target address space.
1947
   inputs: - minimal symbol pointer for the function we want to look up
1948
   - address in target space of the descriptor for the library
1949
   where we want to look the symbol up.
1950
   This address is retrieved using the
1951
   som_solib_get_solib_by_pc function (somsolib.c).
1952
   output: - real address in the library of the function.
1953
   note: the handle can be null, in which case shl_findsym will look for
1954
   the symbol in all the loaded shared libraries.
1955
   files to look at if you need reference on this stuff:
1956
   dld.c, dld_shl_findsym.c
1957
   end.c
1958
   man entry for shl_findsym */
1959
 
1960
CORE_ADDR
1961
find_stub_with_shl_get (function, handle)
1962
     struct minimal_symbol *function;
1963
     CORE_ADDR handle;
1964
{
1965
  struct symbol *get_sym, *symbol2;
1966
  struct minimal_symbol *buff_minsym, *msymbol;
1967
  struct type *ftype;
1968
  value_ptr *args;
1969
  value_ptr funcval, val;
1970
 
1971
  int x, namelen, err_value, tmp = -1;
1972
  CORE_ADDR endo_buff_addr, value_return_addr, errno_return_addr;
1973
  CORE_ADDR stub_addr;
1974
 
1975
 
1976
  args = (value_ptr *) alloca (sizeof (value_ptr) * 8);         /* 6 for the arguments and one null one??? */
1977
  funcval = find_function_in_inferior ("__d_shl_get");
1978
  get_sym = lookup_symbol ("__d_shl_get", NULL, VAR_NAMESPACE, NULL, NULL);
1979
  buff_minsym = lookup_minimal_symbol ("__buffer", NULL, NULL);
1980
  msymbol = lookup_minimal_symbol ("__shldp", NULL, NULL);
1981
  symbol2 = lookup_symbol ("__shldp", NULL, VAR_NAMESPACE, NULL, NULL);
1982
  endo_buff_addr = SYMBOL_VALUE_ADDRESS (buff_minsym);
1983
  namelen = strlen (SYMBOL_NAME (function));
1984
  value_return_addr = endo_buff_addr + namelen;
1985
  ftype = check_typedef (SYMBOL_TYPE (get_sym));
1986
 
1987
  /* do alignment */
1988
  if ((x = value_return_addr % 64) != 0)
1989
    value_return_addr = value_return_addr + 64 - x;
1990
 
1991
  errno_return_addr = value_return_addr + 64;
1992
 
1993
 
1994
  /* set up stuff needed by __d_shl_get in buffer in end.o */
1995
 
1996
  target_write_memory (endo_buff_addr, SYMBOL_NAME (function), namelen);
1997
 
1998
  target_write_memory (value_return_addr, (char *) &tmp, 4);
1999
 
2000
  target_write_memory (errno_return_addr, (char *) &tmp, 4);
2001
 
2002
  target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
2003
                       (char *) &handle, 4);
2004
 
2005
  /* now prepare the arguments for the call */
2006
 
2007
  args[0] = value_from_longest (TYPE_FIELD_TYPE (ftype, 0), 12);
2008
  args[1] = value_from_longest (TYPE_FIELD_TYPE (ftype, 1), SYMBOL_VALUE_ADDRESS (msymbol));
2009
  args[2] = value_from_longest (TYPE_FIELD_TYPE (ftype, 2), endo_buff_addr);
2010
  args[3] = value_from_longest (TYPE_FIELD_TYPE (ftype, 3), TYPE_PROCEDURE);
2011
  args[4] = value_from_longest (TYPE_FIELD_TYPE (ftype, 4), value_return_addr);
2012
  args[5] = value_from_longest (TYPE_FIELD_TYPE (ftype, 5), errno_return_addr);
2013
 
2014
  /* now call the function */
2015
 
2016
  val = call_function_by_hand (funcval, 6, args);
2017
 
2018
  /* now get the results */
2019
 
2020
  target_read_memory (errno_return_addr, (char *) &err_value, sizeof (err_value));
2021
 
2022
  target_read_memory (value_return_addr, (char *) &stub_addr, sizeof (stub_addr));
2023
  if (stub_addr <= 0)
2024
    error ("call to __d_shl_get failed, error code is %d", err_value);
2025
 
2026
  return (stub_addr);
2027
}
2028
 
2029
/* Cover routine for find_stub_with_shl_get to pass to catch_errors */
2030
static int
2031
cover_find_stub_with_shl_get (PTR args_untyped)
2032
{
2033
  args_for_find_stub *args = args_untyped;
2034
  args->return_val = find_stub_with_shl_get (args->msym, args->solib_handle);
2035
  return 0;
2036
}
2037
 
2038
/* Insert the specified number of args and function address
2039
   into a call sequence of the above form stored at DUMMYNAME.
2040
 
2041
   On the hppa we need to call the stack dummy through $$dyncall.
2042
   Therefore our version of FIX_CALL_DUMMY takes an extra argument,
2043
   real_pc, which is the location where gdb should start up the
2044
   inferior to do the function call.
2045
 
2046
   This has to work across several versions of hpux, bsd, osf1.  It has to
2047
   work regardless of what compiler was used to build the inferior program.
2048
   It should work regardless of whether or not end.o is available.  It has
2049
   to work even if gdb can not call into the dynamic loader in the inferior
2050
   to query it for symbol names and addresses.
2051
 
2052
   Yes, all those cases should work.  Luckily code exists to handle most
2053
   of them.  The complexity is in selecting exactly what scheme should
2054
   be used to perform the inferior call.
2055
 
2056
   At the current time this routine is known not to handle cases where
2057
   the program was linked with HP's compiler without including end.o.
2058
 
2059
   Please contact Jeff Law (law@cygnus.com) before changing this code.  */
2060
 
2061
CORE_ADDR
2062
hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
2063
     char *dummy;
2064
     CORE_ADDR pc;
2065
     CORE_ADDR fun;
2066
     int nargs;
2067
     value_ptr *args;
2068
     struct type *type;
2069
     int gcc_p;
2070
{
2071
  CORE_ADDR dyncall_addr;
2072
  struct minimal_symbol *msymbol;
2073
  struct minimal_symbol *trampoline;
2074
  int flags = read_register (FLAGS_REGNUM);
2075
  struct unwind_table_entry *u = NULL;
2076
  CORE_ADDR new_stub = 0;
2077
  CORE_ADDR solib_handle = 0;
2078
 
2079
  /* Nonzero if we will use GCC's PLT call routine.  This routine must be
2080
     passed an import stub, not a PLABEL.  It is also necessary to set %r19
2081
     (the PIC register) before performing the call.
2082
 
2083
     If zero, then we are using __d_plt_call (HP's PLT call routine) or we
2084
     are calling the target directly.  When using __d_plt_call we want to
2085
     use a PLABEL instead of an import stub.  */
2086
  int using_gcc_plt_call = 1;
2087
 
2088
#ifdef GDB_TARGET_IS_HPPA_20W
2089
  /* We currently use completely different code for the PA2.0W inferior
2090
     function call sequences.  This needs to be cleaned up.  */
2091
  {
2092
    CORE_ADDR pcsqh, pcsqt, pcoqh, pcoqt, sr5;
2093
    struct target_waitstatus w;
2094
    int inst1, inst2;
2095
    char buf[4];
2096
    int status;
2097
    struct objfile *objfile;
2098
 
2099
    /* We can not modify the PC space queues directly, so we start
2100
       up the inferior and execute a couple instructions to set the
2101
       space queues so that they point to the call dummy in the stack.  */
2102
    pcsqh = read_register (PCSQ_HEAD_REGNUM);
2103
    sr5 = read_register (SR5_REGNUM);
2104
    if (1)
2105
      {
2106
        pcoqh = read_register (PCOQ_HEAD_REGNUM);
2107
        pcoqt = read_register (PCOQ_TAIL_REGNUM);
2108
        if (target_read_memory (pcoqh, buf, 4) != 0)
2109
          error ("Couldn't modify space queue\n");
2110
        inst1 = extract_unsigned_integer (buf, 4);
2111
 
2112
        if (target_read_memory (pcoqt, buf, 4) != 0)
2113
          error ("Couldn't modify space queue\n");
2114
        inst2 = extract_unsigned_integer (buf, 4);
2115
 
2116
        /* BVE (r1) */
2117
        *((int *) buf) = 0xe820d000;
2118
        if (target_write_memory (pcoqh, buf, 4) != 0)
2119
          error ("Couldn't modify space queue\n");
2120
 
2121
        /* NOP */
2122
        *((int *) buf) = 0x08000240;
2123
        if (target_write_memory (pcoqt, buf, 4) != 0)
2124
          {
2125
            *((int *) buf) = inst1;
2126
            target_write_memory (pcoqh, buf, 4);
2127
            error ("Couldn't modify space queue\n");
2128
          }
2129
 
2130
        write_register (1, pc);
2131
 
2132
        /* Single step twice, the BVE instruction will set the space queue
2133
           such that it points to the PC value written immediately above
2134
           (ie the call dummy).  */
2135
        resume (1, 0);
2136
        target_wait (inferior_pid, &w);
2137
        resume (1, 0);
2138
        target_wait (inferior_pid, &w);
2139
 
2140
        /* Restore the two instructions at the old PC locations.  */
2141
        *((int *) buf) = inst1;
2142
        target_write_memory (pcoqh, buf, 4);
2143
        *((int *) buf) = inst2;
2144
        target_write_memory (pcoqt, buf, 4);
2145
      }
2146
 
2147
    /* The call dummy wants the ultimate destination address initially
2148
       in register %r5.  */
2149
    write_register (5, fun);
2150
 
2151
    /* We need to see if this objfile has a different DP value than our
2152
       own (it could be a shared library for example).  */
2153
    ALL_OBJFILES (objfile)
2154
      {
2155
        struct obj_section *s;
2156
        obj_private_data_t *obj_private;
2157
 
2158
        /* See if FUN is in any section within this shared library.  */
2159
        for (s = objfile->sections; s < objfile->sections_end; s++)
2160
          if (s->addr <= fun && fun < s->endaddr)
2161
            break;
2162
 
2163
        if (s >= objfile->sections_end)
2164
          continue;
2165
 
2166
        obj_private = (obj_private_data_t *) objfile->obj_private;
2167
 
2168
        /* The DP value may be different for each objfile.  But within an
2169
           objfile each function uses the same dp value.  Thus we do not need
2170
           to grope around the opd section looking for dp values.
2171
 
2172
           ?!? This is not strictly correct since we may be in a shared library
2173
           and want to call back into the main program.  To make that case
2174
           work correctly we need to set obj_private->dp for the main program's
2175
           objfile, then remove this conditional.  */
2176
        if (obj_private->dp)
2177
          write_register (27, obj_private->dp);
2178
        break;
2179
      }
2180
    return pc;
2181
  }
2182
#endif
2183
 
2184
#ifndef GDB_TARGET_IS_HPPA_20W
2185
  /* Prefer __gcc_plt_call over the HP supplied routine because
2186
     __gcc_plt_call works for any number of arguments.  */
2187
  trampoline = NULL;
2188
  if (lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL) == NULL)
2189
    using_gcc_plt_call = 0;
2190
 
2191
  msymbol = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
2192
  if (msymbol == NULL)
2193
    error ("Can't find an address for $$dyncall trampoline");
2194
 
2195
  dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol);
2196
 
2197
  /* FUN could be a procedure label, in which case we have to get
2198
     its real address and the value of its GOT/DP if we plan to
2199
     call the routine via gcc_plt_call.  */
2200
  if ((fun & 0x2) && using_gcc_plt_call)
2201
    {
2202
      /* Get the GOT/DP value for the target function.  It's
2203
         at *(fun+4).  Note the call dummy is *NOT* allowed to
2204
         trash %r19 before calling the target function.  */
2205
      write_register (19, read_memory_integer ((fun & ~0x3) + 4,
2206
                      REGISTER_SIZE));
2207
 
2208
      /* Now get the real address for the function we are calling, it's
2209
         at *fun.  */
2210
      fun = (CORE_ADDR) read_memory_integer (fun & ~0x3,
2211
                                             TARGET_PTR_BIT / 8);
2212
    }
2213
  else
2214
    {
2215
 
2216
#ifndef GDB_TARGET_IS_PA_ELF
2217
      /* FUN could be an export stub, the real address of a function, or
2218
         a PLABEL.  When using gcc's PLT call routine we must call an import
2219
         stub rather than the export stub or real function for lazy binding
2220
         to work correctly
2221
 
2222
         /* If we are using the gcc PLT call routine, then we need to
2223
         get the import stub for the target function.  */
2224
      if (using_gcc_plt_call && som_solib_get_got_by_pc (fun))
2225
        {
2226
          struct objfile *objfile;
2227
          struct minimal_symbol *funsymbol, *stub_symbol;
2228
          CORE_ADDR newfun = 0;
2229
 
2230
          funsymbol = lookup_minimal_symbol_by_pc (fun);
2231
          if (!funsymbol)
2232
            error ("Unable to find minimal symbol for target function.\n");
2233
 
2234
          /* Search all the object files for an import symbol with the
2235
             right name. */
2236
          ALL_OBJFILES (objfile)
2237
          {
2238
            stub_symbol
2239
              = lookup_minimal_symbol_solib_trampoline
2240
              (SYMBOL_NAME (funsymbol), NULL, objfile);
2241
 
2242
            if (!stub_symbol)
2243
              stub_symbol = lookup_minimal_symbol (SYMBOL_NAME (funsymbol),
2244
                                                   NULL, objfile);
2245
 
2246
            /* Found a symbol with the right name.  */
2247
            if (stub_symbol)
2248
              {
2249
                struct unwind_table_entry *u;
2250
                /* It must be a shared library trampoline.  */
2251
                if (MSYMBOL_TYPE (stub_symbol) != mst_solib_trampoline)
2252
                  continue;
2253
 
2254
                /* It must also be an import stub.  */
2255
                u = find_unwind_entry (SYMBOL_VALUE (stub_symbol));
2256
                if (u == NULL
2257
                    || (u->stub_unwind.stub_type != IMPORT
2258
#ifdef GDB_NATIVE_HPUX_11
2259
                        /* Sigh.  The hpux 10.20 dynamic linker will blow
2260
                           chunks if we perform a call to an unbound function
2261
                           via the IMPORT_SHLIB stub.  The hpux 11.00 dynamic
2262
                           linker will blow chunks if we do not call the
2263
                           unbound function via the IMPORT_SHLIB stub.
2264
 
2265
                           We currently have no way to select bevahior on just
2266
                           the target.  However, we only support HPUX/SOM in
2267
                           native mode.  So we conditinalize on a native
2268
                           #ifdef.  Ugly.  Ugly.  Ugly  */
2269
                        && u->stub_unwind.stub_type != IMPORT_SHLIB
2270
#endif
2271
                        ))
2272
                  continue;
2273
 
2274
                /* OK.  Looks like the correct import stub.  */
2275
                newfun = SYMBOL_VALUE (stub_symbol);
2276
                fun = newfun;
2277
 
2278
                /* If we found an IMPORT stub, then we want to stop
2279
                   searching now.  If we found an IMPORT_SHLIB, we want
2280
                   to continue the search in the hopes that we will find
2281
                   an IMPORT stub.  */
2282
                if (u->stub_unwind.stub_type == IMPORT)
2283
                  break;
2284
              }
2285
          }
2286
 
2287
          /* Ouch.  We did not find an import stub.  Make an attempt to
2288
             do the right thing instead of just croaking.  Most of the
2289
             time this will actually work.  */
2290
          if (newfun == 0)
2291
            write_register (19, som_solib_get_got_by_pc (fun));
2292
 
2293
          u = find_unwind_entry (fun);
2294
          if (u
2295
              && (u->stub_unwind.stub_type == IMPORT
2296
                  || u->stub_unwind.stub_type == IMPORT_SHLIB))
2297
            trampoline = lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL);
2298
 
2299
          /* If we found the import stub in the shared library, then we have
2300
             to set %r19 before we call the stub.  */
2301
          if (u && u->stub_unwind.stub_type == IMPORT_SHLIB)
2302
            write_register (19, som_solib_get_got_by_pc (fun));
2303
        }
2304
#endif
2305
    }
2306
 
2307
  /* If we are calling into another load module then have sr4export call the
2308
     magic __d_plt_call routine which is linked in from end.o.
2309
 
2310
     You can't use _sr4export to make the call as the value in sp-24 will get
2311
     fried and you end up returning to the wrong location.  You can't call the
2312
     target as the code to bind the PLT entry to a function can't return to a
2313
     stack address.
2314
 
2315
     Also, query the dynamic linker in the inferior to provide a suitable
2316
     PLABEL for the target function.  */
2317
  if (!using_gcc_plt_call)
2318
    {
2319
      CORE_ADDR new_fun;
2320
 
2321
      /* Get a handle for the shared library containing FUN.  Given the
2322
         handle we can query the shared library for a PLABEL.  */
2323
      solib_handle = som_solib_get_solib_by_pc (fun);
2324
 
2325
      if (solib_handle)
2326
        {
2327
          struct minimal_symbol *fmsymbol = lookup_minimal_symbol_by_pc (fun);
2328
 
2329
          trampoline = lookup_minimal_symbol ("__d_plt_call", NULL, NULL);
2330
 
2331
          if (trampoline == NULL)
2332
            {
2333
              error ("Can't find an address for __d_plt_call or __gcc_plt_call trampoline\nSuggest linking executable with -g or compiling with gcc.");
2334
            }
2335
 
2336
          /* This is where sr4export will jump to.  */
2337
          new_fun = SYMBOL_VALUE_ADDRESS (trampoline);
2338
 
2339
          /* If the function is in a shared library, then call __d_shl_get to
2340
             get a PLABEL for the target function.  */
2341
          new_stub = find_stub_with_shl_get (fmsymbol, solib_handle);
2342
 
2343
          if (new_stub == 0)
2344
            error ("Can't find an import stub for %s", SYMBOL_NAME (fmsymbol));
2345
 
2346
          /* We have to store the address of the stub in __shlib_funcptr.  */
2347
          msymbol = lookup_minimal_symbol ("__shlib_funcptr", NULL,
2348
                                           (struct objfile *) NULL);
2349
 
2350
          if (msymbol == NULL)
2351
            error ("Can't find an address for __shlib_funcptr");
2352
          target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
2353
                               (char *) &new_stub, 4);
2354
 
2355
          /* We want sr4export to call __d_plt_call, so we claim it is
2356
             the final target.  Clear trampoline.  */
2357
          fun = new_fun;
2358
          trampoline = NULL;
2359
        }
2360
    }
2361
 
2362
  /* Store upper 21 bits of function address into ldil.  fun will either be
2363
     the final target (most cases) or __d_plt_call when calling into a shared
2364
     library and __gcc_plt_call is not available.  */
2365
  store_unsigned_integer
2366
    (&dummy[FUNC_LDIL_OFFSET],
2367
     INSTRUCTION_SIZE,
2368
     deposit_21 (fun >> 11,
2369
                 extract_unsigned_integer (&dummy[FUNC_LDIL_OFFSET],
2370
                                           INSTRUCTION_SIZE)));
2371
 
2372
  /* Store lower 11 bits of function address into ldo */
2373
  store_unsigned_integer
2374
    (&dummy[FUNC_LDO_OFFSET],
2375
     INSTRUCTION_SIZE,
2376
     deposit_14 (fun & MASK_11,
2377
                 extract_unsigned_integer (&dummy[FUNC_LDO_OFFSET],
2378
                                           INSTRUCTION_SIZE)));
2379
#ifdef SR4EXPORT_LDIL_OFFSET
2380
 
2381
  {
2382
    CORE_ADDR trampoline_addr;
2383
 
2384
    /* We may still need sr4export's address too.  */
2385
 
2386
    if (trampoline == NULL)
2387
      {
2388
        msymbol = lookup_minimal_symbol ("_sr4export", NULL, NULL);
2389
        if (msymbol == NULL)
2390
          error ("Can't find an address for _sr4export trampoline");
2391
 
2392
        trampoline_addr = SYMBOL_VALUE_ADDRESS (msymbol);
2393
      }
2394
    else
2395
      trampoline_addr = SYMBOL_VALUE_ADDRESS (trampoline);
2396
 
2397
 
2398
    /* Store upper 21 bits of trampoline's address into ldil */
2399
    store_unsigned_integer
2400
      (&dummy[SR4EXPORT_LDIL_OFFSET],
2401
       INSTRUCTION_SIZE,
2402
       deposit_21 (trampoline_addr >> 11,
2403
                   extract_unsigned_integer (&dummy[SR4EXPORT_LDIL_OFFSET],
2404
                                             INSTRUCTION_SIZE)));
2405
 
2406
    /* Store lower 11 bits of trampoline's address into ldo */
2407
    store_unsigned_integer
2408
      (&dummy[SR4EXPORT_LDO_OFFSET],
2409
       INSTRUCTION_SIZE,
2410
       deposit_14 (trampoline_addr & MASK_11,
2411
                   extract_unsigned_integer (&dummy[SR4EXPORT_LDO_OFFSET],
2412
                                             INSTRUCTION_SIZE)));
2413
  }
2414
#endif
2415
 
2416
  write_register (22, pc);
2417
 
2418
  /* If we are in a syscall, then we should call the stack dummy
2419
     directly.  $$dyncall is not needed as the kernel sets up the
2420
     space id registers properly based on the value in %r31.  In
2421
     fact calling $$dyncall will not work because the value in %r22
2422
     will be clobbered on the syscall exit path.
2423
 
2424
     Similarly if the current PC is in a shared library.  Note however,
2425
     this scheme won't work if the shared library isn't mapped into
2426
     the same space as the stack.  */
2427
  if (flags & 2)
2428
    return pc;
2429
#ifndef GDB_TARGET_IS_PA_ELF
2430
  else if (som_solib_get_got_by_pc (target_read_pc (inferior_pid)))
2431
    return pc;
2432
#endif
2433
  else
2434
    return dyncall_addr;
2435
#endif
2436
}
2437
 
2438
 
2439
 
2440
 
2441
/* If the pid is in a syscall, then the FP register is not readable.
2442
   We'll return zero in that case, rather than attempting to read it
2443
   and cause a warning. */
2444
CORE_ADDR
2445
target_read_fp (pid)
2446
     int pid;
2447
{
2448
  int flags = read_register (FLAGS_REGNUM);
2449
 
2450
  if (flags & 2)
2451
    {
2452
      return (CORE_ADDR) 0;
2453
    }
2454
 
2455
  /* This is the only site that may directly read_register () the FP
2456
     register.  All others must use TARGET_READ_FP (). */
2457
  return read_register (FP_REGNUM);
2458
}
2459
 
2460
 
2461
/* Get the PC from %r31 if currently in a syscall.  Also mask out privilege
2462
   bits.  */
2463
 
2464
CORE_ADDR
2465
target_read_pc (pid)
2466
     int pid;
2467
{
2468
  int flags = read_register_pid (FLAGS_REGNUM, pid);
2469
 
2470
  /* The following test does not belong here.  It is OS-specific, and belongs
2471
     in native code.  */
2472
  /* Test SS_INSYSCALL */
2473
  if (flags & 2)
2474
    return read_register_pid (31, pid) & ~0x3;
2475
 
2476
  return read_register_pid (PC_REGNUM, pid) & ~0x3;
2477
}
2478
 
2479
/* Write out the PC.  If currently in a syscall, then also write the new
2480
   PC value into %r31.  */
2481
 
2482
void
2483
target_write_pc (v, pid)
2484
     CORE_ADDR v;
2485
     int pid;
2486
{
2487
  int flags = read_register_pid (FLAGS_REGNUM, pid);
2488
 
2489
  /* The following test does not belong here.  It is OS-specific, and belongs
2490
     in native code.  */
2491
  /* If in a syscall, then set %r31.  Also make sure to get the
2492
     privilege bits set correctly.  */
2493
  /* Test SS_INSYSCALL */
2494
  if (flags & 2)
2495
    write_register_pid (31, v | 0x3, pid);
2496
 
2497
  write_register_pid (PC_REGNUM, v, pid);
2498
  write_register_pid (NPC_REGNUM, v + 4, pid);
2499
}
2500
 
2501
/* return the alignment of a type in bytes. Structures have the maximum
2502
   alignment required by their fields. */
2503
 
2504
static int
2505
hppa_alignof (type)
2506
     struct type *type;
2507
{
2508
  int max_align, align, i;
2509
  CHECK_TYPEDEF (type);
2510
  switch (TYPE_CODE (type))
2511
    {
2512
    case TYPE_CODE_PTR:
2513
    case TYPE_CODE_INT:
2514
    case TYPE_CODE_FLT:
2515
      return TYPE_LENGTH (type);
2516
    case TYPE_CODE_ARRAY:
2517
      return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
2518
    case TYPE_CODE_STRUCT:
2519
    case TYPE_CODE_UNION:
2520
      max_align = 1;
2521
      for (i = 0; i < TYPE_NFIELDS (type); i++)
2522
        {
2523
          /* Bit fields have no real alignment. */
2524
          /* if (!TYPE_FIELD_BITPOS (type, i)) */
2525
          if (!TYPE_FIELD_BITSIZE (type, i))    /* elz: this should be bitsize */
2526
            {
2527
              align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
2528
              max_align = max (max_align, align);
2529
            }
2530
        }
2531
      return max_align;
2532
    default:
2533
      return 4;
2534
    }
2535
}
2536
 
2537
/* Print the register regnum, or all registers if regnum is -1 */
2538
 
2539
void
2540
pa_do_registers_info (regnum, fpregs)
2541
     int regnum;
2542
     int fpregs;
2543
{
2544
  char raw_regs[REGISTER_BYTES];
2545
  int i;
2546
 
2547
  /* Make a copy of gdb's save area (may cause actual
2548
     reads from the target). */
2549
  for (i = 0; i < NUM_REGS; i++)
2550
    read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
2551
 
2552
  if (regnum == -1)
2553
    pa_print_registers (raw_regs, regnum, fpregs);
2554
  else if (regnum < FP4_REGNUM)
2555
    {
2556
      long reg_val[2];
2557
 
2558
      /* Why is the value not passed through "extract_signed_integer"
2559
         as in "pa_print_registers" below? */
2560
      pa_register_look_aside (raw_regs, regnum, &reg_val[0]);
2561
 
2562
      if (!is_pa_2)
2563
        {
2564
          printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]);
2565
        }
2566
      else
2567
        {
2568
          /* Fancy % formats to prevent leading zeros. */
2569
          if (reg_val[0] == 0)
2570
            printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]);
2571
          else
2572
            printf_unfiltered ("%s %x%8.8x\n", REGISTER_NAME (regnum),
2573
                               reg_val[0], reg_val[1]);
2574
        }
2575
    }
2576
  else
2577
    /* Note that real floating point values only start at
2578
       FP4_REGNUM.  FP0 and up are just status and error
2579
       registers, which have integral (bit) values. */
2580
    pa_print_fp_reg (regnum);
2581
}
2582
 
2583
/********** new function ********************/
2584
void
2585
pa_do_strcat_registers_info (regnum, fpregs, stream, precision)
2586
     int regnum;
2587
     int fpregs;
2588
     struct ui_file *stream;
2589
     enum precision_type precision;
2590
{
2591
  char raw_regs[REGISTER_BYTES];
2592
  int i;
2593
 
2594
  /* Make a copy of gdb's save area (may cause actual
2595
     reads from the target). */
2596
  for (i = 0; i < NUM_REGS; i++)
2597
    read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
2598
 
2599
  if (regnum == -1)
2600
    pa_strcat_registers (raw_regs, regnum, fpregs, stream);
2601
 
2602
  else if (regnum < FP4_REGNUM)
2603
    {
2604
      long reg_val[2];
2605
 
2606
      /* Why is the value not passed through "extract_signed_integer"
2607
         as in "pa_print_registers" below? */
2608
      pa_register_look_aside (raw_regs, regnum, &reg_val[0]);
2609
 
2610
      if (!is_pa_2)
2611
        {
2612
          fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum), reg_val[1]);
2613
        }
2614
      else
2615
        {
2616
          /* Fancy % formats to prevent leading zeros. */
2617
          if (reg_val[0] == 0)
2618
            fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum),
2619
                                reg_val[1]);
2620
          else
2621
            fprintf_unfiltered (stream, "%s %x%8.8x", REGISTER_NAME (regnum),
2622
                                reg_val[0], reg_val[1]);
2623
        }
2624
    }
2625
  else
2626
    /* Note that real floating point values only start at
2627
       FP4_REGNUM.  FP0 and up are just status and error
2628
       registers, which have integral (bit) values. */
2629
    pa_strcat_fp_reg (regnum, stream, precision);
2630
}
2631
 
2632
/* If this is a PA2.0 machine, fetch the real 64-bit register
2633
   value.  Otherwise use the info from gdb's saved register area.
2634
 
2635
   Note that reg_val is really expected to be an array of longs,
2636
   with two elements. */
2637
static void
2638
pa_register_look_aside (raw_regs, regnum, raw_val)
2639
     char *raw_regs;
2640
     int regnum;
2641
     long *raw_val;
2642
{
2643
  static int know_which = 0;     /* False */
2644
 
2645
  int regaddr;
2646
  unsigned int offset;
2647
  register int i;
2648
  int start;
2649
 
2650
 
2651
  char buf[MAX_REGISTER_RAW_SIZE];
2652
  long long reg_val;
2653
 
2654
  if (!know_which)
2655
    {
2656
      if (CPU_PA_RISC2_0 == sysconf (_SC_CPU_VERSION))
2657
        {
2658
          is_pa_2 = (1 == 1);
2659
        }
2660
 
2661
      know_which = 1;           /* True */
2662
    }
2663
 
2664
  raw_val[0] = 0;
2665
  raw_val[1] = 0;
2666
 
2667
  if (!is_pa_2)
2668
    {
2669
      raw_val[1] = *(long *) (raw_regs + REGISTER_BYTE (regnum));
2670
      return;
2671
    }
2672
 
2673
  /* Code below copied from hppah-nat.c, with fixes for wide
2674
     registers, using different area of save_state, etc. */
2675
  if (regnum == FLAGS_REGNUM || regnum >= FP0_REGNUM ||
2676
      !HAVE_STRUCT_SAVE_STATE_T || !HAVE_STRUCT_MEMBER_SS_WIDE)
2677
    {
2678
      /* Use narrow regs area of save_state and default macro. */
2679
      offset = U_REGS_OFFSET;
2680
      regaddr = register_addr (regnum, offset);
2681
      start = 1;
2682
    }
2683
  else
2684
    {
2685
      /* Use wide regs area, and calculate registers as 8 bytes wide.
2686
 
2687
         We'd like to do this, but current version of "C" doesn't
2688
         permit "offsetof":
2689
 
2690
         offset  = offsetof(save_state_t, ss_wide);
2691
 
2692
         Note that to avoid "C" doing typed pointer arithmetic, we
2693
         have to cast away the type in our offset calculation:
2694
         otherwise we get an offset of 1! */
2695
 
2696
      /* NB: save_state_t is not available before HPUX 9.
2697
         The ss_wide field is not available previous to HPUX 10.20,
2698
         so to avoid compile-time warnings, we only compile this for
2699
         PA 2.0 processors.  This control path should only be followed
2700
         if we're debugging a PA 2.0 processor, so this should not cause
2701
         problems. */
2702
 
2703
      /* #if the following code out so that this file can still be
2704
         compiled on older HPUX boxes (< 10.20) which don't have
2705
         this structure/structure member.  */
2706
#if HAVE_STRUCT_SAVE_STATE_T == 1 && HAVE_STRUCT_MEMBER_SS_WIDE == 1
2707
      save_state_t temp;
2708
 
2709
      offset = ((int) &temp.ss_wide) - ((int) &temp);
2710
      regaddr = offset + regnum * 8;
2711
      start = 0;
2712
#endif
2713
    }
2714
 
2715
  for (i = start; i < 2; i++)
2716
    {
2717
      errno = 0;
2718
      raw_val[i] = call_ptrace (PT_RUREGS, inferior_pid,
2719
                                (PTRACE_ARG3_TYPE) regaddr, 0);
2720
      if (errno != 0)
2721
        {
2722
          /* Warning, not error, in case we are attached; sometimes the
2723
             kernel doesn't let us at the registers.  */
2724
          char *err = safe_strerror (errno);
2725
          char *msg = alloca (strlen (err) + 128);
2726
          sprintf (msg, "reading register %s: %s", REGISTER_NAME (regnum), err);
2727
          warning (msg);
2728
          goto error_exit;
2729
        }
2730
 
2731
      regaddr += sizeof (long);
2732
    }
2733
 
2734
  if (regnum == PCOQ_HEAD_REGNUM || regnum == PCOQ_TAIL_REGNUM)
2735
    raw_val[1] &= ~0x3;         /* I think we're masking out space bits */
2736
 
2737
error_exit:
2738
  ;
2739
}
2740
 
2741
/* "Info all-reg" command */
2742
 
2743
static void
2744
pa_print_registers (raw_regs, regnum, fpregs)
2745
     char *raw_regs;
2746
     int regnum;
2747
     int fpregs;
2748
{
2749
  int i, j;
2750
  /* Alas, we are compiled so that "long long" is 32 bits */
2751
  long raw_val[2];
2752
  long long_val;
2753
  int rows = 48, columns = 2;
2754
 
2755
  for (i = 0; i < rows; i++)
2756
    {
2757
      for (j = 0; j < columns; j++)
2758
        {
2759
          /* We display registers in column-major order.  */
2760
          int regnum = i + j * rows;
2761
 
2762
          /* Q: Why is the value passed through "extract_signed_integer",
2763
             while above, in "pa_do_registers_info" it isn't?
2764
             A: ? */
2765
          pa_register_look_aside (raw_regs, regnum, &raw_val[0]);
2766
 
2767
          /* Even fancier % formats to prevent leading zeros
2768
             and still maintain the output in columns. */
2769
          if (!is_pa_2)
2770
            {
2771
              /* Being big-endian, on this machine the low bits
2772
                 (the ones we want to look at) are in the second longword. */
2773
              long_val = extract_signed_integer (&raw_val[1], 4);
2774
              printf_filtered ("%10.10s: %8x   ",
2775
                               REGISTER_NAME (regnum), long_val);
2776
            }
2777
          else
2778
            {
2779
              /* raw_val = extract_signed_integer(&raw_val, 8); */
2780
              if (raw_val[0] == 0)
2781
                printf_filtered ("%10.10s:         %8x   ",
2782
                                 REGISTER_NAME (regnum), raw_val[1]);
2783
              else
2784
                printf_filtered ("%10.10s: %8x%8.8x   ",
2785
                                 REGISTER_NAME (regnum),
2786
                                 raw_val[0], raw_val[1]);
2787
            }
2788
        }
2789
      printf_unfiltered ("\n");
2790
    }
2791
 
2792
  if (fpregs)
2793
    for (i = FP4_REGNUM; i < NUM_REGS; i++)     /* FP4_REGNUM == 72 */
2794
      pa_print_fp_reg (i);
2795
}
2796
 
2797
/************* new function ******************/
2798
static void
2799
pa_strcat_registers (raw_regs, regnum, fpregs, stream)
2800
     char *raw_regs;
2801
     int regnum;
2802
     int fpregs;
2803
     struct ui_file *stream;
2804
{
2805
  int i, j;
2806
  long raw_val[2];              /* Alas, we are compiled so that "long long" is 32 bits */
2807
  long long_val;
2808
  enum precision_type precision;
2809
 
2810
  precision = unspecified_precision;
2811
 
2812
  for (i = 0; i < 18; i++)
2813
    {
2814
      for (j = 0; j < 4; j++)
2815
        {
2816
          /* Q: Why is the value passed through "extract_signed_integer",
2817
             while above, in "pa_do_registers_info" it isn't?
2818
             A: ? */
2819
          pa_register_look_aside (raw_regs, i + (j * 18), &raw_val[0]);
2820
 
2821
          /* Even fancier % formats to prevent leading zeros
2822
             and still maintain the output in columns. */
2823
          if (!is_pa_2)
2824
            {
2825
              /* Being big-endian, on this machine the low bits
2826
                 (the ones we want to look at) are in the second longword. */
2827
              long_val = extract_signed_integer (&raw_val[1], 4);
2828
              fprintf_filtered (stream, "%8.8s: %8x  ", REGISTER_NAME (i + (j * 18)), long_val);
2829
            }
2830
          else
2831
            {
2832
              /* raw_val = extract_signed_integer(&raw_val, 8); */
2833
              if (raw_val[0] == 0)
2834
                fprintf_filtered (stream, "%8.8s:         %8x  ", REGISTER_NAME (i + (j * 18)),
2835
                                  raw_val[1]);
2836
              else
2837
                fprintf_filtered (stream, "%8.8s: %8x%8.8x  ", REGISTER_NAME (i + (j * 18)),
2838
                                  raw_val[0], raw_val[1]);
2839
            }
2840
        }
2841
      fprintf_unfiltered (stream, "\n");
2842
    }
2843
 
2844
  if (fpregs)
2845
    for (i = FP4_REGNUM; i < NUM_REGS; i++)     /* FP4_REGNUM == 72 */
2846
      pa_strcat_fp_reg (i, stream, precision);
2847
}
2848
 
2849
static void
2850
pa_print_fp_reg (i)
2851
     int i;
2852
{
2853
  char raw_buffer[MAX_REGISTER_RAW_SIZE];
2854
  char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
2855
 
2856
  /* Get 32bits of data.  */
2857
  read_relative_register_raw_bytes (i, raw_buffer);
2858
 
2859
  /* Put it in the buffer.  No conversions are ever necessary.  */
2860
  memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i));
2861
 
2862
  fputs_filtered (REGISTER_NAME (i), gdb_stdout);
2863
  print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
2864
  fputs_filtered ("(single precision)     ", gdb_stdout);
2865
 
2866
  val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, gdb_stdout, 0,
2867
             1, 0, Val_pretty_default);
2868
  printf_filtered ("\n");
2869
 
2870
  /* If "i" is even, then this register can also be a double-precision
2871
     FP register.  Dump it out as such.  */
2872
  if ((i % 2) == 0)
2873
    {
2874
      /* Get the data in raw format for the 2nd half.  */
2875
      read_relative_register_raw_bytes (i + 1, raw_buffer);
2876
 
2877
      /* Copy it into the appropriate part of the virtual buffer.  */
2878
      memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buffer,
2879
              REGISTER_RAW_SIZE (i));
2880
 
2881
      /* Dump it as a double.  */
2882
      fputs_filtered (REGISTER_NAME (i), gdb_stdout);
2883
      print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
2884
      fputs_filtered ("(double precision)     ", gdb_stdout);
2885
 
2886
      val_print (builtin_type_double, virtual_buffer, 0, 0, gdb_stdout, 0,
2887
                 1, 0, Val_pretty_default);
2888
      printf_filtered ("\n");
2889
    }
2890
}
2891
 
2892
/*************** new function ***********************/
2893
static void
2894
pa_strcat_fp_reg (i, stream, precision)
2895
     int i;
2896
     struct ui_file *stream;
2897
     enum precision_type precision;
2898
{
2899
  char raw_buffer[MAX_REGISTER_RAW_SIZE];
2900
  char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
2901
 
2902
  fputs_filtered (REGISTER_NAME (i), stream);
2903
  print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), stream);
2904
 
2905
  /* Get 32bits of data.  */
2906
  read_relative_register_raw_bytes (i, raw_buffer);
2907
 
2908
  /* Put it in the buffer.  No conversions are ever necessary.  */
2909
  memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i));
2910
 
2911
  if (precision == double_precision && (i % 2) == 0)
2912
    {
2913
 
2914
      char raw_buf[MAX_REGISTER_RAW_SIZE];
2915
 
2916
      /* Get the data in raw format for the 2nd half.  */
2917
      read_relative_register_raw_bytes (i + 1, raw_buf);
2918
 
2919
      /* Copy it into the appropriate part of the virtual buffer.  */
2920
      memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buf, REGISTER_RAW_SIZE (i));
2921
 
2922
      val_print (builtin_type_double, virtual_buffer, 0, 0, stream, 0,
2923
                 1, 0, Val_pretty_default);
2924
 
2925
    }
2926
  else
2927
    {
2928
      val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, stream, 0,
2929
                 1, 0, Val_pretty_default);
2930
    }
2931
 
2932
}
2933
 
2934
/* Return one if PC is in the call path of a trampoline, else return zero.
2935
 
2936
   Note we return one for *any* call trampoline (long-call, arg-reloc), not
2937
   just shared library trampolines (import, export).  */
2938
 
2939
int
2940
in_solib_call_trampoline (pc, name)
2941
     CORE_ADDR pc;
2942
     char *name;
2943
{
2944
  struct minimal_symbol *minsym;
2945
  struct unwind_table_entry *u;
2946
  static CORE_ADDR dyncall = 0;
2947
  static CORE_ADDR sr4export = 0;
2948
 
2949
#ifdef GDB_TARGET_IS_HPPA_20W
2950
  /* PA64 has a completely different stub/trampoline scheme.  Is it
2951
     better?  Maybe.  It's certainly harder to determine with any
2952
     certainty that we are in a stub because we can not refer to the
2953
     unwinders to help.
2954
 
2955
     The heuristic is simple.  Try to lookup the current PC value in th
2956
     minimal symbol table.  If that fails, then assume we are not in a
2957
     stub and return.
2958
 
2959
     Then see if the PC value falls within the section bounds for the
2960
     section containing the minimal symbol we found in the first
2961
     step.  If it does, then assume we are not in a stub and return.
2962
 
2963
     Finally peek at the instructions to see if they look like a stub.  */
2964
  {
2965
    struct minimal_symbol *minsym;
2966
    asection *sec;
2967
    CORE_ADDR addr;
2968
    int insn, i;
2969
 
2970
    minsym = lookup_minimal_symbol_by_pc (pc);
2971
    if (! minsym)
2972
      return 0;
2973
 
2974
    sec = SYMBOL_BFD_SECTION (minsym);
2975
 
2976
    if (sec->vma <= pc
2977
        && sec->vma + sec->_cooked_size < pc)
2978
      return 0;
2979
 
2980
    /* We might be in a stub.  Peek at the instructions.  Stubs are 3
2981
       instructions long. */
2982
    insn = read_memory_integer (pc, 4);
2983
 
2984
    /* Find out where we we think we are within the stub.  */
2985
    if ((insn & 0xffffc00e) == 0x53610000)
2986
      addr = pc;
2987
    else if ((insn & 0xffffffff) == 0xe820d000)
2988
      addr = pc - 4;
2989
    else if ((insn & 0xffffc00e) == 0x537b0000)
2990
      addr = pc - 8;
2991
    else
2992
      return 0;
2993
 
2994
    /* Now verify each insn in the range looks like a stub instruction.  */
2995
    insn = read_memory_integer (addr, 4);
2996
    if ((insn & 0xffffc00e) != 0x53610000)
2997
      return 0;
2998
 
2999
    /* Now verify each insn in the range looks like a stub instruction.  */
3000
    insn = read_memory_integer (addr + 4, 4);
3001
    if ((insn & 0xffffffff) != 0xe820d000)
3002
      return 0;
3003
 
3004
    /* Now verify each insn in the range looks like a stub instruction.  */
3005
    insn = read_memory_integer (addr + 8, 4);
3006
    if ((insn & 0xffffc00e) != 0x537b0000)
3007
      return 0;
3008
 
3009
    /* Looks like a stub.  */
3010
    return 1;
3011
  }
3012
#endif
3013
 
3014
  /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3015
     new exec file */
3016
 
3017
  /* First see if PC is in one of the two C-library trampolines.  */
3018
  if (!dyncall)
3019
    {
3020
      minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
3021
      if (minsym)
3022
        dyncall = SYMBOL_VALUE_ADDRESS (minsym);
3023
      else
3024
        dyncall = -1;
3025
    }
3026
 
3027
  if (!sr4export)
3028
    {
3029
      minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
3030
      if (minsym)
3031
        sr4export = SYMBOL_VALUE_ADDRESS (minsym);
3032
      else
3033
        sr4export = -1;
3034
    }
3035
 
3036
  if (pc == dyncall || pc == sr4export)
3037
    return 1;
3038
 
3039
  minsym = lookup_minimal_symbol_by_pc (pc);
3040
  if (minsym && strcmp (SYMBOL_NAME (minsym), ".stub") == 0)
3041
    return 1;
3042
 
3043
  /* Get the unwind descriptor corresponding to PC, return zero
3044
     if no unwind was found.  */
3045
  u = find_unwind_entry (pc);
3046
  if (!u)
3047
    return 0;
3048
 
3049
  /* If this isn't a linker stub, then return now.  */
3050
  if (u->stub_unwind.stub_type == 0)
3051
    return 0;
3052
 
3053
  /* By definition a long-branch stub is a call stub.  */
3054
  if (u->stub_unwind.stub_type == LONG_BRANCH)
3055
    return 1;
3056
 
3057
  /* The call and return path execute the same instructions within
3058
     an IMPORT stub!  So an IMPORT stub is both a call and return
3059
     trampoline.  */
3060
  if (u->stub_unwind.stub_type == IMPORT)
3061
    return 1;
3062
 
3063
  /* Parameter relocation stubs always have a call path and may have a
3064
     return path.  */
3065
  if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
3066
      || u->stub_unwind.stub_type == EXPORT)
3067
    {
3068
      CORE_ADDR addr;
3069
 
3070
      /* Search forward from the current PC until we hit a branch
3071
         or the end of the stub.  */
3072
      for (addr = pc; addr <= u->region_end; addr += 4)
3073
        {
3074
          unsigned long insn;
3075
 
3076
          insn = read_memory_integer (addr, 4);
3077
 
3078
          /* Does it look like a bl?  If so then it's the call path, if
3079
             we find a bv or be first, then we're on the return path.  */
3080
          if ((insn & 0xfc00e000) == 0xe8000000)
3081
            return 1;
3082
          else if ((insn & 0xfc00e001) == 0xe800c000
3083
                   || (insn & 0xfc000000) == 0xe0000000)
3084
            return 0;
3085
        }
3086
 
3087
      /* Should never happen.  */
3088
      warning ("Unable to find branch in parameter relocation stub.\n");
3089
      return 0;
3090
    }
3091
 
3092
  /* Unknown stub type.  For now, just return zero.  */
3093
  return 0;
3094
}
3095
 
3096
/* Return one if PC is in the return path of a trampoline, else return zero.
3097
 
3098
   Note we return one for *any* call trampoline (long-call, arg-reloc), not
3099
   just shared library trampolines (import, export).  */
3100
 
3101
int
3102
in_solib_return_trampoline (pc, name)
3103
     CORE_ADDR pc;
3104
     char *name;
3105
{
3106
  struct unwind_table_entry *u;
3107
 
3108
  /* Get the unwind descriptor corresponding to PC, return zero
3109
     if no unwind was found.  */
3110
  u = find_unwind_entry (pc);
3111
  if (!u)
3112
    return 0;
3113
 
3114
  /* If this isn't a linker stub or it's just a long branch stub, then
3115
     return zero.  */
3116
  if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH)
3117
    return 0;
3118
 
3119
  /* The call and return path execute the same instructions within
3120
     an IMPORT stub!  So an IMPORT stub is both a call and return
3121
     trampoline.  */
3122
  if (u->stub_unwind.stub_type == IMPORT)
3123
    return 1;
3124
 
3125
  /* Parameter relocation stubs always have a call path and may have a
3126
     return path.  */
3127
  if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
3128
      || u->stub_unwind.stub_type == EXPORT)
3129
    {
3130
      CORE_ADDR addr;
3131
 
3132
      /* Search forward from the current PC until we hit a branch
3133
         or the end of the stub.  */
3134
      for (addr = pc; addr <= u->region_end; addr += 4)
3135
        {
3136
          unsigned long insn;
3137
 
3138
          insn = read_memory_integer (addr, 4);
3139
 
3140
          /* Does it look like a bl?  If so then it's the call path, if
3141
             we find a bv or be first, then we're on the return path.  */
3142
          if ((insn & 0xfc00e000) == 0xe8000000)
3143
            return 0;
3144
          else if ((insn & 0xfc00e001) == 0xe800c000
3145
                   || (insn & 0xfc000000) == 0xe0000000)
3146
            return 1;
3147
        }
3148
 
3149
      /* Should never happen.  */
3150
      warning ("Unable to find branch in parameter relocation stub.\n");
3151
      return 0;
3152
    }
3153
 
3154
  /* Unknown stub type.  For now, just return zero.  */
3155
  return 0;
3156
 
3157
}
3158
 
3159
/* Figure out if PC is in a trampoline, and if so find out where
3160
   the trampoline will jump to.  If not in a trampoline, return zero.
3161
 
3162
   Simple code examination probably is not a good idea since the code
3163
   sequences in trampolines can also appear in user code.
3164
 
3165
   We use unwinds and information from the minimal symbol table to
3166
   determine when we're in a trampoline.  This won't work for ELF
3167
   (yet) since it doesn't create stub unwind entries.  Whether or
3168
   not ELF will create stub unwinds or normal unwinds for linker
3169
   stubs is still being debated.
3170
 
3171
   This should handle simple calls through dyncall or sr4export,
3172
   long calls, argument relocation stubs, and dyncall/sr4export
3173
   calling an argument relocation stub.  It even handles some stubs
3174
   used in dynamic executables.  */
3175
 
3176
CORE_ADDR
3177
skip_trampoline_code (pc, name)
3178
     CORE_ADDR pc;
3179
     char *name;
3180
{
3181
  long orig_pc = pc;
3182
  long prev_inst, curr_inst, loc;
3183
  static CORE_ADDR dyncall = 0;
3184
  static CORE_ADDR dyncall_external = 0;
3185
  static CORE_ADDR sr4export = 0;
3186
  struct minimal_symbol *msym;
3187
  struct unwind_table_entry *u;
3188
 
3189
  /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3190
     new exec file */
3191
 
3192
  if (!dyncall)
3193
    {
3194
      msym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
3195
      if (msym)
3196
        dyncall = SYMBOL_VALUE_ADDRESS (msym);
3197
      else
3198
        dyncall = -1;
3199
    }
3200
 
3201
  if (!dyncall_external)
3202
    {
3203
      msym = lookup_minimal_symbol ("$$dyncall_external", NULL, NULL);
3204
      if (msym)
3205
        dyncall_external = SYMBOL_VALUE_ADDRESS (msym);
3206
      else
3207
        dyncall_external = -1;
3208
    }
3209
 
3210
  if (!sr4export)
3211
    {
3212
      msym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
3213
      if (msym)
3214
        sr4export = SYMBOL_VALUE_ADDRESS (msym);
3215
      else
3216
        sr4export = -1;
3217
    }
3218
 
3219
  /* Addresses passed to dyncall may *NOT* be the actual address
3220
     of the function.  So we may have to do something special.  */
3221
  if (pc == dyncall)
3222
    {
3223
      pc = (CORE_ADDR) read_register (22);
3224
 
3225
      /* If bit 30 (counting from the left) is on, then pc is the address of
3226
         the PLT entry for this function, not the address of the function
3227
         itself.  Bit 31 has meaning too, but only for MPE.  */
3228
      if (pc & 0x2)
3229
        pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
3230
    }
3231
  if (pc == dyncall_external)
3232
    {
3233
      pc = (CORE_ADDR) read_register (22);
3234
      pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
3235
    }
3236
  else if (pc == sr4export)
3237
    pc = (CORE_ADDR) (read_register (22));
3238
 
3239
  /* Get the unwind descriptor corresponding to PC, return zero
3240
     if no unwind was found.  */
3241
  u = find_unwind_entry (pc);
3242
  if (!u)
3243
    return 0;
3244
 
3245
  /* If this isn't a linker stub, then return now.  */
3246
  /* elz: attention here! (FIXME) because of a compiler/linker
3247
     error, some stubs which should have a non zero stub_unwind.stub_type
3248
     have unfortunately a value of zero. So this function would return here
3249
     as if we were not in a trampoline. To fix this, we go look at the partial
3250
     symbol information, which reports this guy as a stub.
3251
     (FIXME): Unfortunately, we are not that lucky: it turns out that the
3252
     partial symbol information is also wrong sometimes. This is because
3253
     when it is entered (somread.c::som_symtab_read()) it can happen that
3254
     if the type of the symbol (from the som) is Entry, and the symbol is
3255
     in a shared library, then it can also be a trampoline.  This would
3256
     be OK, except that I believe the way they decide if we are ina shared library
3257
     does not work. SOOOO..., even if we have a regular function w/o trampolines
3258
     its minimal symbol can be assigned type mst_solib_trampoline.
3259
     Also, if we find that the symbol is a real stub, then we fix the unwind
3260
     descriptor, and define the stub type to be EXPORT.
3261
     Hopefully this is correct most of the times. */
3262
  if (u->stub_unwind.stub_type == 0)
3263
    {
3264
 
3265
/* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
3266
   we can delete all the code which appears between the lines */
3267
/*--------------------------------------------------------------------------*/
3268
      msym = lookup_minimal_symbol_by_pc (pc);
3269
 
3270
      if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
3271
        return orig_pc == pc ? 0 : pc & ~0x3;
3272
 
3273
      else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
3274
        {
3275
          struct objfile *objfile;
3276
          struct minimal_symbol *msymbol;
3277
          int function_found = 0;
3278
 
3279
          /* go look if there is another minimal symbol with the same name as
3280
             this one, but with type mst_text. This would happen if the msym
3281
             is an actual trampoline, in which case there would be another
3282
             symbol with the same name corresponding to the real function */
3283
 
3284
          ALL_MSYMBOLS (objfile, msymbol)
3285
          {
3286
            if (MSYMBOL_TYPE (msymbol) == mst_text
3287
                && STREQ (SYMBOL_NAME (msymbol), SYMBOL_NAME (msym)))
3288
              {
3289
                function_found = 1;
3290
                break;
3291
              }
3292
          }
3293
 
3294
          if (function_found)
3295
            /* the type of msym is correct (mst_solib_trampoline), but
3296
               the unwind info is wrong, so set it to the correct value */
3297
            u->stub_unwind.stub_type = EXPORT;
3298
          else
3299
            /* the stub type info in the unwind is correct (this is not a
3300
               trampoline), but the msym type information is wrong, it
3301
               should be mst_text. So we need to fix the msym, and also
3302
               get out of this function */
3303
            {
3304
              MSYMBOL_TYPE (msym) = mst_text;
3305
              return orig_pc == pc ? 0 : pc & ~0x3;
3306
            }
3307
        }
3308
 
3309
/*--------------------------------------------------------------------------*/
3310
    }
3311
 
3312
  /* It's a stub.  Search for a branch and figure out where it goes.
3313
     Note we have to handle multi insn branch sequences like ldil;ble.
3314
     Most (all?) other branches can be determined by examining the contents
3315
     of certain registers and the stack.  */
3316
 
3317
  loc = pc;
3318
  curr_inst = 0;
3319
  prev_inst = 0;
3320
  while (1)
3321
    {
3322
      /* Make sure we haven't walked outside the range of this stub.  */
3323
      if (u != find_unwind_entry (loc))
3324
        {
3325
          warning ("Unable to find branch in linker stub");
3326
          return orig_pc == pc ? 0 : pc & ~0x3;
3327
        }
3328
 
3329
      prev_inst = curr_inst;
3330
      curr_inst = read_memory_integer (loc, 4);
3331
 
3332
      /* Does it look like a branch external using %r1?  Then it's the
3333
         branch from the stub to the actual function.  */
3334
      if ((curr_inst & 0xffe0e000) == 0xe0202000)
3335
        {
3336
          /* Yup.  See if the previous instruction loaded
3337
             a value into %r1.  If so compute and return the jump address.  */
3338
          if ((prev_inst & 0xffe00000) == 0x20200000)
3339
            return (extract_21 (prev_inst) + extract_17 (curr_inst)) & ~0x3;
3340
          else
3341
            {
3342
              warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
3343
              return orig_pc == pc ? 0 : pc & ~0x3;
3344
            }
3345
        }
3346
 
3347
      /* Does it look like a be 0(sr0,%r21)? OR
3348
         Does it look like a be, n 0(sr0,%r21)? OR
3349
         Does it look like a bve (r21)? (this is on PA2.0)
3350
         Does it look like a bve, n(r21)? (this is also on PA2.0)
3351
         That's the branch from an
3352
         import stub to an export stub.
3353
 
3354
         It is impossible to determine the target of the branch via
3355
         simple examination of instructions and/or data (consider
3356
         that the address in the plabel may be the address of the
3357
         bind-on-reference routine in the dynamic loader).
3358
 
3359
         So we have try an alternative approach.
3360
 
3361
         Get the name of the symbol at our current location; it should
3362
         be a stub symbol with the same name as the symbol in the
3363
         shared library.
3364
 
3365
         Then lookup a minimal symbol with the same name; we should
3366
         get the minimal symbol for the target routine in the shared
3367
         library as those take precedence of import/export stubs.  */
3368
      if ((curr_inst == 0xe2a00000) ||
3369
          (curr_inst == 0xe2a00002) ||
3370
          (curr_inst == 0xeaa0d000) ||
3371
          (curr_inst == 0xeaa0d002))
3372
        {
3373
          struct minimal_symbol *stubsym, *libsym;
3374
 
3375
          stubsym = lookup_minimal_symbol_by_pc (loc);
3376
          if (stubsym == NULL)
3377
            {
3378
              warning ("Unable to find symbol for 0x%x", loc);
3379
              return orig_pc == pc ? 0 : pc & ~0x3;
3380
            }
3381
 
3382
          libsym = lookup_minimal_symbol (SYMBOL_NAME (stubsym), NULL, NULL);
3383
          if (libsym == NULL)
3384
            {
3385
              warning ("Unable to find library symbol for %s\n",
3386
                       SYMBOL_NAME (stubsym));
3387
              return orig_pc == pc ? 0 : pc & ~0x3;
3388
            }
3389
 
3390
          return SYMBOL_VALUE (libsym);
3391
        }
3392
 
3393
      /* Does it look like bl X,%rp or bl X,%r0?  Another way to do a
3394
         branch from the stub to the actual function.  */
3395
      /*elz */
3396
      else if ((curr_inst & 0xffe0e000) == 0xe8400000
3397
               || (curr_inst & 0xffe0e000) == 0xe8000000
3398
               || (curr_inst & 0xffe0e000) == 0xe800A000)
3399
        return (loc + extract_17 (curr_inst) + 8) & ~0x3;
3400
 
3401
      /* Does it look like bv (rp)?   Note this depends on the
3402
         current stack pointer being the same as the stack
3403
         pointer in the stub itself!  This is a branch on from the
3404
         stub back to the original caller.  */
3405
      /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
3406
      else if ((curr_inst & 0xffe0f000) == 0xe840c000)
3407
        {
3408
          /* Yup.  See if the previous instruction loaded
3409
             rp from sp - 8.  */
3410
          if (prev_inst == 0x4bc23ff1)
3411
            return (read_memory_integer
3412
                    (read_register (SP_REGNUM) - 8, 4)) & ~0x3;
3413
          else
3414
            {
3415
              warning ("Unable to find restore of %%rp before bv (%%rp).");
3416
              return orig_pc == pc ? 0 : pc & ~0x3;
3417
            }
3418
        }
3419
 
3420
      /* elz: added this case to capture the new instruction
3421
         at the end of the return part of an export stub used by
3422
         the PA2.0: BVE, n (rp) */
3423
      else if ((curr_inst & 0xffe0f000) == 0xe840d000)
3424
        {
3425
          return (read_memory_integer
3426
                  (read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
3427
        }
3428
 
3429
      /* What about be,n 0(sr0,%rp)?  It's just another way we return to
3430
         the original caller from the stub.  Used in dynamic executables.  */
3431
      else if (curr_inst == 0xe0400002)
3432
        {
3433
          /* The value we jump to is sitting in sp - 24.  But that's
3434
             loaded several instructions before the be instruction.
3435
             I guess we could check for the previous instruction being
3436
             mtsp %r1,%sr0 if we want to do sanity checking.  */
3437
          return (read_memory_integer
3438
                  (read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
3439
        }
3440
 
3441
      /* Haven't found the branch yet, but we're still in the stub.
3442
         Keep looking.  */
3443
      loc += 4;
3444
    }
3445
}
3446
 
3447
 
3448
/* For the given instruction (INST), return any adjustment it makes
3449
   to the stack pointer or zero for no adjustment.
3450
 
3451
   This only handles instructions commonly found in prologues.  */
3452
 
3453
static int
3454
prologue_inst_adjust_sp (inst)
3455
     unsigned long inst;
3456
{
3457
  /* This must persist across calls.  */
3458
  static int save_high21;
3459
 
3460
  /* The most common way to perform a stack adjustment ldo X(sp),sp */
3461
  if ((inst & 0xffffc000) == 0x37de0000)
3462
    return extract_14 (inst);
3463
 
3464
  /* stwm X,D(sp) */
3465
  if ((inst & 0xffe00000) == 0x6fc00000)
3466
    return extract_14 (inst);
3467
 
3468
  /* std,ma X,D(sp) */
3469
  if ((inst & 0xffe00008) == 0x73c00008)
3470
    return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
3471
 
3472
  /* addil high21,%r1; ldo low11,(%r1),%r30)
3473
     save high bits in save_high21 for later use.  */
3474
  if ((inst & 0xffe00000) == 0x28200000)
3475
    {
3476
      save_high21 = extract_21 (inst);
3477
      return 0;
3478
    }
3479
 
3480
  if ((inst & 0xffff0000) == 0x343e0000)
3481
    return save_high21 + extract_14 (inst);
3482
 
3483
  /* fstws as used by the HP compilers.  */
3484
  if ((inst & 0xffffffe0) == 0x2fd01220)
3485
    return extract_5_load (inst);
3486
 
3487
  /* No adjustment.  */
3488
  return 0;
3489
}
3490
 
3491
/* Return nonzero if INST is a branch of some kind, else return zero.  */
3492
 
3493
static int
3494
is_branch (inst)
3495
     unsigned long inst;
3496
{
3497
  switch (inst >> 26)
3498
    {
3499
    case 0x20:
3500
    case 0x21:
3501
    case 0x22:
3502
    case 0x23:
3503
    case 0x27:
3504
    case 0x28:
3505
    case 0x29:
3506
    case 0x2a:
3507
    case 0x2b:
3508
    case 0x2f:
3509
    case 0x30:
3510
    case 0x31:
3511
    case 0x32:
3512
    case 0x33:
3513
    case 0x38:
3514
    case 0x39:
3515
    case 0x3a:
3516
    case 0x3b:
3517
      return 1;
3518
 
3519
    default:
3520
      return 0;
3521
    }
3522
}
3523
 
3524
/* Return the register number for a GR which is saved by INST or
3525
   zero it INST does not save a GR.  */
3526
 
3527
static int
3528
inst_saves_gr (inst)
3529
     unsigned long inst;
3530
{
3531
  /* Does it look like a stw?  */
3532
  if ((inst >> 26) == 0x1a || (inst >> 26) == 0x1b
3533
      || (inst >> 26) == 0x1f
3534
      || ((inst >> 26) == 0x1f
3535
          && ((inst >> 6) == 0xa)))
3536
    return extract_5R_store (inst);
3537
 
3538
  /* Does it look like a std?  */
3539
  if ((inst >> 26) == 0x1c
3540
      || ((inst >> 26) == 0x03
3541
          && ((inst >> 6) & 0xf) == 0xb))
3542
    return extract_5R_store (inst);
3543
 
3544
  /* Does it look like a stwm?  GCC & HPC may use this in prologues. */
3545
  if ((inst >> 26) == 0x1b)
3546
    return extract_5R_store (inst);
3547
 
3548
  /* Does it look like sth or stb?  HPC versions 9.0 and later use these
3549
     too.  */
3550
  if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18
3551
      || ((inst >> 26) == 0x3
3552
          && (((inst >> 6) & 0xf) == 0x8
3553
              || (inst >> 6) & 0xf) == 0x9))
3554
    return extract_5R_store (inst);
3555
 
3556
  return 0;
3557
}
3558
 
3559
/* Return the register number for a FR which is saved by INST or
3560
   zero it INST does not save a FR.
3561
 
3562
   Note we only care about full 64bit register stores (that's the only
3563
   kind of stores the prologue will use).
3564
 
3565
   FIXME: What about argument stores with the HP compiler in ANSI mode? */
3566
 
3567
static int
3568
inst_saves_fr (inst)
3569
     unsigned long inst;
3570
{
3571
  /* is this an FSTD ? */
3572
  if ((inst & 0xfc00dfc0) == 0x2c001200)
3573
    return extract_5r_store (inst);
3574
  if ((inst & 0xfc000002) == 0x70000002)
3575
    return extract_5R_store (inst);
3576
  /* is this an FSTW ? */
3577
  if ((inst & 0xfc00df80) == 0x24001200)
3578
    return extract_5r_store (inst);
3579
  if ((inst & 0xfc000002) == 0x7c000000)
3580
    return extract_5R_store (inst);
3581
  return 0;
3582
}
3583
 
3584
/* Advance PC across any function entry prologue instructions
3585
   to reach some "real" code.
3586
 
3587
   Use information in the unwind table to determine what exactly should
3588
   be in the prologue.  */
3589
 
3590
 
3591
CORE_ADDR
3592
skip_prologue_hard_way (pc)
3593
     CORE_ADDR pc;
3594
{
3595
  char buf[4];
3596
  CORE_ADDR orig_pc = pc;
3597
  unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
3598
  unsigned long args_stored, status, i, restart_gr, restart_fr;
3599
  struct unwind_table_entry *u;
3600
 
3601
  restart_gr = 0;
3602
  restart_fr = 0;
3603
 
3604
restart:
3605
  u = find_unwind_entry (pc);
3606
  if (!u)
3607
    return pc;
3608
 
3609
  /* If we are not at the beginning of a function, then return now. */
3610
  if ((pc & ~0x3) != u->region_start)
3611
    return pc;
3612
 
3613
  /* This is how much of a frame adjustment we need to account for.  */
3614
  stack_remaining = u->Total_frame_size << 3;
3615
 
3616
  /* Magic register saves we want to know about.  */
3617
  save_rp = u->Save_RP;
3618
  save_sp = u->Save_SP;
3619
 
3620
  /* An indication that args may be stored into the stack.  Unfortunately
3621
     the HPUX compilers tend to set this in cases where no args were
3622
     stored too!.  */
3623
  args_stored = 1;
3624
 
3625
  /* Turn the Entry_GR field into a bitmask.  */
3626
  save_gr = 0;
3627
  for (i = 3; i < u->Entry_GR + 3; i++)
3628
    {
3629
      /* Frame pointer gets saved into a special location.  */
3630
      if (u->Save_SP && i == FP_REGNUM)
3631
        continue;
3632
 
3633
      save_gr |= (1 << i);
3634
    }
3635
  save_gr &= ~restart_gr;
3636
 
3637
  /* Turn the Entry_FR field into a bitmask too.  */
3638
  save_fr = 0;
3639
  for (i = 12; i < u->Entry_FR + 12; i++)
3640
    save_fr |= (1 << i);
3641
  save_fr &= ~restart_fr;
3642
 
3643
  /* Loop until we find everything of interest or hit a branch.
3644
 
3645
     For unoptimized GCC code and for any HP CC code this will never ever
3646
     examine any user instructions.
3647
 
3648
     For optimzied GCC code we're faced with problems.  GCC will schedule
3649
     its prologue and make prologue instructions available for delay slot
3650
     filling.  The end result is user code gets mixed in with the prologue
3651
     and a prologue instruction may be in the delay slot of the first branch
3652
     or call.
3653
 
3654
     Some unexpected things are expected with debugging optimized code, so
3655
     we allow this routine to walk past user instructions in optimized
3656
     GCC code.  */
3657
  while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
3658
         || args_stored)
3659
    {
3660
      unsigned int reg_num;
3661
      unsigned long old_stack_remaining, old_save_gr, old_save_fr;
3662
      unsigned long old_save_rp, old_save_sp, next_inst;
3663
 
3664
      /* Save copies of all the triggers so we can compare them later
3665
         (only for HPC).  */
3666
      old_save_gr = save_gr;
3667
      old_save_fr = save_fr;
3668
      old_save_rp = save_rp;
3669
      old_save_sp = save_sp;
3670
      old_stack_remaining = stack_remaining;
3671
 
3672
      status = target_read_memory (pc, buf, 4);
3673
      inst = extract_unsigned_integer (buf, 4);
3674
 
3675
      /* Yow! */
3676
      if (status != 0)
3677
        return pc;
3678
 
3679
      /* Note the interesting effects of this instruction.  */
3680
      stack_remaining -= prologue_inst_adjust_sp (inst);
3681
 
3682
      /* There are limited ways to store the return pointer into the
3683
         stack.  */
3684
      if (inst == 0x6bc23fd9 || inst == 0x0fc212c1)
3685
        save_rp = 0;
3686
 
3687
      /* These are the only ways we save SP into the stack.  At this time
3688
         the HP compilers never bother to save SP into the stack.  */
3689
      if ((inst & 0xffffc000) == 0x6fc10000
3690
          || (inst & 0xffffc00c) == 0x73c10008)
3691
        save_sp = 0;
3692
 
3693
      /* Are we loading some register with an offset from the argument
3694
         pointer?  */
3695
      if ((inst & 0xffe00000) == 0x37a00000
3696
          || (inst & 0xffffffe0) == 0x081d0240)
3697
        {
3698
          pc += 4;
3699
          continue;
3700
        }
3701
 
3702
      /* Account for general and floating-point register saves.  */
3703
      reg_num = inst_saves_gr (inst);
3704
      save_gr &= ~(1 << reg_num);
3705
 
3706
      /* Ugh.  Also account for argument stores into the stack.
3707
         Unfortunately args_stored only tells us that some arguments
3708
         where stored into the stack.  Not how many or what kind!
3709
 
3710
         This is a kludge as on the HP compiler sets this bit and it
3711
         never does prologue scheduling.  So once we see one, skip past
3712
         all of them.   We have similar code for the fp arg stores below.
3713
 
3714
         FIXME.  Can still die if we have a mix of GR and FR argument
3715
         stores!  */
3716
      if (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
3717
        {
3718
          while (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
3719
            {
3720
              pc += 4;
3721
              status = target_read_memory (pc, buf, 4);
3722
              inst = extract_unsigned_integer (buf, 4);
3723
              if (status != 0)
3724
                return pc;
3725
              reg_num = inst_saves_gr (inst);
3726
            }
3727
          args_stored = 0;
3728
          continue;
3729
        }
3730
 
3731
      reg_num = inst_saves_fr (inst);
3732
      save_fr &= ~(1 << reg_num);
3733
 
3734
      status = target_read_memory (pc + 4, buf, 4);
3735
      next_inst = extract_unsigned_integer (buf, 4);
3736
 
3737
      /* Yow! */
3738
      if (status != 0)
3739
        return pc;
3740
 
3741
      /* We've got to be read to handle the ldo before the fp register
3742
         save.  */
3743
      if ((inst & 0xfc000000) == 0x34000000
3744
          && inst_saves_fr (next_inst) >= 4
3745
          && inst_saves_fr (next_inst) <= (TARGET_PTR_BIT == 64 ? 11 : 7))
3746
        {
3747
          /* So we drop into the code below in a reasonable state.  */
3748
          reg_num = inst_saves_fr (next_inst);
3749
          pc -= 4;
3750
        }
3751
 
3752
      /* Ugh.  Also account for argument stores into the stack.
3753
         This is a kludge as on the HP compiler sets this bit and it
3754
         never does prologue scheduling.  So once we see one, skip past
3755
         all of them.  */
3756
      if (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
3757
        {
3758
          while (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
3759
            {
3760
              pc += 8;
3761
              status = target_read_memory (pc, buf, 4);
3762
              inst = extract_unsigned_integer (buf, 4);
3763
              if (status != 0)
3764
                return pc;
3765
              if ((inst & 0xfc000000) != 0x34000000)
3766
                break;
3767
              status = target_read_memory (pc + 4, buf, 4);
3768
              next_inst = extract_unsigned_integer (buf, 4);
3769
              if (status != 0)
3770
                return pc;
3771
              reg_num = inst_saves_fr (next_inst);
3772
            }
3773
          args_stored = 0;
3774
          continue;
3775
        }
3776
 
3777
      /* Quit if we hit any kind of branch.  This can happen if a prologue
3778
         instruction is in the delay slot of the first call/branch.  */
3779
      if (is_branch (inst))
3780
        break;
3781
 
3782
      /* What a crock.  The HP compilers set args_stored even if no
3783
         arguments were stored into the stack (boo hiss).  This could
3784
         cause this code to then skip a bunch of user insns (up to the
3785
         first branch).
3786
 
3787
         To combat this we try to identify when args_stored was bogusly
3788
         set and clear it.   We only do this when args_stored is nonzero,
3789
         all other resources are accounted for, and nothing changed on
3790
         this pass.  */
3791
      if (args_stored
3792
       && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
3793
          && old_save_gr == save_gr && old_save_fr == save_fr
3794
          && old_save_rp == save_rp && old_save_sp == save_sp
3795
          && old_stack_remaining == stack_remaining)
3796
        break;
3797
 
3798
      /* Bump the PC.  */
3799
      pc += 4;
3800
    }
3801
 
3802
  /* We've got a tenative location for the end of the prologue.  However
3803
     because of limitations in the unwind descriptor mechanism we may
3804
     have went too far into user code looking for the save of a register
3805
     that does not exist.  So, if there registers we expected to be saved
3806
     but never were, mask them out and restart.
3807
 
3808
     This should only happen in optimized code, and should be very rare.  */
3809
  if (save_gr || (save_fr && !(restart_fr || restart_gr)))
3810
    {
3811
      pc = orig_pc;
3812
      restart_gr = save_gr;
3813
      restart_fr = save_fr;
3814
      goto restart;
3815
    }
3816
 
3817
  return pc;
3818
}
3819
 
3820
 
3821
/* Return the address of the PC after the last prologue instruction if
3822
   we can determine it from the debug symbols.  Else return zero.  */
3823
 
3824
static CORE_ADDR
3825
after_prologue (pc)
3826
     CORE_ADDR pc;
3827
{
3828
  struct symtab_and_line sal;
3829
  CORE_ADDR func_addr, func_end;
3830
  struct symbol *f;
3831
 
3832
  /* If we can not find the symbol in the partial symbol table, then
3833
     there is no hope we can determine the function's start address
3834
     with this code.  */
3835
  if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
3836
    return 0;
3837
 
3838
  /* Get the line associated with FUNC_ADDR.  */
3839
  sal = find_pc_line (func_addr, 0);
3840
 
3841
  /* There are only two cases to consider.  First, the end of the source line
3842
     is within the function bounds.  In that case we return the end of the
3843
     source line.  Second is the end of the source line extends beyond the
3844
     bounds of the current function.  We need to use the slow code to
3845
     examine instructions in that case.
3846
 
3847
     Anything else is simply a bug elsewhere.  Fixing it here is absolutely
3848
     the wrong thing to do.  In fact, it should be entirely possible for this
3849
     function to always return zero since the slow instruction scanning code
3850
     is supposed to *always* work.  If it does not, then it is a bug.  */
3851
  if (sal.end < func_end)
3852
    return sal.end;
3853
  else
3854
    return 0;
3855
}
3856
 
3857
/* To skip prologues, I use this predicate.  Returns either PC itself
3858
   if the code at PC does not look like a function prologue; otherwise
3859
   returns an address that (if we're lucky) follows the prologue.  If
3860
   LENIENT, then we must skip everything which is involved in setting
3861
   up the frame (it's OK to skip more, just so long as we don't skip
3862
   anything which might clobber the registers which are being saved.
3863
   Currently we must not skip more on the alpha, but we might the lenient
3864
   stuff some day.  */
3865
 
3866
CORE_ADDR
3867
hppa_skip_prologue (pc)
3868
     CORE_ADDR pc;
3869
{
3870
  unsigned long inst;
3871
  int offset;
3872
  CORE_ADDR post_prologue_pc;
3873
  char buf[4];
3874
 
3875
  /* See if we can determine the end of the prologue via the symbol table.
3876
     If so, then return either PC, or the PC after the prologue, whichever
3877
     is greater.  */
3878
 
3879
  post_prologue_pc = after_prologue (pc);
3880
 
3881
  /* If after_prologue returned a useful address, then use it.  Else
3882
     fall back on the instruction skipping code.
3883
 
3884
     Some folks have claimed this causes problems because the breakpoint
3885
     may be the first instruction of the prologue.  If that happens, then
3886
     the instruction skipping code has a bug that needs to be fixed.  */
3887
  if (post_prologue_pc != 0)
3888
    return max (pc, post_prologue_pc);
3889
  else
3890
    return (skip_prologue_hard_way (pc));
3891
}
3892
 
3893
/* Put here the code to store, into a struct frame_saved_regs,
3894
   the addresses of the saved registers of frame described by FRAME_INFO.
3895
   This includes special registers such as pc and fp saved in special
3896
   ways in the stack frame.  sp is even more special:
3897
   the address we return for it IS the sp for the next frame.  */
3898
 
3899
void
3900
hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
3901
     struct frame_info *frame_info;
3902
     struct frame_saved_regs *frame_saved_regs;
3903
{
3904
  CORE_ADDR pc;
3905
  struct unwind_table_entry *u;
3906
  unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
3907
  int status, i, reg;
3908
  char buf[4];
3909
  int fp_loc = -1;
3910
  int final_iteration;
3911
 
3912
  /* Zero out everything.  */
3913
  memset (frame_saved_regs, '\0', sizeof (struct frame_saved_regs));
3914
 
3915
  /* Call dummy frames always look the same, so there's no need to
3916
     examine the dummy code to determine locations of saved registers;
3917
     instead, let find_dummy_frame_regs fill in the correct offsets
3918
     for the saved registers.  */
3919
  if ((frame_info->pc >= frame_info->frame
3920
       && frame_info->pc <= (frame_info->frame
3921
                             /* A call dummy is sized in words, but it is
3922
                                actually a series of instructions.  Account
3923
                                for that scaling factor.  */
3924
                             + ((REGISTER_SIZE / INSTRUCTION_SIZE)
3925
                                * CALL_DUMMY_LENGTH)
3926
                             /* Similarly we have to account for 64bit
3927
                                wide register saves.  */
3928
                             + (32 * REGISTER_SIZE)
3929
                             /* We always consider FP regs 8 bytes long.  */
3930
                             + (NUM_REGS - FP0_REGNUM) * 8
3931
                             /* Similarly we have to account for 64bit
3932
                                wide register saves.  */
3933
                             + (6 * REGISTER_SIZE))))
3934
    find_dummy_frame_regs (frame_info, frame_saved_regs);
3935
 
3936
  /* Interrupt handlers are special too.  They lay out the register
3937
     state in the exact same order as the register numbers in GDB.  */
3938
  if (pc_in_interrupt_handler (frame_info->pc))
3939
    {
3940
      for (i = 0; i < NUM_REGS; i++)
3941
        {
3942
          /* SP is a little special.  */
3943
          if (i == SP_REGNUM)
3944
            frame_saved_regs->regs[SP_REGNUM]
3945
              = read_memory_integer (frame_info->frame + SP_REGNUM * 4,
3946
                                     TARGET_PTR_BIT / 8);
3947
          else
3948
            frame_saved_regs->regs[i] = frame_info->frame + i * 4;
3949
        }
3950
      return;
3951
    }
3952
 
3953
#ifdef FRAME_FIND_SAVED_REGS_IN_SIGTRAMP
3954
  /* Handle signal handler callers.  */
3955
  if (frame_info->signal_handler_caller)
3956
    {
3957
      FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info, frame_saved_regs);
3958
      return;
3959
    }
3960
#endif
3961
 
3962
  /* Get the starting address of the function referred to by the PC
3963
     saved in frame.  */
3964
  pc = get_pc_function_start (frame_info->pc);
3965
 
3966
  /* Yow! */
3967
  u = find_unwind_entry (pc);
3968
  if (!u)
3969
    return;
3970
 
3971
  /* This is how much of a frame adjustment we need to account for.  */
3972
  stack_remaining = u->Total_frame_size << 3;
3973
 
3974
  /* Magic register saves we want to know about.  */
3975
  save_rp = u->Save_RP;
3976
  save_sp = u->Save_SP;
3977
 
3978
  /* Turn the Entry_GR field into a bitmask.  */
3979
  save_gr = 0;
3980
  for (i = 3; i < u->Entry_GR + 3; i++)
3981
    {
3982
      /* Frame pointer gets saved into a special location.  */
3983
      if (u->Save_SP && i == FP_REGNUM)
3984
        continue;
3985
 
3986
      save_gr |= (1 << i);
3987
    }
3988
 
3989
  /* Turn the Entry_FR field into a bitmask too.  */
3990
  save_fr = 0;
3991
  for (i = 12; i < u->Entry_FR + 12; i++)
3992
    save_fr |= (1 << i);
3993
 
3994
  /* The frame always represents the value of %sp at entry to the
3995
     current function (and is thus equivalent to the "saved" stack
3996
     pointer.  */
3997
  frame_saved_regs->regs[SP_REGNUM] = frame_info->frame;
3998
 
3999
  /* Loop until we find everything of interest or hit a branch.
4000
 
4001
     For unoptimized GCC code and for any HP CC code this will never ever
4002
     examine any user instructions.
4003
 
4004
     For optimized GCC code we're faced with problems.  GCC will schedule
4005
     its prologue and make prologue instructions available for delay slot
4006
     filling.  The end result is user code gets mixed in with the prologue
4007
     and a prologue instruction may be in the delay slot of the first branch
4008
     or call.
4009
 
4010
     Some unexpected things are expected with debugging optimized code, so
4011
     we allow this routine to walk past user instructions in optimized
4012
     GCC code.  */
4013
  final_iteration = 0;
4014
  while ((save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
4015
         && pc <= frame_info->pc)
4016
    {
4017
      status = target_read_memory (pc, buf, 4);
4018
      inst = extract_unsigned_integer (buf, 4);
4019
 
4020
      /* Yow! */
4021
      if (status != 0)
4022
        return;
4023
 
4024
      /* Note the interesting effects of this instruction.  */
4025
      stack_remaining -= prologue_inst_adjust_sp (inst);
4026
 
4027
      /* There are limited ways to store the return pointer into the
4028
         stack.  */
4029
      if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
4030
        {
4031
          save_rp = 0;
4032
          frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 20;
4033
        }
4034
      else if (inst == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
4035
        {
4036
          save_rp = 0;
4037
          frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 16;
4038
        }
4039
 
4040
      /* Note if we saved SP into the stack.  This also happens to indicate
4041
         the location of the saved frame pointer.  */
4042
      if (   (inst & 0xffffc000) == 0x6fc10000  /* stw,ma r1,N(sr0,sp) */
4043
          || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
4044
        {
4045
          frame_saved_regs->regs[FP_REGNUM] = frame_info->frame;
4046
          save_sp = 0;
4047
        }
4048
 
4049
      /* Account for general and floating-point register saves.  */
4050
      reg = inst_saves_gr (inst);
4051
      if (reg >= 3 && reg <= 18
4052
          && (!u->Save_SP || reg != FP_REGNUM))
4053
        {
4054
          save_gr &= ~(1 << reg);
4055
 
4056
          /* stwm with a positive displacement is a *post modify*.  */
4057
          if ((inst >> 26) == 0x1b
4058
              && extract_14 (inst) >= 0)
4059
            frame_saved_regs->regs[reg] = frame_info->frame;
4060
          /* A std has explicit post_modify forms.  */
4061
          else if ((inst & 0xfc00000c0) == 0x70000008)
4062
            frame_saved_regs->regs[reg] = frame_info->frame;
4063
          else
4064
            {
4065
              CORE_ADDR offset;
4066
 
4067
              if ((inst >> 26) == 0x1c)
4068
                offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
4069
              else if ((inst >> 26) == 0x03)
4070
                offset = low_sign_extend (inst & 0x1f, 5);
4071
              else
4072
                offset = extract_14 (inst);
4073
 
4074
              /* Handle code with and without frame pointers.  */
4075
              if (u->Save_SP)
4076
                frame_saved_regs->regs[reg]
4077
                  = frame_info->frame + offset;
4078
              else
4079
                frame_saved_regs->regs[reg]
4080
                  = (frame_info->frame + (u->Total_frame_size << 3)
4081
                     + offset);
4082
            }
4083
        }
4084
 
4085
 
4086
      /* GCC handles callee saved FP regs a little differently.
4087
 
4088
         It emits an instruction to put the value of the start of
4089
         the FP store area into %r1.  It then uses fstds,ma with
4090
         a basereg of %r1 for the stores.
4091
 
4092
         HP CC emits them at the current stack pointer modifying
4093
         the stack pointer as it stores each register.  */
4094
 
4095
      /* ldo X(%r3),%r1 or ldo X(%r30),%r1.  */
4096
      if ((inst & 0xffffc000) == 0x34610000
4097
          || (inst & 0xffffc000) == 0x37c10000)
4098
        fp_loc = extract_14 (inst);
4099
 
4100
      reg = inst_saves_fr (inst);
4101
      if (reg >= 12 && reg <= 21)
4102
        {
4103
          /* Note +4 braindamage below is necessary because the FP status
4104
             registers are internally 8 registers rather than the expected
4105
             4 registers.  */
4106
          save_fr &= ~(1 << reg);
4107
          if (fp_loc == -1)
4108
            {
4109
              /* 1st HP CC FP register store.  After this instruction
4110
                 we've set enough state that the GCC and HPCC code are
4111
                 both handled in the same manner.  */
4112
              frame_saved_regs->regs[reg + FP4_REGNUM + 4] = frame_info->frame;
4113
              fp_loc = 8;
4114
            }
4115
          else
4116
            {
4117
              frame_saved_regs->regs[reg + FP0_REGNUM + 4]
4118
                = frame_info->frame + fp_loc;
4119
              fp_loc += 8;
4120
            }
4121
        }
4122
 
4123
      /* Quit if we hit any kind of branch the previous iteration.
4124
      if (final_iteration)
4125
        break;
4126
 
4127
      /* We want to look precisely one instruction beyond the branch
4128
         if we have not found everything yet.  */
4129
      if (is_branch (inst))
4130
        final_iteration = 1;
4131
 
4132
      /* Bump the PC.  */
4133
      pc += 4;
4134
    }
4135
}
4136
 
4137
 
4138
/* Exception handling support for the HP-UX ANSI C++ compiler.
4139
   The compiler (aCC) provides a callback for exception events;
4140
   GDB can set a breakpoint on this callback and find out what
4141
   exception event has occurred. */
4142
 
4143
/* The name of the hook to be set to point to the callback function */
4144
static char HP_ACC_EH_notify_hook[] = "__eh_notify_hook";
4145
/* The name of the function to be used to set the hook value */
4146
static char HP_ACC_EH_set_hook_value[] = "__eh_set_hook_value";
4147
/* The name of the callback function in end.o */
4148
static char HP_ACC_EH_notify_callback[] = "__d_eh_notify_callback";
4149
/* Name of function in end.o on which a break is set (called by above) */
4150
static char HP_ACC_EH_break[] = "__d_eh_break";
4151
/* Name of flag (in end.o) that enables catching throws */
4152
static char HP_ACC_EH_catch_throw[] = "__d_eh_catch_throw";
4153
/* Name of flag (in end.o) that enables catching catching */
4154
static char HP_ACC_EH_catch_catch[] = "__d_eh_catch_catch";
4155
/* The enum used by aCC */
4156
typedef enum
4157
  {
4158
    __EH_NOTIFY_THROW,
4159
    __EH_NOTIFY_CATCH
4160
  }
4161
__eh_notification;
4162
 
4163
/* Is exception-handling support available with this executable? */
4164
static int hp_cxx_exception_support = 0;
4165
/* Has the initialize function been run? */
4166
int hp_cxx_exception_support_initialized = 0;
4167
/* Similar to above, but imported from breakpoint.c -- non-target-specific */
4168
extern int exception_support_initialized;
4169
/* Address of __eh_notify_hook */
4170
static CORE_ADDR eh_notify_hook_addr = 0;
4171
/* Address of __d_eh_notify_callback */
4172
static CORE_ADDR eh_notify_callback_addr = 0;
4173
/* Address of __d_eh_break */
4174
static CORE_ADDR eh_break_addr = 0;
4175
/* Address of __d_eh_catch_catch */
4176
static CORE_ADDR eh_catch_catch_addr = 0;
4177
/* Address of __d_eh_catch_throw */
4178
static CORE_ADDR eh_catch_throw_addr = 0;
4179
/* Sal for __d_eh_break */
4180
static struct symtab_and_line *break_callback_sal = 0;
4181
 
4182
/* Code in end.c expects __d_pid to be set in the inferior,
4183
   otherwise __d_eh_notify_callback doesn't bother to call
4184
   __d_eh_break!  So we poke the pid into this symbol
4185
   ourselves.
4186
 
4187
   1 => failure  */
4188
int
4189
setup_d_pid_in_inferior ()
4190
{
4191
  CORE_ADDR anaddr;
4192
  struct minimal_symbol *msymbol;
4193
  char buf[4];                  /* FIXME 32x64? */
4194
 
4195
  /* Slam the pid of the process into __d_pid; failing is only a warning!  */
4196
  msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
4197
  if (msymbol == NULL)
4198
    {
4199
      warning ("Unable to find __d_pid symbol in object file.");
4200
      warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4201
      return 1;
4202
    }
4203
 
4204
  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
4205
  store_unsigned_integer (buf, 4, inferior_pid);        /* FIXME 32x64? */
4206
  if (target_write_memory (anaddr, buf, 4))     /* FIXME 32x64? */
4207
    {
4208
      warning ("Unable to write __d_pid");
4209
      warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4210
      return 1;
4211
    }
4212
  return 0;
4213
}
4214
 
4215
/* Initialize exception catchpoint support by looking for the
4216
   necessary hooks/callbacks in end.o, etc., and set the hook value to
4217
   point to the required debug function
4218
 
4219
   Return 0 => failure
4220
   1 => success          */
4221
 
4222
static int
4223
initialize_hp_cxx_exception_support ()
4224
{
4225
  struct symtabs_and_lines sals;
4226
  struct cleanup *old_chain;
4227
  struct cleanup *canonical_strings_chain = NULL;
4228
  int i;
4229
  char *addr_start;
4230
  char *addr_end = NULL;
4231
  char **canonical = (char **) NULL;
4232
  int thread = -1;
4233
  struct symbol *sym = NULL;
4234
  struct minimal_symbol *msym = NULL;
4235
  struct objfile *objfile;
4236
  asection *shlib_info;
4237
 
4238
  /* Detect and disallow recursion.  On HP-UX with aCC, infinite
4239
     recursion is a possibility because finding the hook for exception
4240
     callbacks involves making a call in the inferior, which means
4241
     re-inserting breakpoints which can re-invoke this code */
4242
 
4243
  static int recurse = 0;
4244
  if (recurse > 0)
4245
    {
4246
      hp_cxx_exception_support_initialized = 0;
4247
      exception_support_initialized = 0;
4248
      return 0;
4249
    }
4250
 
4251
  hp_cxx_exception_support = 0;
4252
 
4253
  /* First check if we have seen any HP compiled objects; if not,
4254
     it is very unlikely that HP's idiosyncratic callback mechanism
4255
     for exception handling debug support will be available!
4256
     This will percolate back up to breakpoint.c, where our callers
4257
     will decide to try the g++ exception-handling support instead. */
4258
  if (!hp_som_som_object_present)
4259
    return 0;
4260
 
4261
  /* We have a SOM executable with SOM debug info; find the hooks */
4262
 
4263
  /* First look for the notify hook provided by aCC runtime libs */
4264
  /* If we find this symbol, we conclude that the executable must
4265
     have HP aCC exception support built in.  If this symbol is not
4266
     found, even though we're a HP SOM-SOM file, we may have been
4267
     built with some other compiler (not aCC).  This results percolates
4268
     back up to our callers in breakpoint.c which can decide to
4269
     try the g++ style of exception support instead.
4270
     If this symbol is found but the other symbols we require are
4271
     not found, there is something weird going on, and g++ support
4272
     should *not* be tried as an alternative.
4273
 
4274
     ASSUMPTION: Only HP aCC code will have __eh_notify_hook defined.
4275
     ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
4276
 
4277
  /* libCsup has this hook; it'll usually be non-debuggable */
4278
  msym = lookup_minimal_symbol (HP_ACC_EH_notify_hook, NULL, NULL);
4279
  if (msym)
4280
    {
4281
      eh_notify_hook_addr = SYMBOL_VALUE_ADDRESS (msym);
4282
      hp_cxx_exception_support = 1;
4283
    }
4284
  else
4285
    {
4286
      warning ("Unable to find exception callback hook (%s).", HP_ACC_EH_notify_hook);
4287
      warning ("Executable may not have been compiled debuggable with HP aCC.");
4288
      warning ("GDB will be unable to intercept exception events.");
4289
      eh_notify_hook_addr = 0;
4290
      hp_cxx_exception_support = 0;
4291
      return 0;
4292
    }
4293
 
4294
  /* Next look for the notify callback routine in end.o */
4295
  /* This is always available in the SOM symbol dictionary if end.o is linked in */
4296
  msym = lookup_minimal_symbol (HP_ACC_EH_notify_callback, NULL, NULL);
4297
  if (msym)
4298
    {
4299
      eh_notify_callback_addr = SYMBOL_VALUE_ADDRESS (msym);
4300
      hp_cxx_exception_support = 1;
4301
    }
4302
  else
4303
    {
4304
      warning ("Unable to find exception callback routine (%s).", HP_ACC_EH_notify_callback);
4305
      warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4306
      warning ("GDB will be unable to intercept exception events.");
4307
      eh_notify_callback_addr = 0;
4308
      return 0;
4309
    }
4310
 
4311
#ifndef GDB_TARGET_IS_HPPA_20W
4312
  /* Check whether the executable is dynamically linked or archive bound */
4313
  /* With an archive-bound executable we can use the raw addresses we find
4314
     for the callback function, etc. without modification. For an executable
4315
     with shared libraries, we have to do more work to find the plabel, which
4316
     can be the target of a call through $$dyncall from the aCC runtime support
4317
     library (libCsup) which is linked shared by default by aCC. */
4318
  /* This test below was copied from somsolib.c/somread.c.  It may not be a very
4319
     reliable one to test that an executable is linked shared. pai/1997-07-18 */
4320
  shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
4321
  if (shlib_info && (bfd_section_size (symfile_objfile->obfd, shlib_info) != 0))
4322
    {
4323
      /* The minsym we have has the local code address, but that's not the
4324
         plabel that can be used by an inter-load-module call. */
4325
      /* Find solib handle for main image (which has end.o), and use that
4326
         and the min sym as arguments to __d_shl_get() (which does the equivalent
4327
         of shl_findsym()) to find the plabel. */
4328
 
4329
      args_for_find_stub args;
4330
      static char message[] = "Error while finding exception callback hook:\n";
4331
 
4332
      args.solib_handle = som_solib_get_solib_by_pc (eh_notify_callback_addr);
4333
      args.msym = msym;
4334
      args.return_val = 0;
4335
 
4336
      recurse++;
4337
      catch_errors (cover_find_stub_with_shl_get, (PTR) &args, message,
4338
                    RETURN_MASK_ALL);
4339
      eh_notify_callback_addr = args.return_val;
4340
      recurse--;
4341
 
4342
      exception_catchpoints_are_fragile = 1;
4343
 
4344
      if (!eh_notify_callback_addr)
4345
        {
4346
          /* We can get here either if there is no plabel in the export list
4347
             for the main image, or if something strange happened (??) */
4348
          warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
4349
          warning ("GDB will not be able to intercept exception events.");
4350
          return 0;
4351
        }
4352
    }
4353
  else
4354
    exception_catchpoints_are_fragile = 0;
4355
#endif
4356
 
4357
  /* Now, look for the breakpointable routine in end.o */
4358
  /* This should also be available in the SOM symbol dict. if end.o linked in */
4359
  msym = lookup_minimal_symbol (HP_ACC_EH_break, NULL, NULL);
4360
  if (msym)
4361
    {
4362
      eh_break_addr = SYMBOL_VALUE_ADDRESS (msym);
4363
      hp_cxx_exception_support = 1;
4364
    }
4365
  else
4366
    {
4367
      warning ("Unable to find exception callback routine to set breakpoint (%s).", HP_ACC_EH_break);
4368
      warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4369
      warning ("GDB will be unable to intercept exception events.");
4370
      eh_break_addr = 0;
4371
      return 0;
4372
    }
4373
 
4374
  /* Next look for the catch enable flag provided in end.o */
4375
  sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
4376
                       VAR_NAMESPACE, 0, (struct symtab **) NULL);
4377
  if (sym)                      /* sometimes present in debug info */
4378
    {
4379
      eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (sym);
4380
      hp_cxx_exception_support = 1;
4381
    }
4382
  else
4383
    /* otherwise look in SOM symbol dict. */
4384
    {
4385
      msym = lookup_minimal_symbol (HP_ACC_EH_catch_catch, NULL, NULL);
4386
      if (msym)
4387
        {
4388
          eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (msym);
4389
          hp_cxx_exception_support = 1;
4390
        }
4391
      else
4392
        {
4393
          warning ("Unable to enable interception of exception catches.");
4394
          warning ("Executable may not have been compiled debuggable with HP aCC.");
4395
          warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4396
          return 0;
4397
        }
4398
    }
4399
 
4400
  /* Next look for the catch enable flag provided end.o */
4401
  sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
4402
                       VAR_NAMESPACE, 0, (struct symtab **) NULL);
4403
  if (sym)                      /* sometimes present in debug info */
4404
    {
4405
      eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (sym);
4406
      hp_cxx_exception_support = 1;
4407
    }
4408
  else
4409
    /* otherwise look in SOM symbol dict. */
4410
    {
4411
      msym = lookup_minimal_symbol (HP_ACC_EH_catch_throw, NULL, NULL);
4412
      if (msym)
4413
        {
4414
          eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (msym);
4415
          hp_cxx_exception_support = 1;
4416
        }
4417
      else
4418
        {
4419
          warning ("Unable to enable interception of exception throws.");
4420
          warning ("Executable may not have been compiled debuggable with HP aCC.");
4421
          warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4422
          return 0;
4423
        }
4424
    }
4425
 
4426
  /* Set the flags */
4427
  hp_cxx_exception_support = 2; /* everything worked so far */
4428
  hp_cxx_exception_support_initialized = 1;
4429
  exception_support_initialized = 1;
4430
 
4431
  return 1;
4432
}
4433
 
4434
/* Target operation for enabling or disabling interception of
4435
   exception events.
4436
   KIND is either EX_EVENT_THROW or EX_EVENT_CATCH
4437
   ENABLE is either 0 (disable) or 1 (enable).
4438
   Return value is NULL if no support found;
4439
   -1 if something went wrong,
4440
   or a pointer to a symtab/line struct if the breakpointable
4441
   address was found. */
4442
 
4443
struct symtab_and_line *
4444
child_enable_exception_callback (kind, enable)
4445
     enum exception_event_kind kind;
4446
     int enable;
4447
{
4448
  char buf[4];
4449
 
4450
  if (!exception_support_initialized || !hp_cxx_exception_support_initialized)
4451
    if (!initialize_hp_cxx_exception_support ())
4452
      return NULL;
4453
 
4454
  switch (hp_cxx_exception_support)
4455
    {
4456
    case 0:
4457
      /* Assuming no HP support at all */
4458
      return NULL;
4459
    case 1:
4460
      /* HP support should be present, but something went wrong */
4461
      return (struct symtab_and_line *) -1;     /* yuck! */
4462
      /* there may be other cases in the future */
4463
    }
4464
 
4465
  /* Set the EH hook to point to the callback routine */
4466
  store_unsigned_integer (buf, 4, enable ? eh_notify_callback_addr : 0); /* FIXME 32x64 problem */
4467
  /* pai: (temp) FIXME should there be a pack operation first? */
4468
  if (target_write_memory (eh_notify_hook_addr, buf, 4))        /* FIXME 32x64 problem */
4469
    {
4470
      warning ("Could not write to target memory for exception event callback.");
4471
      warning ("Interception of exception events may not work.");
4472
      return (struct symtab_and_line *) -1;
4473
    }
4474
  if (enable)
4475
    {
4476
      /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-( */
4477
      if (inferior_pid > 0)
4478
        {
4479
          if (setup_d_pid_in_inferior ())
4480
            return (struct symtab_and_line *) -1;
4481
        }
4482
      else
4483
        {
4484
          warning ("Internal error: Invalid inferior pid?  Cannot intercept exception events.");
4485
          return (struct symtab_and_line *) -1;
4486
        }
4487
    }
4488
 
4489
  switch (kind)
4490
    {
4491
    case EX_EVENT_THROW:
4492
      store_unsigned_integer (buf, 4, enable ? 1 : 0);
4493
      if (target_write_memory (eh_catch_throw_addr, buf, 4))    /* FIXME 32x64? */
4494
        {
4495
          warning ("Couldn't enable exception throw interception.");
4496
          return (struct symtab_and_line *) -1;
4497
        }
4498
      break;
4499
    case EX_EVENT_CATCH:
4500
      store_unsigned_integer (buf, 4, enable ? 1 : 0);
4501
      if (target_write_memory (eh_catch_catch_addr, buf, 4))    /* FIXME 32x64? */
4502
        {
4503
          warning ("Couldn't enable exception catch interception.");
4504
          return (struct symtab_and_line *) -1;
4505
        }
4506
      break;
4507
    default:
4508
      error ("Request to enable unknown or unsupported exception event.");
4509
    }
4510
 
4511
  /* Copy break address into new sal struct, malloc'ing if needed. */
4512
  if (!break_callback_sal)
4513
    {
4514
      break_callback_sal = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
4515
    }
4516
  INIT_SAL (break_callback_sal);
4517
  break_callback_sal->symtab = NULL;
4518
  break_callback_sal->pc = eh_break_addr;
4519
  break_callback_sal->line = 0;
4520
  break_callback_sal->end = eh_break_addr;
4521
 
4522
  return break_callback_sal;
4523
}
4524
 
4525
/* Record some information about the current exception event */
4526
static struct exception_event_record current_ex_event;
4527
/* Convenience struct */
4528
static struct symtab_and_line null_symtab_and_line =
4529
{NULL, 0, 0, 0};
4530
 
4531
/* Report current exception event.  Returns a pointer to a record
4532
   that describes the kind of the event, where it was thrown from,
4533
   and where it will be caught.  More information may be reported
4534
   in the future */
4535
struct exception_event_record *
4536
child_get_current_exception_event ()
4537
{
4538
  CORE_ADDR event_kind;
4539
  CORE_ADDR throw_addr;
4540
  CORE_ADDR catch_addr;
4541
  struct frame_info *fi, *curr_frame;
4542
  int level = 1;
4543
 
4544
  curr_frame = get_current_frame ();
4545
  if (!curr_frame)
4546
    return (struct exception_event_record *) NULL;
4547
 
4548
  /* Go up one frame to __d_eh_notify_callback, because at the
4549
     point when this code is executed, there's garbage in the
4550
     arguments of __d_eh_break. */
4551
  fi = find_relative_frame (curr_frame, &level);
4552
  if (level != 0)
4553
    return (struct exception_event_record *) NULL;
4554
 
4555
  select_frame (fi, -1);
4556
 
4557
  /* Read in the arguments */
4558
  /* __d_eh_notify_callback() is called with 3 arguments:
4559
     1. event kind catch or throw
4560
     2. the target address if known
4561
     3. a flag -- not sure what this is. pai/1997-07-17 */
4562
  event_kind = read_register (ARG0_REGNUM);
4563
  catch_addr = read_register (ARG1_REGNUM);
4564
 
4565
  /* Now go down to a user frame */
4566
  /* For a throw, __d_eh_break is called by
4567
     __d_eh_notify_callback which is called by
4568
     __notify_throw which is called
4569
     from user code.
4570
     For a catch, __d_eh_break is called by
4571
     __d_eh_notify_callback which is called by
4572
     <stackwalking stuff> which is called by
4573
     __throw__<stuff> or __rethrow_<stuff> which is called
4574
     from user code. */
4575
  /* FIXME: Don't use such magic numbers; search for the frames */
4576
  level = (event_kind == EX_EVENT_THROW) ? 3 : 4;
4577
  fi = find_relative_frame (curr_frame, &level);
4578
  if (level != 0)
4579
    return (struct exception_event_record *) NULL;
4580
 
4581
  select_frame (fi, -1);
4582
  throw_addr = fi->pc;
4583
 
4584
  /* Go back to original (top) frame */
4585
  select_frame (curr_frame, -1);
4586
 
4587
  current_ex_event.kind = (enum exception_event_kind) event_kind;
4588
  current_ex_event.throw_sal = find_pc_line (throw_addr, 1);
4589
  current_ex_event.catch_sal = find_pc_line (catch_addr, 1);
4590
 
4591
  return &current_ex_event;
4592
}
4593
 
4594
static void
4595
unwind_command (exp, from_tty)
4596
     char *exp;
4597
     int from_tty;
4598
{
4599
  CORE_ADDR address;
4600
  struct unwind_table_entry *u;
4601
 
4602
  /* If we have an expression, evaluate it and use it as the address.  */
4603
 
4604
  if (exp != 0 && *exp != 0)
4605
    address = parse_and_eval_address (exp);
4606
  else
4607
    return;
4608
 
4609
  u = find_unwind_entry (address);
4610
 
4611
  if (!u)
4612
    {
4613
      printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
4614
      return;
4615
    }
4616
 
4617
  printf_unfiltered ("unwind_table_entry (0x%x):\n", u);
4618
 
4619
  printf_unfiltered ("\tregion_start = ");
4620
  print_address (u->region_start, gdb_stdout);
4621
 
4622
  printf_unfiltered ("\n\tregion_end = ");
4623
  print_address (u->region_end, gdb_stdout);
4624
 
4625
#ifdef __STDC__
4626
#define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
4627
#else
4628
#define pif(FLD) if (u->FLD) printf_unfiltered (" FLD");
4629
#endif
4630
 
4631
  printf_unfiltered ("\n\tflags =");
4632
  pif (Cannot_unwind);
4633
  pif (Millicode);
4634
  pif (Millicode_save_sr0);
4635
  pif (Entry_SR);
4636
  pif (Args_stored);
4637
  pif (Variable_Frame);
4638
  pif (Separate_Package_Body);
4639
  pif (Frame_Extension_Millicode);
4640
  pif (Stack_Overflow_Check);
4641
  pif (Two_Instruction_SP_Increment);
4642
  pif (Ada_Region);
4643
  pif (Save_SP);
4644
  pif (Save_RP);
4645
  pif (Save_MRP_in_frame);
4646
  pif (extn_ptr_defined);
4647
  pif (Cleanup_defined);
4648
  pif (MPE_XL_interrupt_marker);
4649
  pif (HP_UX_interrupt_marker);
4650
  pif (Large_frame);
4651
 
4652
  putchar_unfiltered ('\n');
4653
 
4654
#ifdef __STDC__
4655
#define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
4656
#else
4657
#define pin(FLD) printf_unfiltered ("\tFLD = 0x%x\n", u->FLD);
4658
#endif
4659
 
4660
  pin (Region_description);
4661
  pin (Entry_FR);
4662
  pin (Entry_GR);
4663
  pin (Total_frame_size);
4664
}
4665
 
4666
#ifdef PREPARE_TO_PROCEED
4667
 
4668
/* If the user has switched threads, and there is a breakpoint
4669
   at the old thread's pc location, then switch to that thread
4670
   and return TRUE, else return FALSE and don't do a thread
4671
   switch (or rather, don't seem to have done a thread switch).
4672
 
4673
   Ptrace-based gdb will always return FALSE to the thread-switch
4674
   query, and thus also to PREPARE_TO_PROCEED.
4675
 
4676
   The important thing is whether there is a BPT instruction,
4677
   not how many user breakpoints there are.  So we have to worry
4678
   about things like these:
4679
 
4680
   o  Non-bp stop -- NO
4681
 
4682
   o  User hits bp, no switch -- NO
4683
 
4684
   o  User hits bp, switches threads -- YES
4685
 
4686
   o  User hits bp, deletes bp, switches threads -- NO
4687
 
4688
   o  User hits bp, deletes one of two or more bps
4689
   at that PC, user switches threads -- YES
4690
 
4691
   o  Plus, since we're buffering events, the user may have hit a
4692
   breakpoint, deleted the breakpoint and then gotten another
4693
   hit on that same breakpoint on another thread which
4694
   actually hit before the delete. (FIXME in breakpoint.c
4695
   so that "dead" breakpoints are ignored?) -- NO
4696
 
4697
   For these reasons, we have to violate information hiding and
4698
   call "breakpoint_here_p".  If core gdb thinks there is a bpt
4699
   here, that's what counts, as core gdb is the one which is
4700
   putting the BPT instruction in and taking it out. */
4701
int
4702
hppa_prepare_to_proceed ()
4703
{
4704
  pid_t old_thread;
4705
  pid_t current_thread;
4706
 
4707
  old_thread = hppa_switched_threads (inferior_pid);
4708
  if (old_thread != 0)
4709
    {
4710
      /* Switched over from "old_thread".  Try to do
4711
         as little work as possible, 'cause mostly
4712
         we're going to switch back. */
4713
      CORE_ADDR new_pc;
4714
      CORE_ADDR old_pc = read_pc ();
4715
 
4716
      /* Yuk, shouldn't use global to specify current
4717
         thread.  But that's how gdb does it. */
4718
      current_thread = inferior_pid;
4719
      inferior_pid = old_thread;
4720
 
4721
      new_pc = read_pc ();
4722
      if (new_pc != old_pc      /* If at same pc, no need */
4723
          && breakpoint_here_p (new_pc))
4724
        {
4725
          /* User hasn't deleted the BP.
4726
             Return TRUE, finishing switch to "old_thread". */
4727
          flush_cached_frames ();
4728
          registers_changed ();
4729
#if 0
4730
          printf ("---> PREPARE_TO_PROCEED (was %d, now %d)!\n",
4731
                  current_thread, inferior_pid);
4732
#endif
4733
 
4734
          return 1;
4735
        }
4736
 
4737
      /* Otherwise switch back to the user-chosen thread. */
4738
      inferior_pid = current_thread;
4739
      new_pc = read_pc ();      /* Re-prime register cache */
4740
    }
4741
 
4742
  return 0;
4743
}
4744
#endif /* PREPARE_TO_PROCEED */
4745
 
4746
void
4747
hppa_skip_permanent_breakpoint ()
4748
{
4749
  /* To step over a breakpoint instruction on the PA takes some
4750
     fiddling with the instruction address queue.
4751
 
4752
     When we stop at a breakpoint, the IA queue front (the instruction
4753
     we're executing now) points at the breakpoint instruction, and
4754
     the IA queue back (the next instruction to execute) points to
4755
     whatever instruction we would execute after the breakpoint, if it
4756
     were an ordinary instruction.  This is the case even if the
4757
     breakpoint is in the delay slot of a branch instruction.
4758
 
4759
     Clearly, to step past the breakpoint, we need to set the queue
4760
     front to the back.  But what do we put in the back?  What
4761
     instruction comes after that one?  Because of the branch delay
4762
     slot, the next insn is always at the back + 4.  */
4763
  write_register (PCOQ_HEAD_REGNUM, read_register (PCOQ_TAIL_REGNUM));
4764
  write_register (PCSQ_HEAD_REGNUM, read_register (PCSQ_TAIL_REGNUM));
4765
 
4766
  write_register (PCOQ_TAIL_REGNUM, read_register (PCOQ_TAIL_REGNUM) + 4);
4767
  /* We can leave the tail's space the same, since there's no jump.  */
4768
}
4769
 
4770
void
4771
_initialize_hppa_tdep ()
4772
{
4773
  tm_print_insn = print_insn_hppa;
4774
 
4775
  add_cmd ("unwind", class_maintenance, unwind_command,
4776
           "Print unwind table entry at given address.",
4777
           &maintenanceprintlist);
4778
}

powered by: WebSVN 2.1.0

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