projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* s390-tdep.c (s390_gdbarch_init): Use the default
[deliverable/binutils-gdb.git] / gdb / s390-tdep.c
CommitLineData
5769d3cd
AC		 1/* Target-dependent code for GDB, the GNU debugger.
2 Copyright 2001 Free Software Foundation, Inc.
3 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
4 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
22
23#define S390_TDEP /* for special macros in tm-s390.h */
24#include <defs.h>
25#include "arch-utils.h"
26#include "frame.h"
27#include "inferior.h"
28#include "symtab.h"
29#include "target.h"
30#include "gdbcore.h"
31#include "gdbcmd.h"
32#include "symfile.h"
33#include "objfiles.h"
34#include "tm.h"
35#include "../bfd/bfd.h"
36#include "floatformat.h"
37#include "regcache.h"
fd0407d6 38#include "value.h"
5769d3cd
AC		 39
40
41
42
60e6cc42 43
5769d3cd
AC		 44/* Number of bytes of storage in the actual machine representation
45 for register N.
46 Note that the unsigned cast here forces the result of the
47 subtraction to very high positive values if N < S390_FP0_REGNUM */
48int
49s390_register_raw_size (int reg_nr)
50{
51 return ((unsigned) reg_nr - S390_FP0_REGNUM) <
52 S390_NUM_FPRS ? S390_FPR_SIZE : 4;
53}
54
55int
56s390x_register_raw_size (int reg_nr)
57{
58 return (reg_nr == S390_FPC_REGNUM)
59 || (reg_nr >= S390_FIRST_ACR && reg_nr <= S390_LAST_ACR) ? 4 : 8;
60}
61
62int
63s390_cannot_fetch_register (int regno)
64{
65 return (regno >= S390_FIRST_CR && regno < (S390_FIRST_CR + 9)) ||
66 (regno >= (S390_FIRST_CR + 12) && regno <= S390_LAST_CR);
67}
68
69int
70s390_register_byte (int reg_nr)
71{
72 if (reg_nr <= S390_GP_LAST_REGNUM)
73 return reg_nr * S390_GPR_SIZE;
74 if (reg_nr <= S390_LAST_ACR)
75 return S390_ACR0_OFFSET + (((reg_nr) - S390_FIRST_ACR) * S390_ACR_SIZE);
76 if (reg_nr <= S390_LAST_CR)
77 return S390_CR0_OFFSET + (((reg_nr) - S390_FIRST_CR) * S390_CR_SIZE);
78 if (reg_nr == S390_FPC_REGNUM)
79 return S390_FPC_OFFSET;
80 else
81 return S390_FP0_OFFSET + (((reg_nr) - S390_FP0_REGNUM) * S390_FPR_SIZE);
82}
83
84#ifndef GDBSERVER
85#define S390_MAX_INSTR_SIZE (6)
86#define S390_SYSCALL_OPCODE (0x0a)
87#define S390_SYSCALL_SIZE (2)
88#define S390_SIGCONTEXT_SREGS_OFFSET (8)
89#define S390X_SIGCONTEXT_SREGS_OFFSET (8)
90#define S390_SIGREGS_FP0_OFFSET (144)
91#define S390X_SIGREGS_FP0_OFFSET (216)
92#define S390_UC_MCONTEXT_OFFSET (256)
93#define S390X_UC_MCONTEXT_OFFSET (344)
94#define S390_STACK_FRAME_OVERHEAD (GDB_TARGET_IS_ESAME ? 160:96)
95#define S390_SIGNAL_FRAMESIZE (GDB_TARGET_IS_ESAME ? 160:96)
96#define s390_NR_sigreturn 119
97#define s390_NR_rt_sigreturn 173
98
99
100
101struct frame_extra_info
102{
103 int initialised;
104 int good_prologue;
105 CORE_ADDR function_start;
106 CORE_ADDR skip_prologue_function_start;
107 CORE_ADDR saved_pc_valid;
108 CORE_ADDR saved_pc;
109 CORE_ADDR sig_fixed_saved_pc_valid;
110 CORE_ADDR sig_fixed_saved_pc;
111 CORE_ADDR frame_pointer_saved_pc; /* frame pointer needed for alloca */
112 CORE_ADDR stack_bought; /* amount we decrement the stack pointer by */
113 CORE_ADDR sigcontext;
114};
115
116
117static CORE_ADDR s390_frame_saved_pc_nofix (struct frame_info *fi);
118
119int
120s390_readinstruction (bfd_byte instr[], CORE_ADDR at,
121 struct disassemble_info *info)
122{
123 int instrlen;
124
125 static int s390_instrlen[] = {
126 2,
127 4,
128 4,
129 6
130 };
131 if ((*info->read_memory_func) (at, &instr[0], 2, info))
132 return -1;
133 instrlen = s390_instrlen[instr[0] >> 6];
134 if ((*info->read_memory_func) (at + 2, &instr[2], instrlen - 2, info))
135 return -1;
136 return instrlen;
137}
138
139static void
140s390_memset_extra_info (struct frame_extra_info *fextra_info)
141{
142 memset (fextra_info, 0, sizeof (struct frame_extra_info));
143}
144
145
146
147char *
148s390_register_name (int reg_nr)
149{
150 static char *register_names[] = {
151 "pswm", "pswa",
152 "gpr0", "gpr1", "gpr2", "gpr3", "gpr4", "gpr5", "gpr6", "gpr7",
153 "gpr8", "gpr9", "gpr10", "gpr11", "gpr12", "gpr13", "gpr14", "gpr15",
154 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
155 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
156 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
157 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
158 "fpc",
159 "fpr0", "fpr1", "fpr2", "fpr3", "fpr4", "fpr5", "fpr6", "fpr7",
160 "fpr8", "fpr9", "fpr10", "fpr11", "fpr12", "fpr13", "fpr14", "fpr15"
161 };
162
163 if (reg_nr >= S390_LAST_REGNUM)
164 return NULL;
165 return register_names[reg_nr];
166}
167
168
169
170
171int
172s390_stab_reg_to_regnum (int regno)
173{
174 return regno >= 64 ? S390_PSWM_REGNUM - 64 :
175 regno >= 48 ? S390_FIRST_ACR - 48 :
176 regno >= 32 ? S390_FIRST_CR - 32 :
177 regno <= 15 ? (regno + 2) :
178 S390_FP0_REGNUM + ((regno - 16) & 8) + (((regno - 16) & 3) << 1) +
179 (((regno - 16) & 4) >> 2);
180}
181
182
183
184/* s390_get_frame_info based on Hartmuts
185 prologue definition in
186 gcc-2.8.1/config/l390/linux.c
187
188 It reads one instruction at a time & based on whether
189 it looks like prologue code or not it makes a decision on
190 whether the prologue is over, there are various state machines
191 in the code to determine if the prologue code is possilby valid.
192
193 This is done to hopefully allow the code survive minor revs of
194 calling conventions.
195
196 */
197
198int
199s390_get_frame_info (CORE_ADDR pc, struct frame_extra_info *fextra_info,
200 struct frame_info *fi, int init_extra_info)
201{
202#define CONST_POOL_REGIDX 13
203#define GOT_REGIDX 12
204 bfd_byte instr[S390_MAX_INSTR_SIZE];
205 CORE_ADDR test_pc = pc, test_pc2;
206 CORE_ADDR orig_sp = 0, save_reg_addr = 0, *saved_regs = NULL;
207 int valid_prologue, good_prologue = 0;
208 int gprs_saved[S390_NUM_GPRS];
209 int fprs_saved[S390_NUM_FPRS];
210 int regidx, instrlen;
211 int save_link_regidx, subtract_sp_regidx;
212 int const_pool_state, save_link_state, got_state;
213 int frame_pointer_found, varargs_state;
214 int loop_cnt, gdb_gpr_store, gdb_fpr_store;
215 int frame_pointer_regidx = 0xf;
216 int offset, expected_offset;
217 int err = 0;
218 disassemble_info info;
219 const_pool_state = save_link_state = got_state = varargs_state = 0;
220 frame_pointer_found = 0;
221 memset (gprs_saved, 0, sizeof (gprs_saved));
222 memset (fprs_saved, 0, sizeof (fprs_saved));
223 info.read_memory_func = dis_asm_read_memory;
224
225 save_link_regidx = subtract_sp_regidx = 0;
226 if (fextra_info)
227 {
228 if (fi && fi->frame)
229 {
230 orig_sp = fi->frame + fextra_info->stack_bought;
231 saved_regs = fi->saved_regs;
232 }
233 if (init_extra_info || !fextra_info->initialised)
234 {
235 s390_memset_extra_info (fextra_info);
236 fextra_info->function_start = pc;
237 fextra_info->initialised = 1;
238 }
239 }
240 instrlen = 0;
241 do
242 {
243 valid_prologue = 0;
244 test_pc += instrlen;
245 /* add the previous instruction len */
246 instrlen = s390_readinstruction (instr, test_pc, &info);
247 if (instrlen < 0)
248 {
249 good_prologue = 0;
250 err = -1;
251 break;
252 }
253 /* We probably are in a glibc syscall */
254 if (instr[0] == S390_SYSCALL_OPCODE && test_pc == pc)
255 {
256 good_prologue = 1;
257 if (saved_regs && fextra_info && fi->next && fi->next->extra_info
258 && fi->next->extra_info->sigcontext)
259 {
260 /* We are backtracing from a signal handler */
261 save_reg_addr = fi->next->extra_info->sigcontext +
262 REGISTER_BYTE (S390_GP0_REGNUM);
263 for (regidx = 0; regidx < S390_NUM_GPRS; regidx++)
264 {
265 saved_regs[S390_GP0_REGNUM + regidx] = save_reg_addr;
266 save_reg_addr += S390_GPR_SIZE;
267 }
268 save_reg_addr = fi->next->extra_info->sigcontext +
269 (GDB_TARGET_IS_ESAME ? S390X_SIGREGS_FP0_OFFSET :
270 S390_SIGREGS_FP0_OFFSET);
271 for (regidx = 0; regidx < S390_NUM_FPRS; regidx++)
272 {
273 saved_regs[S390_FP0_REGNUM + regidx] = save_reg_addr;
274 save_reg_addr += S390_FPR_SIZE;
275 }
276 }
277 break;
278 }
279 if (save_link_state == 0)
280 {
281 /* check for a stack relative STMG or STM */
282 if (((GDB_TARGET_IS_ESAME &&
283 ((instr[0] == 0xeb) && (instr[5] == 0x24))) ||
284 (instr[0] == 0x90)) && ((instr[2] >> 4) == 0xf))
285 {
286 regidx = (instr[1] >> 4);
287 if (regidx < 6)
288 varargs_state = 1;
289 offset = ((instr[2] & 0xf) << 8) + instr[3];
290 expected_offset =
291 S390_GPR6_STACK_OFFSET + (S390_GPR_SIZE * (regidx - 6));
292 if (offset != expected_offset)
293 {
294 good_prologue = 0;
295 break;
296 }
297 if (saved_regs)
298 save_reg_addr = orig_sp + offset;
299 for (; regidx <= (instr[1] & 0xf); regidx++)
300 {
301 if (gprs_saved[regidx])
302 {
303 good_prologue = 0;
304 break;
305 }
306 good_prologue = 1;
307 gprs_saved[regidx] = 1;
308 if (saved_regs)
309 {
310 saved_regs[S390_GP0_REGNUM + regidx] = save_reg_addr;
311 save_reg_addr += S390_GPR_SIZE;
312 }
313 }
314 valid_prologue = 1;
315 continue;
316 }
317 }
318 /* check for a stack relative STG or ST */
319 if ((save_link_state == 0 || save_link_state == 3) &&
320 ((GDB_TARGET_IS_ESAME &&
321 ((instr[0] == 0xe3) && (instr[5] == 0x24))) ||
322 (instr[0] == 0x50)) && ((instr[2] >> 4) == 0xf))
323 {
324 regidx = instr[1] >> 4;
325 offset = ((instr[2] & 0xf) << 8) + instr[3];
326 if (offset == 0)
327 {
328 if (save_link_state == 3 && regidx == save_link_regidx)
329 {
330 save_link_state = 4;
331 valid_prologue = 1;
332 continue;
333 }
334 else
335 break;
336 }
337 if (regidx < 6)
338 varargs_state = 1;
339 expected_offset =
340 S390_GPR6_STACK_OFFSET + (S390_GPR_SIZE * (regidx - 6));
341 if (offset != expected_offset)
342 {
343 good_prologue = 0;
344 break;
345 }
346 if (gprs_saved[regidx])
347 {
348 good_prologue = 0;
349 break;
350 }
351 good_prologue = 1;
352 gprs_saved[regidx] = 1;
353 if (saved_regs)
354 {
355 save_reg_addr = orig_sp + offset;
356 saved_regs[S390_GP0_REGNUM + regidx] = save_reg_addr;
357 }
358 valid_prologue = 1;
359 continue;
360 }
361
362 /* check for STD */
363 if (instr[0] == 0x60 && (instr[2] >> 4) == 0xf)
364 {
365 regidx = instr[1] >> 4;
366 if (regidx == 0 || regidx == 2)
367 varargs_state = 1;
368 if (fprs_saved[regidx])
369 {
370 good_prologue = 0;
371 break;
372 }
373 fprs_saved[regidx] = 1;
374 if (saved_regs)
375 {
376 save_reg_addr = orig_sp + (((instr[2] & 0xf) << 8) + instr[3]);
377 saved_regs[S390_FP0_REGNUM + regidx] = save_reg_addr;
378 }
379 valid_prologue = 1;
380 continue;
381 }
382
383
384 if (const_pool_state == 0)
385 {
386
387 if (GDB_TARGET_IS_ESAME)
388 {
389 /* Check for larl CONST_POOL_REGIDX,offset on ESAME */
390 if ((instr[0] == 0xc0)
391 && (instr[1] == (CONST_POOL_REGIDX << 4)))
392 {
393 const_pool_state = 2;
394 valid_prologue = 1;
395 continue;
396 }
397 }
398 else
399 {
400 /* Check for BASR gpr13,gpr0 used to load constant pool pointer to r13 in old compiler */
401 if (instr[0] == 0xd && (instr[1] & 0xf) == 0
402 && ((instr[1] >> 4) == CONST_POOL_REGIDX))
403 {
404 const_pool_state = 1;
405 valid_prologue = 1;
406 continue;
407 }
408 }
409 /* Check for new fangled bras %r13,newpc to load new constant pool */
410 /* embedded in code, older pre abi compilers also emitted this stuff. */
411 if ((instr[0] == 0xa7) && ((instr[1] & 0xf) == 0x5) &&
412 ((instr[1] >> 4) == CONST_POOL_REGIDX)
413 && ((instr[2] & 0x80) == 0))
414 {
415 const_pool_state = 2;
416 test_pc +=
417 (((((instr[2] & 0xf) << 8) + instr[3]) << 1) - instrlen);
418 valid_prologue = 1;
419 continue;
420 }
421 }
422 /* Check for AGHI or AHI CONST_POOL_REGIDX,val */
423 if (const_pool_state == 1 && (instr[0] == 0xa7) &&
424 ((GDB_TARGET_IS_ESAME &&
425 (instr[1] == ((CONST_POOL_REGIDX << 4) | 0xb))) ||
426 (instr[1] == ((CONST_POOL_REGIDX << 4) | 0xa))))
427 {
428 const_pool_state = 2;
429 valid_prologue = 1;
430 continue;
431 }
432 /* Check for LGR or LR gprx,15 */
433 if ((GDB_TARGET_IS_ESAME &&
434 instr[0] == 0xb9 && instr[1] == 0x04 && (instr[3] & 0xf) == 0xf) ||
435 (instr[0] == 0x18 && (instr[1] & 0xf) == 0xf))
436 {
437 if (GDB_TARGET_IS_ESAME)
438 regidx = instr[3] >> 4;
439 else
440 regidx = instr[1] >> 4;
441 if (save_link_state == 0 && regidx != 0xb)
442 {
443 /* Almost defintely code for
444 decrementing the stack pointer
445 ( i.e. a non leaf function
446 or else leaf with locals ) */
447 save_link_regidx = regidx;
448 save_link_state = 1;
449 valid_prologue = 1;
450 continue;
451 }
452 /* We use this frame pointer for alloca
453 unfortunately we need to assume its gpr11
454 otherwise we would need a smarter prologue
455 walker. */
456 if (!frame_pointer_found && regidx == 0xb)
457 {
458 frame_pointer_regidx = 0xb;
459 frame_pointer_found = 1;
460 if (fextra_info)
461 fextra_info->frame_pointer_saved_pc = test_pc;
462 valid_prologue = 1;
463 continue;
464 }
465 }
466 /* Check for AHI or AGHI gpr15,val */
467 if (save_link_state == 1 && (instr[0] == 0xa7) &&
468 ((GDB_TARGET_IS_ESAME && (instr[1] == 0xfb)) || (instr[1] == 0xfa)))
469 {
470 if (fextra_info)
471 fextra_info->stack_bought =
472 -extract_signed_integer (&instr[2], 2);
473 save_link_state = 3;
474 valid_prologue = 1;
475 continue;
476 }
477 /* Alternatively check for the complex construction for
478 buying more than 32k of stack
479 BRAS gprx,.+8
480 long vals %r15,0(%gprx) gprx currently r1 */
481 if ((save_link_state == 1) && (instr[0] == 0xa7)
482 && ((instr[1] & 0xf) == 0x5) && (instr[2] == 0)
483 && (instr[3] == 0x4) && ((instr[1] >> 4) != CONST_POOL_REGIDX))
484 {
485 subtract_sp_regidx = instr[1] >> 4;
486 save_link_state = 2;
487 if (fextra_info)
488 target_read_memory (test_pc + instrlen,
489 (char *) &fextra_info->stack_bought,
490 sizeof (fextra_info->stack_bought));
491 test_pc += 4;
492 valid_prologue = 1;
493 continue;
494 }
495 if (save_link_state == 2 && instr[0] == 0x5b
496 && instr[1] == 0xf0 &&
497 instr[2] == (subtract_sp_regidx << 4) && instr[3] == 0)
498 {
499 save_link_state = 3;
500 valid_prologue = 1;
501 continue;
502 }
503 /* check for LA gprx,offset(15) used for varargs */
504 if ((instr[0] == 0x41) && ((instr[2] >> 4) == 0xf) &&
505 ((instr[1] & 0xf) == 0))
506 {
507 /* some code uses gpr7 to point to outgoing args */
508 if (((instr[1] >> 4) == 7) && (save_link_state == 0) &&
509 ((instr[2] & 0xf) == 0)
510 && (instr[3] == S390_STACK_FRAME_OVERHEAD))
511 {
512 valid_prologue = 1;
513 continue;
514 }
515 if (varargs_state == 1)
516 {
517 varargs_state = 2;
518 valid_prologue = 1;
519 continue;
520 }
521 }
522 /* Check for a GOT load */
523
524 if (GDB_TARGET_IS_ESAME)
525 {
526 /* Check for larl GOT_REGIDX, on ESAME */
527 if ((got_state == 0) && (instr[0] == 0xc0)
528 && (instr[1] == (GOT_REGIDX << 4)))
529 {
530 got_state = 2;
531 valid_prologue = 1;
532 continue;
533 }
534 }
535 else
536 {
537 /* check for l GOT_REGIDX,x(CONST_POOL_REGIDX) */
538 if (got_state == 0 && const_pool_state == 2 && instr[0] == 0x58
539 && (instr[2] == (CONST_POOL_REGIDX << 4))
540 && ((instr[1] >> 4) == GOT_REGIDX))
541 {
542 got_state == 1;
543 valid_prologue = 1;
544 continue;
545 }
546 /* Check for subsequent ar got_regidx,basr_regidx */
547 if (got_state == 1 && instr[0] == 0x1a &&
548 instr[1] == ((GOT_REGIDX << 4) | CONST_POOL_REGIDX))
549 {
550 got_state = 2;
551 valid_prologue = 1;
552 continue;
553 }
554 }
555 }
556 while (valid_prologue && good_prologue);
557 if (good_prologue)
558 {
559 good_prologue = (((got_state == 0) || (got_state == 2)) &&
560 ((const_pool_state == 0) || (const_pool_state == 2)) &&
561 ((save_link_state == 0) || (save_link_state == 4)) &&
562 ((varargs_state == 0) || (varargs_state == 2)));
563 }
564 if (fextra_info)
565 {
566 fextra_info->good_prologue = good_prologue;
567 fextra_info->skip_prologue_function_start =
568 (good_prologue ? test_pc : pc);
569 }
570 return err;
571}
572
573
574int
575s390_check_function_end (CORE_ADDR pc)
576{
577 bfd_byte instr[S390_MAX_INSTR_SIZE];
578 disassemble_info info;
579 int regidx, instrlen;
580
581 info.read_memory_func = dis_asm_read_memory;
582 instrlen = s390_readinstruction (instr, pc, &info);
583 if (instrlen < 0)
584 return -1;
585 /* check for BR */
586 if (instrlen != 2 || instr[0] != 07 || (instr[1] >> 4) != 0xf)
587 return 0;
588 regidx = instr[1] & 0xf;
589 /* Check for LMG or LG */
590 instrlen =
591 s390_readinstruction (instr, pc - (GDB_TARGET_IS_ESAME ? 6 : 4), &info);
592 if (instrlen < 0)
593 return -1;
594 if (GDB_TARGET_IS_ESAME)
595 {
596
597 if (instrlen != 6 || instr[0] != 0xeb || instr[5] != 0x4)
598 return 0;
599 }
600 else if (instrlen != 4 || instr[0] != 0x98)
601 {
602 return 0;
603 }
604 if ((instr[2] >> 4) != 0xf)
605 return 0;
606 if (regidx == 14)
607 return 1;
608 instrlen = s390_readinstruction (instr, pc - (GDB_TARGET_IS_ESAME ? 12 : 8),
609 &info);
610 if (instrlen < 0)
611 return -1;
612 if (GDB_TARGET_IS_ESAME)
613 {
614 /* Check for LG */
615 if (instrlen != 6 || instr[0] != 0xe3 || instr[5] != 0x4)
616 return 0;
617 }
618 else
619 {
620 /* Check for L */
621 if (instrlen != 4 || instr[0] != 0x58)
622 return 0;
623 }
624 if (instr[2] >> 4 != 0xf)
625 return 0;
626 if (instr[1] >> 4 != regidx)
627 return 0;
628 return 1;
629}
630
631static CORE_ADDR
632s390_sniff_pc_function_start (CORE_ADDR pc, struct frame_info *fi)
633{
634 CORE_ADDR function_start, test_function_start;
635 int loop_cnt, err, function_end;
636 struct frame_extra_info fextra_info;
637 function_start = get_pc_function_start (pc);
638
639 if (function_start == 0)
640 {
641 test_function_start = pc;
642 if (test_function_start & 1)
643 return 0; /* This has to be bogus */
644 loop_cnt = 0;
645 do
646 {
647
648 err =
649 s390_get_frame_info (test_function_start, &fextra_info, fi, 1);
650 loop_cnt++;
651 test_function_start -= 2;
652 function_end = s390_check_function_end (test_function_start);
653 }
654 while (!(function_end == 1 || err || loop_cnt >= 4096 ||
655 (fextra_info.good_prologue)));
656 if (fextra_info.good_prologue)
657 function_start = fextra_info.function_start;
658 else if (function_end == 1)
659 function_start = test_function_start;
660 }
661 return function_start;
662}
663
664
665
666CORE_ADDR
667s390_function_start (struct frame_info *fi)
668{
669 CORE_ADDR function_start = 0;
670
671 if (fi->extra_info && fi->extra_info->initialised)
672 function_start = fi->extra_info->function_start;
673 else if (fi->pc)
674 function_start = get_pc_function_start (fi->pc);
675 return function_start;
676}
677
678
679
680
681int
682s390_frameless_function_invocation (struct frame_info *fi)
683{
684 struct frame_extra_info fextra_info, *fextra_info_ptr;
685 int frameless = 0;
686
687 if (fi->next == NULL) /* no may be frameless */
688 {
689 if (fi->extra_info)
690 fextra_info_ptr = fi->extra_info;
691 else
692 {
693 fextra_info_ptr = &fextra_info;
694 s390_get_frame_info (s390_sniff_pc_function_start (fi->pc, fi),
695 fextra_info_ptr, fi, 1);
696 }
697 frameless = ((fextra_info_ptr->stack_bought == 0));
698 }
699 return frameless;
700
701}
702
703
704static int
705s390_is_sigreturn (CORE_ADDR pc, struct frame_info *sighandler_fi,
706 CORE_ADDR *sregs, CORE_ADDR *sigcaller_pc)
707{
708 bfd_byte instr[S390_MAX_INSTR_SIZE];
709 disassemble_info info;
710 int instrlen;
711 CORE_ADDR scontext;
712 int retval = 0;
713 CORE_ADDR orig_sp;
714 CORE_ADDR temp_sregs;
715
716 scontext = temp_sregs = 0;
717
718 info.read_memory_func = dis_asm_read_memory;
719 instrlen = s390_readinstruction (instr, pc, &info);
720 if (sigcaller_pc)
721 *sigcaller_pc = 0;
722 if (((instrlen == S390_SYSCALL_SIZE) &&
723 (instr[0] == S390_SYSCALL_OPCODE)) &&
724 ((instr[1] == s390_NR_sigreturn) || (instr[1] == s390_NR_rt_sigreturn)))
725 {
726 if (sighandler_fi)
727 {
728 if (s390_frameless_function_invocation (sighandler_fi))
729 orig_sp = sighandler_fi->frame;
730 else
731 orig_sp = ADDR_BITS_REMOVE ((CORE_ADDR)
732 read_memory_integer (sighandler_fi->
733 frame,
734 S390_GPR_SIZE));
735 if (orig_sp && sigcaller_pc)
736 {
737 scontext = orig_sp + S390_SIGNAL_FRAMESIZE;
738 if (pc == scontext && instr[1] == s390_NR_rt_sigreturn)
739 {
740 /* We got a new style rt_signal */
741 /* get address of read ucontext->uc_mcontext */
742 temp_sregs = orig_sp + (GDB_TARGET_IS_ESAME ?
743 S390X_UC_MCONTEXT_OFFSET :
744 S390_UC_MCONTEXT_OFFSET);
745 }
746 else
747 {
748 /* read sigcontext->sregs */
749 temp_sregs = ADDR_BITS_REMOVE ((CORE_ADDR)
750 read_memory_integer (scontext
751 +
752 (GDB_TARGET_IS_ESAME
753 ?
754 S390X_SIGCONTEXT_SREGS_OFFSET
755 :
756 S390_SIGCONTEXT_SREGS_OFFSET),
757 S390_GPR_SIZE));
758
759 }
760 /* read sigregs->psw.addr */
761 *sigcaller_pc =
762 ADDR_BITS_REMOVE ((CORE_ADDR)
763 read_memory_integer (temp_sregs +
764 REGISTER_BYTE
765 (S390_PC_REGNUM),
766 S390_PSW_ADDR_SIZE));
767 }
768 }
769 retval = 1;
770 }
771 if (sregs)
772 *sregs = temp_sregs;
773 return retval;
774}
775
776/*
777 We need to do something better here but this will keep us out of trouble
778 for the moment.
779 For some reason the blockframe.c calls us with fi->next->fromleaf
780 so this seems of little use to us. */
781void
782s390_init_frame_pc_first (int next_fromleaf, struct frame_info *fi)
783{
784 CORE_ADDR sigcaller_pc;
785
786 fi->pc = 0;
787 if (next_fromleaf)
788 {
789 fi->pc = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
790 /* fix signal handlers */
791 }
792 else if (fi->next && fi->next->pc)
793 fi->pc = s390_frame_saved_pc_nofix (fi->next);
794 if (fi->pc && fi->next && fi->next->frame &&
795 s390_is_sigreturn (fi->pc, fi->next, NULL, &sigcaller_pc))
796 {
797 fi->pc = sigcaller_pc;
798 }
799
800}
801
802void
803s390_init_extra_frame_info (int fromleaf, struct frame_info *fi)
804{
805 fi->extra_info = frame_obstack_alloc (sizeof (struct frame_extra_info));
806 if (fi->pc)
807 s390_get_frame_info (s390_sniff_pc_function_start (fi->pc, fi),
808 fi->extra_info, fi, 1);
809 else
810 s390_memset_extra_info (fi->extra_info);
811}
812
813/* If saved registers of frame FI are not known yet, read and cache them.
814 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
815 in which case the framedata are read. */
816
817void
818s390_frame_init_saved_regs (struct frame_info *fi)
819{
820
821 int quick;
822
823 if (fi->saved_regs == NULL)
824 {
825 /* zalloc memsets the saved regs */
826 frame_saved_regs_zalloc (fi);
827 if (fi->pc)
828 {
829 quick = (fi->extra_info && fi->extra_info->initialised
830 && fi->extra_info->good_prologue);
831 s390_get_frame_info (quick ? fi->extra_info->function_start :
832 s390_sniff_pc_function_start (fi->pc, fi),
833 fi->extra_info, fi, !quick);
834 }
835 }
836}
837
838
839
840CORE_ADDR
841s390_frame_args_address (struct frame_info *fi)
842{
843
844 /* Apparently gdb already knows gdb_args_offset itself */
845 return fi->frame;
846}
847
848
849static CORE_ADDR
850s390_frame_saved_pc_nofix (struct frame_info *fi)
851{
852 if (fi->extra_info && fi->extra_info->saved_pc_valid)
853 return fi->extra_info->saved_pc;
854 s390_frame_init_saved_regs (fi);
855 if (fi->extra_info)
856 {
857 fi->extra_info->saved_pc_valid = 1;
858 if (fi->extra_info->good_prologue)
859 {
860 if (fi->saved_regs[S390_RETADDR_REGNUM])
861 {
862 return (fi->extra_info->saved_pc =
863 ADDR_BITS_REMOVE (read_memory_integer
864 (fi->saved_regs[S390_RETADDR_REGNUM],
865 S390_GPR_SIZE)));
866 }
867 }
868 }
869 return 0;
870}
871
872CORE_ADDR
873s390_frame_saved_pc (struct frame_info *fi)
874{
875 CORE_ADDR saved_pc = 0, sig_pc;
876
877 if (fi->extra_info && fi->extra_info->sig_fixed_saved_pc_valid)
878 return fi->extra_info->sig_fixed_saved_pc;
879 saved_pc = s390_frame_saved_pc_nofix (fi);
880
881 if (fi->extra_info)
882 {
883 fi->extra_info->sig_fixed_saved_pc_valid = 1;
884 if (saved_pc)
885 {
886 if (s390_is_sigreturn (saved_pc, fi, NULL, &sig_pc))
887 saved_pc = sig_pc;
888 }
889 fi->extra_info->sig_fixed_saved_pc = saved_pc;
890 }
891 return saved_pc;
892}
893
894
895
896
897/* We want backtraces out of signal handlers so we don't
898 set thisframe->signal_handler_caller to 1 */
899
900CORE_ADDR
901s390_frame_chain (struct frame_info *thisframe)
902{
903 CORE_ADDR prev_fp = 0;
904
905 if (thisframe->prev && thisframe->prev->frame)
906 prev_fp = thisframe->prev->frame;
907 else
908 {
909 int sigreturn = 0;
910 CORE_ADDR sregs = 0;
911 struct frame_extra_info prev_fextra_info;
912
913 memset (&prev_fextra_info, 0, sizeof (prev_fextra_info));
914 if (thisframe->pc)
915 {
916 CORE_ADDR saved_pc, sig_pc;
917
918 saved_pc = s390_frame_saved_pc_nofix (thisframe);
919 if (saved_pc)
920 {
921 if ((sigreturn =
922 s390_is_sigreturn (saved_pc, thisframe, &sregs, &sig_pc)))
923 saved_pc = sig_pc;
924 s390_get_frame_info (s390_sniff_pc_function_start
925 (saved_pc, NULL), &prev_fextra_info, NULL,
926 1);
927 }
928 }
929 if (sigreturn)
930 {
931 /* read sigregs,regs.gprs[11 or 15] */
932 prev_fp = read_memory_integer (sregs +
933 REGISTER_BYTE (S390_GP0_REGNUM +
934 (prev_fextra_info.
935 frame_pointer_saved_pc
936 ? 11 : 15)),
937 S390_GPR_SIZE);
938 thisframe->extra_info->sigcontext = sregs;
939 }
940 else
941 {
942 if (thisframe->saved_regs)
943 {
944
945 int regno;
946
947 regno =
948 ((prev_fextra_info.frame_pointer_saved_pc
949 && thisframe->
950 saved_regs[S390_FRAME_REGNUM]) ? S390_FRAME_REGNUM :
951 S390_SP_REGNUM);
952 if (thisframe->saved_regs[regno])
953 prev_fp =
954 read_memory_integer (thisframe->saved_regs[regno],
955 S390_GPR_SIZE);
956 }
957 }
958 }
959 return ADDR_BITS_REMOVE (prev_fp);
960}
961
962/*
963 Whether struct frame_extra_info is actually needed I'll have to figure
964 out as our frames are similar to rs6000 there is a possibility
965 i386 dosen't need it. */
966
967
968
969/* a given return value in `regbuf' with a type `valtype', extract and copy its
970 value into `valbuf' */
971void
972s390_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
973{
974 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
975 We need to truncate the return value into float size (4 byte) if
976 necessary. */
977 int len = TYPE_LENGTH (valtype);
978
979 if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
980 {
981 if (len > (TARGET_FLOAT_BIT >> 3))
982 memcpy (valbuf, &regbuf[REGISTER_BYTE (S390_FP0_REGNUM)], len);
983 else
984 {
985 /* float */
986 DOUBLEST val;
987
988 floatformat_to_doublest (&floatformat_ieee_double_big,
989 &regbuf[REGISTER_BYTE (S390_FP0_REGNUM)],
990 &val);
991 store_floating (valbuf, len, val);
992 }
993 }
994 else
995 {
996 int offset = 0;
997 /* return value is copied starting from r2. */
998 if (TYPE_LENGTH (valtype) < S390_GPR_SIZE)
999 offset = S390_GPR_SIZE - TYPE_LENGTH (valtype);
1000 memcpy (valbuf,
1001 regbuf + REGISTER_BYTE (S390_GP0_REGNUM + 2) + offset,
1002 TYPE_LENGTH (valtype));
1003 }
1004}
1005
1006
1007static char *
1008s390_promote_integer_argument (struct type *valtype, char *valbuf,
1009 char *reg_buff, int *arglen)
1010{
1011 char *value = valbuf;
1012 int len = TYPE_LENGTH (valtype);
1013
1014 if (len < S390_GPR_SIZE)
1015 {
1016 /* We need to upgrade this value to a register to pass it correctly */
1017 int idx, diff = S390_GPR_SIZE - len, negative =
1018 (!TYPE_UNSIGNED (valtype) && value[0] & 0x80);
1019 for (idx = 0; idx < S390_GPR_SIZE; idx++)
1020 {
1021 reg_buff[idx] = (idx < diff ? (negative ? 0xff : 0x0) :
1022 value[idx - diff]);
1023 }
1024 value = reg_buff;
1025 *arglen = S390_GPR_SIZE;
1026 }
1027 else
1028 {
1029 if (len & (S390_GPR_SIZE - 1))
1030 {
1031 fprintf_unfiltered (gdb_stderr,
1032 "s390_promote_integer_argument detected an argument not "
1033 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1034 "we might not deal with this correctly.\n");
1035 }
1036 *arglen = len;
1037 }
1038
1039 return (value);
1040}
1041
1042void
1043s390_store_return_value (struct type *valtype, char *valbuf)
1044{
1045 int arglen;
1046 char *reg_buff = alloca (max (S390_FPR_SIZE, REGISTER_SIZE)), *value;
1047
1048 if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
1049 {
1050 DOUBLEST tempfloat = extract_floating (valbuf, TYPE_LENGTH (valtype));
1051
1052 floatformat_from_doublest (&floatformat_ieee_double_big, &tempfloat,
1053 reg_buff);
1054 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM), reg_buff,
1055 S390_FPR_SIZE);
1056 }
1057 else
1058 {
1059 value =
1060 s390_promote_integer_argument (valtype, valbuf, reg_buff, &arglen);
1061 /* Everything else is returned in GPR2 and up. */
1062 write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM + 2), value,
1063 arglen);
1064 }
1065}
1066static int
1067gdb_print_insn_s390 (bfd_vma memaddr, disassemble_info * info)
1068{
1069 bfd_byte instrbuff[S390_MAX_INSTR_SIZE];
1070 int instrlen, cnt;
1071
1072 instrlen = s390_readinstruction (instrbuff, (CORE_ADDR) memaddr, info);
1073 if (instrlen < 0)
1074 {
1075 (*info->memory_error_func) (instrlen, memaddr, info);
1076 return -1;
1077 }
1078 for (cnt = 0; cnt < instrlen; cnt++)
1079 info->fprintf_func (info->stream, "%02X ", instrbuff[cnt]);
1080 for (cnt = instrlen; cnt < S390_MAX_INSTR_SIZE; cnt++)
1081 info->fprintf_func (info->stream, " ");
1082 instrlen = print_insn_s390 (memaddr, info);
1083 return instrlen;
1084}
1085
1086
1087
1088/* Not the most efficent code in the world */
1089int
1090s390_fp_regnum ()
1091{
1092 int regno = S390_SP_REGNUM;
1093 struct frame_extra_info fextra_info;
1094
1095 CORE_ADDR pc = ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM));
1096
1097 s390_get_frame_info (s390_sniff_pc_function_start (pc, NULL), &fextra_info,
1098 NULL, 1);
1099 if (fextra_info.frame_pointer_saved_pc)
1100 regno = S390_FRAME_REGNUM;
1101 return regno;
1102}
1103
1104CORE_ADDR
1105s390_read_fp ()
1106{
1107 return read_register (s390_fp_regnum ());
1108}
1109
1110
1111void
1112s390_write_fp (CORE_ADDR val)
1113{
1114 write_register (s390_fp_regnum (), val);
1115}
1116
1117
1118void
1119s390_push_dummy_frame ()
1120{
1121 CORE_ADDR orig_sp = read_register (S390_SP_REGNUM), new_sp;
1122 void *saved_regs = alloca (REGISTER_BYTES);
1123
1124 new_sp = (orig_sp - (REGISTER_BYTES + S390_GPR_SIZE));
1125 read_register_bytes (0, (char *) saved_regs, REGISTER_BYTES);
1126 /* Use saved copy instead of orig_sp as this will have the correct endianness */
1127 write_memory (new_sp, (char *) saved_regs + REGISTER_BYTE (S390_SP_REGNUM),
1128 S390_GPR_SIZE);
1129 write_memory (new_sp + S390_GPR_SIZE, (char *) &saved_regs, REGISTER_BYTES);
1130 write_register (S390_SP_REGNUM, new_sp);
1131}
1132
1133/* pop the innermost frame, go back to the caller.
1134 Used in `call_function_by_hand' to remove an artificial stack
1135 frame. */
1136void
1137s390_pop_frame ()
1138{
1139 CORE_ADDR new_sp = read_register (S390_SP_REGNUM), orig_sp;
1140 void *saved_regs = alloca (REGISTER_BYTES);
1141
1142
1143 read_memory (new_sp + S390_GPR_SIZE, (char *) saved_regs, REGISTER_BYTES);
1144 write_register_bytes (0, (char *) &saved_regs, REGISTER_BYTES);
1145}
1146
1147/* used by call function by hand
1148 struct_return indicates that this function returns a structure &
1149 therefore gpr2 stores a pointer to the structure to be returned as
1150 opposed to the first argument.
1151 Currently I haven't seen a TYPE_CODE_INT whose size wasn't 2^n or less
1152 than S390_GPR_SIZE this is good because I don't seem to have to worry
1153 about sign extending pushed arguments (i.e. a signed char currently
1154 comes into this code with a size of 4 ). */
1155
1156CORE_ADDR
d45fc520 1157s390_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
5769d3cd
AC		 1158 int struct_return, CORE_ADDR struct_addr)
1159{
1160 int num_float_args, num_gpr_args, orig_num_gpr_args, argno;
1161 int second_pass, len, arglen, gprs_required;
1162 CORE_ADDR outgoing_args_ptr, outgoing_args_space;
d45fc520 1163 struct value *arg;
5769d3cd
AC		 1164 struct type *type;
1165 int max_num_gpr_args = 5 - (struct_return ? 1 : 0);
1166 int arg0_regnum = S390_GP0_REGNUM + 2 + (struct_return ? 1 : 0);
1167 char *reg_buff = alloca (max (S390_FPR_SIZE, REGISTER_SIZE)), *value;
1168
1169 for (second_pass = 0; second_pass <= 1; second_pass++)
1170 {
1171 if (second_pass)
1172 outgoing_args_ptr = sp + S390_STACK_FRAME_OVERHEAD;
1173 else
1174 outgoing_args_ptr = 0;
1175 num_float_args = 0;
1176 num_gpr_args = 0;
1177 for (argno = 0; argno < nargs; argno++)
1178 {
1179 arg = args[argno];
1180 type = check_typedef (VALUE_TYPE (arg));
1181 len = TYPE_LENGTH (type);
1182 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1183 {
1184 int all_float_registers_used =
1185 num_float_args > (GDB_TARGET_IS_ESAME ? 3 : 1);
1186
1187 if (second_pass)
1188 {
1189 DOUBLEST tempfloat =
1190 extract_floating (VALUE_CONTENTS (arg), len);
1191
1192
1193 floatformat_from_doublest (all_float_registers_used &&
1194 len == (TARGET_FLOAT_BIT >> 3)
1195 ? &floatformat_ieee_single_big
1196 : &floatformat_ieee_double_big,
1197 &tempfloat, reg_buff);
1198 if (all_float_registers_used)
1199 write_memory (outgoing_args_ptr, reg_buff, len);
1200 else
1201 write_register_bytes (REGISTER_BYTE ((S390_FP0_REGNUM)
1202 +
1203 (2 *
1204 num_float_args)),
1205 reg_buff, S390_FPR_SIZE);
1206 }
1207 if (all_float_registers_used)
1208 outgoing_args_ptr += len;
1209 num_float_args++;
1210 }
1211 else
1212 {
1213 gprs_required = ((len + (S390_GPR_SIZE - 1)) / S390_GPR_SIZE);
1214
1215 value =
1216 s390_promote_integer_argument (type, VALUE_CONTENTS (arg),
1217 reg_buff, &arglen);
1218
1219 orig_num_gpr_args = num_gpr_args;
1220 num_gpr_args += gprs_required;
1221 if (num_gpr_args > max_num_gpr_args)
1222 {
1223 if (second_pass)
1224 write_memory (outgoing_args_ptr, value, arglen);
1225 outgoing_args_ptr += arglen;
1226 }
1227 else
1228 {
1229 if (second_pass)
1230 write_register_bytes (REGISTER_BYTE (arg0_regnum)
1231 +
1232 (orig_num_gpr_args * S390_GPR_SIZE),
1233 value, arglen);
1234 }
1235 }
1236 }
1237 if (!second_pass)
1238 {
1239 outgoing_args_space = outgoing_args_ptr;
1240 /* Align to 16 bytes because because I like alignment &
1241 some of the kernel code requires 8 byte stack alignment at least. */
1242 sp = (sp - (S390_STACK_FRAME_OVERHEAD + outgoing_args_ptr)) & (-16);
1243 }
1244
1245 }
1246 return sp;
1247
1248}
1249
1250void
1251s390_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
1252 struct value **args, struct type *value_type,
1253 int using_gcc)
1254{
1255 store_unsigned_integer (dummy + 4, REGISTER_SIZE, fun);
1256}
1257
1258
1259/* Return the GDB type object for the "standard" data type
1260 of data in register N. */
1261struct type *
1262s390_register_virtual_type (int regno)
1263{
1264 return ((unsigned) regno - S390_FPC_REGNUM) <
1265 S390_NUM_FPRS ? builtin_type_double : builtin_type_int;
1266}
1267
1268
1269struct type *
1270s390x_register_virtual_type (int regno)
1271{
1272 return (regno == S390_FPC_REGNUM) ||
1273 (regno >= S390_FIRST_ACR && regno <= S390_LAST_ACR) ? builtin_type_int :
1274 (regno >= S390_FP0_REGNUM) ? builtin_type_double : builtin_type_long;
1275}
1276
1277
1278
1279void
1280s390_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1281{
1282 write_register (S390_GP0_REGNUM + 2, addr);
1283}
1284
1285
1286
1287static unsigned char *
1288s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
1289{
1290 static unsigned char breakpoint[] = { 0x0, 0x1 };
1291
1292 *lenptr = sizeof (breakpoint);
1293 return breakpoint;
1294}
1295
1296/* Advance PC across any function entry prologue instructions to reach some
1297 "real" code. */
1298CORE_ADDR
1299s390_skip_prologue (CORE_ADDR pc)
1300{
1301 struct frame_extra_info fextra_info;
1302
1303 s390_get_frame_info (pc, &fextra_info, NULL, 1);
1304 return fextra_info.skip_prologue_function_start;
1305}
1306
1307/* pc_in_call_dummy_on stack may work for us must test this */
1308int
1309s390_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
1310{
1311 return pc > sp && pc < (sp + 4096);
1312}
1313
1314/* Immediately after a function call, return the saved pc.
1315 Can't go through the frames for this because on some machines
1316 the new frame is not set up until the new function executes
1317 some instructions. */
1318CORE_ADDR
1319s390_saved_pc_after_call (struct frame_info *frame)
1320{
1321 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
1322}
1323
1324static CORE_ADDR
1325s390_addr_bits_remove (CORE_ADDR addr)
1326{
1327 return (addr) & 0x7fffffff;
1328}
1329
1330
1331static CORE_ADDR
1332s390_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1333{
1334 return sp;
1335}
1336
1337struct gdbarch *
1338s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1339{
1340
1341 /* instruction sequence for s390 call dummy is as follows
1342 bras %r1,.+8 ; 0xA7150004
1343 long basraddr ; 0x00000000
1344 l %r1,0(%r1) ; 0x58101000
1345 basr %r14,%r1 ; 0x0DE1
1346 breakpoint ; 0x0001 */
1347 static LONGEST s390_call_dummy_words[] = { 0xA7150004, 0x00000000,
1348 0x58101000, 0x0DE10001
1349 };
1350 /* instruction sequence for esame call dummy is as follows
1351 bras %r1,.+12 ; 0xA7150006
1352 long basraddr ; 0x0000000000000000
1353 lg %r1,0(%r1) ; 0xE31010000004
1354 basr %r14,%r1 ; 0x0DE1
1355 breakpoint ; 0x0001 */
1356 static LONGEST s390x_call_dummy_words[] = { 0xA715000600000000,
1357 0x00000000E3101000,
1358 0x00040DE100010000
1359 };
1360 struct gdbarch *gdbarch;
1361 struct gdbarch_tdep *tdep;
1362 int elf_flags;
1363
1364 /* First see if there is already a gdbarch that can satisfy the request. */
1365 arches = gdbarch_list_lookup_by_info (arches, &info);
1366 if (arches != NULL)
1367 return arches->gdbarch;
1368
1369 /* None found: is the request for a s390 architecture? */
1370 if (info.bfd_arch_info->arch != bfd_arch_s390)
1371 return NULL; /* No; then it's not for us. */
1372
1373 /* Yes: create a new gdbarch for the specified machine type. */
1374 gdbarch = gdbarch_alloc (&info, NULL);
1375
1376 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
1377
1378 /* We don't define set_gdbarch_call_dummy_breakpoint_offset
1379 as we already have a breakpoint inserted. */
1380 set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
1381
1382 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
1383 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1384 set_gdbarch_pc_in_call_dummy (gdbarch, s390_pc_in_call_dummy);
1385 set_gdbarch_frame_args_skip (gdbarch, 0);
1386 set_gdbarch_frame_args_address (gdbarch, s390_frame_args_address);
1387 set_gdbarch_frame_chain (gdbarch, s390_frame_chain);
1388 set_gdbarch_frame_init_saved_regs (gdbarch, s390_frame_init_saved_regs);
1389 set_gdbarch_frame_locals_address (gdbarch, s390_frame_args_address);
1390 /* We can't do this */
1391 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1392 set_gdbarch_store_struct_return (gdbarch, s390_store_struct_return);
1393 set_gdbarch_extract_return_value (gdbarch, s390_extract_return_value);
1394 set_gdbarch_store_return_value (gdbarch, s390_store_return_value);
1395 /* Amount PC must be decremented by after a breakpoint.
1396 This is often the number of bytes in BREAKPOINT
1397 but not always. */
1398 set_gdbarch_decr_pc_after_break (gdbarch, 2);
1399 set_gdbarch_pop_frame (gdbarch, s390_pop_frame);
1400 set_gdbarch_push_dummy_frame (gdbarch, s390_push_dummy_frame);
1401 set_gdbarch_push_arguments (gdbarch, s390_push_arguments);
1402 set_gdbarch_ieee_float (gdbarch, 1);
1403 /* Stack grows downward. */
1404 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1405 /* Offset from address of function to start of its code.
1406 Zero on most machines. */
1407 set_gdbarch_function_start_offset (gdbarch, 0);
1408 set_gdbarch_max_register_raw_size (gdbarch, 8);
1409 set_gdbarch_max_register_virtual_size (gdbarch, 8);
1410 set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
1411 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
1412 set_gdbarch_init_extra_frame_info (gdbarch, s390_init_extra_frame_info);
1413 set_gdbarch_init_frame_pc_first (gdbarch, s390_init_frame_pc_first);
1414 set_gdbarch_read_fp (gdbarch, s390_read_fp);
1415 set_gdbarch_write_fp (gdbarch, s390_write_fp);
1416 /* This function that tells us whether the function invocation represented
1417 by FI does not have a frame on the stack associated with it. If it
1418 does not, FRAMELESS is set to 1, else 0. */
1419 set_gdbarch_frameless_function_invocation (gdbarch,
1420 s390_frameless_function_invocation);
1421 /* Return saved PC from a frame */
1422 set_gdbarch_frame_saved_pc (gdbarch, s390_frame_saved_pc);
1423 /* FRAME_CHAIN takes a frame's nominal address
1424 and produces the frame's chain-pointer. */
1425 set_gdbarch_frame_chain (gdbarch, s390_frame_chain);
1426 set_gdbarch_saved_pc_after_call (gdbarch, s390_saved_pc_after_call);
1427 set_gdbarch_register_byte (gdbarch, s390_register_byte);
1428 set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
1429 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
1430 set_gdbarch_fp_regnum (gdbarch, S390_FP_REGNUM);
1431 set_gdbarch_fp0_regnum (gdbarch, S390_FP0_REGNUM);
1432 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
1433 set_gdbarch_cannot_fetch_register (gdbarch, s390_cannot_fetch_register);
1434 set_gdbarch_cannot_store_register (gdbarch, s390_cannot_fetch_register);
1435 set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
1436 set_gdbarch_use_struct_convention (gdbarch, generic_use_struct_convention);
1437 set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
1438 set_gdbarch_register_name (gdbarch, s390_register_name);
1439 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
1440 set_gdbarch_dwarf_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
1441 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
5769d3cd
AC		 1442
1443 /* Stuff below here wouldn't be required if gdbarch.sh was a little */
1444 /* more intelligent */
1445 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 0);
1446 set_gdbarch_call_dummy_p (gdbarch, 1);
1447 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1448 set_gdbarch_extract_struct_value_address (gdbarch, 0);
1449 set_gdbarch_fix_call_dummy (gdbarch, s390_fix_call_dummy);
5769d3cd
AC		 1450 set_gdbarch_push_return_address (gdbarch, s390_push_return_address);
1451
1452 switch (info.bfd_arch_info->mach)
1453 {
1454 case bfd_mach_s390_esa:
1455 set_gdbarch_register_size (gdbarch, 4);
1456 set_gdbarch_call_dummy_length (gdbarch, 16);
1457 set_gdbarch_register_raw_size (gdbarch, s390_register_raw_size);
1458 set_gdbarch_register_virtual_size (gdbarch, s390_register_raw_size);
1459 set_gdbarch_register_virtual_type (gdbarch, s390_register_virtual_type);
1460
1461 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
1462
1463 set_gdbarch_sizeof_call_dummy_words (gdbarch,
1464 sizeof (s390_call_dummy_words));
1465 set_gdbarch_call_dummy_words (gdbarch, s390_call_dummy_words);
1466 set_gdbarch_register_bytes (gdbarch, S390_REGISTER_BYTES);
1467 break;
1468 case bfd_mach_s390_esame:
1469 set_gdbarch_register_size (gdbarch, 8);
1470 set_gdbarch_call_dummy_length (gdbarch, 22);
1471 set_gdbarch_register_raw_size (gdbarch, s390x_register_raw_size);
1472 set_gdbarch_register_virtual_size (gdbarch, s390x_register_raw_size);
1473 set_gdbarch_register_virtual_type (gdbarch,
1474 s390x_register_virtual_type);
1475
1476 set_gdbarch_long_bit (gdbarch, 64);
1477 set_gdbarch_long_long_bit (gdbarch, 64);
1478 set_gdbarch_ptr_bit (gdbarch, 64);
1479 set_gdbarch_sizeof_call_dummy_words (gdbarch,
1480 sizeof (s390x_call_dummy_words));
1481 set_gdbarch_call_dummy_words (gdbarch, s390x_call_dummy_words);
1482 set_gdbarch_register_bytes (gdbarch, S390X_REGISTER_BYTES);
1483 break;
1484 }
1485
1486 return gdbarch;
1487}
1488
1489
1490
1491void
1492_initialize_s390_tdep ()
1493{
1494
1495 /* Hook us into the gdbarch mechanism. */
1496 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
1497 if (!tm_print_insn) /* Someone may have already set it */
1498 tm_print_insn = gdb_print_insn_s390;
1499}
1500
1501#endif /* GDBSERVER */
GDB Binutils - Deliverables
This page took 0.082567 seconds and 4 git commands to generate.