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