1 /* GNU/Linux S/390 specific low level interface, for the remote server
3 Copyright (C) 2001-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* This file is used for both 31-bit and 64-bit S/390 systems. */
23 #include "linux-low.h"
24 #include "elf/common.h"
26 #include "tracepoint.h"
28 #include <asm/ptrace.h>
29 #include "nat/gdb_ptrace.h"
34 #include "linux-s390-tdesc.h"
36 #ifndef HWCAP_S390_HIGH_GPRS
37 #define HWCAP_S390_HIGH_GPRS 512
41 #define HWCAP_S390_TE 1024
45 #define HWCAP_S390_VX 2048
49 #define HWCAP_S390_GS 16384
52 #define s390_num_regs 52
54 /* Linux target op definitions for the S/390 architecture. */
56 class s390_target
: public linux_process_target
60 const regs_info
*get_regs_info () override
;
62 const gdb_byte
*sw_breakpoint_from_kind (int kind
, int *size
) override
;
64 bool supports_z_point_type (char z_type
) override
;
66 bool supports_tracepoints () override
;
68 bool supports_fast_tracepoints () override
;
70 int install_fast_tracepoint_jump_pad
71 (CORE_ADDR tpoint
, CORE_ADDR tpaddr
, CORE_ADDR collector
,
72 CORE_ADDR lockaddr
, ULONGEST orig_size
, CORE_ADDR
*jump_entry
,
73 CORE_ADDR
*trampoline
, ULONGEST
*trampoline_size
,
74 unsigned char *jjump_pad_insn
, ULONGEST
*jjump_pad_insn_size
,
75 CORE_ADDR
*adjusted_insn_addr
, CORE_ADDR
*adjusted_insn_addr_end
,
78 int get_min_fast_tracepoint_insn_len () override
;
80 void low_collect_ptrace_register (regcache
*regcache
, int regno
,
83 void low_supply_ptrace_register (regcache
*regcache
, int regno
,
84 const char *buf
) override
;
86 struct emit_ops
*emit_ops () override
;
88 int get_ipa_tdesc_idx () override
;
92 void low_arch_setup () override
;
94 bool low_cannot_fetch_register (int regno
) override
;
96 bool low_cannot_store_register (int regno
) override
;
98 bool low_supports_breakpoints () override
;
100 CORE_ADDR
low_get_pc (regcache
*regcache
) override
;
102 void low_set_pc (regcache
*regcache
, CORE_ADDR newpc
) override
;
104 int low_decr_pc_after_break () override
;
106 bool low_breakpoint_at (CORE_ADDR pc
) override
;
108 int low_get_thread_area (int lwpid
, CORE_ADDR
*addrp
) override
;
111 /* The singleton target ops object. */
113 static s390_target the_s390_target
;
115 static int s390_regmap
[] = {
116 PT_PSWMASK
, PT_PSWADDR
,
118 PT_GPR0
, PT_GPR1
, PT_GPR2
, PT_GPR3
,
119 PT_GPR4
, PT_GPR5
, PT_GPR6
, PT_GPR7
,
120 PT_GPR8
, PT_GPR9
, PT_GPR10
, PT_GPR11
,
121 PT_GPR12
, PT_GPR13
, PT_GPR14
, PT_GPR15
,
123 PT_ACR0
, PT_ACR1
, PT_ACR2
, PT_ACR3
,
124 PT_ACR4
, PT_ACR5
, PT_ACR6
, PT_ACR7
,
125 PT_ACR8
, PT_ACR9
, PT_ACR10
, PT_ACR11
,
126 PT_ACR12
, PT_ACR13
, PT_ACR14
, PT_ACR15
,
131 PT_FPR0_HI
, PT_FPR1_HI
, PT_FPR2_HI
, PT_FPR3_HI
,
132 PT_FPR4_HI
, PT_FPR5_HI
, PT_FPR6_HI
, PT_FPR7_HI
,
133 PT_FPR8_HI
, PT_FPR9_HI
, PT_FPR10_HI
, PT_FPR11_HI
,
134 PT_FPR12_HI
, PT_FPR13_HI
, PT_FPR14_HI
, PT_FPR15_HI
,
136 PT_FPR0
, PT_FPR1
, PT_FPR2
, PT_FPR3
,
137 PT_FPR4
, PT_FPR5
, PT_FPR6
, PT_FPR7
,
138 PT_FPR8
, PT_FPR9
, PT_FPR10
, PT_FPR11
,
139 PT_FPR12
, PT_FPR13
, PT_FPR14
, PT_FPR15
,
145 #define s390_num_regs_3264 68
148 static int s390_regmap_3264
[] = {
149 PT_PSWMASK
, PT_PSWADDR
,
151 PT_GPR0
, PT_GPR0
, PT_GPR1
, PT_GPR1
,
152 PT_GPR2
, PT_GPR2
, PT_GPR3
, PT_GPR3
,
153 PT_GPR4
, PT_GPR4
, PT_GPR5
, PT_GPR5
,
154 PT_GPR6
, PT_GPR6
, PT_GPR7
, PT_GPR7
,
155 PT_GPR8
, PT_GPR8
, PT_GPR9
, PT_GPR9
,
156 PT_GPR10
, PT_GPR10
, PT_GPR11
, PT_GPR11
,
157 PT_GPR12
, PT_GPR12
, PT_GPR13
, PT_GPR13
,
158 PT_GPR14
, PT_GPR14
, PT_GPR15
, PT_GPR15
,
160 PT_ACR0
, PT_ACR1
, PT_ACR2
, PT_ACR3
,
161 PT_ACR4
, PT_ACR5
, PT_ACR6
, PT_ACR7
,
162 PT_ACR8
, PT_ACR9
, PT_ACR10
, PT_ACR11
,
163 PT_ACR12
, PT_ACR13
, PT_ACR14
, PT_ACR15
,
167 PT_FPR0
, PT_FPR1
, PT_FPR2
, PT_FPR3
,
168 PT_FPR4
, PT_FPR5
, PT_FPR6
, PT_FPR7
,
169 PT_FPR8
, PT_FPR9
, PT_FPR10
, PT_FPR11
,
170 PT_FPR12
, PT_FPR13
, PT_FPR14
, PT_FPR15
,
175 static int s390_regmap_3264
[] = {
176 PT_PSWMASK
, PT_PSWADDR
,
178 -1, PT_GPR0
, -1, PT_GPR1
,
179 -1, PT_GPR2
, -1, PT_GPR3
,
180 -1, PT_GPR4
, -1, PT_GPR5
,
181 -1, PT_GPR6
, -1, PT_GPR7
,
182 -1, PT_GPR8
, -1, PT_GPR9
,
183 -1, PT_GPR10
, -1, PT_GPR11
,
184 -1, PT_GPR12
, -1, PT_GPR13
,
185 -1, PT_GPR14
, -1, PT_GPR15
,
187 PT_ACR0
, PT_ACR1
, PT_ACR2
, PT_ACR3
,
188 PT_ACR4
, PT_ACR5
, PT_ACR6
, PT_ACR7
,
189 PT_ACR8
, PT_ACR9
, PT_ACR10
, PT_ACR11
,
190 PT_ACR12
, PT_ACR13
, PT_ACR14
, PT_ACR15
,
194 PT_FPR0_HI
, PT_FPR1_HI
, PT_FPR2_HI
, PT_FPR3_HI
,
195 PT_FPR4_HI
, PT_FPR5_HI
, PT_FPR6_HI
, PT_FPR7_HI
,
196 PT_FPR8_HI
, PT_FPR9_HI
, PT_FPR10_HI
, PT_FPR11_HI
,
197 PT_FPR12_HI
, PT_FPR13_HI
, PT_FPR14_HI
, PT_FPR15_HI
,
205 s390_target::low_cannot_fetch_register (int regno
)
211 s390_target::low_cannot_store_register (int regno
)
217 s390_target::low_collect_ptrace_register (regcache
*regcache
, int regno
,
220 int size
= register_size (regcache
->tdesc
, regno
);
221 const struct regs_info
*regs_info
= get_regs_info ();
222 struct usrregs_info
*usr
= regs_info
->usrregs
;
223 int regaddr
= usr
->regmap
[regno
];
225 if (size
< sizeof (long))
227 memset (buf
, 0, sizeof (long));
229 if ((regno
^ 1) < usr
->num_regs
230 && usr
->regmap
[regno
^ 1] == regaddr
)
232 collect_register (regcache
, regno
& ~1, buf
);
233 collect_register (regcache
, (regno
& ~1) + 1,
234 buf
+ sizeof (long) - size
);
236 else if (regaddr
== PT_PSWMASK
)
238 /* Convert 4-byte PSW mask to 8 bytes by clearing bit 12 and copying
239 the basic addressing mode bit from the PSW address. */
240 gdb_byte
*addr
= (gdb_byte
*) alloca (register_size (regcache
->tdesc
, regno
^ 1));
241 collect_register (regcache
, regno
, buf
);
242 collect_register (regcache
, regno
^ 1, addr
);
244 buf
[size
] |= (addr
[0] & 0x80);
246 else if (regaddr
== PT_PSWADDR
)
248 /* Convert 4-byte PSW address to 8 bytes by clearing the addressing
249 mode bit (which gets copied to the PSW mask instead). */
250 collect_register (regcache
, regno
, buf
+ sizeof (long) - size
);
251 buf
[sizeof (long) - size
] &= ~0x80;
253 else if ((regaddr
>= PT_GPR0
&& regaddr
<= PT_GPR15
)
254 || regaddr
== PT_ORIGGPR2
)
255 collect_register (regcache
, regno
, buf
+ sizeof (long) - size
);
257 collect_register (regcache
, regno
, buf
);
259 else if (regaddr
!= -1)
260 collect_register (regcache
, regno
, buf
);
264 s390_target::low_supply_ptrace_register (regcache
*regcache
, int regno
,
267 int size
= register_size (regcache
->tdesc
, regno
);
268 const struct regs_info
*regs_info
= get_regs_info ();
269 struct usrregs_info
*usr
= regs_info
->usrregs
;
270 int regaddr
= usr
->regmap
[regno
];
272 if (size
< sizeof (long))
274 if ((regno
^ 1) < usr
->num_regs
275 && usr
->regmap
[regno
^ 1] == regaddr
)
277 supply_register (regcache
, regno
& ~1, buf
);
278 supply_register (regcache
, (regno
& ~1) + 1,
279 buf
+ sizeof (long) - size
);
281 else if (regaddr
== PT_PSWMASK
)
283 /* Convert 8-byte PSW mask to 4 bytes by setting bit 12 and copying
284 the basic addressing mode into the PSW address. */
285 gdb_byte
*mask
= (gdb_byte
*) alloca (size
);
286 gdb_byte
*addr
= (gdb_byte
*) alloca (register_size (regcache
->tdesc
, regno
^ 1));
287 memcpy (mask
, buf
, size
);
289 supply_register (regcache
, regno
, mask
);
291 collect_register (regcache
, regno
^ 1, addr
);
293 addr
[0] |= (buf
[size
] & 0x80);
294 supply_register (regcache
, regno
^ 1, addr
);
296 else if (regaddr
== PT_PSWADDR
)
298 /* Convert 8-byte PSW address to 4 bytes by truncating, but
299 keeping the addressing mode bit (which was set from the mask). */
300 gdb_byte
*addr
= (gdb_byte
*) alloca (size
);
302 collect_register (regcache
, regno
, addr
);
303 amode
= addr
[0] & 0x80;
304 memcpy (addr
, buf
+ sizeof (long) - size
, size
);
307 supply_register (regcache
, regno
, addr
);
309 else if ((regaddr
>= PT_GPR0
&& regaddr
<= PT_GPR15
)
310 || regaddr
== PT_ORIGGPR2
)
311 supply_register (regcache
, regno
, buf
+ sizeof (long) - size
);
313 supply_register (regcache
, regno
, buf
);
315 else if (regaddr
!= -1)
316 supply_register (regcache
, regno
, buf
);
319 /* Provide only a fill function for the general register set. ps_lgetregs
320 will use this for NPTL support. */
323 s390_fill_gregset (struct regcache
*regcache
, void *buf
)
326 const struct regs_info
*regs_info
= the_linux_target
->get_regs_info ();
327 struct usrregs_info
*usr
= regs_info
->usrregs
;
329 for (i
= 0; i
< usr
->num_regs
; i
++)
331 if (usr
->regmap
[i
] < PT_PSWMASK
332 || usr
->regmap
[i
] > PT_ACR15
)
335 ((s390_target
*) the_linux_target
)->low_collect_ptrace_register
336 (regcache
, i
, (char *) buf
+ usr
->regmap
[i
]);
340 /* Fill and store functions for extended register sets. */
344 s390_fill_gprs_high (struct regcache
*regcache
, void *buf
)
346 int r0h
= find_regno (regcache
->tdesc
, "r0h");
349 for (i
= 0; i
< 16; i
++)
350 collect_register (regcache
, r0h
+ 2 * i
, (char *) buf
+ 4 * i
);
354 s390_store_gprs_high (struct regcache
*regcache
, const void *buf
)
356 int r0h
= find_regno (regcache
->tdesc
, "r0h");
359 for (i
= 0; i
< 16; i
++)
360 supply_register (regcache
, r0h
+ 2 * i
, (const char *) buf
+ 4 * i
);
365 s390_store_last_break (struct regcache
*regcache
, const void *buf
)
369 p
= (const char *) buf
+ 8 - register_size (regcache
->tdesc
, 0);
370 supply_register_by_name (regcache
, "last_break", p
);
374 s390_fill_system_call (struct regcache
*regcache
, void *buf
)
376 collect_register_by_name (regcache
, "system_call", buf
);
380 s390_store_system_call (struct regcache
*regcache
, const void *buf
)
382 supply_register_by_name (regcache
, "system_call", buf
);
386 s390_store_tdb (struct regcache
*regcache
, const void *buf
)
388 int tdb0
= find_regno (regcache
->tdesc
, "tdb0");
389 int tr0
= find_regno (regcache
->tdesc
, "tr0");
392 for (i
= 0; i
< 4; i
++)
393 supply_register (regcache
, tdb0
+ i
, (const char *) buf
+ 8 * i
);
395 for (i
= 0; i
< 16; i
++)
396 supply_register (regcache
, tr0
+ i
, (const char *) buf
+ 8 * (16 + i
));
400 s390_fill_vxrs_low (struct regcache
*regcache
, void *buf
)
402 int v0
= find_regno (regcache
->tdesc
, "v0l");
405 for (i
= 0; i
< 16; i
++)
406 collect_register (regcache
, v0
+ i
, (char *) buf
+ 8 * i
);
410 s390_store_vxrs_low (struct regcache
*regcache
, const void *buf
)
412 int v0
= find_regno (regcache
->tdesc
, "v0l");
415 for (i
= 0; i
< 16; i
++)
416 supply_register (regcache
, v0
+ i
, (const char *) buf
+ 8 * i
);
420 s390_fill_vxrs_high (struct regcache
*regcache
, void *buf
)
422 int v16
= find_regno (regcache
->tdesc
, "v16");
425 for (i
= 0; i
< 16; i
++)
426 collect_register (regcache
, v16
+ i
, (char *) buf
+ 16 * i
);
430 s390_store_vxrs_high (struct regcache
*regcache
, const void *buf
)
432 int v16
= find_regno (regcache
->tdesc
, "v16");
435 for (i
= 0; i
< 16; i
++)
436 supply_register (regcache
, v16
+ i
, (const char *) buf
+ 16 * i
);
440 s390_store_gs (struct regcache
*regcache
, const void *buf
)
442 int gsd
= find_regno (regcache
->tdesc
, "gsd");
445 for (i
= 0; i
< 3; i
++)
446 supply_register (regcache
, gsd
+ i
, (const char *) buf
+ 8 * (i
+ 1));
450 s390_store_gsbc (struct regcache
*regcache
, const void *buf
)
452 int bc_gsd
= find_regno (regcache
->tdesc
, "bc_gsd");
455 for (i
= 0; i
< 3; i
++)
456 supply_register (regcache
, bc_gsd
+ i
, (const char *) buf
+ 8 * (i
+ 1));
459 static struct regset_info s390_regsets
[] = {
460 { 0, 0, 0, 0, GENERAL_REGS
, s390_fill_gregset
, NULL
},
462 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_S390_HIGH_GPRS
, 0,
463 EXTENDED_REGS
, s390_fill_gprs_high
, s390_store_gprs_high
},
465 /* Last break address is read-only; no fill function. */
466 { PTRACE_GETREGSET
, -1, NT_S390_LAST_BREAK
, 0, EXTENDED_REGS
,
467 NULL
, s390_store_last_break
},
468 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_S390_SYSTEM_CALL
, 0,
469 EXTENDED_REGS
, s390_fill_system_call
, s390_store_system_call
},
470 /* TDB is read-only. */
471 { PTRACE_GETREGSET
, -1, NT_S390_TDB
, 0, EXTENDED_REGS
,
472 NULL
, s390_store_tdb
},
473 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_S390_VXRS_LOW
, 0,
474 EXTENDED_REGS
, s390_fill_vxrs_low
, s390_store_vxrs_low
},
475 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_S390_VXRS_HIGH
, 0,
476 EXTENDED_REGS
, s390_fill_vxrs_high
, s390_store_vxrs_high
},
477 /* Guarded storage registers are read-only. */
478 { PTRACE_GETREGSET
, -1, NT_S390_GS_CB
, 0, EXTENDED_REGS
,
479 NULL
, s390_store_gs
},
480 { PTRACE_GETREGSET
, -1, NT_S390_GS_BC
, 0, EXTENDED_REGS
,
481 NULL
, s390_store_gsbc
},
486 static const gdb_byte s390_breakpoint
[] = { 0, 1 };
487 #define s390_breakpoint_len 2
489 /* Implementation of target ops method "sw_breakpoint_from_kind". */
492 s390_target::sw_breakpoint_from_kind (int kind
, int *size
)
494 *size
= s390_breakpoint_len
;
495 return s390_breakpoint
;
499 s390_target::low_supports_breakpoints ()
505 s390_target::low_get_pc (regcache
*regcache
)
507 if (register_size (regcache
->tdesc
, 0) == 4)
510 collect_register_by_name (regcache
, "pswa", &pswa
);
511 return pswa
& 0x7fffffff;
516 collect_register_by_name (regcache
, "pswa", &pc
);
522 s390_target::low_set_pc (regcache
*regcache
, CORE_ADDR newpc
)
524 if (register_size (regcache
->tdesc
, 0) == 4)
527 collect_register_by_name (regcache
, "pswa", &pswa
);
528 pswa
= (pswa
& 0x80000000) | (newpc
& 0x7fffffff);
529 supply_register_by_name (regcache
, "pswa", &pswa
);
533 unsigned long pc
= newpc
;
534 supply_register_by_name (regcache
, "pswa", &pc
);
539 s390_target::low_decr_pc_after_break ()
541 return s390_breakpoint_len
;
544 /* Determine the word size for the given PID, in bytes. */
548 s390_get_wordsize (int pid
)
551 PTRACE_XFER_TYPE pswm
= ptrace (PTRACE_PEEKUSER
, pid
,
552 (PTRACE_TYPE_ARG3
) 0,
553 (PTRACE_TYPE_ARG4
) 0);
556 warning (_("Couldn't determine word size, assuming 64-bit."));
559 /* Derive word size from extended addressing mode (PSW bit 31). */
560 return pswm
& (1L << 32) ? 8 : 4;
563 #define s390_get_wordsize(pid) 4
567 s390_check_regset (int pid
, int regset
, int regsize
)
569 void *buf
= alloca (regsize
);
573 iov
.iov_len
= regsize
;
575 if (ptrace (PTRACE_GETREGSET
, pid
, (long) regset
, (long) &iov
) >= 0
581 /* For a 31-bit inferior, whether the kernel supports using the full
583 static int have_hwcap_s390_high_gprs
= 0;
584 static int have_hwcap_s390_vx
= 0;
587 s390_target::low_arch_setup ()
589 const struct target_desc
*tdesc
;
590 struct regset_info
*regset
;
592 /* Determine word size and HWCAP. */
593 int pid
= pid_of (current_thread
);
594 int wordsize
= s390_get_wordsize (pid
);
595 unsigned long hwcap
= linux_get_hwcap (wordsize
);
597 /* Check whether the kernel supports extra register sets. */
598 int have_regset_last_break
599 = s390_check_regset (pid
, NT_S390_LAST_BREAK
, 8);
600 int have_regset_system_call
601 = s390_check_regset (pid
, NT_S390_SYSTEM_CALL
, 4);
603 = (s390_check_regset (pid
, NT_S390_TDB
, 256)
604 && (hwcap
& HWCAP_S390_TE
) != 0);
606 = (s390_check_regset (pid
, NT_S390_VXRS_LOW
, 128)
607 && s390_check_regset (pid
, NT_S390_VXRS_HIGH
, 256)
608 && (hwcap
& HWCAP_S390_VX
) != 0);
610 = (s390_check_regset (pid
, NT_S390_GS_CB
, 32)
611 && s390_check_regset (pid
, NT_S390_GS_BC
, 32)
612 && (hwcap
& HWCAP_S390_GS
) != 0);
619 tdesc
= tdesc_s390x_gs_linux64
;
620 else if (have_regset_vxrs
)
621 tdesc
= (have_regset_tdb
? tdesc_s390x_tevx_linux64
:
622 tdesc_s390x_vx_linux64
);
623 else if (have_regset_tdb
)
624 tdesc
= tdesc_s390x_te_linux64
;
625 else if (have_regset_system_call
)
626 tdesc
= tdesc_s390x_linux64v2
;
627 else if (have_regset_last_break
)
628 tdesc
= tdesc_s390x_linux64v1
;
630 tdesc
= tdesc_s390x_linux64
;
633 /* For a 31-bit inferior, check whether the kernel supports
634 using the full 64-bit GPRs. */
637 if (hwcap
& HWCAP_S390_HIGH_GPRS
)
639 have_hwcap_s390_high_gprs
= 1;
641 tdesc
= tdesc_s390_gs_linux64
;
642 else if (have_regset_vxrs
)
643 tdesc
= (have_regset_tdb
? tdesc_s390_tevx_linux64
:
644 tdesc_s390_vx_linux64
);
645 else if (have_regset_tdb
)
646 tdesc
= tdesc_s390_te_linux64
;
647 else if (have_regset_system_call
)
648 tdesc
= tdesc_s390_linux64v2
;
649 else if (have_regset_last_break
)
650 tdesc
= tdesc_s390_linux64v1
;
652 tdesc
= tdesc_s390_linux64
;
656 /* Assume 31-bit inferior process. */
657 if (have_regset_system_call
)
658 tdesc
= tdesc_s390_linux32v2
;
659 else if (have_regset_last_break
)
660 tdesc
= tdesc_s390_linux32v1
;
662 tdesc
= tdesc_s390_linux32
;
665 have_hwcap_s390_vx
= have_regset_vxrs
;
668 /* Update target_regsets according to available register sets. */
669 for (regset
= s390_regsets
; regset
->size
>= 0; regset
++)
670 if (regset
->get_request
== PTRACE_GETREGSET
)
671 switch (regset
->nt_type
)
674 case NT_S390_HIGH_GPRS
:
675 regset
->size
= have_hwcap_s390_high_gprs
? 64 : 0;
678 case NT_S390_LAST_BREAK
:
679 regset
->size
= have_regset_last_break
? 8 : 0;
681 case NT_S390_SYSTEM_CALL
:
682 regset
->size
= have_regset_system_call
? 4 : 0;
685 regset
->size
= have_regset_tdb
? 256 : 0;
687 case NT_S390_VXRS_LOW
:
688 regset
->size
= have_regset_vxrs
? 128 : 0;
690 case NT_S390_VXRS_HIGH
:
691 regset
->size
= have_regset_vxrs
? 256 : 0;
695 regset
->size
= have_regset_gs
? 32 : 0;
700 current_process ()->tdesc
= tdesc
;
705 s390_target::low_breakpoint_at (CORE_ADDR pc
)
707 unsigned char c
[s390_breakpoint_len
];
708 read_inferior_memory (pc
, c
, s390_breakpoint_len
);
709 return memcmp (c
, s390_breakpoint
, s390_breakpoint_len
) == 0;
712 /* Breakpoint/Watchpoint support. */
714 /* The "supports_z_point_type" target ops method. */
717 s390_target::supports_z_point_type (char z_type
)
728 static struct usrregs_info s390_usrregs_info
=
734 static struct regsets_info s390_regsets_info
=
736 s390_regsets
, /* regsets */
738 NULL
, /* disabled_regsets */
741 static struct regs_info myregs_info
=
743 NULL
, /* regset_bitmap */
748 static struct usrregs_info s390_usrregs_info_3264
=
754 static struct regsets_info s390_regsets_info_3264
=
756 s390_regsets
, /* regsets */
758 NULL
, /* disabled_regsets */
761 static struct regs_info regs_info_3264
=
763 NULL
, /* regset_bitmap */
764 &s390_usrregs_info_3264
,
765 &s390_regsets_info_3264
769 s390_target::get_regs_info ()
771 if (have_hwcap_s390_high_gprs
)
774 const struct target_desc
*tdesc
= current_process ()->tdesc
;
776 if (register_size (tdesc
, 0) == 4)
777 return ®s_info_3264
;
779 return ®s_info_3264
;
785 /* The "supports_tracepoints" target ops method. */
788 s390_target::supports_tracepoints ()
793 /* Implementation of linux target ops method "low_get_thread_area". */
796 s390_target::low_get_thread_area (int lwpid
, CORE_ADDR
*addrp
)
798 CORE_ADDR res
= ptrace (PTRACE_PEEKUSER
, lwpid
, (long) PT_ACR0
, (long) 0);
800 struct regcache
*regcache
= get_thread_regcache (current_thread
, 0);
802 if (register_size (regcache
->tdesc
, 0) == 4)
803 res
&= 0xffffffffull
;
810 /* Fast tracepoint support.
812 The register save area on stack is identical for all targets:
814 0x000+i*0x10: VR0-VR31
821 If we're on 31-bit linux, we just don't store the high parts of the GPRs.
822 Likewise, if there's no VX support, we just store the FRs into the slots
823 of low VR halves. The agent code is responsible for rearranging that
826 /* Code sequence saving GPRs for 31-bit target with no high GPRs. There's
827 one trick used at the very beginning: since there's no way to allocate
828 stack space without destroying CC (lay instruction can do it, but it's
829 only supported on later CPUs), we take 4 different execution paths for
830 every possible value of CC, allocate stack space, save %r0, stuff the
831 CC value in %r0 (shifted to match its position in PSWM high word),
832 then branch to common path. */
834 static const unsigned char s390_ft_entry_gpr_esa
[] = {
835 0xa7, 0x14, 0x00, 0x1e, /* jo .Lcc3 */
836 0xa7, 0x24, 0x00, 0x14, /* jh .Lcc2 */
837 0xa7, 0x44, 0x00, 0x0a, /* jl .Lcc1 */
839 0xa7, 0xfa, 0xfd, 0x00, /* ahi %r15, -0x300 */
840 0x50, 0x00, 0xf2, 0x04, /* st %r0, 0x204(%r15) */
841 0xa7, 0x08, 0x00, 0x00, /* lhi %r0, 0 */
842 0xa7, 0xf4, 0x00, 0x18, /* j .Lccdone */
844 0xa7, 0xfa, 0xfd, 0x00, /* ahi %r15, -0x300 */
845 0x50, 0x00, 0xf2, 0x04, /* st %r0, 0x204(%r15) */
846 0xa7, 0x08, 0x10, 0x00, /* lhi %r0, 0x1000 */
847 0xa7, 0xf4, 0x00, 0x10, /* j .Lccdone */
849 0xa7, 0xfa, 0xfd, 0x00, /* ahi %r15, -0x300 */
850 0x50, 0x00, 0xf2, 0x04, /* st %r0, 0x204(%r15) */
851 0xa7, 0x08, 0x20, 0x00, /* lhi %r0, 0x2000 */
852 0xa7, 0xf4, 0x00, 0x08, /* j .Lccdone */
854 0xa7, 0xfa, 0xfd, 0x00, /* ahi %r15, -0x300 */
855 0x50, 0x00, 0xf2, 0x04, /* st %r0, 0x204(%r15) */
856 0xa7, 0x08, 0x30, 0x00, /* lhi %r0, 0x3000 */
858 0x50, 0x10, 0xf2, 0x0c, /* st %r1, 0x20c(%r15) */
859 0x50, 0x20, 0xf2, 0x14, /* st %r2, 0x214(%r15) */
860 0x50, 0x30, 0xf2, 0x1c, /* st %r3, 0x21c(%r15) */
861 0x50, 0x40, 0xf2, 0x24, /* st %r4, 0x224(%r15) */
862 0x50, 0x50, 0xf2, 0x2c, /* st %r5, 0x22c(%r15) */
863 0x50, 0x60, 0xf2, 0x34, /* st %r6, 0x234(%r15) */
864 0x50, 0x70, 0xf2, 0x3c, /* st %r7, 0x23c(%r15) */
865 0x50, 0x80, 0xf2, 0x44, /* st %r8, 0x244(%r15) */
866 0x50, 0x90, 0xf2, 0x4c, /* st %r9, 0x24c(%r15) */
867 0x50, 0xa0, 0xf2, 0x54, /* st %r10, 0x254(%r15) */
868 0x50, 0xb0, 0xf2, 0x5c, /* st %r11, 0x25c(%r15) */
869 0x50, 0xc0, 0xf2, 0x64, /* st %r12, 0x264(%r15) */
870 0x50, 0xd0, 0xf2, 0x6c, /* st %r13, 0x26c(%r15) */
871 0x50, 0xe0, 0xf2, 0x74, /* st %r14, 0x274(%r15) */
872 /* Compute original value of %r15 and store it. We use ahi instead
873 of la to preserve the whole value, and not just the low 31 bits.
874 This is not particularly important here, but essential in the
875 zarch case where someone might be using the high word of %r15
876 as an extra register. */
877 0x18, 0x1f, /* lr %r1, %r15 */
878 0xa7, 0x1a, 0x03, 0x00, /* ahi %r1, 0x300 */
879 0x50, 0x10, 0xf2, 0x7c, /* st %r1, 0x27c(%r15) */
882 /* Code sequence saving GPRs for 31-bit target with high GPRs and for 64-bit
883 target. Same as above, except this time we can use load/store multiple,
884 since the 64-bit regs are tightly packed. */
886 static const unsigned char s390_ft_entry_gpr_zarch
[] = {
887 0xa7, 0x14, 0x00, 0x21, /* jo .Lcc3 */
888 0xa7, 0x24, 0x00, 0x16, /* jh .Lcc2 */
889 0xa7, 0x44, 0x00, 0x0b, /* jl .Lcc1 */
891 0xa7, 0xfb, 0xfd, 0x00, /* aghi %r15, -0x300 */
892 0xeb, 0x0e, 0xf2, 0x00, 0x00, 0x24, /* stmg %r0, %r14, 0x200(%r15) */
893 0xa7, 0x08, 0x00, 0x00, /* lhi %r0, 0 */
894 0xa7, 0xf4, 0x00, 0x1b, /* j .Lccdone */
896 0xa7, 0xfb, 0xfd, 0x00, /* aghi %r15, -0x300 */
897 0xeb, 0x0e, 0xf2, 0x00, 0x00, 0x24, /* stmg %r0, %r14, 0x200(%r15) */
898 0xa7, 0x08, 0x10, 0x00, /* lhi %r0, 0x1000 */
899 0xa7, 0xf4, 0x00, 0x12, /* j .Lccdone */
901 0xa7, 0xfb, 0xfd, 0x00, /* aghi %r15, -0x300 */
902 0xeb, 0x0e, 0xf2, 0x00, 0x00, 0x24, /* stmg %r0, %r14, 0x200(%r15) */
903 0xa7, 0x08, 0x20, 0x00, /* lhi %r0, 0x2000 */
904 0xa7, 0xf4, 0x00, 0x09, /* j .Lccdone */
906 0xa7, 0xfb, 0xfd, 0x00, /* aghi %r15, -0x300 */
907 0xeb, 0x0e, 0xf2, 0x00, 0x00, 0x24, /* stmg %r0, %r14, 0x200(%r15) */
908 0xa7, 0x08, 0x30, 0x00, /* lhi %r0, 0x3000 */
910 0xb9, 0x04, 0x00, 0x1f, /* lgr %r1, %r15 */
911 0xa7, 0x1b, 0x03, 0x00, /* aghi %r1, 0x300 */
912 0xe3, 0x10, 0xf2, 0x78, 0x00, 0x24, /* stg %r1, 0x278(%r15) */
915 /* Code sequence saving ARs, PSWM and FPC. PSWM has to be assembled from
916 current PSWM (read by epsw) and CC from entry (in %r0). */
918 static const unsigned char s390_ft_entry_misc
[] = {
919 0x9b, 0x0f, 0xf2, 0x80, /* stam %a0, %a15, 0x20(%%r15) */
920 0xb9, 0x8d, 0x00, 0x23, /* epsw %r2, %r3 */
921 0xa7, 0x18, 0xcf, 0xff, /* lhi %r1, ~0x3000 */
922 0x14, 0x21, /* nr %r2, %r1 */
923 0x16, 0x20, /* or %r2, %r0 */
924 0x50, 0x20, 0xf2, 0xc0, /* st %r2, 0x2c0(%r15) */
925 0x50, 0x30, 0xf2, 0xc4, /* st %r3, 0x2c4(%r15) */
926 0xb2, 0x9c, 0xf2, 0xd0, /* stfpc 0x2d0(%r15) */
929 /* Code sequence saving FRs, used if VX not supported. */
931 static const unsigned char s390_ft_entry_fr
[] = {
932 0x60, 0x00, 0xf0, 0x00, /* std %f0, 0x000(%r15) */
933 0x60, 0x10, 0xf0, 0x10, /* std %f1, 0x010(%r15) */
934 0x60, 0x20, 0xf0, 0x20, /* std %f2, 0x020(%r15) */
935 0x60, 0x30, 0xf0, 0x30, /* std %f3, 0x030(%r15) */
936 0x60, 0x40, 0xf0, 0x40, /* std %f4, 0x040(%r15) */
937 0x60, 0x50, 0xf0, 0x50, /* std %f5, 0x050(%r15) */
938 0x60, 0x60, 0xf0, 0x60, /* std %f6, 0x060(%r15) */
939 0x60, 0x70, 0xf0, 0x70, /* std %f7, 0x070(%r15) */
940 0x60, 0x80, 0xf0, 0x80, /* std %f8, 0x080(%r15) */
941 0x60, 0x90, 0xf0, 0x90, /* std %f9, 0x090(%r15) */
942 0x60, 0xa0, 0xf0, 0xa0, /* std %f10, 0x0a0(%r15) */
943 0x60, 0xb0, 0xf0, 0xb0, /* std %f11, 0x0b0(%r15) */
944 0x60, 0xc0, 0xf0, 0xc0, /* std %f12, 0x0c0(%r15) */
945 0x60, 0xd0, 0xf0, 0xd0, /* std %f13, 0x0d0(%r15) */
946 0x60, 0xe0, 0xf0, 0xe0, /* std %f14, 0x0e0(%r15) */
947 0x60, 0xf0, 0xf0, 0xf0, /* std %f15, 0x0f0(%r15) */
950 /* Code sequence saving VRs, used if VX not supported. */
952 static const unsigned char s390_ft_entry_vr
[] = {
953 0xe7, 0x0f, 0xf0, 0x00, 0x00, 0x3e, /* vstm %v0, %v15, 0x000(%r15) */
954 0xe7, 0x0f, 0xf1, 0x00, 0x0c, 0x3e, /* vstm %v16, %v31, 0x100(%r15) */
957 /* Code sequence doing the collection call for 31-bit target. %r1 contains
958 the address of the literal pool. */
960 static const unsigned char s390_ft_main_31
[] = {
961 /* Load the literals into registers. */
962 0x58, 0x50, 0x10, 0x00, /* l %r5, 0x0(%r1) */
963 0x58, 0x20, 0x10, 0x04, /* l %r2, 0x4(%r1) */
964 0x58, 0x40, 0x10, 0x08, /* l %r4, 0x8(%r1) */
965 0x58, 0x60, 0x10, 0x0c, /* l %r6, 0xc(%r1) */
966 /* Save original PSWA (tracepoint address | 0x80000000). */
967 0x50, 0x50, 0xf2, 0xcc, /* st %r5, 0x2cc(%r15) */
968 /* Construct a collecting_t object at %r15+0x2e0. */
969 0x50, 0x20, 0xf2, 0xe0, /* st %r2, 0x2e0(%r15) */
970 0x9b, 0x00, 0xf2, 0xe4, /* stam %a0, %a0, 0x2e4(%r15) */
971 /* Move its address to %r0. */
972 0x41, 0x00, 0xf2, 0xe0, /* la %r0, 0x2e0(%r15) */
975 0xa7, 0x18, 0x00, 0x00, /* lhi %r1, 0 */
976 0xba, 0x10, 0x60, 0x00, /* cs %r1, %r0, 0(%r6) */
977 0xa7, 0x74, 0xff, 0xfc, /* jne .Lloop */
978 /* Address of the register save block to %r3. */
979 0x18, 0x3f, /* lr %r3, %r15 */
980 /* Make a stack frame, so that we can call the collector. */
981 0xa7, 0xfa, 0xff, 0xa0, /* ahi %r15, -0x60 */
983 0x0d, 0xe4, /* basr %r14, %r4 */
984 /* And get rid of the stack frame again. */
985 0x41, 0xf0, 0xf0, 0x60, /* la %r15, 0x60(%r15) */
986 /* Leave the lock. */
987 0x07, 0xf0, /* br %r0 */
988 0xa7, 0x18, 0x00, 0x00, /* lhi %r1, 0 */
989 0x50, 0x10, 0x60, 0x00, /* st %t1, 0(%r6) */
992 /* Code sequence doing the collection call for 64-bit target. %r1 contains
993 the address of the literal pool. */
995 static const unsigned char s390_ft_main_64
[] = {
996 /* Load the literals into registers. */
997 0xe3, 0x50, 0x10, 0x00, 0x00, 0x04, /* lg %r5, 0x00(%r1) */
998 0xe3, 0x20, 0x10, 0x08, 0x00, 0x04, /* lg %r2, 0x08(%r1) */
999 0xe3, 0x40, 0x10, 0x10, 0x00, 0x04, /* lg %r4, 0x10(%r1) */
1000 0xe3, 0x60, 0x10, 0x18, 0x00, 0x04, /* lg %r6, 0x18(%r1) */
1001 /* Save original PSWA (tracepoint address). */
1002 0xe3, 0x50, 0xf2, 0xc8, 0x00, 0x24, /* stg %r5, 0x2c8(%r15) */
1003 /* Construct a collecting_t object at %r15+0x2e0. */
1004 0xe3, 0x20, 0xf2, 0xe0, 0x00, 0x24, /* stg %r2, 0x2e0(%r15) */
1005 0x9b, 0x01, 0xf2, 0xe8, /* stam %a0, %a1, 0x2e8(%r15) */
1006 /* Move its address to %r0. */
1007 0x41, 0x00, 0xf2, 0xe0, /* la %r0, 0x2e0(%r15) */
1008 /* Take the lock. */
1010 0xa7, 0x19, 0x00, 0x00, /* lghi %r1, 0 */
1011 0xeb, 0x10, 0x60, 0x00, 0x00, 0x30, /* csg %r1, %r0, 0(%r6) */
1012 0xa7, 0x74, 0xff, 0xfb, /* jne .Lloop */
1013 /* Address of the register save block to %r3. */
1014 0xb9, 0x04, 0x00, 0x3f, /* lgr %r3, %r15 */
1015 /* Make a stack frame, so that we can call the collector. */
1016 0xa7, 0xfb, 0xff, 0x60, /* aghi %r15, -0xa0 */
1018 0x0d, 0xe4, /* basr %r14, %r4 */
1019 /* And get rid of the stack frame again. */
1020 0x41, 0xf0, 0xf0, 0xa0, /* la %r15, 0xa0(%r15) */
1021 /* Leave the lock. */
1022 0x07, 0xf0, /* br %r0 */
1023 0xa7, 0x19, 0x00, 0x00, /* lghi %r1, 0 */
1024 0xe3, 0x10, 0x60, 0x00, 0x00, 0x24, /* stg %t1, 0(%r6) */
1027 /* Code sequence restoring FRs, for targets with no VX support. */
1029 static const unsigned char s390_ft_exit_fr
[] = {
1030 0x68, 0x00, 0xf0, 0x00, /* ld %f0, 0x000(%r15) */
1031 0x68, 0x10, 0xf0, 0x10, /* ld %f1, 0x010(%r15) */
1032 0x68, 0x20, 0xf0, 0x20, /* ld %f2, 0x020(%r15) */
1033 0x68, 0x30, 0xf0, 0x30, /* ld %f3, 0x030(%r15) */
1034 0x68, 0x40, 0xf0, 0x40, /* ld %f4, 0x040(%r15) */
1035 0x68, 0x50, 0xf0, 0x50, /* ld %f5, 0x050(%r15) */
1036 0x68, 0x60, 0xf0, 0x60, /* ld %f6, 0x060(%r15) */
1037 0x68, 0x70, 0xf0, 0x70, /* ld %f7, 0x070(%r15) */
1038 0x68, 0x80, 0xf0, 0x80, /* ld %f8, 0x080(%r15) */
1039 0x68, 0x90, 0xf0, 0x90, /* ld %f9, 0x090(%r15) */
1040 0x68, 0xa0, 0xf0, 0xa0, /* ld %f10, 0x0a0(%r15) */
1041 0x68, 0xb0, 0xf0, 0xb0, /* ld %f11, 0x0b0(%r15) */
1042 0x68, 0xc0, 0xf0, 0xc0, /* ld %f12, 0x0c0(%r15) */
1043 0x68, 0xd0, 0xf0, 0xd0, /* ld %f13, 0x0d0(%r15) */
1044 0x68, 0xe0, 0xf0, 0xe0, /* ld %f14, 0x0e0(%r15) */
1045 0x68, 0xf0, 0xf0, 0xf0, /* ld %f15, 0x0f0(%r15) */
1048 /* Code sequence restoring VRs. */
1050 static const unsigned char s390_ft_exit_vr
[] = {
1051 0xe7, 0x0f, 0xf0, 0x00, 0x00, 0x36, /* vlm %v0, %v15, 0x000(%r15) */
1052 0xe7, 0x0f, 0xf1, 0x00, 0x0c, 0x36, /* vlm %v16, %v31, 0x100(%r15) */
1055 /* Code sequence restoring misc registers. As for PSWM, only CC should be
1056 modified by C code, so we use the alr instruction to restore it by
1057 manufacturing an operand that'll result in the original flags. */
1059 static const unsigned char s390_ft_exit_misc
[] = {
1060 0xb2, 0x9d, 0xf2, 0xd0, /* lfpc 0x2d0(%r15) */
1061 0x58, 0x00, 0xf2, 0xc0, /* l %r0, 0x2c0(%r15) */
1062 /* Extract CC to high 2 bits of %r0. */
1063 0x88, 0x00, 0x00, 0x0c, /* srl %r0, 12 */
1064 0x89, 0x00, 0x00, 0x1e, /* sll %r0, 30 */
1065 /* Add %r0 to itself. Result will be nonzero iff CC bit 0 is set, and
1066 will have carry iff CC bit 1 is set - resulting in the same flags
1068 0x1e, 0x00, /* alr %r0, %r0 */
1069 0x9a, 0x0f, 0xf2, 0x80, /* lam %a0, %a15, 0x280(%r15) */
1072 /* Code sequence restoring GPRs, for 31-bit targets with no high GPRs. */
1074 static const unsigned char s390_ft_exit_gpr_esa
[] = {
1075 0x58, 0x00, 0xf2, 0x04, /* l %r0, 0x204(%r15) */
1076 0x58, 0x10, 0xf2, 0x0c, /* l %r1, 0x20c(%r15) */
1077 0x58, 0x20, 0xf2, 0x14, /* l %r2, 0x214(%r15) */
1078 0x58, 0x30, 0xf2, 0x1c, /* l %r3, 0x21c(%r15) */
1079 0x58, 0x40, 0xf2, 0x24, /* l %r4, 0x224(%r15) */
1080 0x58, 0x50, 0xf2, 0x2c, /* l %r5, 0x22c(%r15) */
1081 0x58, 0x60, 0xf2, 0x34, /* l %r6, 0x234(%r15) */
1082 0x58, 0x70, 0xf2, 0x3c, /* l %r7, 0x23c(%r15) */
1083 0x58, 0x80, 0xf2, 0x44, /* l %r8, 0x244(%r15) */
1084 0x58, 0x90, 0xf2, 0x4c, /* l %r9, 0x24c(%r15) */
1085 0x58, 0xa0, 0xf2, 0x54, /* l %r10, 0x254(%r15) */
1086 0x58, 0xb0, 0xf2, 0x5c, /* l %r11, 0x25c(%r15) */
1087 0x58, 0xc0, 0xf2, 0x64, /* l %r12, 0x264(%r15) */
1088 0x58, 0xd0, 0xf2, 0x6c, /* l %r13, 0x26c(%r15) */
1089 0x58, 0xe0, 0xf2, 0x74, /* l %r14, 0x274(%r15) */
1090 0x58, 0xf0, 0xf2, 0x7c, /* l %r15, 0x27c(%r15) */
1093 /* Code sequence restoring GPRs, for 64-bit targets and 31-bit targets
1096 static const unsigned char s390_ft_exit_gpr_zarch
[] = {
1097 0xeb, 0x0f, 0xf2, 0x00, 0x00, 0x04, /* lmg %r0, %r15, 0x200(%r15) */
1100 /* Writes instructions to target, updating the to pointer. */
1103 append_insns (CORE_ADDR
*to
, size_t len
, const unsigned char *buf
)
1105 target_write_memory (*to
, buf
, len
);
1109 /* Relocates an instruction from oldloc to *to, updating to. */
1112 s390_relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
, int is_64
)
1117 /* 0: no fixup, 1: PC16DBL fixup, 2: PC32DBL fixup. */
1120 read_inferior_memory (oldloc
, buf
, sizeof buf
);
1123 else if (buf
[0] < 0xc0)
1129 case 0x05: /* BALR */
1130 case 0x0c: /* BASSM */
1131 case 0x0d: /* BASR */
1132 case 0x45: /* BAL */
1133 case 0x4d: /* BAS */
1134 /* These save a return address and mess around with registers.
1135 We can't relocate them. */
1137 case 0x84: /* BRXH */
1138 case 0x85: /* BRXLE */
1143 /* BRC, BRAS, BRCT, BRCTG */
1144 if (op2
>= 4 && op2
<= 7)
1152 /* LARL, BRCL, BRASL */
1153 if (op2
== 0 || op2
== 4 || op2
== 5)
1161 /* PC-relative addressing instructions. */
1164 case 0xc5: /* BPRP */
1165 case 0xc7: /* BPP */
1166 /* Branch prediction - just skip it. */
1178 case 0x44: /* BRXHG */
1179 case 0x45: /* BRXLG */
1180 case 0x64: /* CGRJ */
1181 case 0x65: /* CLGRJ */
1182 case 0x76: /* CRJ */
1183 case 0x77: /* CLRJ */
1192 /* We'll have to relocate an instruction with a PC-relative field.
1193 First, compute the target. */
1194 int64_t loffset
= 0;
1198 int16_t soffset
= 0;
1199 memcpy (&soffset
, buf
+ 2, 2);
1204 int32_t soffset
= 0;
1205 memcpy (&soffset
, buf
+ 2, 4);
1208 target
= oldloc
+ loffset
* 2;
1210 target
&= 0x7fffffff;
1214 /* BRAS or BRASL was used. We cannot just relocate those, since
1215 they save the return address in a register. We can, however,
1216 replace them with a LARL+JG sequence. */
1218 /* Make the LARL. */
1222 loffset
= oldloc
+ ilen
- *to
;
1225 if (soffset
!= loffset
&& is_64
)
1227 memcpy (buf
+ 2, &soffset
, 4);
1228 append_insns (to
, 6, buf
);
1230 /* Note: this is not fully correct. In 31-bit mode, LARL will write
1231 an address with the top bit 0, while BRAS/BRASL will write it
1232 with top bit 1. It should not matter much, since linux compilers
1233 use BR and not BSM to return from functions, but it could confuse
1234 some poor stack unwinder. */
1236 /* We'll now be writing a JG. */
1243 /* Compute the new offset and write it to the buffer. */
1244 loffset
= target
- *to
;
1249 int16_t soffset
= loffset
;
1250 if (soffset
!= loffset
)
1252 memcpy (buf
+ 2, &soffset
, 2);
1256 int32_t soffset
= loffset
;
1257 if (soffset
!= loffset
&& is_64
)
1259 memcpy (buf
+ 2, &soffset
, 4);
1262 append_insns (to
, ilen
, buf
);
1267 s390_target::supports_fast_tracepoints ()
1272 /* Implementation of target ops method
1273 "install_fast_tracepoint_jump_pad". */
1276 s390_target::install_fast_tracepoint_jump_pad
1277 (CORE_ADDR tpoint
, CORE_ADDR tpaddr
, CORE_ADDR collector
,
1278 CORE_ADDR lockaddr
, ULONGEST orig_size
, CORE_ADDR
*jump_entry
,
1279 CORE_ADDR
*trampoline
, ULONGEST
*trampoline_size
,
1280 unsigned char *jjump_pad_insn
, ULONGEST
*jjump_pad_insn_size
,
1281 CORE_ADDR
*adjusted_insn_addr
, CORE_ADDR
*adjusted_insn_addr_end
,
1287 unsigned char jbuf
[6] = { 0xc0, 0xf4, 0, 0, 0, 0 }; /* jg ... */
1288 CORE_ADDR buildaddr
= *jump_entry
;
1290 struct regcache
*regcache
= get_thread_regcache (current_thread
, 0);
1291 int is_64
= register_size (regcache
->tdesc
, 0) == 8;
1292 int is_zarch
= is_64
|| have_hwcap_s390_high_gprs
;
1293 int has_vx
= have_hwcap_s390_vx
;
1295 int is_64
= 0, is_zarch
= 0, has_vx
= 0;
1297 CORE_ADDR literals
[4] = {
1304 /* First, store the GPRs. */
1306 append_insns (&buildaddr
, sizeof s390_ft_entry_gpr_zarch
,
1307 s390_ft_entry_gpr_zarch
);
1309 append_insns (&buildaddr
, sizeof s390_ft_entry_gpr_esa
,
1310 s390_ft_entry_gpr_esa
);
1312 /* Second, misc registers (ARs, PSWM, FPC). PSWA will be stored below. */
1313 append_insns (&buildaddr
, sizeof s390_ft_entry_misc
, s390_ft_entry_misc
);
1315 /* Third, FRs or VRs. */
1317 append_insns (&buildaddr
, sizeof s390_ft_entry_vr
, s390_ft_entry_vr
);
1319 append_insns (&buildaddr
, sizeof s390_ft_entry_fr
, s390_ft_entry_fr
);
1321 /* Now, the main part of code - store PSWA, take lock, call collector,
1322 leave lock. First, we'll need to fetch 4 literals. */
1324 unsigned char buf
[] = {
1325 0x07, 0x07, /* nopr %r7 */
1326 0x07, 0x07, /* nopr %r7 */
1327 0x07, 0x07, /* nopr %r7 */
1328 0xa7, 0x15, 0x00, 0x12, /* bras %r1, .Lend */
1329 0, 0, 0, 0, 0, 0, 0, 0, /* tpaddr */
1330 0, 0, 0, 0, 0, 0, 0, 0, /* tpoint */
1331 0, 0, 0, 0, 0, 0, 0, 0, /* collector */
1332 0, 0, 0, 0, 0, 0, 0, 0, /* lockaddr */
1335 /* Find the proper start place in buf, so that literals will be
1337 int bufpos
= (buildaddr
+ 2) & 7;
1338 /* Stuff the literals into the buffer. */
1339 for (i
= 0; i
< 4; i
++) {
1340 uint64_t lit
= literals
[i
];
1341 memcpy (&buf
[sizeof buf
- 32 + i
* 8], &lit
, 8);
1343 append_insns (&buildaddr
, sizeof buf
- bufpos
, buf
+ bufpos
);
1344 append_insns (&buildaddr
, sizeof s390_ft_main_64
, s390_ft_main_64
);
1346 unsigned char buf
[] = {
1347 0x07, 0x07, /* nopr %r7 */
1348 0xa7, 0x15, 0x00, 0x0a, /* bras %r1, .Lend */
1349 0, 0, 0, 0, /* tpaddr */
1350 0, 0, 0, 0, /* tpoint */
1351 0, 0, 0, 0, /* collector */
1352 0, 0, 0, 0, /* lockaddr */
1355 /* Find the proper start place in buf, so that literals will be
1357 int bufpos
= (buildaddr
+ 2) & 3;
1358 /* First literal will be saved as the PSWA, make sure it has the high bit
1360 literals
[0] |= 0x80000000;
1361 /* Stuff the literals into the buffer. */
1362 for (i
= 0; i
< 4; i
++) {
1363 uint32_t lit
= literals
[i
];
1364 memcpy (&buf
[sizeof buf
- 16 + i
* 4], &lit
, 4);
1366 append_insns (&buildaddr
, sizeof buf
- bufpos
, buf
+ bufpos
);
1367 append_insns (&buildaddr
, sizeof s390_ft_main_31
, s390_ft_main_31
);
1370 /* Restore FRs or VRs. */
1372 append_insns (&buildaddr
, sizeof s390_ft_exit_vr
, s390_ft_exit_vr
);
1374 append_insns (&buildaddr
, sizeof s390_ft_exit_fr
, s390_ft_exit_fr
);
1376 /* Restore misc registers. */
1377 append_insns (&buildaddr
, sizeof s390_ft_exit_misc
, s390_ft_exit_misc
);
1379 /* Restore the GPRs. */
1381 append_insns (&buildaddr
, sizeof s390_ft_exit_gpr_zarch
,
1382 s390_ft_exit_gpr_zarch
);
1384 append_insns (&buildaddr
, sizeof s390_ft_exit_gpr_esa
,
1385 s390_ft_exit_gpr_esa
);
1387 /* Now, adjust the original instruction to execute in the jump
1389 *adjusted_insn_addr
= buildaddr
;
1390 if (s390_relocate_instruction (&buildaddr
, tpaddr
, is_64
))
1392 sprintf (err
, "E.Could not relocate instruction for tracepoint.");
1395 *adjusted_insn_addr_end
= buildaddr
;
1397 /* Finally, write a jump back to the program. */
1399 loffset
= (tpaddr
+ orig_size
) - buildaddr
;
1402 if (is_64
&& offset
!= loffset
)
1405 "E.Jump back from jump pad too far from tracepoint "
1406 "(offset 0x%" PRIx64
" > int33).", loffset
);
1409 memcpy (jbuf
+ 2, &offset
, 4);
1410 append_insns (&buildaddr
, sizeof jbuf
, jbuf
);
1412 /* The jump pad is now built. Wire in a jump to our jump pad. This
1413 is always done last (by our caller actually), so that we can
1414 install fast tracepoints with threads running. This relies on
1415 the agent's atomic write support. */
1416 loffset
= *jump_entry
- tpaddr
;
1419 if (is_64
&& offset
!= loffset
)
1422 "E.Jump back from jump pad too far from tracepoint "
1423 "(offset 0x%" PRIx64
" > int33).", loffset
);
1426 memcpy (jbuf
+ 2, &offset
, 4);
1427 memcpy (jjump_pad_insn
, jbuf
, sizeof jbuf
);
1428 *jjump_pad_insn_size
= sizeof jbuf
;
1430 /* Return the end address of our pad. */
1431 *jump_entry
= buildaddr
;
1436 /* Implementation of target ops method
1437 "get_min_fast_tracepoint_insn_len". */
1440 s390_target::get_min_fast_tracepoint_insn_len ()
1442 /* We only support using 6-byte jumps to reach the tracepoint code.
1443 If the tracepoint buffer were allocated sufficiently close (64kiB)
1444 to the executable code, and the traced instruction itself was close
1445 enough to the beginning, we could use 4-byte jumps, but this doesn't
1446 seem to be worth the effort. */
1450 /* Implementation of target ops method "get_ipa_tdesc_idx". */
1453 s390_target::get_ipa_tdesc_idx ()
1455 struct regcache
*regcache
= get_thread_regcache (current_thread
, 0);
1456 const struct target_desc
*tdesc
= regcache
->tdesc
;
1459 if (tdesc
== tdesc_s390x_linux64
)
1460 return S390_TDESC_64
;
1461 if (tdesc
== tdesc_s390x_linux64v1
)
1462 return S390_TDESC_64V1
;
1463 if (tdesc
== tdesc_s390x_linux64v2
)
1464 return S390_TDESC_64V2
;
1465 if (tdesc
== tdesc_s390x_te_linux64
)
1466 return S390_TDESC_TE
;
1467 if (tdesc
== tdesc_s390x_vx_linux64
)
1468 return S390_TDESC_VX
;
1469 if (tdesc
== tdesc_s390x_tevx_linux64
)
1470 return S390_TDESC_TEVX
;
1471 if (tdesc
== tdesc_s390x_gs_linux64
)
1472 return S390_TDESC_GS
;
1475 if (tdesc
== tdesc_s390_linux32
)
1476 return S390_TDESC_32
;
1477 if (tdesc
== tdesc_s390_linux32v1
)
1478 return S390_TDESC_32V1
;
1479 if (tdesc
== tdesc_s390_linux32v2
)
1480 return S390_TDESC_32V2
;
1481 if (tdesc
== tdesc_s390_linux64
)
1482 return S390_TDESC_64
;
1483 if (tdesc
== tdesc_s390_linux64v1
)
1484 return S390_TDESC_64V1
;
1485 if (tdesc
== tdesc_s390_linux64v2
)
1486 return S390_TDESC_64V2
;
1487 if (tdesc
== tdesc_s390_te_linux64
)
1488 return S390_TDESC_TE
;
1489 if (tdesc
== tdesc_s390_vx_linux64
)
1490 return S390_TDESC_VX
;
1491 if (tdesc
== tdesc_s390_tevx_linux64
)
1492 return S390_TDESC_TEVX
;
1493 if (tdesc
== tdesc_s390_gs_linux64
)
1494 return S390_TDESC_GS
;
1499 /* Appends given buffer to current_insn_ptr in the target. */
1502 add_insns (const unsigned char *start
, int len
)
1504 CORE_ADDR buildaddr
= current_insn_ptr
;
1507 debug_printf ("Adding %d bytes of insn at %s\n",
1508 len
, paddress (buildaddr
));
1510 append_insns (&buildaddr
, len
, start
);
1511 current_insn_ptr
= buildaddr
;
1514 /* Register usage in emit:
1517 - %r2: top of stack (high word for 31-bit)
1518 - %r3: low word of top of stack (for 31-bit)
1520 - %r6, %r7, %r8: don't use
1523 - %r11: frame pointer
1524 - %r12: saved top of stack for void_call_2 (high word for 31-bit)
1525 - %r13: low word of saved top of stack (for 31-bit)
1526 - %r14: return address for calls
1527 - %r15: stack pointer
1531 /* The "emit_prologue" emit_ops method for s390. */
1534 s390_emit_prologue (void)
1536 static const unsigned char buf
[] = {
1537 0x90, 0x9f, 0xf0, 0x24, /* stm %r9, %r15, 0x24(%r15) */
1538 0x18, 0x92, /* lr %r9, %r2 */
1539 0x18, 0xa3, /* lr %r10, %r3 */
1540 0x18, 0xbf, /* lr %r11, %r15 */
1542 add_insns (buf
, sizeof buf
);
1545 /* The "emit_epilogue" emit_ops method for s390. */
1548 s390_emit_epilogue (void)
1550 static const unsigned char buf
[] = {
1551 0x90, 0x23, 0xa0, 0x00, /* stm %r2, %r3, 0(%r10) */
1552 0xa7, 0x28, 0x00, 0x00, /* lhi %r2, 0 */
1553 0x98, 0x9f, 0xb0, 0x24, /* lm %r9, %r15, 0x24(%r11) */
1554 0x07, 0xfe, /* br %r14 */
1556 add_insns (buf
, sizeof buf
);
1559 /* The "emit_add" emit_ops method for s390. */
1562 s390_emit_add (void)
1564 static const unsigned char buf
[] = {
1565 0x5e, 0x30, 0xf0, 0x04, /* al %r3, 4(%r15) */
1566 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x98, /* al %r2, 0(%r15) */
1567 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1569 add_insns (buf
, sizeof buf
);
1572 /* The "emit_sub" emit_ops method for s390. */
1575 s390_emit_sub (void)
1577 static const unsigned char buf
[] = {
1578 0x98, 0x45, 0xf0, 0x00, /* lm %r4, %r5, 0(%r15) */
1579 0x1f, 0x53, /* slr %r5, %r3 */
1580 0xb9, 0x99, 0x00, 0x42, /* slbr %r4, %r2 */
1581 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1582 0x18, 0x35, /* lr %r3, %r5 */
1583 0x18, 0x24, /* lr %r2, %r4 */
1585 add_insns (buf
, sizeof buf
);
1588 /* The "emit_mul" emit_ops method for s390. */
1591 s390_emit_mul (void)
1596 /* The "emit_lsh" emit_ops method for s390. */
1599 s390_emit_lsh (void)
1601 static const unsigned char buf
[] = {
1602 0x18, 0x43, /* lr %r4, %r3 */
1603 0x98, 0x23, 0xf0, 0x00, /* lm %r2, %r3, 0(%r15) */
1604 0x8d, 0x20, 0x40, 0x00, /* sldl %r2, 0(%r4) */
1605 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1607 add_insns (buf
, sizeof buf
);
1610 /* The "emit_rsh_signed" emit_ops method for s390. */
1613 s390_emit_rsh_signed (void)
1615 static const unsigned char buf
[] = {
1616 0x18, 0x43, /* lr %r4, %r3 */
1617 0x98, 0x23, 0xf0, 0x00, /* lm %r2, %r3, 0(%r15) */
1618 0x8e, 0x20, 0x40, 0x00, /* srda %r2, 0(%r4) */
1619 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1621 add_insns (buf
, sizeof buf
);
1624 /* The "emit_rsh_unsigned" emit_ops method for s390. */
1627 s390_emit_rsh_unsigned (void)
1629 static const unsigned char buf
[] = {
1630 0x18, 0x43, /* lr %r4, %r3 */
1631 0x98, 0x23, 0xf0, 0x00, /* lm %r2, %r3, 0(%r15) */
1632 0x8c, 0x20, 0x40, 0x00, /* srdl %r2, 0(%r4) */
1633 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1635 add_insns (buf
, sizeof buf
);
1638 /* The "emit_ext" emit_ops method for s390. */
1641 s390_emit_ext (int arg
)
1643 unsigned char buf
[] = {
1644 0x8d, 0x20, 0x00, (unsigned char) (64 - arg
), /* sldl %r2, <64-arg> */
1645 0x8e, 0x20, 0x00, (unsigned char) (64 - arg
), /* srda %r2, <64-arg> */
1647 add_insns (buf
, sizeof buf
);
1650 /* The "emit_log_not" emit_ops method for s390. */
1653 s390_emit_log_not (void)
1655 static const unsigned char buf
[] = {
1656 0x16, 0x23, /* or %r2, %r3 */
1657 0xa7, 0x28, 0x00, 0x00, /* lhi %r2, 0 */
1658 0xa7, 0x38, 0x00, 0x00, /* lhi %r3, 0 */
1659 0xa7, 0x74, 0x00, 0x04, /* jne .Lskip */
1660 0xa7, 0x38, 0x00, 0x01, /* lhi %r3, 1 */
1663 add_insns (buf
, sizeof buf
);
1666 /* The "emit_bit_and" emit_ops method for s390. */
1669 s390_emit_bit_and (void)
1671 static const unsigned char buf
[] = {
1672 0x54, 0x20, 0xf0, 0x00, /* n %r2, 0(%r15) */
1673 0x54, 0x30, 0xf0, 0x04, /* n %r3, 4(%r15) */
1674 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1676 add_insns (buf
, sizeof buf
);
1679 /* The "emit_bit_or" emit_ops method for s390. */
1682 s390_emit_bit_or (void)
1684 static const unsigned char buf
[] = {
1685 0x56, 0x20, 0xf0, 0x00, /* o %r2, 0(%r15) */
1686 0x56, 0x30, 0xf0, 0x04, /* o %r3, 4(%r15) */
1687 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1689 add_insns (buf
, sizeof buf
);
1692 /* The "emit_bit_xor" emit_ops method for s390. */
1695 s390_emit_bit_xor (void)
1697 static const unsigned char buf
[] = {
1698 0x57, 0x20, 0xf0, 0x00, /* x %r2, 0(%r15) */
1699 0x57, 0x30, 0xf0, 0x04, /* x %r3, 4(%r15) */
1700 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1702 add_insns (buf
, sizeof buf
);
1705 /* The "emit_bit_not" emit_ops method for s390. */
1708 s390_emit_bit_not (void)
1710 static const unsigned char buf
[] = {
1711 0xa7, 0x48, 0xff, 0xff, /* lhi %r4, -1 */
1712 0x17, 0x24, /* xr %r2, %r4 */
1713 0x17, 0x34, /* xr %r3, %r4 */
1715 add_insns (buf
, sizeof buf
);
1718 /* The "emit_equal" emit_ops method for s390. */
1721 s390_emit_equal (void)
1723 s390_emit_bit_xor ();
1724 s390_emit_log_not ();
1727 /* The "emit_less_signed" emit_ops method for s390. */
1730 s390_emit_less_signed (void)
1732 static const unsigned char buf
[] = {
1733 0x59, 0x20, 0xf0, 0x00, /* c %r2, 0(%r15) */
1734 0xa7, 0x24, 0x00, 0x0c, /* jh .Lless */
1735 0xa7, 0x44, 0x00, 0x06, /* jl .Lhigh */
1736 0x55, 0x30, 0xf0, 0x04, /* cl %r3, 4(%r15) */
1737 0xa7, 0x24, 0x00, 0x06, /* jh .Lless */
1739 0xa7, 0x38, 0x00, 0x00, /* lhi %r3, 0 */
1740 0xa7, 0xf4, 0x00, 0x04, /* j .Lend */
1742 0xa7, 0x38, 0x00, 0x01, /* lhi %r3, 1 */
1744 0xa7, 0x28, 0x00, 0x00, /* lhi %r2, 0 */
1745 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1747 add_insns (buf
, sizeof buf
);
1750 /* The "emit_less_unsigned" emit_ops method for s390. */
1753 s390_emit_less_unsigned (void)
1755 static const unsigned char buf
[] = {
1756 0x55, 0x20, 0xf0, 0x00, /* cl %r2, 0(%r15) */
1757 0xa7, 0x24, 0x00, 0x0c, /* jh .Lless */
1758 0xa7, 0x44, 0x00, 0x06, /* jl .Lhigh */
1759 0x55, 0x30, 0xf0, 0x04, /* cl %r3, 4(%r15) */
1760 0xa7, 0x24, 0x00, 0x06, /* jh .Lless */
1762 0xa7, 0x38, 0x00, 0x00, /* lhi %r3, 0 */
1763 0xa7, 0xf4, 0x00, 0x04, /* j .Lend */
1765 0xa7, 0x38, 0x00, 0x01, /* lhi %r3, 1 */
1767 0xa7, 0x28, 0x00, 0x00, /* lhi %r2, 0 */
1768 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1770 add_insns (buf
, sizeof buf
);
1773 /* The "emit_ref" emit_ops method for s390. */
1776 s390_emit_ref (int size
)
1778 static const unsigned char buf1
[] = {
1779 0xa7, 0x28, 0x00, 0x00, /* lhi %r2, 0 */
1780 0x43, 0x30, 0x30, 0x00, /* ic %r3, 0(%r3) */
1782 static const unsigned char buf2
[] = {
1783 0xa7, 0x28, 0x00, 0x00, /* lhi %r2, 0 */
1784 0x48, 0x30, 0x30, 0x00, /* lh %r3, 0(%r3) */
1786 static const unsigned char buf4
[] = {
1787 0xa7, 0x28, 0x00, 0x00, /* lhi %r2, 0 */
1788 0x58, 0x30, 0x30, 0x00, /* l %r3, 0(%r3) */
1790 static const unsigned char buf8
[] = {
1791 0x98, 0x23, 0x30, 0x00, /* lm %r2, %r3, 0(%r3) */
1796 add_insns (buf1
, sizeof buf1
);
1799 add_insns (buf2
, sizeof buf2
);
1802 add_insns (buf4
, sizeof buf4
);
1805 add_insns (buf8
, sizeof buf8
);
1812 /* The "emit_if_goto" emit_ops method for s390. */
1815 s390_emit_if_goto (int *offset_p
, int *size_p
)
1817 static const unsigned char buf
[] = {
1818 0x16, 0x23, /* or %r2, %r3 */
1819 0x98, 0x23, 0xf0, 0x00, /* lm %r2, %r3, 0(%r15) */
1820 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1821 0xc0, 0x74, 0x00, 0x00, 0x00, 0x00 /* jgne <fillme> */
1823 add_insns (buf
, sizeof buf
);
1830 /* The "emit_goto" emit_ops method for s390 and s390x. */
1833 s390_emit_goto (int *offset_p
, int *size_p
)
1835 static const unsigned char buf
[] = {
1836 0xc0, 0xf4, 0x00, 0x00, 0x00, 0x00, /* jg <fillme> */
1838 add_insns (buf
, sizeof buf
);
1845 /* The "write_goto_address" emit_ops method for s390 and s390x. */
1848 s390_write_goto_address (CORE_ADDR from
, CORE_ADDR to
, int size
)
1850 long diff
= ((long) (to
- (from
- 2))) / 2;
1852 unsigned char buf
[sizeof sdiff
];
1854 /* We're only doing 4-byte sizes at the moment. */
1855 if (size
!= sizeof sdiff
|| sdiff
!= diff
)
1861 memcpy (buf
, &sdiff
, sizeof sdiff
);
1862 target_write_memory (from
, buf
, sizeof sdiff
);
1865 /* Preparation for emitting a literal pool of given size. Loads the address
1866 of the pool into %r1, and jumps over it. Called should emit the pool data
1867 immediately afterwards. Used for both s390 and s390x. */
1870 s390_emit_litpool (int size
)
1872 static const unsigned char nop
[] = {
1875 unsigned char buf
[] = {
1877 (unsigned char) ((size
+ 4) / 2), /* bras %r1, .Lend+size */
1882 /* buf needs to start at even halfword for litpool to be aligned */
1883 if (current_insn_ptr
& 2)
1884 add_insns (nop
, sizeof nop
);
1888 while ((current_insn_ptr
& 6) != 4)
1889 add_insns (nop
, sizeof nop
);
1891 add_insns (buf
, sizeof buf
);
1894 /* The "emit_const" emit_ops method for s390. */
1897 s390_emit_const (LONGEST num
)
1899 unsigned long long n
= num
;
1900 unsigned char buf_s
[] = {
1901 /* lhi %r3, <num> */
1903 (unsigned char) (num
>> 8), (unsigned char) num
,
1907 static const unsigned char buf_l
[] = {
1908 0x98, 0x23, 0x10, 0x00, /* lm %r2, %r3, 0(%r1) */
1910 if (num
< 0x8000 && num
>= 0)
1911 add_insns (buf_s
, sizeof buf_s
);
1914 s390_emit_litpool (8);
1915 add_insns ((unsigned char *) &n
, sizeof n
);
1916 add_insns (buf_l
, sizeof buf_l
);
1920 /* The "emit_call" emit_ops method for s390. */
1923 s390_emit_call (CORE_ADDR fn
)
1925 unsigned int n
= fn
;
1926 static const unsigned char buf
[] = {
1927 0x58, 0x10, 0x10, 0x00, /* l %r1, 0(%r1) */
1928 0xa7, 0xfa, 0xff, 0xa0, /* ahi %r15, -0x60 */
1929 0x0d, 0xe1, /* basr %r14, %r1 */
1930 0xa7, 0xfa, 0x00, 0x60, /* ahi %r15, 0x60 */
1932 s390_emit_litpool (4);
1933 add_insns ((unsigned char *) &n
, sizeof n
);
1934 add_insns (buf
, sizeof buf
);
1937 /* The "emit_reg" emit_ops method for s390. */
1940 s390_emit_reg (int reg
)
1942 unsigned char bufpre
[] = {
1945 /* lhi %r3, <reg> */
1946 0xa7, 0x38, (unsigned char) (reg
>> 8), (unsigned char) reg
,
1948 add_insns (bufpre
, sizeof bufpre
);
1949 s390_emit_call (get_raw_reg_func_addr ());
1952 /* The "emit_pop" emit_ops method for s390. */
1955 s390_emit_pop (void)
1957 static const unsigned char buf
[] = {
1958 0x98, 0x23, 0xf0, 0x00, /* lm %r2, %r3, 0(%r15) */
1959 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
1961 add_insns (buf
, sizeof buf
);
1964 /* The "emit_stack_flush" emit_ops method for s390. */
1967 s390_emit_stack_flush (void)
1969 static const unsigned char buf
[] = {
1970 0xa7, 0xfa, 0xff, 0xf8, /* ahi %r15, -8 */
1971 0x90, 0x23, 0xf0, 0x00, /* stm %r2, %r3, 0(%r15) */
1973 add_insns (buf
, sizeof buf
);
1976 /* The "emit_zero_ext" emit_ops method for s390. */
1979 s390_emit_zero_ext (int arg
)
1981 unsigned char buf
[] = {
1982 0x8d, 0x20, 0x00, (unsigned char) (64 - arg
), /* sldl %r2, <64-arg> */
1983 0x8c, 0x20, 0x00, (unsigned char) (64 - arg
), /* srdl %r2, <64-arg> */
1985 add_insns (buf
, sizeof buf
);
1988 /* The "emit_swap" emit_ops method for s390. */
1991 s390_emit_swap (void)
1993 static const unsigned char buf
[] = {
1994 0x98, 0x45, 0xf0, 0x00, /* lm %r4, %r5, 0(%r15) */
1995 0x90, 0x23, 0xf0, 0x00, /* stm %r2, %r3, 0(%r15) */
1996 0x18, 0x24, /* lr %r2, %r4 */
1997 0x18, 0x35, /* lr %r3, %r5 */
1999 add_insns (buf
, sizeof buf
);
2002 /* The "emit_stack_adjust" emit_ops method for s390. */
2005 s390_emit_stack_adjust (int n
)
2007 unsigned char buf
[] = {
2010 (unsigned char ) (n
* 8 >> 8), (unsigned char) (n
* 8),
2012 add_insns (buf
, sizeof buf
);
2015 /* Sets %r2 to a 32-bit constant. */
2018 s390_emit_set_r2 (int arg1
)
2020 unsigned char buf_s
[] = {
2021 /* lhi %r2, <arg1> */
2022 0xa7, 0x28, (unsigned char) (arg1
>> 8), (unsigned char) arg1
,
2024 static const unsigned char buf_l
[] = {
2025 0x58, 0x20, 0x10, 0x00, /* l %r2, 0(%r1) */
2027 if (arg1
< 0x8000 && arg1
>= -0x8000)
2028 add_insns (buf_s
, sizeof buf_s
);
2031 s390_emit_litpool (4);
2032 add_insns ((unsigned char *) &arg1
, sizeof arg1
);
2033 add_insns (buf_l
, sizeof buf_l
);
2037 /* The "emit_int_call_1" emit_ops method for s390. */
2040 s390_emit_int_call_1 (CORE_ADDR fn
, int arg1
)
2042 /* FN's prototype is `LONGEST(*fn)(int)'. */
2043 s390_emit_set_r2 (arg1
);
2044 s390_emit_call (fn
);
2047 /* The "emit_void_call_2" emit_ops method for s390. */
2050 s390_emit_void_call_2 (CORE_ADDR fn
, int arg1
)
2052 /* FN's prototype is `void(*fn)(int,LONGEST)'. */
2053 static const unsigned char buf
[] = {
2054 0x18, 0xc2, /* lr %r12, %r2 */
2055 0x18, 0xd3, /* lr %r13, %r3 */
2056 0x18, 0x43, /* lr %r4, %r3 */
2057 0x18, 0x32, /* lr %r3, %r2 */
2059 static const unsigned char buf2
[] = {
2060 0x18, 0x2c, /* lr %r2, %r12 */
2061 0x18, 0x3d, /* lr %r3, %r13 */
2063 add_insns (buf
, sizeof buf
);
2064 s390_emit_set_r2 (arg1
);
2065 s390_emit_call (fn
);
2066 add_insns (buf2
, sizeof buf2
);
2069 /* The "emit_eq_goto" emit_ops method for s390. */
2072 s390_emit_eq_goto (int *offset_p
, int *size_p
)
2074 static const unsigned char buf
[] = {
2075 0x57, 0x20, 0xf0, 0x00, /* x %r2, 0(%r15) */
2076 0x57, 0x30, 0xf0, 0x04, /* x %r3, 4(%r15) */
2077 0x16, 0x23, /* or %r2, %r3 */
2078 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2079 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2080 0xc0, 0x84, 0x00, 0x00, 0x00, 0x00, /* jge <fillme> */
2082 add_insns (buf
, sizeof buf
);
2089 /* The "emit_ne_goto" emit_ops method for s390. */
2092 s390_emit_ne_goto (int *offset_p
, int *size_p
)
2094 static const unsigned char buf
[] = {
2095 0x57, 0x20, 0xf0, 0x00, /* x %r2, 0(%r15) */
2096 0x57, 0x30, 0xf0, 0x04, /* x %r3, 4(%r15) */
2097 0x16, 0x23, /* or %r2, %r3 */
2098 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2099 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2100 0xc0, 0x74, 0x00, 0x00, 0x00, 0x00, /* jgne <fillme> */
2102 add_insns (buf
, sizeof buf
);
2109 /* The "emit_lt_goto" emit_ops method for s390. */
2112 s390_emit_lt_goto (int *offset_p
, int *size_p
)
2114 static const unsigned char buf
[] = {
2115 0x59, 0x20, 0xf0, 0x00, /* c %r2, 0(%r15) */
2116 0xa7, 0x24, 0x00, 0x0e, /* jh .Ltrue */
2117 0xa7, 0x44, 0x00, 0x06, /* jl .Lfalse */
2118 0x55, 0x30, 0xf0, 0x04, /* cl %r3, 4(%r15) */
2119 0xa7, 0x24, 0x00, 0x08, /* jh .Ltrue */
2121 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2122 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2123 0xa7, 0xf4, 0x00, 0x09, /* j .Lend */
2125 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2126 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2127 0xc0, 0xf4, 0x00, 0x00, 0x00, 0x00, /* jg <fillme> */
2130 add_insns (buf
, sizeof buf
);
2137 /* The "emit_le_goto" emit_ops method for s390. */
2140 s390_emit_le_goto (int *offset_p
, int *size_p
)
2142 static const unsigned char buf
[] = {
2143 0x59, 0x20, 0xf0, 0x00, /* c %r2, 0(%r15) */
2144 0xa7, 0x24, 0x00, 0x0e, /* jh .Ltrue */
2145 0xa7, 0x44, 0x00, 0x06, /* jl .Lfalse */
2146 0x55, 0x30, 0xf0, 0x04, /* cl %r3, 4(%r15) */
2147 0xa7, 0xa4, 0x00, 0x08, /* jhe .Ltrue */
2149 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2150 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2151 0xa7, 0xf4, 0x00, 0x09, /* j .Lend */
2153 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2154 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2155 0xc0, 0xf4, 0x00, 0x00, 0x00, 0x00, /* jg <fillme> */
2158 add_insns (buf
, sizeof buf
);
2165 /* The "emit_gt_goto" emit_ops method for s390. */
2168 s390_emit_gt_goto (int *offset_p
, int *size_p
)
2170 static const unsigned char buf
[] = {
2171 0x59, 0x20, 0xf0, 0x00, /* c %r2, 0(%r15) */
2172 0xa7, 0x44, 0x00, 0x0e, /* jl .Ltrue */
2173 0xa7, 0x24, 0x00, 0x06, /* jh .Lfalse */
2174 0x55, 0x30, 0xf0, 0x04, /* cl %r3, 4(%r15) */
2175 0xa7, 0x44, 0x00, 0x08, /* jl .Ltrue */
2177 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2178 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2179 0xa7, 0xf4, 0x00, 0x09, /* j .Lend */
2181 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2182 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2183 0xc0, 0xf4, 0x00, 0x00, 0x00, 0x00, /* jg <fillme> */
2186 add_insns (buf
, sizeof buf
);
2193 /* The "emit_ge_goto" emit_ops method for s390. */
2196 s390_emit_ge_goto (int *offset_p
, int *size_p
)
2198 static const unsigned char buf
[] = {
2199 0x59, 0x20, 0xf0, 0x00, /* c %r2, 0(%r15) */
2200 0xa7, 0x44, 0x00, 0x0e, /* jl .Ltrue */
2201 0xa7, 0x24, 0x00, 0x06, /* jh .Lfalse */
2202 0x55, 0x30, 0xf0, 0x04, /* cl %r3, 4(%r15) */
2203 0xa7, 0xc4, 0x00, 0x08, /* jle .Ltrue */
2205 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2206 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2207 0xa7, 0xf4, 0x00, 0x09, /* j .Lend */
2209 0x98, 0x23, 0xf0, 0x08, /* lm %r2, %r3, 8(%r15) */
2210 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2211 0xc0, 0xf4, 0x00, 0x00, 0x00, 0x00, /* jg <fillme> */
2214 add_insns (buf
, sizeof buf
);
2221 /* The "emit_ops" structure for s390. Named _impl to avoid name
2222 collision with s390_emit_ops function. */
2224 static struct emit_ops s390_emit_ops_impl
=
2232 s390_emit_rsh_signed
,
2233 s390_emit_rsh_unsigned
,
2241 s390_emit_less_signed
,
2242 s390_emit_less_unsigned
,
2246 s390_write_goto_address
,
2251 s390_emit_stack_flush
,
2254 s390_emit_stack_adjust
,
2255 s390_emit_int_call_1
,
2256 s390_emit_void_call_2
,
2267 /* The "emit_prologue" emit_ops method for s390x. */
2270 s390x_emit_prologue (void)
2272 static const unsigned char buf
[] = {
2273 0xeb, 0x9f, 0xf0, 0x48, 0x00, 0x24, /* stmg %r9, %r15, 0x48(%r15) */
2274 0xb9, 0x04, 0x00, 0x92, /* lgr %r9, %r2 */
2275 0xb9, 0x04, 0x00, 0xa3, /* lgr %r10, %r3 */
2276 0xb9, 0x04, 0x00, 0xbf, /* lgr %r11, %r15 */
2278 add_insns (buf
, sizeof buf
);
2281 /* The "emit_epilogue" emit_ops method for s390x. */
2284 s390x_emit_epilogue (void)
2286 static const unsigned char buf
[] = {
2287 0xe3, 0x20, 0xa0, 0x00, 0x00, 0x24, /* stg %r2, 0(%r10) */
2288 0xa7, 0x29, 0x00, 0x00, /* lghi %r2, 0 */
2289 0xeb, 0x9f, 0xf0, 0x48, 0x00, 0x04, /* lmg %r9, %r15, 0x48(%r15) */
2290 0x07, 0xfe, /* br %r14 */
2292 add_insns (buf
, sizeof buf
);
2295 /* The "emit_add" emit_ops method for s390x. */
2298 s390x_emit_add (void)
2300 static const unsigned char buf
[] = {
2301 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x0a, /* alg %r2, 0(%r15) */
2302 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2304 add_insns (buf
, sizeof buf
);
2307 /* The "emit_sub" emit_ops method for s390x. */
2310 s390x_emit_sub (void)
2312 static const unsigned char buf
[] = {
2313 0xe3, 0x30, 0xf0, 0x00, 0x00, 0x04, /* lg %r3, 0(%r15) */
2314 0xb9, 0x0b, 0x00, 0x32, /* slgr %r3, %r2 */
2315 0xb9, 0x04, 0x00, 0x23, /* lgr %r2, %r3 */
2316 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2318 add_insns (buf
, sizeof buf
);
2321 /* The "emit_mul" emit_ops method for s390x. */
2324 s390x_emit_mul (void)
2329 /* The "emit_lsh" emit_ops method for s390x. */
2332 s390x_emit_lsh (void)
2334 static const unsigned char buf
[] = {
2335 0xe3, 0x30, 0xf0, 0x00, 0x00, 0x04, /* lg %r3, 0(%r15) */
2336 0xeb, 0x23, 0x20, 0x00, 0x00, 0x0d, /* sllg %r2, %r3, 0(%r2) */
2337 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2339 add_insns (buf
, sizeof buf
);
2342 /* The "emit_rsh_signed" emit_ops method for s390x. */
2345 s390x_emit_rsh_signed (void)
2347 static const unsigned char buf
[] = {
2348 0xe3, 0x30, 0xf0, 0x00, 0x00, 0x04, /* lg %r3, 0(%r15) */
2349 0xeb, 0x23, 0x20, 0x00, 0x00, 0x0a, /* srag %r2, %r3, 0(%r2) */
2350 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2352 add_insns (buf
, sizeof buf
);
2355 /* The "emit_rsh_unsigned" emit_ops method for s390x. */
2358 s390x_emit_rsh_unsigned (void)
2360 static const unsigned char buf
[] = {
2361 0xe3, 0x30, 0xf0, 0x00, 0x00, 0x04, /* lg %r3, 0(%r15) */
2362 0xeb, 0x23, 0x20, 0x00, 0x00, 0x0c, /* srlg %r2, %r3, 0(%r2) */
2363 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2365 add_insns (buf
, sizeof buf
);
2368 /* The "emit_ext" emit_ops method for s390x. */
2371 s390x_emit_ext (int arg
)
2373 unsigned char buf
[] = {
2374 /* sllg %r2, %r2, <64-arg> */
2375 0xeb, 0x22, 0x00, (unsigned char) (64 - arg
), 0x00, 0x0d,
2376 /* srag %r2, %r2, <64-arg> */
2377 0xeb, 0x22, 0x00, (unsigned char) (64 - arg
), 0x00, 0x0a,
2379 add_insns (buf
, sizeof buf
);
2382 /* The "emit_log_not" emit_ops method for s390x. */
2385 s390x_emit_log_not (void)
2387 static const unsigned char buf
[] = {
2388 0xb9, 0x00, 0x00, 0x22, /* lpgr %r2, %r2 */
2389 0xa7, 0x2b, 0xff, 0xff, /* aghi %r2, -1 */
2390 0xeb, 0x22, 0x00, 0x3f, 0x00, 0x0c, /* srlg %r2, %r2, 63 */
2392 add_insns (buf
, sizeof buf
);
2395 /* The "emit_bit_and" emit_ops method for s390x. */
2398 s390x_emit_bit_and (void)
2400 static const unsigned char buf
[] = {
2401 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x80, /* ng %r2, 0(%r15) */
2402 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2404 add_insns (buf
, sizeof buf
);
2407 /* The "emit_bit_or" emit_ops method for s390x. */
2410 s390x_emit_bit_or (void)
2412 static const unsigned char buf
[] = {
2413 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x81, /* og %r2, 0(%r15) */
2414 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2416 add_insns (buf
, sizeof buf
);
2419 /* The "emit_bit_xor" emit_ops method for s390x. */
2422 s390x_emit_bit_xor (void)
2424 static const unsigned char buf
[] = {
2425 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x82, /* xg %r2, 0(%r15) */
2426 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2428 add_insns (buf
, sizeof buf
);
2431 /* The "emit_bit_not" emit_ops method for s390x. */
2434 s390x_emit_bit_not (void)
2436 static const unsigned char buf
[] = {
2437 0xa7, 0x39, 0xff, 0xff, /* lghi %r3, -1 */
2438 0xb9, 0x82, 0x00, 0x23, /* xgr %r2, %r3 */
2440 add_insns (buf
, sizeof buf
);
2443 /* The "emit_equal" emit_ops method for s390x. */
2446 s390x_emit_equal (void)
2448 s390x_emit_bit_xor ();
2449 s390x_emit_log_not ();
2452 /* The "emit_less_signed" emit_ops method for s390x. */
2455 s390x_emit_less_signed (void)
2457 static const unsigned char buf
[] = {
2458 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x20, /* cg %r2, 0(%r15) */
2459 0xa7, 0x29, 0x00, 0x01, /* lghi %r2, 1 */
2460 0xa7, 0x24, 0x00, 0x04, /* jh .Lend */
2461 0xa7, 0x29, 0x00, 0x00, /* lghi %r2, 0 */
2463 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2465 add_insns (buf
, sizeof buf
);
2468 /* The "emit_less_unsigned" emit_ops method for s390x. */
2471 s390x_emit_less_unsigned (void)
2473 static const unsigned char buf
[] = {
2474 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x21, /* clg %r2, 0(%r15) */
2475 0xa7, 0x29, 0x00, 0x01, /* lghi %r2, 1 */
2476 0xa7, 0x24, 0x00, 0x04, /* jh .Lend */
2477 0xa7, 0x29, 0x00, 0x00, /* lghi %r2, 0 */
2479 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2481 add_insns (buf
, sizeof buf
);
2484 /* The "emit_ref" emit_ops method for s390x. */
2487 s390x_emit_ref (int size
)
2489 static const unsigned char buf1
[] = {
2490 0xe3, 0x20, 0x20, 0x00, 0x00, 0x90, /* llgc %r2, 0(%r2) */
2492 static const unsigned char buf2
[] = {
2493 0xe3, 0x20, 0x20, 0x00, 0x00, 0x91 /* llgh %r2, 0(%r2) */
2495 static const unsigned char buf4
[] = {
2496 0xe3, 0x20, 0x20, 0x00, 0x00, 0x16, /* llgf %r2, 0(%r2) */
2498 static const unsigned char buf8
[] = {
2499 0xe3, 0x20, 0x20, 0x00, 0x00, 0x04, /* lg %r2, 0(%r2) */
2504 add_insns (buf1
, sizeof buf1
);
2507 add_insns (buf2
, sizeof buf2
);
2510 add_insns (buf4
, sizeof buf4
);
2513 add_insns (buf8
, sizeof buf8
);
2520 /* The "emit_if_goto" emit_ops method for s390x. */
2523 s390x_emit_if_goto (int *offset_p
, int *size_p
)
2525 static const unsigned char buf
[] = {
2526 0xb9, 0x02, 0x00, 0x22, /* ltgr %r2, %r2 */
2527 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x04, /* lg %r2, 0(%r15) */
2528 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2529 0xc0, 0x74, 0x00, 0x00, 0x00, 0x00, /* jgne <fillme> */
2531 add_insns (buf
, sizeof buf
);
2538 /* The "emit_const" emit_ops method for s390x. */
2541 s390x_emit_const (LONGEST num
)
2543 unsigned long long n
= num
;
2544 unsigned char buf_s
[] = {
2545 /* lghi %r2, <num> */
2546 0xa7, 0x29, (unsigned char) (num
>> 8), (unsigned char) num
,
2548 static const unsigned char buf_l
[] = {
2549 0xe3, 0x20, 0x10, 0x00, 0x00, 0x04, /* lg %r2, 0(%r1) */
2551 if (num
< 0x8000 && num
>= -0x8000)
2552 add_insns (buf_s
, sizeof buf_s
);
2555 s390_emit_litpool (8);
2556 add_insns ((unsigned char *) &n
, sizeof n
);
2557 add_insns (buf_l
, sizeof buf_l
);
2561 /* The "emit_call" emit_ops method for s390x. */
2564 s390x_emit_call (CORE_ADDR fn
)
2566 unsigned long n
= fn
;
2567 static const unsigned char buf
[] = {
2568 0xe3, 0x10, 0x10, 0x00, 0x00, 0x04, /* lg %r1, 0(%r1) */
2569 0xa7, 0xfb, 0xff, 0x60, /* aghi %r15, -0xa0 */
2570 0x0d, 0xe1, /* basr %r14, %r1 */
2571 0xa7, 0xfb, 0x00, 0xa0, /* aghi %r15, 0xa0 */
2573 s390_emit_litpool (8);
2574 add_insns ((unsigned char *) &n
, sizeof n
);
2575 add_insns (buf
, sizeof buf
);
2578 /* The "emit_reg" emit_ops method for s390x. */
2581 s390x_emit_reg (int reg
)
2583 unsigned char buf
[] = {
2585 0xb9, 0x04, 0x00, 0x29,
2586 /* lghi %r3, <reg> */
2587 0xa7, 0x39, (unsigned char) (reg
>> 8), (unsigned char) reg
,
2589 add_insns (buf
, sizeof buf
);
2590 s390x_emit_call (get_raw_reg_func_addr ());
2593 /* The "emit_pop" emit_ops method for s390x. */
2596 s390x_emit_pop (void)
2598 static const unsigned char buf
[] = {
2599 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x04, /* lg %r2, 0(%r15) */
2600 0x41, 0xf0, 0xf0, 0x08, /* la %r15, 8(%r15) */
2602 add_insns (buf
, sizeof buf
);
2605 /* The "emit_stack_flush" emit_ops method for s390x. */
2608 s390x_emit_stack_flush (void)
2610 static const unsigned char buf
[] = {
2611 0xa7, 0xfb, 0xff, 0xf8, /* aghi %r15, -8 */
2612 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x24, /* stg %r2, 0(%r15) */
2614 add_insns (buf
, sizeof buf
);
2617 /* The "emit_zero_ext" emit_ops method for s390x. */
2620 s390x_emit_zero_ext (int arg
)
2622 unsigned char buf
[] = {
2623 /* sllg %r2, %r2, <64-arg> */
2624 0xeb, 0x22, 0x00, (unsigned char) (64 - arg
), 0x00, 0x0d,
2625 /* srlg %r2, %r2, <64-arg> */
2626 0xeb, 0x22, 0x00, (unsigned char) (64 - arg
), 0x00, 0x0c,
2628 add_insns (buf
, sizeof buf
);
2631 /* The "emit_swap" emit_ops method for s390x. */
2634 s390x_emit_swap (void)
2636 static const unsigned char buf
[] = {
2637 0xe3, 0x30, 0xf0, 0x00, 0x00, 0x04, /* lg %r3, 0(%r15) */
2638 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x24, /* stg %r2, 0(%r15) */
2639 0xb9, 0x04, 0x00, 0x23, /* lgr %r2, %r3 */
2641 add_insns (buf
, sizeof buf
);
2644 /* The "emit_stack_adjust" emit_ops method for s390x. */
2647 s390x_emit_stack_adjust (int n
)
2649 unsigned char buf
[] = {
2650 /* aghi %r15, 8*n */
2652 (unsigned char) (n
* 8 >> 8), (unsigned char) (n
* 8),
2654 add_insns (buf
, sizeof buf
);
2657 /* The "emit_int_call_1" emit_ops method for s390x. */
2660 s390x_emit_int_call_1 (CORE_ADDR fn
, int arg1
)
2662 /* FN's prototype is `LONGEST(*fn)(int)'. */
2663 s390x_emit_const (arg1
);
2664 s390x_emit_call (fn
);
2667 /* The "emit_void_call_2" emit_ops method for s390x. */
2670 s390x_emit_void_call_2 (CORE_ADDR fn
, int arg1
)
2672 /* FN's prototype is `void(*fn)(int,LONGEST)'. */
2673 static const unsigned char buf
[] = {
2674 0xb9, 0x04, 0x00, 0x32, /* lgr %r3, %r2 */
2675 0xb9, 0x04, 0x00, 0xc2, /* lgr %r12, %r2 */
2677 static const unsigned char buf2
[] = {
2678 0xb9, 0x04, 0x00, 0x2c, /* lgr %r2, %r12 */
2680 add_insns (buf
, sizeof buf
);
2681 s390x_emit_const (arg1
);
2682 s390x_emit_call (fn
);
2683 add_insns (buf2
, sizeof buf2
);
2686 /* The "emit_eq_goto" emit_ops method for s390x. */
2689 s390x_emit_eq_goto (int *offset_p
, int *size_p
)
2691 static const unsigned char buf
[] = {
2692 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x20, /* cg %r2, 0(%r15) */
2693 0xe3, 0x20, 0xf0, 0x08, 0x00, 0x04, /* lg %r2, 8(%r15) */
2694 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2695 0xc0, 0x84, 0x00, 0x00, 0x00, 0x00, /* jge <fillme> */
2697 add_insns (buf
, sizeof buf
);
2704 /* The "emit_ne_goto" emit_ops method for s390x. */
2707 s390x_emit_ne_goto (int *offset_p
, int *size_p
)
2709 static const unsigned char buf
[] = {
2710 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x20, /* cg %r2, 0(%r15) */
2711 0xe3, 0x20, 0xf0, 0x08, 0x00, 0x04, /* lg %r2, 8(%r15) */
2712 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2713 0xc0, 0x74, 0x00, 0x00, 0x00, 0x00, /* jgne <fillme> */
2715 add_insns (buf
, sizeof buf
);
2722 /* The "emit_lt_goto" emit_ops method for s390x. */
2725 s390x_emit_lt_goto (int *offset_p
, int *size_p
)
2727 static const unsigned char buf
[] = {
2728 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x20, /* cg %r2, 0(%r15) */
2729 0xe3, 0x20, 0xf0, 0x08, 0x00, 0x04, /* lg %r2, 8(%r15) */
2730 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2731 0xc0, 0x24, 0x00, 0x00, 0x00, 0x00, /* jgh <fillme> */
2733 add_insns (buf
, sizeof buf
);
2740 /* The "emit_le_goto" emit_ops method for s390x. */
2743 s390x_emit_le_goto (int *offset_p
, int *size_p
)
2745 static const unsigned char buf
[] = {
2746 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x20, /* cg %r2, 0(%r15) */
2747 0xe3, 0x20, 0xf0, 0x08, 0x00, 0x04, /* lg %r2, 8(%r15) */
2748 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2749 0xc0, 0xa4, 0x00, 0x00, 0x00, 0x00, /* jghe <fillme> */
2751 add_insns (buf
, sizeof buf
);
2758 /* The "emit_gt_goto" emit_ops method for s390x. */
2761 s390x_emit_gt_goto (int *offset_p
, int *size_p
)
2763 static const unsigned char buf
[] = {
2764 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x20, /* cg %r2, 0(%r15) */
2765 0xe3, 0x20, 0xf0, 0x08, 0x00, 0x04, /* lg %r2, 8(%r15) */
2766 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2767 0xc0, 0x44, 0x00, 0x00, 0x00, 0x00, /* jgl <fillme> */
2769 add_insns (buf
, sizeof buf
);
2776 /* The "emit_ge_goto" emit_ops method for s390x. */
2779 s390x_emit_ge_goto (int *offset_p
, int *size_p
)
2781 static const unsigned char buf
[] = {
2782 0xe3, 0x20, 0xf0, 0x00, 0x00, 0x20, /* cg %r2, 0(%r15) */
2783 0xe3, 0x20, 0xf0, 0x08, 0x00, 0x04, /* lg %r2, 8(%r15) */
2784 0x41, 0xf0, 0xf0, 0x10, /* la %r15, 16(%r15) */
2785 0xc0, 0xc4, 0x00, 0x00, 0x00, 0x00, /* jgle <fillme> */
2787 add_insns (buf
, sizeof buf
);
2794 /* The "emit_ops" structure for s390x. */
2796 static struct emit_ops s390x_emit_ops
=
2798 s390x_emit_prologue
,
2799 s390x_emit_epilogue
,
2804 s390x_emit_rsh_signed
,
2805 s390x_emit_rsh_unsigned
,
2813 s390x_emit_less_signed
,
2814 s390x_emit_less_unsigned
,
2818 s390_write_goto_address
,
2823 s390x_emit_stack_flush
,
2824 s390x_emit_zero_ext
,
2826 s390x_emit_stack_adjust
,
2827 s390x_emit_int_call_1
,
2828 s390x_emit_void_call_2
,
2838 /* The "emit_ops" target ops method. */
2841 s390_target::emit_ops ()
2844 struct regcache
*regcache
= get_thread_regcache (current_thread
, 0);
2846 if (register_size (regcache
->tdesc
, 0) == 8)
2847 return &s390x_emit_ops
;
2850 return &s390_emit_ops_impl
;
2853 /* The linux target ops object. */
2855 linux_process_target
*the_linux_target
= &the_s390_target
;
2858 initialize_low_arch (void)
2860 /* Initialize the Linux target descriptions. */
2862 init_registers_s390_linux32 ();
2863 init_registers_s390_linux32v1 ();
2864 init_registers_s390_linux32v2 ();
2865 init_registers_s390_linux64 ();
2866 init_registers_s390_linux64v1 ();
2867 init_registers_s390_linux64v2 ();
2868 init_registers_s390_te_linux64 ();
2869 init_registers_s390_vx_linux64 ();
2870 init_registers_s390_tevx_linux64 ();
2871 init_registers_s390_gs_linux64 ();
2873 init_registers_s390x_linux64 ();
2874 init_registers_s390x_linux64v1 ();
2875 init_registers_s390x_linux64v2 ();
2876 init_registers_s390x_te_linux64 ();
2877 init_registers_s390x_vx_linux64 ();
2878 init_registers_s390x_tevx_linux64 ();
2879 init_registers_s390x_gs_linux64 ();
2882 initialize_regsets_info (&s390_regsets_info
);
2883 initialize_regsets_info (&s390_regsets_info_3264
);