Yaya48/QEMU-S5L8950X
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import QEMU upstream snapshot d2e570c

Browse Source 
Upstream: https://gitlab.com/qemu-project/qemu.git

Upstream-Commit: d2e570cc0f97b936902a5b1b86b73c0f5998b475
This commit is contained in:
Yaya48
2026-08-31 02:15:30 +02:00
commit cf256aa081
11315 changed files with 3598369 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
linux-user/sh4/Makefile.vdso
+18
View File
@@ -0,0 +1,18 @@
include $(BUILD_DIR)/tests/tcg/sh4-linux-user/config-target.mak
SUBDIR = $(SRC_PATH)/linux-user/sh4
VPATH += $(SUBDIR)
all: $(SUBDIR)/vdso-le.so $(SUBDIR)/vdso-be.so
LDFLAGS = -nostdlib -shared -Wl,-h,linux-gate.so.1 \
-Wl,--build-id=sha1 -Wl,--hash-style=both \
-Wl,-T,$(SUBDIR)/vdso.ld
$(SUBDIR)/vdso-le.so: vdso.S vdso.ld vdso-asmoffset.h
$(CC) -o $@ $(LDFLAGS) -ml $<
CC_BE = sh4eb-unknown-linux-gnu-gcc
$(SUBDIR)/vdso-be.so: vdso.S vdso.ld vdso-asmoffset.h
$(CC_BE) -o $@ $(LDFLAGS) $<
linux-user/sh4/cpu_loop.c
+97
View File
@@ -0,0 +1,97 @@
/*
* qemu user cpu loop
*
* Copyright (c) 2003-2008 Fabrice Bellard
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "qemu/osdep.h"
#include "qemu.h"
#include "user-internals.h"
#include "user/cpu_loop.h"
#include "signal-common.h"
void cpu_loop(CPUSH4State *env)
{
CPUState *cs = env_cpu(env);
int trapnr, ret;
while (1) {
bool arch_interrupt = true;
cpu_exec_start(cs);
trapnr = cpu_exec(cs);
cpu_exec_end(cs);
qemu_process_cpu_events(cs);
switch (trapnr) {
case 0x160:
env->pc += 2;
ret = do_syscall(env,
env->gregs[3],
env->gregs[4],
env->gregs[5],
env->gregs[6],
env->gregs[7],
env->gregs[0],
env->gregs[1],
0, 0);
if (ret == -QEMU_ERESTARTSYS) {
env->pc -= 2;
} else if (ret != -QEMU_ESIGRETURN && ret != -QEMU_ESETPC) {
env->gregs[0] = ret;
}
break;
case EXCP_INTERRUPT:
/* just indicate that signals should be handled asap */
break;
case EXCP_DEBUG:
force_sig_fault(TARGET_SIGTRAP, TARGET_TRAP_BRKPT, env->pc);
break;
case EXCP_ATOMIC:
cpu_exec_step_atomic(cs);
arch_interrupt = false;
break;
case 0x180:
/* Illegal instruction */
/* fallthrough */
case 0x1a0:
/* Illegal instruction in delay slot */
force_sig_fault(TARGET_SIGILL, TARGET_ILL_ILLOPC, env->pc);
break;
default:
fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr);
cpu_dump_state(cs, stderr, 0);
exit(EXIT_FAILURE);
}
process_pending_signals (env);
/* Most of the traps imply an exception or interrupt, which
implies an REI instruction has been executed. Which means
that LDST (aka LOK_ADDR) should be cleared. But there are
a few exceptions for traps internal to QEMU. */
if (arch_interrupt) {
env->lock_addr = -1;
}
}
}
void init_main_thread(CPUState *cs, struct image_info *info)
{
CPUArchState *env = cpu_env(cs);
env->pc = info->entry;
env->gregs[15] = info->start_stack;
}
linux-user/sh4/elfload.c
+77
View File
@@ -0,0 +1,77 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
#include "qemu/osdep.h"
#include "qemu.h"
#include "loader.h"
#include "target_elf.h"
#if TARGET_BIG_ENDIAN
# include "vdso-be.c.inc"
#else
# include "vdso-le.c.inc"
#endif
const VdsoImageInfo *get_vdso_image_info(uint32_t elf_flags G_GNUC_UNUSED)
{
#if TARGET_BIG_ENDIAN
return &vdso_be_image_info;
#else
return &vdso_le_image_info;
#endif
}
const char *get_elf_cpu_model(uint32_t eflags)
{
return "sh7785";
}
enum {
SH_CPU_HAS_FPU = 0x0001, /* Hardware FPU support */
SH_CPU_HAS_P2_FLUSH_BUG = 0x0002, /* Need to flush the cache in P2 area */
SH_CPU_HAS_MMU_PAGE_ASSOC = 0x0004, /* SH3: TLB way selection bit support */
SH_CPU_HAS_DSP = 0x0008, /* SH-DSP: DSP support */
SH_CPU_HAS_PERF_COUNTER = 0x0010, /* Hardware performance counters */
SH_CPU_HAS_PTEA = 0x0020, /* PTEA register */
SH_CPU_HAS_LLSC = 0x0040, /* movli.l/movco.l */
SH_CPU_HAS_L2_CACHE = 0x0080, /* Secondary cache / URAM */
SH_CPU_HAS_OP32 = 0x0100, /* 32-bit instruction support */
SH_CPU_HAS_PTEAEX = 0x0200, /* PTE ASID Extension support */
};
abi_ulong get_elf_hwcap(CPUState *cs)
{
SuperHCPU *cpu = SUPERH_CPU(cs);
abi_ulong hwcap = 0;
hwcap |= SH_CPU_HAS_FPU;
if (cpu->env.features & SH_FEATURE_SH4A) {
hwcap |= SH_CPU_HAS_LLSC;
}
return hwcap;
}
void elf_core_copy_fpregs(target_elf_fpregset_t *r, const CPUSH4State *env)
{
for (int i = 0; i < 16; i++) {
r->fpregs[i] = tswap32(env->fregs[i]);
r->xfpregs[i] = tswap32(env->fregs[16 + i]);
}
r->fpscr = tswap32(env->fpscr);
r->fpul = tswap32(env->fpul);
}
void elf_core_copy_regs(target_elf_gregset_t *r, const CPUSH4State *env)
{
for (int i = 0; i < 16; i++) {
r->pt.regs[i] = tswapal(env->gregs[i]);
}
r->pt.pc = tswapal(env->pc);
r->pt.pr = tswapal(env->pr);
r->pt.sr = tswapal(env->sr);
r->pt.gbr = tswapal(env->gbr);
r->pt.mach = tswapal(env->mach);
r->pt.macl = tswapal(env->macl);
}
linux-user/sh4/meson.build
+17
View File
@@ -0,0 +1,17 @@
syscall_nr_generators += {
'sh4': generator(sh,
arguments: [ meson.current_source_dir() / 'syscallhdr.sh', '@INPUT@', '@OUTPUT@', '@EXTRA_ARGS@' ],
output: '@BASENAME@_nr.h')
}
vdso_le_inc = gen_vdso.process('vdso-le.so',
extra_args: ['-s', '__kernel_sigreturn',
'-r', '__kernel_rt_sigreturn',
'-p', 'vdso_le'])
vdso_be_inc = gen_vdso.process('vdso-be.so',
extra_args: ['-s', '__kernel_sigreturn',
'-r', '__kernel_rt_sigreturn',
'-p', 'vdso_be'])
linux_user_ss.add(when: 'TARGET_SH4', if_true: [vdso_le_inc, vdso_be_inc])
linux-user/sh4/signal.c
+387
View File
@@ -0,0 +1,387 @@
/*
* Emulation of Linux signals
*
* Copyright (c) 2003 Fabrice Bellard
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "qemu/osdep.h"
#include "qemu.h"
#include "user-internals.h"
#include "signal-common.h"
#include "linux-user/trace.h"
/*
* code and data structures from linux kernel:
* include/asm-sh/sigcontext.h
* arch/sh/kernel/signal.c
*/
struct target_sigcontext {
target_ulong oldmask;
/* CPU registers */
target_ulong sc_gregs[16];
target_ulong sc_pc;
target_ulong sc_pr;
target_ulong sc_sr;
target_ulong sc_gbr;
target_ulong sc_mach;
target_ulong sc_macl;
/* FPU registers */
target_ulong sc_fpregs[16];
target_ulong sc_xfpregs[16];
unsigned int sc_fpscr;
unsigned int sc_fpul;
unsigned int sc_ownedfp;
};
struct target_sigframe
{
struct target_sigcontext sc;
target_ulong extramask[TARGET_NSIG_WORDS-1];
};
struct target_ucontext {
target_ulong tuc_flags;
abi_ulong tuc_link;
target_stack_t tuc_stack;
struct target_sigcontext tuc_mcontext;
target_sigset_t tuc_sigmask; /* mask last for extensibility */
};
struct target_rt_sigframe
{
struct target_siginfo info;
struct target_ucontext uc;
};
#define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
#define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
static abi_ulong get_sigframe(struct target_sigaction *ka,
unsigned long sp, size_t frame_size)
{
sp = target_sigsp(sp, ka);
return (sp - frame_size) & -8ul;
}
/*
* Notice when we're in the middle of a gUSA region and reset.
* Note that this will only occur when #CF_PARALLEL is unset, as we
* will translate such sequences differently in a parallel context.
*/
static void unwind_gusa(CPUSH4State *regs)
{
/* If the stack pointer is sufficiently negative, and we haven't
completed the sequence, then reset to the entry to the region. */
/* ??? The SH4 kernel checks for and address above 0xC0000000.
However, the page mappings in qemu linux-user aren't as restricted
and we wind up with the normal stack mapped above 0xF0000000.
That said, there is no reason why the kernel should be allowing
a gUSA region that spans 1GB. Use a tighter check here, for what
can actually be enabled by the immediate move. */
if (regs->gregs[15] >= -128u && regs->pc < regs->gregs[0]) {
/* Reset the PC to before the gUSA region, as computed from
R0 = region end, SP = -(region size), plus one more for the
insn that actually initializes SP to the region size. */
regs->pc = regs->gregs[0] + regs->gregs[15] - 2;
/* Reset the SP to the saved version in R1. */
regs->gregs[15] = regs->gregs[1];
} else if (regs->gregs[15] >= -128u && regs->pc == regs->gregs[0]) {
/* If we are on the last instruction of a gUSA region, we must reset
the SP, otherwise we would be pushing the signal context to
invalid memory. */
regs->gregs[15] = regs->gregs[1];
} else if (regs->flags & (TB_FLAG_DELAY_SLOT | TB_FLAG_DELAY_SLOT_COND)) {
/* If we are in a delay slot, push the previous instruction. */
regs->pc -= 2;
}
}
static void setup_sigcontext(struct target_sigcontext *sc,
CPUSH4State *regs, unsigned long mask)
{
int i;
#define COPY(x) __put_user(regs->x, &sc->sc_##x)
COPY(gregs[0]); COPY(gregs[1]);
COPY(gregs[2]); COPY(gregs[3]);
COPY(gregs[4]); COPY(gregs[5]);
COPY(gregs[6]); COPY(gregs[7]);
COPY(gregs[8]); COPY(gregs[9]);
COPY(gregs[10]); COPY(gregs[11]);
COPY(gregs[12]); COPY(gregs[13]);
COPY(gregs[14]); COPY(gregs[15]);
COPY(gbr); COPY(mach);
COPY(macl); COPY(pr);
COPY(pc);
#undef COPY
/* The T, M and Q bits live outside env->sr; fold them back in. */
__put_user(cpu_read_sr(regs), &sc->sc_sr);
for (i=0; i<16; i++) {
__put_user(regs->fregs[i], &sc->sc_fpregs[i]);
}
__put_user(regs->fpscr, &sc->sc_fpscr);
__put_user(regs->fpul, &sc->sc_fpul);
/* non-iBCS2 extensions.. */
__put_user(mask, &sc->oldmask);
}
static void restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc)
{
int i;
#define COPY(x) __get_user(regs->x, &sc->sc_##x)
COPY(gregs[0]); COPY(gregs[1]);
COPY(gregs[2]); COPY(gregs[3]);
COPY(gregs[4]); COPY(gregs[5]);
COPY(gregs[6]); COPY(gregs[7]);
COPY(gregs[8]); COPY(gregs[9]);
COPY(gregs[10]); COPY(gregs[11]);
COPY(gregs[12]); COPY(gregs[13]);
COPY(gregs[14]); COPY(gregs[15]);
COPY(gbr); COPY(mach);
COPY(macl); COPY(pr);
COPY(pc);
#undef COPY
/* The T, M and Q bits live outside env->sr; unfold them. */
{
uint32_t sr;
__get_user(sr, &sc->sc_sr);
cpu_write_sr(regs, sr);
}
for (i=0; i<16; i++) {
__get_user(regs->fregs[i], &sc->sc_fpregs[i]);
}
/* Resync the derived float_status state, not just env->fpscr. */
{
uint32_t fpscr;
__get_user(fpscr, &sc->sc_fpscr);
cpu_load_fpscr(regs, fpscr);
}
__get_user(regs->fpul, &sc->sc_fpul);
regs->tra = -1; /* disable syscall checks */
regs->flags = 0;
}
void setup_frame(int sig, struct target_sigaction *ka,
target_sigset_t *set, CPUSH4State *regs)
{
struct target_sigframe *frame;
abi_ulong frame_addr;
int i;
unwind_gusa(regs);
frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
trace_user_setup_frame(regs, frame_addr);
if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
goto give_sigsegv;
}
setup_sigcontext(&frame->sc, regs, set->sig[0]);
for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
__put_user(set->sig[i + 1], &frame->extramask[i]);
}
regs->fpscr = FPSCR_PR;
/* Set up to return from userspace. If provided, use a stub
already in userspace. */
if (ka->sa_flags & TARGET_SA_RESTORER) {
regs->pr = ka->sa_restorer;
} else {
regs->pr = default_sigreturn;
}
/* Set up registers for signal handler */
regs->gregs[15] = frame_addr;
regs->gregs[4] = sig; /* Arg for signal handler */
regs->gregs[5] = 0;
regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
regs->pc = (unsigned long) ka->_sa_handler;
regs->flags &= ~(TB_FLAG_DELAY_SLOT_MASK | TB_FLAG_GUSA_MASK);
unlock_user_struct(frame, frame_addr, 1);
return;
give_sigsegv:
unlock_user_struct(frame, frame_addr, 1);
force_sigsegv(sig);
}
void setup_rt_frame(int sig, struct target_sigaction *ka,
target_siginfo_t *info,
target_sigset_t *set, CPUSH4State *regs)
{
struct target_rt_sigframe *frame;
abi_ulong frame_addr;
int i;
unwind_gusa(regs);
frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
trace_user_setup_rt_frame(regs, frame_addr);
if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
goto give_sigsegv;
}
frame->info = *info;
/* Create the ucontext. */
__put_user(0, &frame->uc.tuc_flags);
__put_user(0, &frame->uc.tuc_link);
target_save_altstack(&frame->uc.tuc_stack, regs);
setup_sigcontext(&frame->uc.tuc_mcontext,
regs, set->sig[0]);
for(i = 0; i < TARGET_NSIG_WORDS; i++) {
__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
}
regs->fpscr = FPSCR_PR;
/* Set up to return from userspace. If provided, use a stub
already in userspace. */
if (ka->sa_flags & TARGET_SA_RESTORER) {
regs->pr = ka->sa_restorer;
} else {
regs->pr = default_rt_sigreturn;
}
/* Set up registers for signal handler */
regs->gregs[15] = frame_addr;
regs->gregs[4] = sig; /* Arg for signal handler */
regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
regs->pc = (unsigned long) ka->_sa_handler;
regs->flags &= ~(TB_FLAG_DELAY_SLOT_MASK | TB_FLAG_GUSA_MASK);
unlock_user_struct(frame, frame_addr, 1);
return;
give_sigsegv:
unlock_user_struct(frame, frame_addr, 1);
force_sigsegv(sig);
}
long do_sigreturn(CPUSH4State *regs)
{
struct target_sigframe *frame;
abi_ulong frame_addr;
sigset_t blocked;
target_sigset_t target_set;
int i;
frame_addr = regs->gregs[15];
trace_user_do_sigreturn(regs, frame_addr);
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
goto badframe;
}
__get_user(target_set.sig[0], &frame->sc.oldmask);
for(i = 1; i < TARGET_NSIG_WORDS; i++) {
__get_user(target_set.sig[i], &frame->extramask[i - 1]);
}
target_to_host_sigset_internal(&blocked, &target_set);
set_sigmask(&blocked);
restore_sigcontext(regs, &frame->sc);
unlock_user_struct(frame, frame_addr, 0);
return -QEMU_ESIGRETURN;
badframe:
unlock_user_struct(frame, frame_addr, 0);
force_sig(TARGET_SIGSEGV);
return -QEMU_ESIGRETURN;
}
long do_rt_sigreturn(CPUSH4State *regs)
{
struct target_rt_sigframe *frame;
abi_ulong frame_addr;
sigset_t blocked;
frame_addr = regs->gregs[15];
trace_user_do_rt_sigreturn(regs, frame_addr);
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
goto badframe;
}
target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
set_sigmask(&blocked);
restore_sigcontext(regs, &frame->uc.tuc_mcontext);
target_restore_altstack(&frame->uc.tuc_stack, regs);
unlock_user_struct(frame, frame_addr, 0);
return -QEMU_ESIGRETURN;
badframe:
unlock_user_struct(frame, frame_addr, 0);
force_sig(TARGET_SIGSEGV);
return -QEMU_ESIGRETURN;
}
/*
* "or r0,r0" nop used by the Linux kernel inline sigreturn trampolines to
* avoid a hardware bug (OR_R0_R0 in arch/sh/kernel/signal_32.c). Five of
* these nops follow TRAP_NOARG, placing the syscall number word 14 bytes
* past the MOVW(7) instruction (at MOVW(7)'s load offset). This yields the
* fixed 16-byte layout that libunwind's unw_is_signal_frame detects:
* [MOVW(7), TRAP_NOARG, 5x NOP_OR, .word syscall_nr]
*/
#define NOP_OR 0x200b
void setup_sigtramp(abi_ulong sigtramp_page)
{
uint16_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 2 * 16, 0);
assert(tramp != NULL);
/* sigreturn trampoline (non-RT) at offset 0 */
default_sigreturn = sigtramp_page;
__put_user(MOVW(7), &tramp[0]);
__put_user(TRAP_NOARG, &tramp[1]);
__put_user(NOP_OR, &tramp[2]);
__put_user(NOP_OR, &tramp[3]);
__put_user(NOP_OR, &tramp[4]);
__put_user(NOP_OR, &tramp[5]);
__put_user(NOP_OR, &tramp[6]);
__put_user(TARGET_NR_sigreturn, &tramp[7]);
/* rt_sigreturn trampoline at offset 16 */
default_rt_sigreturn = sigtramp_page + 16;
__put_user(MOVW(7), &tramp[8]);
__put_user(TRAP_NOARG, &tramp[9]);
__put_user(NOP_OR, &tramp[10]);
__put_user(NOP_OR, &tramp[11]);
__put_user(NOP_OR, &tramp[12]);
__put_user(NOP_OR, &tramp[13]);
__put_user(NOP_OR, &tramp[14]);
__put_user(TARGET_NR_rt_sigreturn, &tramp[15]);
unlock_user(tramp, sigtramp_page, 2 * 16);
}
linux-user/sh4/sockbits.h
+1
View File
@@ -0,0 +1 @@
#include "../generic/sockbits.h"
linux-user/sh4/syscall.tbl
+468
View File
@@ -0,0 +1,468 @@
# SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note
#
# system call numbers and entry vectors for sh
#
# The format is:
# <number> <abi> <name> <entry point>
#
# The <abi> is always "common" for this file
#
0 common restart_syscall sys_restart_syscall
1 common exit sys_exit
2 common fork sys_fork
3 common read sys_read
4 common write sys_write
5 common open sys_open
6 common close sys_close
7 common waitpid sys_waitpid
8 common creat sys_creat
9 common link sys_link
10 common unlink sys_unlink
11 common execve sys_execve
12 common chdir sys_chdir
13 common time sys_time32
14 common mknod sys_mknod
15 common chmod sys_chmod
16 common lchown sys_lchown16
# 17 was break
18 common oldstat sys_stat
19 common lseek sys_lseek
20 common getpid sys_getpid
21 common mount sys_mount
22 common umount sys_oldumount
23 common setuid sys_setuid16
24 common getuid sys_getuid16
25 common stime sys_stime32
26 common ptrace sys_ptrace
27 common alarm sys_alarm
28 common oldfstat sys_fstat
29 common pause sys_pause
30 common utime sys_utime32
# 31 was stty
# 32 was gtty
33 common access sys_access
34 common nice sys_nice
# 35 was ftime
36 common sync sys_sync
37 common kill sys_kill
38 common rename sys_rename
39 common mkdir sys_mkdir
40 common rmdir sys_rmdir
41 common dup sys_dup
42 common pipe sys_sh_pipe
43 common times sys_times
# 44 was prof
45 common brk sys_brk
46 common setgid sys_setgid16
47 common getgid sys_getgid16
48 common signal sys_signal
49 common geteuid sys_geteuid16
50 common getegid sys_getegid16
51 common acct sys_acct
52 common umount2 sys_umount
# 53 was lock
54 common ioctl sys_ioctl
55 common fcntl sys_fcntl
# 56 was mpx
57 common setpgid sys_setpgid
# 58 was ulimit
# 59 was olduname
60 common umask sys_umask
61 common chroot sys_chroot
62 common ustat sys_ustat
63 common dup2 sys_dup2
64 common getppid sys_getppid
65 common getpgrp sys_getpgrp
66 common setsid sys_setsid
67 common sigaction sys_sigaction
68 common sgetmask sys_sgetmask
69 common ssetmask sys_ssetmask
70 common setreuid sys_setreuid16
71 common setregid sys_setregid16
72 common sigsuspend sys_sigsuspend
73 common sigpending sys_sigpending
74 common sethostname sys_sethostname
75 common setrlimit sys_setrlimit
76 common getrlimit sys_old_getrlimit
77 common getrusage sys_getrusage
78 common gettimeofday sys_gettimeofday
79 common settimeofday sys_settimeofday
80 common getgroups sys_getgroups16
81 common setgroups sys_setgroups16
# 82 was select
83 common symlink sys_symlink
84 common oldlstat sys_lstat
85 common readlink sys_readlink
86 common uselib sys_uselib
87 common swapon sys_swapon
88 common reboot sys_reboot
89 common readdir sys_old_readdir
90 common mmap old_mmap
91 common munmap sys_munmap
92 common truncate sys_truncate
93 common ftruncate sys_ftruncate
94 common fchmod sys_fchmod
95 common fchown sys_fchown16
96 common getpriority sys_getpriority
97 common setpriority sys_setpriority
# 98 was profil
99 common statfs sys_statfs
100 common fstatfs sys_fstatfs
# 101 was ioperm
102 common socketcall sys_socketcall
103 common syslog sys_syslog
104 common setitimer sys_setitimer
105 common getitimer sys_getitimer
106 common stat sys_newstat
107 common lstat sys_newlstat
108 common fstat sys_newfstat
109 common olduname sys_uname
# 110 was iopl
111 common vhangup sys_vhangup
# 112 was idle
# 113 was vm86old
114 common wait4 sys_wait4
115 common swapoff sys_swapoff
116 common sysinfo sys_sysinfo
117 common ipc sys_ipc
118 common fsync sys_fsync
119 common sigreturn sys_sigreturn
120 common clone sys_clone
121 common setdomainname sys_setdomainname
122 common uname sys_newuname
123 common cacheflush sys_cacheflush
124 common adjtimex sys_adjtimex_time32
125 common mprotect sys_mprotect
126 common sigprocmask sys_sigprocmask
# 127 was create_module
128 common init_module sys_init_module
129 common delete_module sys_delete_module
# 130 was get_kernel_syms
131 common quotactl sys_quotactl
132 common getpgid sys_getpgid
133 common fchdir sys_fchdir
134 common bdflush sys_ni_syscall
135 common sysfs sys_sysfs
136 common personality sys_personality
# 137 was afs_syscall
138 common setfsuid sys_setfsuid16
139 common setfsgid sys_setfsgid16
140 common _llseek sys_llseek
141 common getdents sys_getdents
142 common _newselect sys_select
143 common flock sys_flock
144 common msync sys_msync
145 common readv sys_readv
146 common writev sys_writev
147 common getsid sys_getsid
148 common fdatasync sys_fdatasync
149 common _sysctl sys_ni_syscall
150 common mlock sys_mlock
151 common munlock sys_munlock
152 common mlockall sys_mlockall
153 common munlockall sys_munlockall
154 common sched_setparam sys_sched_setparam
155 common sched_getparam sys_sched_getparam
156 common sched_setscheduler sys_sched_setscheduler
157 common sched_getscheduler sys_sched_getscheduler
158 common sched_yield sys_sched_yield
159 common sched_get_priority_max sys_sched_get_priority_max
160 common sched_get_priority_min sys_sched_get_priority_min
161 common sched_rr_get_interval sys_sched_rr_get_interval_time32
162 common nanosleep sys_nanosleep_time32
163 common mremap sys_mremap
164 common setresuid sys_setresuid16
165 common getresuid sys_getresuid16
# 166 was vm86
# 167 was query_module
168 common poll sys_poll
169 common nfsservctl sys_ni_syscall
170 common setresgid sys_setresgid16
171 common getresgid sys_getresgid16
172 common prctl sys_prctl
173 common rt_sigreturn sys_rt_sigreturn
174 common rt_sigaction sys_rt_sigaction
175 common rt_sigprocmask sys_rt_sigprocmask
176 common rt_sigpending sys_rt_sigpending
177 common rt_sigtimedwait sys_rt_sigtimedwait_time32
178 common rt_sigqueueinfo sys_rt_sigqueueinfo
179 common rt_sigsuspend sys_rt_sigsuspend
180 common pread64 sys_pread_wrapper
181 common pwrite64 sys_pwrite_wrapper
182 common chown sys_chown16
183 common getcwd sys_getcwd
184 common capget sys_capget
185 common capset sys_capset
186 common sigaltstack sys_sigaltstack
187 common sendfile sys_sendfile
# 188 is reserved for getpmsg
# 189 is reserved for putpmsg
190 common vfork sys_vfork
191 common ugetrlimit sys_getrlimit
192 common mmap2 sys_mmap2
193 common truncate64 sys_truncate64
194 common ftruncate64 sys_ftruncate64
195 common stat64 sys_stat64
196 common lstat64 sys_lstat64
197 common fstat64 sys_fstat64
198 common lchown32 sys_lchown
199 common getuid32 sys_getuid
200 common getgid32 sys_getgid
201 common geteuid32 sys_geteuid
202 common getegid32 sys_getegid
203 common setreuid32 sys_setreuid
204 common setregid32 sys_setregid
205 common getgroups32 sys_getgroups
206 common setgroups32 sys_setgroups
207 common fchown32 sys_fchown
208 common setresuid32 sys_setresuid
209 common getresuid32 sys_getresuid
210 common setresgid32 sys_setresgid
211 common getresgid32 sys_getresgid
212 common chown32 sys_chown
213 common setuid32 sys_setuid
214 common setgid32 sys_setgid
215 common setfsuid32 sys_setfsuid
216 common setfsgid32 sys_setfsgid
217 common pivot_root sys_pivot_root
218 common mincore sys_mincore
219 common madvise sys_madvise
220 common getdents64 sys_getdents64
221 common fcntl64 sys_fcntl64
# 222 is reserved for tux
# 223 is unused
224 common gettid sys_gettid
225 common readahead sys_readahead
226 common setxattr sys_setxattr
227 common lsetxattr sys_lsetxattr
228 common fsetxattr sys_fsetxattr
229 common getxattr sys_getxattr
230 common lgetxattr sys_lgetxattr
231 common fgetxattr sys_fgetxattr
232 common listxattr sys_listxattr
233 common llistxattr sys_llistxattr
234 common flistxattr sys_flistxattr
235 common removexattr sys_removexattr
236 common lremovexattr sys_lremovexattr
237 common fremovexattr sys_fremovexattr
238 common tkill sys_tkill
239 common sendfile64 sys_sendfile64
240 common futex sys_futex_time32
241 common sched_setaffinity sys_sched_setaffinity
242 common sched_getaffinity sys_sched_getaffinity
# 243 is reserved for set_thread_area
# 244 is reserved for get_thread_area
245 common io_setup sys_io_setup
246 common io_destroy sys_io_destroy
247 common io_getevents sys_io_getevents_time32
248 common io_submit sys_io_submit
249 common io_cancel sys_io_cancel
250 common fadvise64 sys_fadvise64
# 251 is unused
252 common exit_group sys_exit_group
253 common lookup_dcookie sys_ni_syscall
254 common epoll_create sys_epoll_create
255 common epoll_ctl sys_epoll_ctl
256 common epoll_wait sys_epoll_wait
257 common remap_file_pages sys_remap_file_pages
258 common set_tid_address sys_set_tid_address
259 common timer_create sys_timer_create
260 common timer_settime sys_timer_settime32
261 common timer_gettime sys_timer_gettime32
262 common timer_getoverrun sys_timer_getoverrun
263 common timer_delete sys_timer_delete
264 common clock_settime sys_clock_settime32
265 common clock_gettime sys_clock_gettime32
266 common clock_getres sys_clock_getres_time32
267 common clock_nanosleep sys_clock_nanosleep_time32
268 common statfs64 sys_statfs64
269 common fstatfs64 sys_fstatfs64
270 common tgkill sys_tgkill
271 common utimes sys_utimes_time32
272 common fadvise64_64 sys_fadvise64_64_wrapper
# 273 is reserved for vserver
274 common mbind sys_mbind
275 common get_mempolicy sys_get_mempolicy
276 common set_mempolicy sys_set_mempolicy
277 common mq_open sys_mq_open
278 common mq_unlink sys_mq_unlink
279 common mq_timedsend sys_mq_timedsend_time32
280 common mq_timedreceive sys_mq_timedreceive_time32
281 common mq_notify sys_mq_notify
282 common mq_getsetattr sys_mq_getsetattr
283 common kexec_load sys_kexec_load
284 common waitid sys_waitid
285 common add_key sys_add_key
286 common request_key sys_request_key
287 common keyctl sys_keyctl
288 common ioprio_set sys_ioprio_set
289 common ioprio_get sys_ioprio_get
290 common inotify_init sys_inotify_init
291 common inotify_add_watch sys_inotify_add_watch
292 common inotify_rm_watch sys_inotify_rm_watch
# 293 is unused
294 common migrate_pages sys_migrate_pages
295 common openat sys_openat
296 common mkdirat sys_mkdirat
297 common mknodat sys_mknodat
298 common fchownat sys_fchownat
299 common futimesat sys_futimesat_time32
300 common fstatat64 sys_fstatat64
301 common unlinkat sys_unlinkat
302 common renameat sys_renameat
303 common linkat sys_linkat
304 common symlinkat sys_symlinkat
305 common readlinkat sys_readlinkat
306 common fchmodat sys_fchmodat
307 common faccessat sys_faccessat
308 common pselect6 sys_pselect6_time32
309 common ppoll sys_ppoll_time32
310 common unshare sys_unshare
311 common set_robust_list sys_set_robust_list
312 common get_robust_list sys_get_robust_list
313 common splice sys_splice
314 common sync_file_range sys_sh_sync_file_range6
315 common tee sys_tee
316 common vmsplice sys_vmsplice
317 common move_pages sys_move_pages
318 common getcpu sys_getcpu
319 common epoll_pwait sys_epoll_pwait
320 common utimensat sys_utimensat_time32
321 common signalfd sys_signalfd
322 common timerfd_create sys_timerfd_create
323 common eventfd sys_eventfd
324 common fallocate sys_fallocate
325 common timerfd_settime sys_timerfd_settime32
326 common timerfd_gettime sys_timerfd_gettime32
327 common signalfd4 sys_signalfd4
328 common eventfd2 sys_eventfd2
329 common epoll_create1 sys_epoll_create1
330 common dup3 sys_dup3
331 common pipe2 sys_pipe2
332 common inotify_init1 sys_inotify_init1
333 common preadv sys_preadv
334 common pwritev sys_pwritev
335 common rt_tgsigqueueinfo sys_rt_tgsigqueueinfo
336 common perf_event_open sys_perf_event_open
337 common fanotify_init sys_fanotify_init
338 common fanotify_mark sys_fanotify_mark
339 common prlimit64 sys_prlimit64
340 common socket sys_socket
341 common bind sys_bind
342 common connect sys_connect
343 common listen sys_listen
344 common accept sys_accept
345 common getsockname sys_getsockname
346 common getpeername sys_getpeername
347 common socketpair sys_socketpair
348 common send sys_send
349 common sendto sys_sendto
350 common recv sys_recv
351 common recvfrom sys_recvfrom
352 common shutdown sys_shutdown
353 common setsockopt sys_setsockopt
354 common getsockopt sys_getsockopt
355 common sendmsg sys_sendmsg
356 common recvmsg sys_recvmsg
357 common recvmmsg sys_recvmmsg_time32
358 common accept4 sys_accept4
359 common name_to_handle_at sys_name_to_handle_at
360 common open_by_handle_at sys_open_by_handle_at
361 common clock_adjtime sys_clock_adjtime32
362 common syncfs sys_syncfs
363 common sendmmsg sys_sendmmsg
364 common setns sys_setns
365 common process_vm_readv sys_process_vm_readv
366 common process_vm_writev sys_process_vm_writev
367 common kcmp sys_kcmp
368 common finit_module sys_finit_module
369 common sched_getattr sys_sched_getattr
370 common sched_setattr sys_sched_setattr
371 common renameat2 sys_renameat2
372 common seccomp sys_seccomp
373 common getrandom sys_getrandom
374 common memfd_create sys_memfd_create
375 common bpf sys_bpf
376 common execveat sys_execveat
377 common userfaultfd sys_userfaultfd
378 common membarrier sys_membarrier
379 common mlock2 sys_mlock2
380 common copy_file_range sys_copy_file_range
381 common preadv2 sys_preadv2
382 common pwritev2 sys_pwritev2
383 common statx sys_statx
384 common pkey_mprotect sys_pkey_mprotect
385 common pkey_alloc sys_pkey_alloc
386 common pkey_free sys_pkey_free
387 common rseq sys_rseq
388 common sync_file_range2 sys_sync_file_range2
# room for arch specific syscalls
393 common semget sys_semget
394 common semctl sys_semctl
395 common shmget sys_shmget
396 common shmctl sys_shmctl
397 common shmat sys_shmat
398 common shmdt sys_shmdt
399 common msgget sys_msgget
400 common msgsnd sys_msgsnd
401 common msgrcv sys_msgrcv
402 common msgctl sys_msgctl
403 common clock_gettime64 sys_clock_gettime
404 common clock_settime64 sys_clock_settime
405 common clock_adjtime64 sys_clock_adjtime
406 common clock_getres_time64 sys_clock_getres
407 common clock_nanosleep_time64 sys_clock_nanosleep
408 common timer_gettime64 sys_timer_gettime
409 common timer_settime64 sys_timer_settime
410 common timerfd_gettime64 sys_timerfd_gettime
411 common timerfd_settime64 sys_timerfd_settime
412 common utimensat_time64 sys_utimensat
413 common pselect6_time64 sys_pselect6
414 common ppoll_time64 sys_ppoll
416 common io_pgetevents_time64 sys_io_pgetevents
417 common recvmmsg_time64 sys_recvmmsg
418 common mq_timedsend_time64 sys_mq_timedsend
419 common mq_timedreceive_time64 sys_mq_timedreceive
420 common semtimedop_time64 sys_semtimedop
421 common rt_sigtimedwait_time64 sys_rt_sigtimedwait
422 common futex_time64 sys_futex
423 common sched_rr_get_interval_time64 sys_sched_rr_get_interval
424 common pidfd_send_signal sys_pidfd_send_signal
425 common io_uring_setup sys_io_uring_setup
426 common io_uring_enter sys_io_uring_enter
427 common io_uring_register sys_io_uring_register
428 common open_tree sys_open_tree
429 common move_mount sys_move_mount
430 common fsopen sys_fsopen
431 common fsconfig sys_fsconfig
432 common fsmount sys_fsmount
433 common fspick sys_fspick
434 common pidfd_open sys_pidfd_open
# 435 reserved for clone3
436 common close_range sys_close_range
437 common openat2 sys_openat2
438 common pidfd_getfd sys_pidfd_getfd
439 common faccessat2 sys_faccessat2
440 common process_madvise sys_process_madvise
441 common epoll_pwait2 sys_epoll_pwait2
442 common mount_setattr sys_mount_setattr
443 common quotactl_fd sys_quotactl_fd
444 common landlock_create_ruleset sys_landlock_create_ruleset
445 common landlock_add_rule sys_landlock_add_rule
446 common landlock_restrict_self sys_landlock_restrict_self
# 447 reserved for memfd_secret
448 common process_mrelease sys_process_mrelease
449 common futex_waitv sys_futex_waitv
450 common set_mempolicy_home_node sys_set_mempolicy_home_node
451 common cachestat sys_cachestat
452 common fchmodat2 sys_fchmodat2
453 common map_shadow_stack sys_map_shadow_stack
454 common futex_wake sys_futex_wake
455 common futex_wait sys_futex_wait
456 common futex_requeue sys_futex_requeue
457 common statmount sys_statmount
458 common listmount sys_listmount
459 common lsm_get_self_attr sys_lsm_get_self_attr
460 common lsm_set_self_attr sys_lsm_set_self_attr
461 common lsm_list_modules sys_lsm_list_modules
462 common mseal sys_mseal
linux-user/sh4/syscallhdr.sh
+32
View File
@@ -0,0 +1,32 @@
#!/bin/sh
# SPDX-License-Identifier: GPL-2.0-only
in="$1"
out="$2"
my_abis=`echo "($3)" | tr ',' '|'`
prefix="$4"
offset="$5"
fileguard=LINUX_USER_SH4_`basename "$out" | sed \
-e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' \
-e 's/[^A-Z0-9_]/_/g' -e 's/__/_/g'`
grep -E "^[0-9A-Fa-fXx]+[[:space:]]+${my_abis}" "$in" | sort -n | (
printf "#ifndef %s\n" "${fileguard}"
printf "#define %s\n" "${fileguard}"
printf "\n"
nxt=0
while read nr abi name entry ; do
if [ -z "$offset" ]; then
printf "#define TARGET_NR_%s%s\t%s\n" \
"${prefix}" "${name}" "${nr}"
else
printf "#define TARGET_NR_%s%s\t(%s + %s)\n" \
"${prefix}" "${name}" "${offset}" "${nr}"
fi
nxt=$((nr+1))
done
printf "\n"
printf "#endif /* %s */" "${fileguard}"
) > "$out"
linux-user/sh4/target_cpu.h
+44
View File
@@ -0,0 +1,44 @@
/*
* SH4 specific CPU ABI and functions for linux-user
*
* Copyright (c) 2005 Samuel Tardieu
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SH4_TARGET_CPU_H
#define SH4_TARGET_CPU_H
static inline void cpu_clone_regs_child(CPUSH4State *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->gregs[15] = newsp;
}
env->gregs[0] = 0;
}
static inline void cpu_clone_regs_parent(CPUSH4State *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUSH4State *env, target_ulong newtls)
{
env->gbr = newtls;
}
static inline abi_ulong get_sp_from_cpustate(CPUSH4State *state)
{
return state->gregs[15];
}
#endif
linux-user/sh4/target_elf.h
+40
View File
@@ -0,0 +1,40 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation, or (at your option) any
* later version. See the COPYING file in the top-level directory.
*/
#ifndef SH4_TARGET_ELF_H
#define SH4_TARGET_ELF_H
#include "target_ptrace.h"
#define ELF_CLASS ELFCLASS32
#define ELF_MACHINE EM_SH
#define HAVE_ELF_HWCAP 1
#define HAVE_ELF_CORE_DUMP 1
#define HAVE_VDSO_IMAGE_INFO 1
/*
* See linux kernel: arch/sh/include/asm/elf.h, where
* elf_gregset_t is mapped to struct pt_regs via sizeof.
*/
typedef struct target_elf_gregset_t {
struct target_pt_regs pt;
} target_elf_gregset_t;
#define HAVE_ELF_CORE_FPREGS 1
/*
* Matches struct user_fpu_struct from arch/sh/include/asm/user.h.
*/
typedef struct target_elf_fpregset_t {
uint32_t fpregs[16];
uint32_t xfpregs[16];
uint32_t fpscr;
uint32_t fpul;
} target_elf_fpregset_t;
#endif
linux-user/sh4/target_errno_defs.h
+7
View File
@@ -0,0 +1,7 @@
#ifndef SH4_TARGET_ERRNO_DEFS_H
#define SH4_TARGET_ERRNO_DEFS_H
/* Target uses generic errno */
#include "../generic/target_errno_defs.h"
#endif
linux-user/sh4/target_fcntl.h
+11
View File
@@ -0,0 +1,11 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation, or (at your option) any
* later version. See the COPYING file in the top-level directory.
*/
#ifndef SH4_TARGET_FCNTL_H
#define SH4_TARGET_FCNTL_H
#include "../generic/fcntl.h"
#endif
linux-user/sh4/target_flat.h
+1
View File
@@ -0,0 +1 @@
#include "../generic/target_flat.h"
linux-user/sh4/target_mman.h
+8
View File
@@ -0,0 +1,8 @@
/* arch/sh/include/asm/processor_32.h */
#define TASK_UNMAPPED_BASE \
TARGET_PAGE_ALIGN((1ull << TARGET_VIRT_ADDR_SPACE_BITS) / 3)
/* arch/sh/include/asm/elf.h */
#define ELF_ET_DYN_BASE (TASK_UNMAPPED_BASE * 2)
#include "../generic/target_mman.h"
linux-user/sh4/target_prctl.h
+1
View File
@@ -0,0 +1 @@
#include "../generic/target_prctl_unalign.h"
linux-user/sh4/target_proc.h
+1
View File
@@ -0,0 +1 @@
/* No target-specific /proc support */
linux-user/sh4/target_ptrace.h
+18
View File
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
#ifndef SH4_TARGET_PTRACE_H
#define SH4_TARGET_PTRACE_H
/* See arch/sh/include/uapi/asm/ptrace_32.h. */
struct target_pt_regs {
abi_ulong regs[16];
abi_ulong pc;
abi_ulong pr;
abi_ulong sr;
abi_ulong gbr;
abi_ulong mach;
abi_ulong macl;
abi_long tra;
};
#endif /* SH4_TARGET_PTRACE_H */
linux-user/sh4/target_resource.h
+1
View File
@@ -0,0 +1 @@
#include "../generic/target_resource.h"
linux-user/sh4/target_signal.h
+11
View File
@@ -0,0 +1,11 @@
#ifndef SH4_TARGET_SIGNAL_H
#define SH4_TARGET_SIGNAL_H
#include "../generic/signal.h"
#define TARGET_SA_RESTORER 0x04000000
#define TARGET_ARCH_HAS_SETUP_FRAME
#define TARGET_ARCH_HAS_SIGTRAMP_PAGE 1
#endif /* SH4_TARGET_SIGNAL_H */
linux-user/sh4/target_structs.h
+1
View File
@@ -0,0 +1 @@
#include "../generic/target_structs.h"
linux-user/sh4/target_syscall.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef SH4_TARGET_SYSCALL_H
#define SH4_TARGET_SYSCALL_H
#define UNAME_MACHINE "sh4"
#define UNAME_MINIMUM_RELEASE "2.6.32"
#define TARGET_MCL_CURRENT 1
#define TARGET_MCL_FUTURE 2
#define TARGET_MCL_ONFAULT 4
#define TARGET_FORCE_SHMLBA
static inline abi_ulong target_shmlba(CPUSH4State *env)
{
return 0x4000;
}
#endif /* SH4_TARGET_SYSCALL_H */
linux-user/sh4/termbits.h
+312
View File
@@ -0,0 +1,312 @@
/* from asm/termbits.h */
#ifndef LINUX_USER_SH4_TERMBITS_H
#define LINUX_USER_SH4_TERMBITS_H
#define TARGET_NCCS 19
typedef unsigned char target_cc_t; /* cc_t */
typedef unsigned int target_speed_t; /* speed_t */
typedef unsigned int target_tcflag_t; /* tcflag_t */
struct target_termios {
target_tcflag_t c_iflag; /* input mode flags */
target_tcflag_t c_oflag; /* output mode flags */
target_tcflag_t c_cflag; /* control mode flags */
target_tcflag_t c_lflag; /* local mode flags */
target_cc_t c_line; /* line discipline */
target_cc_t c_cc[TARGET_NCCS]; /* control characters */
};
struct target_termios2 {
target_tcflag_t c_iflag; /* input mode flags */
target_tcflag_t c_oflag; /* output mode flags */
target_tcflag_t c_cflag; /* control mode flags */
target_tcflag_t c_lflag; /* local mode flags */
target_cc_t c_line; /* line discipline */
target_cc_t c_cc[TARGET_NCCS]; /* control characters */
target_speed_t c_ispeed; /* input speed */
target_speed_t c_ospeed; /* output speed */
};
struct target_ktermios {
target_tcflag_t c_iflag; /* input mode flags */
target_tcflag_t c_oflag; /* output mode flags */
target_tcflag_t c_cflag; /* control mode flags */
target_tcflag_t c_lflag; /* local mode flags */
target_cc_t c_line; /* line discipline */
target_cc_t c_cc[TARGET_NCCS]; /* control characters */
target_speed_t c_ispeed; /* input speed */
target_speed_t c_ospeed; /* output speed */
};
/* c_cc characters */
#define TARGET_VINTR 0
#define TARGET_VQUIT 1
#define TARGET_VERASE 2
#define TARGET_VKILL 3
#define TARGET_VEOF 4
#define TARGET_VTIME 5
#define TARGET_VMIN 6
#define TARGET_VSWTC 7
#define TARGET_VSTART 8
#define TARGET_VSTOP 9
#define TARGET_VSUSP 10
#define TARGET_VEOL 11
#define TARGET_VREPRINT 12
#define TARGET_VDISCARD 13
#define TARGET_VWERASE 14
#define TARGET_VLNEXT 15
#define TARGET_VEOL2 16
/* c_iflag bits */
#define TARGET_IGNBRK 0000001
#define TARGET_BRKINT 0000002
#define TARGET_IGNPAR 0000004
#define TARGET_PARMRK 0000010
#define TARGET_INPCK 0000020
#define TARGET_ISTRIP 0000040
#define TARGET_INLCR 0000100
#define TARGET_IGNCR 0000200
#define TARGET_ICRNL 0000400
#define TARGET_IUCLC 0001000
#define TARGET_IXON 0002000
#define TARGET_IXANY 0004000
#define TARGET_IXOFF 0010000
#define TARGET_IMAXBEL 0020000
#define TARGET_IUTF8 0040000
/* c_oflag bits */
#define TARGET_OPOST 0000001
#define TARGET_OLCUC 0000002
#define TARGET_ONLCR 0000004
#define TARGET_OCRNL 0000010
#define TARGET_ONOCR 0000020
#define TARGET_ONLRET 0000040
#define TARGET_OFILL 0000100
#define TARGET_OFDEL 0000200
#define TARGET_NLDLY 0000400
#define TARGET_NL0 0000000
#define TARGET_NL1 0000400
#define TARGET_CRDLY 0003000
#define TARGET_CR0 0000000
#define TARGET_CR1 0001000
#define TARGET_CR2 0002000
#define TARGET_CR3 0003000
#define TARGET_TABDLY 0014000
#define TARGET_TAB0 0000000
#define TARGET_TAB1 0004000
#define TARGET_TAB2 0010000
#define TARGET_TAB3 0014000
#define TARGET_XTABS 0014000
#define TARGET_BSDLY 0020000
#define TARGET_BS0 0000000
#define TARGET_BS1 0020000
#define TARGET_VTDLY 0040000
#define TARGET_VT0 0000000
#define TARGET_VT1 0040000
#define TARGET_FFDLY 0100000
#define TARGET_FF0 0000000
#define TARGET_FF1 0100000
/* c_cflag bit meaning */
#define TARGET_CBAUD 0010017
#define TARGET_B0 0000000 /* hang up */
#define TARGET_B50 0000001
#define TARGET_B75 0000002
#define TARGET_B110 0000003
#define TARGET_B134 0000004
#define TARGET_B150 0000005
#define TARGET_B200 0000006
#define TARGET_B300 0000007
#define TARGET_B600 0000010
#define TARGET_B1200 0000011
#define TARGET_B1800 0000012
#define TARGET_B2400 0000013
#define TARGET_B4800 0000014
#define TARGET_B9600 0000015
#define TARGET_B19200 0000016
#define TARGET_B38400 0000017
#define TARGET_EXTA B19200
#define TARGET_EXTB B38400
#define TARGET_CSIZE 0000060
#define TARGET_CS5 0000000
#define TARGET_CS6 0000020
#define TARGET_CS7 0000040
#define TARGET_CS8 0000060
#define TARGET_CSTOPB 0000100
#define TARGET_CREAD 0000200
#define TARGET_PARENB 0000400
#define TARGET_PARODD 0001000
#define TARGET_HUPCL 0002000
#define TARGET_CLOCAL 0004000
#define TARGET_CBAUDEX 0010000
#define TARGET_BOTHER 0010000
#define TARGET_B57600 0010001
#define TARGET_B115200 0010002
#define TARGET_B230400 0010003
#define TARGET_B460800 0010004
#define TARGET_B500000 0010005
#define TARGET_B576000 0010006
#define TARGET_B921600 0010007
#define TARGET_B1000000 0010010
#define TARGET_B1152000 0010011
#define TARGET_B1500000 0010012
#define TARGET_B2000000 0010013
#define TARGET_B2500000 0010014
#define TARGET_B3000000 0010015
#define TARGET_B3500000 0010016
#define TARGET_B4000000 0010017
#define TARGET_CIBAUD 002003600000 /* input baud rate */
#define TARGET_CMSPAR 010000000000 /* mark or space (stick) parity */
#define TARGET_CRTSCTS 020000000000 /* flow control */
#define TARGET_IBSHIFT 16 /* Shift from CBAUD to CIBAUD */
/* c_lflag bits */
#define TARGET_ISIG 0000001
#define TARGET_ICANON 0000002
#define TARGET_XCASE 0000004
#define TARGET_ECHO 0000010
#define TARGET_ECHOE 0000020
#define TARGET_ECHOK 0000040
#define TARGET_ECHONL 0000100
#define TARGET_NOFLSH 0000200
#define TARGET_TOSTOP 0000400
#define TARGET_ECHOCTL 0001000
#define TARGET_ECHOPRT 0002000
#define TARGET_ECHOKE 0004000
#define TARGET_FLUSHO 0010000
#define TARGET_PENDIN 0040000
#define TARGET_IEXTEN 0100000
#define TARGET_EXTPROC 0200000
/* tcflow() and TCXONC use these */
#define TARGET_TCOOFF 0
#define TARGET_TCOON 1
#define TARGET_TCIOFF 2
#define TARGET_TCION 3
/* tcflush() and TCFLSH use these */
#define TARGET_TCIFLUSH 0
#define TARGET_TCOFLUSH 1
#define TARGET_TCIOFLUSH 2
/* tcsetattr uses these */
#define TARGET_TCSANOW 0
#define TARGET_TCSADRAIN 1
#define TARGET_TARGET_TCSAFLUSH 2
/* ioctl */
#define TARGET_FIOCLEX TARGET_IO('f', 1)
#define TARGET_FIONCLEX TARGET_IO('f', 2)
#define TARGET_FIOASYNC TARGET_IOW('f', 125, int)
#define TARGET_FIONBIO TARGET_IOW('f', 126, int)
#define TARGET_FIONREAD TARGET_IOR('f', 127, int)
#define TARGET_TIOCINQ TARGET_FIONREAD
#define TARGET_FIOQSIZE TARGET_IOR('f', 128, loff_t)
#define TARGET_TCGETS 0x5401
#define TARGET_TCSETS 0x5402
#define TARGET_TCSETSW 0x5403
#define TARGET_TCSETSF 0x5404
#define TARGET_TCGETA TARGET_IOR('t', 23, struct termio)
#define TARGET_TIOCSWINSZ TARGET_IOW('t', 103, struct winsize)
#define TARGET_TIOCGWINSZ TARGET_IOR('t', 104, struct winsize)
#define TARGET_TIOCSTART TARGET_IO('t', 110) /* start output, like ^Q */
#define TARGET_TIOCSTOP TARGET_IO('t', 111) /* stop output, like ^S */
#define TARGET_TIOCOUTQ TARGET_IOR('t', 115, int) /* output queue size */
#define TARGET_TIOCSPGRP TARGET_IOW('t', 118, int)
#define TARGET_TIOCGPGRP TARGET_IOR('t', 119, int)
#define TARGET_TCSETA TARGET_IOW('t', 24, struct termio)
#define TARGET_TCSETAW TARGET_IOW('t', 25, struct termio)
#define TARGET_TCSETAF TARGET_IOW('t', 28, struct termio)
#define TARGET_TCSBRK TARGET_IO('t', 29)
#define TARGET_TCXONC TARGET_IO('t', 30)
#define TARGET_TCFLSH TARGET_IO('t', 31)
#define TARGET_TIOCSWINSZ TARGET_IOW('t', 103, struct winsize)
#define TARGET_TIOCGWINSZ TARGET_IOR('t', 104, struct winsize)
#define TARGET_TIOCSTART TARGET_IO('t', 110) /* start output, like ^Q */
#define TARGET_TIOCSTOP TARGET_IO('t', 111) /* stop output, like ^S */
#define TARGET_TIOCOUTQ TARGET_IOR('t', 115, int) /* output queue size */
#define TARGET_TIOCSPGRP TARGET_IOW('t', 118, int)
#define TARGET_TIOCGPGRP TARGET_IOR('t', 119, int)
#define TARGET_TIOCEXCL TARGET_IO('T', 12) /* 0x540C */
#define TARGET_TIOCNXCL TARGET_IO('T', 13) /* 0x540D */
#define TARGET_TIOCSCTTY TARGET_IO('T', 14) /* 0x540E */
#define TARGET_TIOCSTI TARGET_IOW('T', 18, char) /* 0x5412 */
#define TARGET_TIOCMGET TARGET_IOR('T', 21, unsigned int) /* 0x5415 */
#define TARGET_TIOCMBIS TARGET_IOW('T', 22, unsigned int) /* 0x5416 */
#define TARGET_TIOCMBIC TARGET_IOW('T', 23, unsigned int) /* 0x5417 */
#define TARGET_TIOCMSET TARGET_IOW('T', 24, unsigned int) /* 0x5418 */
#define TARGET_TIOCM_LE 0x001
#define TARGET_TIOCM_DTR 0x002
#define TARGET_TIOCM_RTS 0x004
#define TARGET_TIOCM_ST 0x008
#define TARGET_TIOCM_SR 0x010
#define TARGET_TIOCM_CTS 0x020
#define TARGET_TIOCM_CAR 0x040
#define TARGET_TIOCM_RNG 0x080
#define TARGET_TIOCM_DSR 0x100
#define TARGET_TIOCM_CD TARGET_TIOCM_CAR
#define TARGET_TIOCM_RI TARGET_TIOCM_RNG
#define TARGET_TIOCGSOFTCAR TARGET_IOR('T', 25, unsigned int) /* 0x5419 */
#define TARGET_TIOCSSOFTCAR TARGET_IOW('T', 26, unsigned int) /* 0x541A */
#define TARGET_TIOCLINUX TARGET_IOW('T', 28, char) /* 0x541C */
#define TARGET_TIOCCONS TARGET_IO('T', 29) /* 0x541D */
#define TARGET_TIOCGSERIAL TARGET_IOR('T', 30, int) /* 0x541E */
#define TARGET_TIOCSSERIAL TARGET_IOW('T', 31, int) /* 0x541F */
#define TARGET_TIOCPKT TARGET_IOW('T', 32, int) /* 0x5420 */
#define TARGET_TIOCPKT_DATA 0
#define TARGET_TIOCPKT_FLUSHREAD 1
#define TARGET_TIOCPKT_FLUSHWRITE 2
#define TARGET_TIOCPKT_STOP 4
#define TARGET_TIOCPKT_START 8
#define TARGET_TIOCPKT_NOSTOP 16
#define TARGET_TIOCPKT_DOSTOP 32
#define TARGET_TIOCNOTTY TARGET_IO('T', 34) /* 0x5422 */
#define TARGET_TIOCSETD TARGET_IOW('T', 35, int) /* 0x5423 */
#define TARGET_TIOCGETD TARGET_IOR('T', 36, int) /* 0x5424 */
#define TARGET_TCSBRKP TARGET_IOW('T', 37, int) /* 0x5425 */ /* Needed for POSIX tcsendbreak() */
#define TARGET_TIOCSBRK TARGET_IO('T', 39) /* 0x5427 */ /* BSD compatibility */
#define TARGET_TIOCCBRK TARGET_IO('T', 40) /* 0x5428 */ /* BSD compatibility */
#define TARGET_TIOCGSID TARGET_IOR('T', 41, pid_t) /* 0x5429 */ /* Return the session ID of FD */
#define TARGET_TCGETS2 TARGET_IOR('T', 0x2A, struct target_termios2)
#define TARGET_TCSETS2 TARGET_IOW('T', 0x2B, struct target_termios2)
#define TARGET_TCSETSW2 TARGET_IOW('T', 0x2C, struct target_termios2)
#define TARGET_TCSETSF2 TARGET_IOW('T', 0x2D, struct target_termios2)
#define TARGET_TIOCGRS485 TARGET_IOR('T', 0x2E, struct serial_rs485)
#define TARGET_TIOCSRS485 TARGET_IOWR('T', 0x2F, struct serial_rs485)
#define TARGET_TIOCGPTN TARGET_IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
#define TARGET_TIOCSPTLCK TARGET_IOW('T',0x31, int) /* Lock/unlock Pty */
#define TARGET_TIOCGPTPEER TARGET_IO('T', 0x41) /* Safely open the slave */
#define TARGET_TIOCSERCONFIG TARGET_IO('T', 83) /* 0x5453 */
#define TARGET_TIOCSERGWILD TARGET_IOR('T', 84, int) /* 0x5454 */
#define TARGET_TIOCSERSWILD TARGET_IOW('T', 85, int) /* 0x5455 */
#define TARGET_TIOCGLCKTRMIOS 0x5456
#define TARGET_TIOCSLCKTRMIOS 0x5457
#define TARGET_TIOCSERGSTRUCT TARGET_IOR('T', 88, int) /* 0x5458 */ /* For d
ebugging only */
#define TARGET_TIOCSERGETLSR TARGET_IOR('T', 89, unsigned int) /* 0x5459 */ /* Get line status register */
/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
# define TARGET_TIOCSER_TEMT 0x01 /* Transmitter physically empty */
#define TARGET_TIOCSERGETMULTI TARGET_IOR('T', 90, int) /* 0x545A
*/ /* Get multiport config */
#define TARGET_TIOCSERSETMULTI TARGET_IOW('T', 91, int) /* 0x545B
*/ /* Set multiport config */
#define TARGET_TIOCMIWAIT TARGET_IO('T', 92) /* 0x545C */ /* wait for a change on serial input line(s) */
#define TARGET_TIOCGICOUNT TARGET_IOR('T', 93, int) /* 0x545D */ /* read serial port inline interrupt counts */
#endif
linux-user/sh4/vdso-asmoffset.h
+45
View File
@@ -0,0 +1,45 @@
/*
* Offsets into target signal frames for sh4 vdso.
*
* From linux-user/sh4/signal.c:
*
* struct target_sigcontext {
* target_ulong oldmask; // 0
* target_ulong sc_gregs[16]; // 4
* target_ulong sc_pc; // 68
* target_ulong sc_pr; // 72
* target_ulong sc_sr; // 76
* target_ulong sc_gbr; // 80
* target_ulong sc_mach; // 84
* target_ulong sc_macl; // 88
* target_ulong sc_fpregs[16]; // 92
* target_ulong sc_xfpregs[16]; // 156
* unsigned int sc_fpscr; // 220
* unsigned int sc_fpul; // 224
* unsigned int sc_ownedfp; // 228
* }; // sizeof = 232
*
* struct sigframe { sigcontext sc; ... }
* struct rt_sigframe { siginfo info[128]; ucontext uc; }
* ucontext = { flags[4], link[4], stack[12], sigcontext mcontext; ... }
* => mcontext at rt_sigframe + 128 + 20 = rt_sigframe + 148
*/
/* Offset of sigcontext within sigframe (CFA base for sigreturn). */
#define SIGFRAME_SC_OFFSET 0
/* Offset of tuc_mcontext within rt_sigframe (CFA base for rt_sigreturn). */
#define RT_SIGFRAME_SC_OFFSET 148
/* Offsets within struct sigcontext. */
#define SC_GREGS 4
#define SC_PC 68
#define SC_PR 72
#define SC_SR 76
#define SC_GBR 80
#define SC_MACH 84
#define SC_MACL 88
#define SC_FPREGS 92
#define SC_XFPREGS 156
#define SC_FPSCR 220
#define SC_FPUL 224
linux-user/sh4/vdso-be.so
Executable
BIN
View File
Binary file not shown.
linux-user/sh4/vdso-le.so
Executable
BIN
View File
Binary file not shown.
linux-user/sh4/vdso.S
+142
View File
@@ -0,0 +1,142 @@
/*
* sh4 linux replacement vdso.
*
* Copyright 2023 Linaro, Ltd.
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include <asm/unistd.h>
#include "vdso-asmoffset.h"
.text
.macro endf name
.globl \name
.type \name, @function
.size \name, . - \name
.endm
/*
* SH4 syscall convention:
* Syscall number in r3 (caller-saved, so no save/restore needed)
* Arguments in r4-r7
* Return value in r0
* Syscall instruction: trapa #0x10
*/
.macro vdso_syscall name, nr
\name:
.cfi_startproc
mov.l 1f, r3
trapa #0x10
rts
nop
.align 2
1: .long \nr
.cfi_endproc
endf \name
.endm
vdso_syscall __vdso_clock_gettime, __NR_clock_gettime
vdso_syscall __vdso_clock_gettime64, __NR_clock_gettime64
vdso_syscall __vdso_clock_getres, __NR_clock_getres
vdso_syscall __vdso_gettimeofday, __NR_gettimeofday
/*
* Signal return trampolines.
*
* For sigreturn: r15 points to struct sigframe; sigcontext is at
* offset SIGFRAME_SC_OFFSET (0).
* For rt_sigreturn: r15 points to struct rt_sigframe; sigcontext is at
* offset RT_SIGFRAME_SC_OFFSET (148).
*
* A single CFI region covers both trampolines. The CFA is set to the
* start of the relevant sigcontext; all register offsets are then
* identical for both trampolines. Between the two trampolines we use
* .cfi_def_cfa_offset to update the CFA base for the different layout.
*/
/*
* Start the unwind info at least one instruction before the signal
* trampoline, because the unwinder will assume we are returning
* after a call site.
*/
.cfi_startproc simple
.cfi_signal_frame
.cfi_return_column 16 /* return column is PC */
/* CFA = r15 + SIGFRAME_SC_OFFSET = r15 (sigcontext base, sigreturn). */
.cfi_def_cfa 15, SIGFRAME_SC_OFFSET
/* Integer registers r0-r15: sc_gregs[n] at sigcontext + SC_GREGS + n*4. */
.cfi_offset 0, SC_GREGS + 0 * 4
.cfi_offset 1, SC_GREGS + 1 * 4
.cfi_offset 2, SC_GREGS + 2 * 4
.cfi_offset 3, SC_GREGS + 3 * 4
.cfi_offset 4, SC_GREGS + 4 * 4
.cfi_offset 5, SC_GREGS + 5 * 4
.cfi_offset 6, SC_GREGS + 6 * 4
.cfi_offset 7, SC_GREGS + 7 * 4
.cfi_offset 8, SC_GREGS + 8 * 4
.cfi_offset 9, SC_GREGS + 9 * 4
.cfi_offset 10, SC_GREGS + 10 * 4
.cfi_offset 11, SC_GREGS + 11 * 4
.cfi_offset 12, SC_GREGS + 12 * 4
.cfi_offset 13, SC_GREGS + 13 * 4
.cfi_offset 14, SC_GREGS + 14 * 4
.cfi_offset 15, SC_GREGS + 15 * 4
/* PC (return column). */
.cfi_offset 16, SC_PC
/* Control registers. */
.cfi_offset 17, SC_PR
.cfi_offset 18, SC_GBR
.cfi_offset 20, SC_MACH
.cfi_offset 21, SC_MACL
/* FP registers fr0-fr15: sc_fpregs[n] at sigcontext + SC_FPREGS + n*4. */
.cfi_offset 25, SC_FPREGS + 0 * 4
.cfi_offset 26, SC_FPREGS + 1 * 4
.cfi_offset 27, SC_FPREGS + 2 * 4
.cfi_offset 28, SC_FPREGS + 3 * 4
.cfi_offset 29, SC_FPREGS + 4 * 4
.cfi_offset 30, SC_FPREGS + 5 * 4
.cfi_offset 31, SC_FPREGS + 6 * 4
.cfi_offset 32, SC_FPREGS + 7 * 4
.cfi_offset 33, SC_FPREGS + 8 * 4
.cfi_offset 34, SC_FPREGS + 9 * 4
.cfi_offset 35, SC_FPREGS + 10 * 4
.cfi_offset 36, SC_FPREGS + 11 * 4
.cfi_offset 37, SC_FPREGS + 12 * 4
.cfi_offset 38, SC_FPREGS + 13 * 4
.cfi_offset 39, SC_FPREGS + 14 * 4
.cfi_offset 40, SC_FPREGS + 15 * 4
/* FPUL, FPSCR. */
.cfi_offset 23, SC_FPUL
.cfi_offset 24, SC_FPSCR
nop
sigreturn_region_start:
__kernel_sigreturn:
mov.l 1f, r3
trapa #0x10
.align 2
1: .long __NR_sigreturn
endf __kernel_sigreturn
/* Update CFA base for the rt_sigreturn frame layout. */
.cfi_def_cfa_offset RT_SIGFRAME_SC_OFFSET
__kernel_rt_sigreturn:
mov.l 2f, r3
trapa #0x10
.align 2
2: .long __NR_rt_sigreturn
endf __kernel_rt_sigreturn
sigreturn_region_end:
.cfi_endproc
linux-user/sh4/vdso.ld
+67
View File
@@ -0,0 +1,67 @@
/*
* Linker script for linux sh4 replacement vdso.
*
* Copyright 2023 Linaro, Ltd.
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
VERSION {
LINUX_2.6 {
global:
__vdso_clock_gettime;
__vdso_clock_gettime64;
__vdso_clock_getres;
__vdso_gettimeofday;
__kernel_sigreturn;
__kernel_rt_sigreturn;
local: *;
};
}
PHDRS {
phdr PT_PHDR FLAGS(4) PHDRS;
load PT_LOAD FLAGS(7) FILEHDR PHDRS; /* FLAGS=RWX */
dynamic PT_DYNAMIC FLAGS(4);
eh_frame_hdr PT_GNU_EH_FRAME;
note PT_NOTE FLAGS(4);
}
SECTIONS {
. = SIZEOF_HEADERS;
/*
* The following, including the FILEHDRS and PHDRS, are modified
* when we relocate the binary. We want them to be initially
* writable for the relocation; we'll force them read-only after.
*/
.note : { *(.note*) } :load :note
.dynamic : { *(.dynamic) } :load :dynamic
.dynsym : { *(.dynsym) } :load
.data : {
/*
* There ought not be any real read-write data.
* But since we manipulated the segment layout,
* we have to put these sections somewhere.
*/
*(.data*)
*(.sdata*)
*(.got.plt) *(.got)
*(.gnu.linkonce.d.*)
*(.bss*)
*(.dynbss*)
*(.gnu.linkonce.b.*)
}
.rodata : { *(.rodata*) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.eh_frame_hdr : { *(.eh_frame_hdr) } :load :eh_frame_hdr
.eh_frame : { *(.eh_frame) } :load
.text : { *(.text*) } :load
}