zenithsiz/ftmemsim-valgrind
1
0
Fork 0
mirror of https://github.com/Zenithsiz/ftmemsim-valgrind.git synced 2026-02-04 02:18:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge in a port for mips32-linux, by Petar Jovanovic and Dejan Jevtic,

Browse Source 
mips-valgrind@rt-rk.com, Bug 270777.

Valgrind: new non-test files for mips32-linux.


git-svn-id: svn://svn.valgrind.org/valgrind/trunk@12617
This commit is contained in:
Julian Seward 2012-06-07 09:23:23 +00:00
parent 3e344c57f6
commit d971e9300f
20 changed files with 4725 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
cachegrind/cg-mips32.c Normal file
View File

@ -0,0 +1,59 @@
/*--------------------------------------------------------------------*/
/*--- MIPS-specific definitions. cg-mips32.c ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Cachegrind, a Valgrind tool for cache
profiling programs.
Copyright (C) 2010-2012 RT-RK
mips-valgrind@rt-rk.com
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#if defined(VGA_mips32)
#include "pub_tool_basics.h"
#include "pub_tool_libcbase.h"
#include "pub_tool_libcassert.h"
#include "pub_tool_libcprint.h"
#include "cg_arch.h"
void VG_(configure_caches)(cache_t* I1c, cache_t* D1c, cache_t* L2c,
Bool all_caches_clo_defined)
{
// Set caches to default (for MIPS32-r2(mips 74kc))
*I1c = (cache_t) { 32768, 4, 32 };
*D1c = (cache_t) { 32768, 4, 32 };
*L2c = (cache_t) { 524288, 8, 32 };
if (!all_caches_clo_defined) {
VG_(message)(Vg_DebugMsg,
"Warning: Cannot auto-detect cache config on MIPS32, using one "
"or more defaults\n");
}
}
#endif // #if defined(VGA_mips32)
/*--------------------------------------------------------------------*/
/*--- end cg-mips32.c ---*/
/*--------------------------------------------------------------------*/

249
coregrind/m_dispatch/dispatch-mips32-linux.S Normal file
View File

@ -0,0 +1,249 @@
/*--------------------------------------------------------------------*/
/*--- The core dispatch loop, for jumping to a code address. ---*/
/*--- dispatch-mips-linux.S ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2000-2012 RT-RK
mips-valgrind@rt-rk.com
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#if defined(VGP_mips32_linux)
#include "pub_core_basics_asm.h"
#include "pub_core_dispatch_asm.h"
#include "pub_core_transtab_asm.h"
#include "libvex_guest_offsets.h" /* for OFFSET_mips_PC */
/*------------------------------------------------------------*/
/*--- ---*/
/*--- The dispatch loop. VG_(disp_run_translations) is ---*/
/*--- used to run all translations, ---*/
/*--- including no-redir ones. ---*/
/*--- ---*/
/*------------------------------------------------------------*/
/*----------------------------------------------------*/
/*--- Entry and preamble (set everything up) ---*/
/*----------------------------------------------------*/
/* signature:
void VG_(disp_run_translations)( UWord* two_words,
void* guest_state,
Addr host_addr );
*/
.text
.globl VG_(disp_run_translations)
VG_(disp_run_translations):
/* a0 ($4) holds two_words */
/* a1 ($5) holds guest_state */
/* a2 ($6) holds host_addr */
/* New stack frame. Stack must remain 8 aligned (at least) */
addiu $29, -56
/* Save ra */
sw $31, 0($29)
/* ... and orig guest state*/
sw $5, 4($29)
/* ... and s0 - s7 */
sw $16, 8($29)
sw $17, 12($29)
sw $18, 16($29)
sw $19, 20($29)
sw $20, 24($29)
sw $21, 28($29)
sw $22, 32($29)
sw $23, 36($29)
/* ... and gp, fp/s8 */
sw $28, 40($29)
sw $30, 44($29)
/* Save a0 ($4) on stack. In postamble it will be restored such that the
return values can be written */
sw $4, 48($29)
/* Load address of guest state into guest state register (r10) */
move $10, $5
/* and jump into the code cache. Chained translations in
the code cache run, until for whatever reason, they can't
continue. When that happens, the translation in question
will jump (or call) to one of the continuation points
VG_(cp_...) below. */
jr $6
/*NOTREACHED*/
/*----------------------------------------------------*/
/*--- Postamble and exit. ---*/
/*----------------------------------------------------*/
postamble:
/* At this point, r2 and r3 contain two
words to be returned to the caller. r2
holds a TRC value, and r3 optionally may
hold another word (for CHAIN_ME exits, the
address of the place to patch.) */
/* Restore $4 from stack; holds address of two_words */
lw $4, 48($29)
sw $2, 0($4) /* Store $2 to two_words[0] */
sw $3, 4($4) /* Store $3 to two_words[1] */
/* Restore callee-saved registers... */
/* Restore ra */
lw $31, 0($29)
/* ... and s0 - s7 */
lw $16, 8($29)
lw $17, 12($29)
lw $18, 16($29)
lw $19, 20($29)
lw $20, 24($29)
lw $21, 28($29)
lw $22, 32($29)
lw $23, 36($29)
/* ... and gp, fp/s8 */
lw $28, 40($29)
lw $30, 44($29)
addiu $29, 56 /* stack_size */
jr $31
nop
/*----------------------------------------------------*/
/*--- Continuation points ---*/
/*----------------------------------------------------*/
/* ------ Chain me to slow entry point ------ */
.global VG_(disp_cp_chain_me_to_slowEP)
VG_(disp_cp_chain_me_to_slowEP):
/* We got called. The return address indicates
where the patching needs to happen. Collect
the return address and, exit back to C land,
handing the caller the pair (Chain_me_S, RA) */
li $2, VG_TRC_CHAIN_ME_TO_SLOW_EP
move $3, $31
/* 8 = mkLoadImm_EXACTLY2or5
4 = jalr $9
4 = nop */
addiu $3, $3, -16
b postamble
/* ------ Chain me to slow entry point ------ */
.global VG_(disp_cp_chain_me_to_fastEP)
VG_(disp_cp_chain_me_to_fastEP):
/* We got called. The return address indicates
where the patching needs to happen. Collect
the return address and, exit back to C land,
handing the caller the pair (Chain_me_S, RA) */
li $2, VG_TRC_CHAIN_ME_TO_FAST_EP
move $3, $31
/* 8 = mkLoadImm_EXACTLY2or5
4 = jalr $9
4 = nop */
addiu $3, $3, -16
b postamble
/* ------ Indirect but boring jump ------ */
.global VG_(disp_cp_xindir)
VG_(disp_cp_xindir):
/* Where are we going? */
lw $11, OFFSET_mips32_PC($10)
lw $13, vgPlain_stats__n_xindirs_32
addiu $13, $13, 0x1
sw $13, vgPlain_stats__n_xindirs_32
/* try a fast lookup in the translation cache */
/* t1 = VG_TT_FAST_HASH(addr) * sizeof(ULong*)
= (t8 >> 2 & VG_TT_FAST_MASK) << 3 */
move $14, $11
li $12, VG_TT_FAST_MASK
srl $14, $14, 2
and $14, $14, $12
sll $14, $14, 3
/* t2 = (addr of VG_(tt_fast)) + t1 */
la $13, VG_(tt_fast)
addu $13, $13, $14
lw $12, 0($13) /* t3 = VG_(tt_fast)[hash] :: ULong* */
addi $13, $13, 4
lw $25, 0($13) /* little-endian, so comparing 1st 32bit word */
nop
check:
bne $12, $11, fast_lookup_failed
/* run the translation */
jr $25
.long 0x0 /* persuade insn decoders not to speculate past here */
fast_lookup_failed:
/* %PC is up to date */
/* back out decrement of the dispatch counter */
/* hold dispatch_ctr in t0 (r8) */
lw $13, vgPlain_stats__n_xindirs_32
addiu $13, $13, 0x1
sw $13, vgPlain_stats__n_xindirs_32
li $2, VG_TRC_INNER_FASTMISS
li $3, 0
b postamble
/* ------ Assisted jump ------ */
.global VG_(disp_cp_xassisted)
VG_(disp_cp_xassisted):
/* guest-state-pointer contains the TRC. Put the value into the
return register */
move $2, $10
move $3, $0
b postamble
/* ------ Event check failed ------ */
.global VG_(disp_cp_evcheck_fail)
VG_(disp_cp_evcheck_fail):
li $2, VG_TRC_INNER_COUNTERZERO
move $3, $0
b postamble
.size VG_(disp_run_translations), .-VG_(disp_run_translations)
/* Let the linker know we do not need an executable stack */
.section .note.GNU-stack,"",@progbits
#endif // defined(VGP_mips32_linux)
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/

13
coregrind/m_gdbserver/mips-cp0-valgrind-s1.xml Normal file
View File

@ -0,0 +1,13 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.cp0.valgrind.s1">
<reg name="statuss1" bitsize="32" regnum="32"/>
<reg name="badvaddrs1" bitsize="32" regnum="35"/>
<reg name="causes1" bitsize="32" regnum="36"/>
</feature>

13
coregrind/m_gdbserver/mips-cp0-valgrind-s2.xml Normal file
View File

@ -0,0 +1,13 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.cp0.valgrind.s2">
<reg name="statuss2" bitsize="32" regnum="32"/>
<reg name="badvaddrs2" bitsize="32" regnum="35"/>
<reg name="causes2" bitsize="32" regnum="36"/>
</feature>

13
coregrind/m_gdbserver/mips-cp0.xml Normal file
View File

@ -0,0 +1,13 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.cp0">
<reg name="status" bitsize="32" regnum="32"/>
<reg name="badvaddr" bitsize="32" regnum="35"/>
<reg name="cause" bitsize="32" regnum="36"/>
</feature>

46
coregrind/m_gdbserver/mips-cpu-valgrind-s1.xml Normal file
View File

@ -0,0 +1,46 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.cpu.valgrind.s1">
<reg name="r0s1" bitsize="32" regnum="0"/>
<reg name="r1s1" bitsize="32"/>
<reg name="r2s1" bitsize="32"/>
<reg name="r3s1" bitsize="32"/>
<reg name="r4s1" bitsize="32"/>
<reg name="r5s1" bitsize="32"/>
<reg name="r6s1" bitsize="32"/>
<reg name="r7s1" bitsize="32"/>
<reg name="r8s1" bitsize="32"/>
<reg name="r9s1" bitsize="32"/>
<reg name="r10s1" bitsize="32"/>
<reg name="r11s1" bitsize="32"/>
<reg name="r12s1" bitsize="32"/>
<reg name="r13s1" bitsize="32"/>
<reg name="r14s1" bitsize="32"/>
<reg name="r15s1" bitsize="32"/>
<reg name="r16s1" bitsize="32"/>
<reg name="r17s1" bitsize="32"/>
<reg name="r18s1" bitsize="32"/>
<reg name="r19s1" bitsize="32"/>
<reg name="r20s1" bitsize="32"/>
<reg name="r21s1" bitsize="32"/>
<reg name="r22s1" bitsize="32"/>
<reg name="r23s1" bitsize="32"/>
<reg name="r24s1" bitsize="32"/>
<reg name="r25s1" bitsize="32"/>
<reg name="r26s1" bitsize="32"/>
<reg name="r27s1" bitsize="32"/>
<reg name="r28s1" bitsize="32"/>
<reg name="r29s1" bitsize="32"/>
<reg name="r30s1" bitsize="32"/>
<reg name="r31s1" bitsize="32"/>
<reg name="los1" bitsize="32" regnum="33"/>
<reg name="his1" bitsize="32" regnum="34"/>
<reg name="pcs1" bitsize="32" regnum="37"/>
</feature>

46
coregrind/m_gdbserver/mips-cpu-valgrind-s2.xml Normal file
View File

@ -0,0 +1,46 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.cpu.valgrind.s2">
<reg name="r0s2" bitsize="32" regnum="0"/>
<reg name="r1s2" bitsize="32"/>
<reg name="r2s2" bitsize="32"/>
<reg name="r3s2" bitsize="32"/>
<reg name="r4s2" bitsize="32"/>
<reg name="r5s2" bitsize="32"/>
<reg name="r6s2" bitsize="32"/>
<reg name="r7s2" bitsize="32"/>
<reg name="r8s2" bitsize="32"/>
<reg name="r9s2" bitsize="32"/>
<reg name="r10s2" bitsize="32"/>
<reg name="r11s2" bitsize="32"/>
<reg name="r12s2" bitsize="32"/>
<reg name="r13s2" bitsize="32"/>
<reg name="r14s2" bitsize="32"/>
<reg name="r15s2" bitsize="32"/>
<reg name="r16s2" bitsize="32"/>
<reg name="r17s2" bitsize="32"/>
<reg name="r18s2" bitsize="32"/>
<reg name="r19s2" bitsize="32"/>
<reg name="r20s2" bitsize="32"/>
<reg name="r21s2" bitsize="32"/>
<reg name="r22s2" bitsize="32"/>
<reg name="r23s2" bitsize="32"/>
<reg name="r24s2" bitsize="32"/>
<reg name="r25s2" bitsize="32"/>
<reg name="r26s2" bitsize="32"/>
<reg name="r27s2" bitsize="32"/>
<reg name="r28s2" bitsize="32"/>
<reg name="r29s2" bitsize="32"/>
<reg name="r30s2" bitsize="32"/>
<reg name="r31s2" bitsize="32"/>
<reg name="los2" bitsize="32" regnum="33"/>
<reg name="his2" bitsize="32" regnum="34"/>
<reg name="pcs2" bitsize="32" regnum="37"/>
</feature>

46
coregrind/m_gdbserver/mips-cpu.xml Normal file
View File

@ -0,0 +1,46 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.cpu">
<reg name="r0" bitsize="32" regnum="0"/>
<reg name="r1" bitsize="32"/>
<reg name="r2" bitsize="32"/>
<reg name="r3" bitsize="32"/>
<reg name="r4" bitsize="32"/>
<reg name="r5" bitsize="32"/>
<reg name="r6" bitsize="32"/>
<reg name="r7" bitsize="32"/>
<reg name="r8" bitsize="32"/>
<reg name="r9" bitsize="32"/>
<reg name="r10" bitsize="32"/>
<reg name="r11" bitsize="32"/>
<reg name="r12" bitsize="32"/>
<reg name="r13" bitsize="32"/>
<reg name="r14" bitsize="32"/>
<reg name="r15" bitsize="32"/>
<reg name="r16" bitsize="32"/>
<reg name="r17" bitsize="32"/>
<reg name="r18" bitsize="32"/>
<reg name="r19" bitsize="32"/>
<reg name="r20" bitsize="32"/>
<reg name="r21" bitsize="32"/>
<reg name="r22" bitsize="32"/>
<reg name="r23" bitsize="32"/>
<reg name="r24" bitsize="32"/>
<reg name="r25" bitsize="32"/>
<reg name="r26" bitsize="32"/>
<reg name="r27" bitsize="32"/>
<reg name="r28" bitsize="32"/>
<reg name="r29" bitsize="32"/>
<reg name="r30" bitsize="32"/>
<reg name="r31" bitsize="32"/>
<reg name="lo" bitsize="32" regnum="33"/>
<reg name="hi" bitsize="32" regnum="34"/>
<reg name="pc" bitsize="32" regnum="37"/>
</feature>

45
coregrind/m_gdbserver/mips-fpu-valgrind-s1.xml Normal file
View File

@ -0,0 +1,45 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.fpu.valgrind.s1">
<reg name="f0s1" bitsize="32" type="ieee_single" regnum="38"/>
<reg name="f1s1" bitsize="32" type="ieee_single"/>
<reg name="f2s1" bitsize="32" type="ieee_single"/>
<reg name="f3s1" bitsize="32" type="ieee_single"/>
<reg name="f4s1" bitsize="32" type="ieee_single"/>
<reg name="f5s1" bitsize="32" type="ieee_single"/>
<reg name="f6s1" bitsize="32" type="ieee_single"/>
<reg name="f7s1" bitsize="32" type="ieee_single"/>
<reg name="f8s1" bitsize="32" type="ieee_single"/>
<reg name="f9s1" bitsize="32" type="ieee_single"/>
<reg name="f10s1" bitsize="32" type="ieee_single"/>
<reg name="f11s1" bitsize="32" type="ieee_single"/>
<reg name="f12s1" bitsize="32" type="ieee_single"/>
<reg name="f13s1" bitsize="32" type="ieee_single"/>
<reg name="f14s1" bitsize="32" type="ieee_single"/>
<reg name="f15s1" bitsize="32" type="ieee_single"/>
<reg name="f16s1" bitsize="32" type="ieee_single"/>
<reg name="f17s1" bitsize="32" type="ieee_single"/>
<reg name="f18s1" bitsize="32" type="ieee_single"/>
<reg name="f19s1" bitsize="32" type="ieee_single"/>
<reg name="f20s1" bitsize="32" type="ieee_single"/>
<reg name="f21s1" bitsize="32" type="ieee_single"/>
<reg name="f22s1" bitsize="32" type="ieee_single"/>
<reg name="f23s1" bitsize="32" type="ieee_single"/>
<reg name="f24s1" bitsize="32" type="ieee_single"/>
<reg name="f25s1" bitsize="32" type="ieee_single"/>
<reg name="f26s1" bitsize="32" type="ieee_single"/>
<reg name="f27s1" bitsize="32" type="ieee_single"/>
<reg name="f28s1" bitsize="32" type="ieee_single"/>
<reg name="f29s1" bitsize="32" type="ieee_single"/>
<reg name="f30s1" bitsize="32" type="ieee_single"/>
<reg name="f31s1" bitsize="32" type="ieee_single"/>
<reg name="fcsrs1" bitsize="32" group="float"/>
<reg name="firs1" bitsize="32" group="float"/>
</feature>

45
coregrind/m_gdbserver/mips-fpu-valgrind-s2.xml Normal file
View File

@ -0,0 +1,45 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.fpu.valgrind.s2">
<reg name="f0s2" bitsize="32" type="ieee_single" regnum="38"/>
<reg name="f1s2" bitsize="32" type="ieee_single"/>
<reg name="f2s2" bitsize="32" type="ieee_single"/>
<reg name="f3s2" bitsize="32" type="ieee_single"/>
<reg name="f4s2" bitsize="32" type="ieee_single"/>
<reg name="f5s2" bitsize="32" type="ieee_single"/>
<reg name="f6s2" bitsize="32" type="ieee_single"/>
<reg name="f7s2" bitsize="32" type="ieee_single"/>
<reg name="f8s2" bitsize="32" type="ieee_single"/>
<reg name="f9s2" bitsize="32" type="ieee_single"/>
<reg name="f10s2" bitsize="32" type="ieee_single"/>
<reg name="f11s2" bitsize="32" type="ieee_single"/>
<reg name="f12s2" bitsize="32" type="ieee_single"/>
<reg name="f13s2" bitsize="32" type="ieee_single"/>
<reg name="f14s2" bitsize="32" type="ieee_single"/>
<reg name="f15s2" bitsize="32" type="ieee_single"/>
<reg name="f16s2" bitsize="32" type="ieee_single"/>
<reg name="f17s2" bitsize="32" type="ieee_single"/>
<reg name="f18s2" bitsize="32" type="ieee_single"/>
<reg name="f19s2" bitsize="32" type="ieee_single"/>
<reg name="f20s2" bitsize="32" type="ieee_single"/>
<reg name="f21s2" bitsize="32" type="ieee_single"/>
<reg name="f22s2" bitsize="32" type="ieee_single"/>
<reg name="f23s2" bitsize="32" type="ieee_single"/>
<reg name="f24s2" bitsize="32" type="ieee_single"/>
<reg name="f25s2" bitsize="32" type="ieee_single"/>
<reg name="f26s2" bitsize="32" type="ieee_single"/>
<reg name="f27s2" bitsize="32" type="ieee_single"/>
<reg name="f28s2" bitsize="32" type="ieee_single"/>
<reg name="f29s2" bitsize="32" type="ieee_single"/>
<reg name="f30s2" bitsize="32" type="ieee_single"/>
<reg name="f31s2" bitsize="32" type="ieee_single"/>
<reg name="fcsrs2" bitsize="32" group="float"/>
<reg name="firs2" bitsize="32" group="float"/>
</feature>

45
coregrind/m_gdbserver/mips-fpu.xml Normal file
View File

@ -0,0 +1,45 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE feature SYSTEM "gdb-target.dtd">
<feature name="org.gnu.gdb.mips.fpu">
<reg name="f0" bitsize="32" type="ieee_single" regnum="38"/>
<reg name="f1" bitsize="32" type="ieee_single"/>
<reg name="f2" bitsize="32" type="ieee_single"/>
<reg name="f3" bitsize="32" type="ieee_single"/>
<reg name="f4" bitsize="32" type="ieee_single"/>
<reg name="f5" bitsize="32" type="ieee_single"/>
<reg name="f6" bitsize="32" type="ieee_single"/>
<reg name="f7" bitsize="32" type="ieee_single"/>
<reg name="f8" bitsize="32" type="ieee_single"/>
<reg name="f9" bitsize="32" type="ieee_single"/>
<reg name="f10" bitsize="32" type="ieee_single"/>
<reg name="f11" bitsize="32" type="ieee_single"/>
<reg name="f12" bitsize="32" type="ieee_single"/>
<reg name="f13" bitsize="32" type="ieee_single"/>
<reg name="f14" bitsize="32" type="ieee_single"/>
<reg name="f15" bitsize="32" type="ieee_single"/>
<reg name="f16" bitsize="32" type="ieee_single"/>
<reg name="f17" bitsize="32" type="ieee_single"/>
<reg name="f18" bitsize="32" type="ieee_single"/>
<reg name="f19" bitsize="32" type="ieee_single"/>
<reg name="f20" bitsize="32" type="ieee_single"/>
<reg name="f21" bitsize="32" type="ieee_single"/>
<reg name="f22" bitsize="32" type="ieee_single"/>
<reg name="f23" bitsize="32" type="ieee_single"/>
<reg name="f24" bitsize="32" type="ieee_single"/>
<reg name="f25" bitsize="32" type="ieee_single"/>
<reg name="f26" bitsize="32" type="ieee_single"/>
<reg name="f27" bitsize="32" type="ieee_single"/>
<reg name="f28" bitsize="32" type="ieee_single"/>
<reg name="f29" bitsize="32" type="ieee_single"/>
<reg name="f30" bitsize="32" type="ieee_single"/>
<reg name="f31" bitsize="32" type="ieee_single"/>
<reg name="fcsr" bitsize="32" group="float"/>
<reg name="fir" bitsize="32" group="float"/>
</feature>

25
coregrind/m_gdbserver/mips-linux-valgrind.xml Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE target SYSTEM "gdb-target.dtd">
<target>
<architecture>mips</architecture>
<osabi>GNU/Linux</osabi>
<xi:include href="mips-cpu.xml"/>
<xi:include href="mips-cp0.xml"/>
<xi:include href="mips-fpu.xml"/>
<xi:include href="mips-cpu-valgrind-s1.xml"/>
<xi:include href="mips-cp0-valgrind-s1.xml"/>
<xi:include href="mips-fpu-valgrind-s1.xml"/>
<xi:include href="mips-cpu-valgrind-s2.xml"/>
<xi:include href="mips-cp0-valgrind-s2.xml"/>
<xi:include href="mips-fpu-valgrind-s2.xml"/>
<feature name="org.gnu.gdb.mips.linux">
<reg name="restart" bitsize="32" group="system"/>
</feature>
</target>

19
coregrind/m_gdbserver/mips-linux.xml Normal file
View File

@ -0,0 +1,19 @@
<?xml version="1.0"?>
<!-- Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. -->
<!DOCTYPE target SYSTEM "gdb-target.dtd">
<target>
<architecture>mips</architecture>
<osabi>GNU/Linux</osabi>
<xi:include href="mips-cpu.xml"/>
<xi:include href="mips-cp0.xml"/>
<xi:include href="mips-fpu.xml"/>
<feature name="org.gnu.gdb.mips.linux">
<reg name="restart" bitsize="32" group="system"/>
</feature>
</target>

258
coregrind/m_gdbserver/valgrind-low-mips32.c Normal file
View File

@ -0,0 +1,258 @@
/* Low level interface to valgrind, for the remote server for GDB integrated
in valgrind.
Copyright (C) 2012
Free Software Foundation, Inc.
This file is part of VALGRIND.
It has been inspired from a file from gdbserver in gdb 6.6.
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, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
#include "server.h"
#include "target.h"
#include "regdef.h"
#include "regcache.h"
#include "pub_core_aspacemgr.h"
#include "pub_tool_machine.h"
#include "pub_core_threadstate.h"
#include "pub_core_transtab.h"
#include "pub_core_gdbserver.h"
#include "valgrind_low.h"
#include "libvex_guest_mips32.h"
struct reg regs[] = {
{ "r0", 0, 32 },
{ "r1", 32, 32 },
{ "r2", 64, 32 },
{ "r3", 96, 32 },
{ "r4", 128, 32 },
{ "r5", 160, 32 },
{ "r6", 192, 32 },
{ "r7", 224, 32 },
{ "r8", 256, 32 },
{ "r9", 288, 32 },
{ "r10", 320, 32 },
{ "r11", 352, 32 },
{ "r12", 384, 32 },
{ "r13", 416, 32 },
{ "r14", 448, 32 },
{ "r15", 480, 32 },
{ "r16", 512, 32 },
{ "r17", 544, 32 },
{ "r18", 576, 32 },
{ "r19", 608, 32 },
{ "r20", 640, 32 },
{ "r21", 672, 32 },
{ "r22", 704, 32 },
{ "r23", 736, 32 },
{ "r24", 768, 32 },
{ "r25", 800, 32 },
{ "r26", 832, 32 },
{ "r27", 864, 32 },
{ "r28", 896, 32 },
{ "r29", 928, 32 },
{ "r30", 960, 32 },
{ "r31", 992, 32 },
{ "status", 1024, 32 },
{ "lo", 1056, 32 },
{ "hi", 1088, 32 },
{ "badvaddr", 1120, 32 },
{ "cause", 1152, 32 },
{ "pc", 1184, 32 },
{ "f0", 1216, 32 },
{ "f1", 1248, 32 },
{ "f2", 1280, 32 },
{ "f3", 1312, 32 },
{ "f4", 1344, 32 },
{ "f5", 1376, 32 },
{ "f6", 1408, 32 },
{ "f7", 1440, 32 },
{ "f8", 1472, 32 },
{ "f9", 1504, 32 },
{ "f10", 1536, 32 },
{ "f11", 1568, 32 },
{ "f12", 1600, 32 },
{ "f13", 1632, 32 },
{ "f14", 1664, 32 },
{ "f15", 1696, 32 },
{ "f16", 1728, 32 },
{ "f17", 1760, 32 },
{ "f18", 1792, 32 },
{ "f19", 1824, 32 },
{ "f20", 1856, 32 },
{ "f21", 1888, 32 },
{ "f22", 1920, 32 },
{ "f23", 1952, 32 },
{ "f24", 1984, 32 },
{ "f25", 2016, 32 },
{ "f26", 2048, 32 },
{ "f27", 2080, 32 },
{ "f28", 2112, 32 },
{ "f29", 2144, 32 },
{ "f30", 2176, 32 },
{ "f31", 2208, 32 },
{ "fcsr", 2240, 32 },
{ "fir", 2272, 32 },
{ "restart", 2304, 32 },
};
#define num_regs (sizeof (regs) / sizeof (regs[0]))
static const char *expedite_regs[] = { "r29", "pc", 0 };
static
CORE_ADDR get_pc (void)
{
unsigned long pc;
collect_register_by_name ("pc", &pc);
dlog(1, "stop pc is %p\n", (void *) pc);
return pc;
}
static
void set_pc (CORE_ADDR newpc)
{
Bool mod;
supply_register_by_name ("pc", &newpc, &mod);
if (mod)
dlog(1, "set pc to %p\n", C2v (newpc));
else
dlog(1, "set pc not changed %p\n", C2v (newpc));
}
/* store registers in the guest state (gdbserver_to_valgrind)
or fetch register from the guest state (valgrind_to_gdbserver). */
static
void transfer_register (ThreadId tid, int abs_regno, void * buf,
transfer_direction dir, int size, Bool *mod)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
int set = abs_regno / num_regs;
int regno = abs_regno % num_regs;
*mod = False;
VexGuestMIPS32State* mips1 = (VexGuestMIPS32State*) get_arch (set, tst);
switch (regno) {
case 0: VG_(transfer) (&mips1->guest_r0, buf, dir, size, mod); break;
case 1: VG_(transfer) (&mips1->guest_r1, buf, dir, size, mod); break;
case 2: VG_(transfer) (&mips1->guest_r2, buf, dir, size, mod); break;
case 3: VG_(transfer) (&mips1->guest_r3, buf, dir, size, mod); break;
case 4: VG_(transfer) (&mips1->guest_r4, buf, dir, size, mod); break;
case 5: VG_(transfer) (&mips1->guest_r5, buf, dir, size, mod); break;
case 6: VG_(transfer) (&mips1->guest_r6, buf, dir, size, mod); break;
case 7: VG_(transfer) (&mips1->guest_r7, buf, dir, size, mod); break;
case 8: VG_(transfer) (&mips1->guest_r8, buf, dir, size, mod); break;
case 9: VG_(transfer) (&mips1->guest_r9, buf, dir, size, mod); break;
case 10: VG_(transfer) (&mips1->guest_r10, buf, dir, size, mod); break;
case 11: VG_(transfer) (&mips1->guest_r11, buf, dir, size, mod); break;
case 12: VG_(transfer) (&mips1->guest_r12, buf, dir, size, mod); break;
case 13: VG_(transfer) (&mips1->guest_r13, buf, dir, size, mod); break;
case 14: VG_(transfer) (&mips1->guest_r14, buf, dir, size, mod); break;
case 15: VG_(transfer) (&mips1->guest_r15, buf, dir, size, mod); break;
case 16: VG_(transfer) (&mips1->guest_r16, buf, dir, size, mod); break;
case 17: VG_(transfer) (&mips1->guest_r17, buf, dir, size, mod); break;
case 18: VG_(transfer) (&mips1->guest_r18, buf, dir, size, mod); break;
case 19: VG_(transfer) (&mips1->guest_r19, buf, dir, size, mod); break;
case 20: VG_(transfer) (&mips1->guest_r20, buf, dir, size, mod); break;
case 21: VG_(transfer) (&mips1->guest_r21, buf, dir, size, mod); break;
case 22: VG_(transfer) (&mips1->guest_r22, buf, dir, size, mod); break;
case 23: VG_(transfer) (&mips1->guest_r23, buf, dir, size, mod); break;
case 24: VG_(transfer) (&mips1->guest_r24, buf, dir, size, mod); break;
case 25: VG_(transfer) (&mips1->guest_r25, buf, dir, size, mod); break;
case 26: VG_(transfer) (&mips1->guest_r26, buf, dir, size, mod); break;
case 27: VG_(transfer) (&mips1->guest_r27, buf, dir, size, mod); break;
case 28: VG_(transfer) (&mips1->guest_r28, buf, dir, size, mod); break;
case 29: VG_(transfer) (&mips1->guest_r29, buf, dir, size, mod); break;
case 30: VG_(transfer) (&mips1->guest_r30, buf, dir, size, mod); break;
case 31: VG_(transfer) (&mips1->guest_r31, buf, dir, size, mod); break;
case 32: *mod = False; break; // GDBTD???? VEX { "status", 1024, 32 },
case 33: VG_(transfer) (&mips1->guest_LO, buf, dir, size, mod); break;
case 34: VG_(transfer) (&mips1->guest_HI, buf, dir, size, mod); break;
case 35: *mod = False; break; // GDBTD???? VEX { "badvaddr", 1120, 32 },
case 36: *mod = False; break; // GDBTD???? VEX { "cause", 1152, 32 },
case 37: VG_(transfer) (&mips1->guest_PC, buf, dir, size, mod); break;
case 38: VG_(transfer) (&mips1->guest_f0, buf, dir, size, mod); break;
case 39: VG_(transfer) (&mips1->guest_f1, buf, dir, size, mod); break;
case 40: VG_(transfer) (&mips1->guest_f2, buf, dir, size, mod); break;
case 41: VG_(transfer) (&mips1->guest_f3, buf, dir, size, mod); break;
case 42: VG_(transfer) (&mips1->guest_f4, buf, dir, size, mod); break;
case 43: VG_(transfer) (&mips1->guest_f5, buf, dir, size, mod); break;
case 44: VG_(transfer) (&mips1->guest_f6, buf, dir, size, mod); break;
case 45: VG_(transfer) (&mips1->guest_f7, buf, dir, size, mod); break;
case 46: VG_(transfer) (&mips1->guest_f8, buf, dir, size, mod); break;
case 47: VG_(transfer) (&mips1->guest_f9, buf, dir, size, mod); break;
case 48: VG_(transfer) (&mips1->guest_f10, buf, dir, size, mod); break;
case 49: VG_(transfer) (&mips1->guest_f11, buf, dir, size, mod); break;
case 50: VG_(transfer) (&mips1->guest_f12, buf, dir, size, mod); break;
case 51: VG_(transfer) (&mips1->guest_f13, buf, dir, size, mod); break;
case 52: VG_(transfer) (&mips1->guest_f14, buf, dir, size, mod); break;
case 53: VG_(transfer) (&mips1->guest_f15, buf, dir, size, mod); break;
case 54: VG_(transfer) (&mips1->guest_f16, buf, dir, size, mod); break;
case 55: VG_(transfer) (&mips1->guest_f17, buf, dir, size, mod); break;
case 56: VG_(transfer) (&mips1->guest_f18, buf, dir, size, mod); break;
case 57: VG_(transfer) (&mips1->guest_f19, buf, dir, size, mod); break;
case 58: VG_(transfer) (&mips1->guest_f20, buf, dir, size, mod); break;
case 59: VG_(transfer) (&mips1->guest_f21, buf, dir, size, mod); break;
case 60: VG_(transfer) (&mips1->guest_f22, buf, dir, size, mod); break;
case 61: VG_(transfer) (&mips1->guest_f23, buf, dir, size, mod); break;
case 62: VG_(transfer) (&mips1->guest_f24, buf, dir, size, mod); break;
case 63: VG_(transfer) (&mips1->guest_f25, buf, dir, size, mod); break;
case 64: VG_(transfer) (&mips1->guest_f26, buf, dir, size, mod); break;
case 65: VG_(transfer) (&mips1->guest_f27, buf, dir, size, mod); break;
case 66: VG_(transfer) (&mips1->guest_f28, buf, dir, size, mod); break;
case 67: VG_(transfer) (&mips1->guest_f29, buf, dir, size, mod); break;
case 68: VG_(transfer) (&mips1->guest_f30, buf, dir, size, mod); break;
case 69: VG_(transfer) (&mips1->guest_f31, buf, dir, size, mod); break;
case 70: VG_(transfer) (&mips1->guest_FCSR, buf, dir, size, mod); break;
case 71: VG_(transfer) (&mips1->guest_FIR, buf, dir, size, mod); break;
case 72: *mod = False; break; // GDBTD???? VEX{ "restart", 2304, 32 },
default: VG_(printf)("regno: %d\n", regno); vg_assert(0);
}
}
static
char* target_xml (Bool shadow_mode)
{
if (shadow_mode) {
return "mips-linux-valgrind.xml";
} else {
return "mips-linux.xml";
}
}
static struct valgrind_target_ops low_target = {
num_regs,
regs,
29, //sp = r29, which is register offset 29 in regs
transfer_register,
get_pc,
set_pc,
"mips",
target_xml
};
void mips32_init_architecture (struct valgrind_target_ops *target)
{
*target = low_target;
set_register_cache (regs, num_regs);
gdbserver_expedite_regs = expedite_regs;
}

398
coregrind/m_sigframe/sigframe-mips32-linux.c Normal file
View File

@ -0,0 +1,398 @@
/*--------------------------------------------------------------------*/
/*--- Create/destroy signal delivery frames. ---*/
/*--- sigframe-mips32-linux.c ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2010-2012 RT-RK
mips-valgrind@rt-rk.com
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#if defined(VGP_mips32_linux)
#include "pub_core_basics.h"
#include "pub_core_vki.h"
#include "pub_core_vkiscnums.h"
#include "pub_core_libcsetjmp.h" // to keep _threadstate.h happy
#include "pub_core_threadstate.h"
#include "pub_core_aspacemgr.h"
#include "pub_core_libcbase.h"
#include "pub_core_libcassert.h"
#include "pub_core_libcprint.h"
#include "pub_core_machine.h"
#include "pub_core_options.h"
#include "pub_core_sigframe.h"
#include "pub_core_signals.h"
#include "pub_core_tooliface.h"
#include "pub_core_trampoline.h"
#include "pub_core_transtab.h" // VG_(discard_translations)
struct vg_sig_private
{
UInt magicPI;
UInt sigNo_private;
VexGuestMIPS32State vex_shadow1;
VexGuestMIPS32State vex_shadow2;
};
struct sigframe
{
UInt sf_ass[4]; /* argument save space for o32 */
UInt sf_pad[2]; /* Was: signal trampoline */
struct vki_sigcontext sf_sc;
vki_sigset_t sf_mask;
struct vg_sig_private priv;
};
struct rt_sigframe
{
UInt rs_ass[4]; /* argument save space for o32 */
UInt rs_pad[2]; /* Was: signal trampoline */
vki_siginfo_t rs_info;
struct vki_ucontext rs_uc;
struct vg_sig_private priv;
};
/* Extend the stack segment downwards if needed so as to ensure the
new signal frames are mapped to something. Return a Bool
indicating whether or not the operation was successful.
*/
static Bool extend ( ThreadState *tst, Addr addr, SizeT size )
{
ThreadId tid = tst->tid;
NSegment const* stackseg = NULL;
if (VG_(extend_stack)(addr, tst->client_stack_szB))
{
stackseg = VG_(am_find_nsegment)(addr);
}
if (stackseg == NULL || !stackseg->hasR || !stackseg->hasW)
{
VG_(message)(Vg_UserMsg,
"Can't extend stack to %#lx during signal delivery for thread %d:\n",
addr, tid );
if (stackseg == NULL)
VG_(message)( Vg_UserMsg, " no stack segment\n" );
else
VG_(message)( Vg_UserMsg, " too small or bad protection modes\n" );
/* set SIGSEGV to default handler */
VG_(set_default_handler)( VKI_SIGSEGV );
VG_(synth_fault_mapping)( tid, addr );
/* The whole process should be about to die, since the default
action of SIGSEGV to kill the whole process. */
return False;
}
/* For tracking memory events, indicate the entire frame has been
allocated. */
VG_TRACK( new_mem_stack_signal, addr - VG_STACK_REDZONE_SZB,
size + VG_STACK_REDZONE_SZB, tid );
return True;
}
static
void setup_sigcontext2 ( ThreadState* tst, struct vki_sigcontext **sc1, const vki_siginfo_t *si)
{
struct vki_sigcontext *sc = *sc1;
VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, "signal frame mcontext",
(Addr)sc, sizeof(unsigned long long)*34 );
sc->sc_regs[1] = tst->arch.vex.guest_r1;
sc->sc_regs[2] = tst->arch.vex.guest_r2;
sc->sc_regs[3] = tst->arch.vex.guest_r3;
sc->sc_regs[4] = tst->arch.vex.guest_r4;
sc->sc_regs[5] = tst->arch.vex.guest_r5;
sc->sc_regs[6] = tst->arch.vex.guest_r6;
sc->sc_regs[7] = tst->arch.vex.guest_r7;
sc->sc_regs[8] = tst->arch.vex.guest_r8;
sc->sc_regs[9] = tst->arch.vex.guest_r9;
sc->sc_regs[10] = tst->arch.vex.guest_r10;
sc->sc_regs[11] = tst->arch.vex.guest_r11;
sc->sc_regs[12] = tst->arch.vex.guest_r12;
sc->sc_regs[13] = tst->arch.vex.guest_r13;
sc->sc_regs[14] = tst->arch.vex.guest_r14;
sc->sc_regs[15] = tst->arch.vex.guest_r15;
sc->sc_regs[16] = tst->arch.vex.guest_r16;
sc->sc_regs[17] = tst->arch.vex.guest_r17;
sc->sc_regs[18] = tst->arch.vex.guest_r18;
sc->sc_regs[19] = tst->arch.vex.guest_r19;
sc->sc_regs[20] = tst->arch.vex.guest_r20;
sc->sc_regs[21] = tst->arch.vex.guest_r21;
sc->sc_regs[22] = tst->arch.vex.guest_r22;
sc->sc_regs[23] = tst->arch.vex.guest_r23;
sc->sc_regs[24] = tst->arch.vex.guest_r24;
sc->sc_regs[25] = tst->arch.vex.guest_r25;
sc->sc_regs[26] = tst->arch.vex.guest_r26;
sc->sc_regs[27] = tst->arch.vex.guest_r27;
sc->sc_regs[28] = tst->arch.vex.guest_r28;
sc->sc_regs[29] = tst->arch.vex.guest_r29;
sc->sc_regs[30] = tst->arch.vex.guest_r30;
sc->sc_regs[31] = tst->arch.vex.guest_r31;
sc->sc_pc = tst->arch.vex.guest_PC;
sc->sc_mdhi = tst->arch.vex.guest_HI;
sc->sc_mdlo = tst->arch.vex.guest_LO;
}
/* EXPORTED */
void VG_(sigframe_create)( ThreadId tid,
Addr sp_top_of_frame,
const vki_siginfo_t *siginfo,
const struct vki_ucontext *siguc,
void *handler,
UInt flags,
const vki_sigset_t *mask,
void *restorer )
{
Addr sp;
ThreadState* tst = VG_(get_ThreadState)(tid);
Addr faultaddr;
Int sigNo = siginfo->si_signo;
struct vg_sig_private *priv;
/* Stack must be 8-byte aligned */
sp_top_of_frame &= ~0xf;
if (flags & VKI_SA_SIGINFO)
{
sp = sp_top_of_frame - sizeof(struct rt_sigframe);
}
else
{
sp = sp_top_of_frame - sizeof(struct sigframe);
}
tst = VG_(get_ThreadState)(tid);
if (!extend(tst, sp, sp_top_of_frame - sp))
return;
vg_assert(VG_IS_8_ALIGNED(sp));
/* SIGILL defines addr to be the faulting address */
faultaddr = (Addr)siginfo->_sifields._sigfault._addr;
if (sigNo == VKI_SIGILL && siginfo->si_code > 0)
faultaddr = tst->arch.vex.guest_PC;
if (flags & VKI_SA_SIGINFO)
{
struct rt_sigframe *frame = (struct rt_sigframe *) sp;
struct vki_ucontext *ucp = &frame->rs_uc;
if (VG_(clo_trace_signals))
VG_(printf)("rt_sigframe\n");
/* Create siginfo. */
VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame siginfo",
(Addr)&frame->rs_info, sizeof(frame->rs_info) );
VG_(memcpy)(&frame->rs_info, siginfo, sizeof(*siginfo));
VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
(Addr)&frame->rs_info, sizeof(frame->rs_info) );
/* Create the ucontext. */
VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal frame ucontext",
(Addr)ucp, offsetof(struct vki_ucontext, uc_mcontext) );
ucp->uc_flags = 0;
ucp->uc_link = 0;
ucp->uc_stack = tst->altstack;
VG_TRACK( post_mem_write, Vg_CoreSignal, tid, (Addr)ucp,
offsetof(struct vki_ucontext, uc_mcontext) );
struct vki_sigcontext *scp = &(frame->rs_uc.uc_mcontext);
setup_sigcontext2(tst, &(scp), siginfo);
ucp->uc_sigmask = tst->sig_mask;
priv = &frame->priv;
/*
* Arguments to signal handler:
*
* a0 = signal number
* a1 = 0 (should be cause)
* a2 = pointer to ucontext
*
* $25 and c0_epc point to the signal handler, $29 points to
* the struct rt_sigframe.
*/
tst->arch.vex.guest_r4 = siginfo->si_signo;
tst->arch.vex.guest_r5 = (Addr) &frame->rs_info;
tst->arch.vex.guest_r6 = (Addr) &frame->rs_uc;
tst->arch.vex.guest_r29 = (Addr) frame;
tst->arch.vex.guest_r25 = (Addr) handler;
if (flags & VKI_SA_RESTORER)
{
tst->arch.vex.guest_r31 = (Addr) restorer;
}
else
{
tst->arch.vex.guest_r31 = (Addr)&VG_(mips32_linux_SUBST_FOR_rt_sigreturn);
}
}
else
{
if (VG_(clo_trace_signals))
VG_(printf)("sigframe\n");
struct sigframe *frame = (struct sigframe *) sp;
struct vki_sigcontext *scp = &(frame->sf_sc);
setup_sigcontext2(tst, &(scp), siginfo);
frame->sf_mask = tst->sig_mask;
priv = &frame->priv;
/*
* Arguments to signal handler:
*
* a0 = signal number
* a1 = 0 (should be cause)
* a2 = pointer to struct sigcontext
*
* $25 and c0_epc point to the signal handler, $29 points to the
* struct sigframe.
*/
tst->arch.vex.guest_r4 = siginfo->si_signo;
tst->arch.vex.guest_r5 = 0;
tst->arch.vex.guest_r6 = (Addr) &frame->sf_sc;
tst->arch.vex.guest_r29 = (Addr) frame;
tst->arch.vex.guest_r25 = (Addr) handler;
if (flags & VKI_SA_RESTORER)
{
tst->arch.vex.guest_r31 = (Addr) restorer;
}
else
{
tst->arch.vex.guest_r31 = (Addr)&VG_(mips32_linux_SUBST_FOR_sigreturn);
}
}
priv->magicPI = 0x31415927;
priv->sigNo_private = sigNo;
priv->vex_shadow1 = tst->arch.vex_shadow1;
priv->vex_shadow2 = tst->arch.vex_shadow2;
/* Set the thread so it will next run the handler. */
/* tst->m_sp = sp; also notify the tool we've updated SP */
VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr));
if (VG_(clo_trace_signals))
VG_(printf)("handler = %p\n", handler);
tst->arch.vex.guest_PC = (Addr) handler;
/* This thread needs to be marked runnable, but we leave that the
caller to do. */
}
/* EXPORTED */
void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
{
ThreadState *tst;
struct vg_sig_private *priv1;
Addr sp;
UInt frame_size;
struct vki_sigcontext *mc;
Int sigNo;
Bool has_siginfo = isRT;
vg_assert(VG_(is_valid_tid)(tid));
tst = VG_(get_ThreadState)(tid);
sp = tst->arch.vex.guest_r29;
if (has_siginfo)
{
struct rt_sigframe *frame = (struct rt_sigframe *)sp;
struct vki_ucontext *ucp = &frame->rs_uc;
frame_size = sizeof(*frame);
mc = &ucp->uc_mcontext;
priv1 = &frame->priv;
vg_assert(priv1->magicPI == 0x31415927);
sigNo = priv1->sigNo_private;
}
else
{
struct sigframe *frame = (struct sigframe *)sp;
frame_size = sizeof(*frame);
mc = &(frame->sf_sc);
priv1 = &frame->priv;
vg_assert(priv1->magicPI == 0x31415927);
tst->sig_mask = frame->sf_mask;
tst->tmp_sig_mask = tst->sig_mask;
sigNo = priv1->sigNo_private;
}
//restore regs
tst->arch.vex.guest_r1 = mc->sc_regs[1];
tst->arch.vex.guest_r2 = mc->sc_regs[2];
tst->arch.vex.guest_r3 = mc->sc_regs[3];
tst->arch.vex.guest_r4 = mc->sc_regs[4];
tst->arch.vex.guest_r5 = mc->sc_regs[5];
tst->arch.vex.guest_r6 = mc->sc_regs[6];
tst->arch.vex.guest_r7 = mc->sc_regs[7];
tst->arch.vex.guest_r8 = mc->sc_regs[8];
tst->arch.vex.guest_r9 = mc->sc_regs[9];
tst->arch.vex.guest_r10 = mc->sc_regs[10];
tst->arch.vex.guest_r11 = mc->sc_regs[11];
tst->arch.vex.guest_r12 = mc->sc_regs[12];
tst->arch.vex.guest_r13= mc->sc_regs[13];
tst->arch.vex.guest_r14 = mc->sc_regs[14];
tst->arch.vex.guest_r15 = mc->sc_regs[15];
tst->arch.vex.guest_r16 = mc->sc_regs[16];
tst->arch.vex.guest_r17 = mc->sc_regs[17];
tst->arch.vex.guest_r18 = mc->sc_regs[18];
tst->arch.vex.guest_r19 = mc->sc_regs[19];
tst->arch.vex.guest_r20 = mc->sc_regs[20];
tst->arch.vex.guest_r21 = mc->sc_regs[21];
tst->arch.vex.guest_r22 = mc->sc_regs[22];
tst->arch.vex.guest_r23 = mc->sc_regs[23];
tst->arch.vex.guest_r24 = mc->sc_regs[24];
tst->arch.vex.guest_r25 = mc->sc_regs[25];
tst->arch.vex.guest_r26 = mc->sc_regs[26];
tst->arch.vex.guest_r27 = mc->sc_regs[27];
tst->arch.vex.guest_r28 = mc->sc_regs[28];
tst->arch.vex.guest_r30 = mc->sc_regs[30];
tst->arch.vex.guest_PC = mc->sc_pc;
tst->arch.vex.guest_r31 = mc->sc_regs[31];
tst->arch.vex.guest_r29 = mc->sc_regs[29];
tst->arch.vex.guest_HI = mc->sc_mdhi;
tst->arch.vex.guest_LO = mc->sc_mdlo;
tst->arch.vex_shadow1 = priv1->vex_shadow1;
tst->arch.vex_shadow2 = priv1->vex_shadow2;
VG_TRACK(die_mem_stack_signal, sp, frame_size);
if (VG_(clo_trace_signals))
VG_(message)( Vg_DebugMsg,
"VG_(signal_return) (thread %d): isRT=%d valid magic; EIP=%#x\n",
tid, isRT, tst->arch.vex.guest_PC);
/* tell the tools */
VG_TRACK( post_deliver_signal, tid, sigNo );
}
#endif // defined(VGP_mips32_linux)
/*--------------------------------------------------------------------*/
/*--- end sigframe-mips32-linux.c ---*/
/*--------------------------------------------------------------------*/

215
coregrind/m_syswrap/syscall-mips32-linux.S Normal file
View File

@ -0,0 +1,215 @@
/*--------------------------------------------------------------------*/
/*--- Support for doing system calls. syscall-mips32-linux.S ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2010-2012 RT-RK
mips-valgrind@rt-rk.com
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#if defined(VGP_mips32_linux)
#include "pub_core_basics_asm.h"
#include "pub_core_vkiscnums_asm.h"
#include "libvex_guest_offsets.h"
/*----------------------------------------------------------------*/
/*
Perform a syscall for the client. This will run a syscall
with the client's specific per-thread signal mask.
The structure of this function is such that, if the syscall is
interrupted by a signal, we can determine exactly what
execution state we were in with respect to the execution of
the syscall by examining the value of IP in the signal
handler. This means that we can always do the appropriate
thing to precisely emulate the kernel's signal/syscall
interactions.
The syscall number is taken from the argument, even though it
should also be in regs->v0. The syscall result is written
back to regs->v0 on completion.
Returns 0 if the syscall was successfully called (even if the
syscall itself failed), or a nonzero error code in the lowest
8 bits if one of the sigprocmasks failed (there's no way to
determine which one failed). And there's no obvious way to
recover from that either, but nevertheless we want to know.
VG_(fixup_guest_state_after_syscall_interrupted) does the
thread state fixup in the case where we were interrupted by a
signal.
Prototype:
UWord ML_(do_syscall_for_client_WRK)(
Int syscallno, // $4 - a0
void* guest_state, // $5 - a1
const vki_sigset_t *sysmask, // $6 - a2
const vki_sigset_t *postmask, // $7 - a3
Int nsigwords) // stack
*/
/* from vki_arch.h */
#define VKI_SIG_SETMASK 3
.globl ML_(do_syscall_for_client_WRK)
ML_(do_syscall_for_client_WRK):
subu $29, $29, 56 #set up the steck frame,
sw $4, 52($29)
sw $5, 48($29)
sw $6, 44($29)
sw $7, 40($29)
sw $31, 36($29)
sw $30, 32($29)
sw $16, 28($29)
sw $17, 24($29)
sw $18, 20($29)
sw $19, 16($29)
sw $20, 12($29)
sw $21, 8($29)
sw $22, 4($29)
sw $23, 0($29)
addu $30, $29, 56
/* Set the signal mask which should be current during the syscall. */
1: li $2, __NR_rt_sigprocmask
li $4, VKI_SIG_SETMASK
move $5, $6 /* sysmask */
move $6, $7 /* postmask */
lw $7, 72($29) /* nsigwords */
syscall
nop
# TODO: this should remain, keep it just for now
bnez $7, 7f
nop
lw $8, 48($29) /* t0 == ThreadState */
lw $2, 52($29) /* v0 == syscallno */
lw $4, OFFSET_mips32_r4($8)
lw $5, OFFSET_mips32_r5($8)
lw $6, OFFSET_mips32_r6($8)
lw $7, OFFSET_mips32_r7($8)
subu $29, $29, 24 #set up the steck frame,
lw $9, OFFSET_mips32_r29($8)
lw $10, 16($9)
sw $10, 16($29)
lw $10, 20($9)
sw $10, 20($29)
2: syscall
3: addu $29, $29, 24 #set up the steck frame,
lw $8, 48($29) /* t0 == ThreadState */
sw $2, OFFSET_mips32_r2($8)
sw $3, OFFSET_mips32_r3($8)
sw $7, OFFSET_mips32_r7($8)
4: li $2, __NR_rt_sigprocmask
li $4, VKI_SIG_SETMASK
lw $5, 40($29)
li $6, 0
lw $7, 72($29) /* nsigwords */
syscall
nop
bnez $7, 7f
nop
/* Success */
li $2, 0
5: lw $4, 52($29)
lw $5, 48($29)
lw $6, 44($29)
lw $7, 40($29)
lw $31, 36($29)
lw $30, 32($29)
lw $16, 28($29)
lw $17, 24($29)
lw $18, 20($29)
lw $19, 16($29)
lw $20, 12($29)
lw $21, 8($29)
lw $22, 4($29)
lw $23, 0($29)
addu $29, $29, 56 #release the stack frame.
jr $31
nop
7: /* Failure: return 0x8000 | error code */
li $2, 0x8000
lw $4, 52($29)
lw $5, 48($29)
lw $6, 44($29)
lw $7, 40($29)
lw $31, 36($29)
lw $30, 32($29)
lw $16, 28($29)
lw $17, 24($29)
lw $18, 20($29)
lw $19, 16($29)
lw $20, 12($29)
lw $21, 8($29)
lw $22, 4($29)
lw $23, 0($29)
addu $29, $29, 56 #release the stack frame.
jr $31
nop
.section .rodata
/* export the ranges so that
VG_(fixup_guest_state_after_syscall_interrupted) can do the
right thing */
.globl ML_(blksys_setup)
.globl ML_(blksys_restart)
.globl ML_(blksys_complete)
.globl ML_(blksys_committed)
.globl ML_(blksys_finished)
ML_(blksys_setup): .long 1b
ML_(blksys_restart): .long 2b
ML_(blksys_complete): .long 3b
ML_(blksys_committed): .long 4b
ML_(blksys_finished): .long 5b
.previous
/* Let the linker know we don't need an executable stack */
.section .note.GNU-stack,"",%progbits
#endif // defined(VGP_mips32_linux)
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/

1759
coregrind/m_syswrap/syswrap-mips32-linux.c Normal file
View File

File diff suppressed because it is too large Load Diff

973
include/vki/vki-mips32-linux.h Normal file
View File

@ -0,0 +1,973 @@
/*--------------------------------------------------------------------*/
/*--- mips/Linux-specific kernel interface. vki-mips32-linux.h ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2010-2012 RT-RK
mips-valgrind@rt-rk.com
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#ifndef __VKI_MIPS32_LINUX_H
#define __VKI_MIPS32_LINUX_H
#include <config.h>
// mips endian
#if defined (_MIPSEL)
#define VKI_LITTLE_ENDIAN 1
#elif defined (_MIPSEB)
#define VKI_BIG_ENDIAN 1
#endif
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-generic/int-ll64.h
//----------------------------------------------------------------------
typedef __signed__ char __vki_s8;
typedef unsigned char __vki_u8;
typedef __signed__ short __vki_s16;
typedef unsigned short __vki_u16;
typedef __signed__ int __vki_s32;
typedef unsigned int __vki_u32;
typedef __signed char vki_s8;
typedef unsigned char vki_u8;
typedef __signed short vki_s16;
typedef unsigned short vki_u16;
typedef __signed int vki_s32;
typedef unsigned int vki_u32;
typedef __signed__ long long __vki_s64;
typedef unsigned long long __vki_u64;
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/page.h
//----------------------------------------------------------------------
/* PAGE_SHIFT determines the page size */
#define VKI_PAGE_SHIFT MIPS_PAGE_SHIFT
#define VKI_PAGE_SIZE (1UL << VKI_PAGE_SHIFT)
#define VKI_PAGE_MASK (~(VKI_PAGE_SIZE-1))
#define VKI_MAX_PAGE_SHIFT VKI_PAGE_SHIFT
#define VKI_MAX_PAGE_SIZE VKI_PAGE_SIZE
//----------------------------------------------------------------------
// From linux-2.6.35.5/arch/mips/include/asm-generic/shmparam.h
//----------------------------------------------------------------------
#define VKI_SHMLBA SHM_ALIGNMENT
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm/signal.h
//----------------------------------------------------------------------
#define VKI_MINSIGSTKSZ 2048
#define VKI_SIG_BLOCK 1 /* for blocking signals */
#define VKI_SIG_UNBLOCK 2 /* for unblocking signals */
#define VKI_SIG_SETMASK 3 /* for setting the signal mask */
/* Type of a signal handler. */
typedef void (*__vki_signalfn_t)(int);
typedef __vki_signalfn_t __user *__vki_sighandler_t;
typedef void __vki_restorefn_t(void);
typedef __vki_restorefn_t __user *__vki_sigrestore_t;
/* Fake signal functions */
#define VKI_SIG_DFL ((__vki_signalfn_t)0) /* default signal handling */
#define VKI_SIG_IGN ((__vki_signalfn_t)1) /* ignore signal */
#define VKI_SIG_ERR ((__vki_signalfn_t)-1) /* error return from signal */
#define _VKI_NSIG 128
#define _VKI_NSIG_BPW 32
#define _VKI_NSIG_WORDS (_VKI_NSIG / _VKI_NSIG_BPW)
typedef unsigned long vki_old_sigset_t; /* at least 32 bits */
typedef struct {
unsigned long sig[_VKI_NSIG_WORDS];
} vki_sigset_t;
#define VKI_SIGHUP 1 /* Hangup (POSIX). */
#define VKI_SIGINT 2 /* Interrupt (ANSI). */
#define VKI_SIGQUIT 3 /* Quit (POSIX). */
#define VKI_SIGILL 4 /* Illegal instruction (ANSI). */
#define VKI_SIGTRAP 5 /* Trace trap (POSIX). */
#define VKI_SIGIOT 6 /* IOT trap (4.2 BSD). */
#define VKI_SIGABRT VKI_SIGIOT /* Abort (ANSI). */
#define VKI_SIGEMT 7
#define VKI_SIGFPE 8 /* Floating-point exception (ANSI). */
#define VKI_SIGKILL 9 /* Kill, unblockable (POSIX). */
#define VKI_SIGBUS 10 /* BUS error (4.2 BSD). */
#define VKI_SIGSEGV 11 /* Segmentation violation (ANSI). */
#define VKI_SIGSYS 12
#define VKI_SIGPIPE 13 /* Broken pipe (POSIX). */
#define VKI_SIGALRM 14 /* Alarm clock (POSIX). */
#define VKI_SIGTERM 15 /* Termination (ANSI). */
#define VKI_SIGUSR1 16 /* User-defined signal 1 (POSIX). */
#define VKI_SIGUSR2 17 /* User-defined signal 2 (POSIX). */
#define VKI_SIGCHLD 18 /* Child status has changed (POSIX). */
#define VKI_SIGCLD VKI_SIGCHLD /* Same as SIGCHLD (System V). */
#define VKI_SIGPWR 19 /* Power failure restart (System V). */
#define VKI_SIGWINCH 20 /* Window size change (4.3 BSD, Sun). */
#define VKI_SIGURG 21 /* Urgent condition on socket (4.2 BSD). */
#define VKI_SIGIO 22 /* I/O now possible (4.2 BSD). */
#define VKI_SIGPOLL VKI_SIGIO /* Pollable event occurred (System V). */
#define VKI_SIGSTOP 23 /* Stop, unblockable (POSIX). */
#define VKI_SIGTSTP 24 /* Keyboard stop (POSIX). */
#define VKI_SIGCONT 25 /* Continue (POSIX). */
#define VKI_SIGTTIN 26 /* Background read from tty (POSIX). */
#define VKI_SIGTTOU 27 /* Background write to tty (POSIX). */
#define VKI_SIGVTALRM 28 /* Virtual alarm clock (4.2 BSD). */
#define VKI_SIGPROF 29 /* Profiling alarm clock (4.2 BSD). */
#define VKI_SIGXCPU 30 /* CPU limit exceeded (4.2 BSD). */
#define VKI_SIGXFSZ 31 /* File size limit exceeded (4.2 BSD). */
/* These should not be considered constants from userland. */
#define VKI_SIGRTMIN 32
// [[This was (_NSIG-1) in 2.4.X... not sure if it matters.]]
#define VKI_SIGRTMAX _VKI_NSIG
#define VKI_SA_ONSTACK 0x08000000
#define VKI_SA_RESETHAND 0x80000000
#define VKI_SA_RESTART 0x10000000
#define VKI_SA_SIGINFO 0x00000008
#define VKI_SA_NODEFER 0x40000000
#define VKI_SA_NOCLDWAIT 0x00010000
#define VKI_SA_NOCLDSTOP 0x00000001
#define VKI_SA_NOMASK VKI_SA_NODEFER
#define VKI_SA_ONESHOT VKI_SA_RESETHAND
//#define VKI_SA_INTERRUPT 0x20000000 /* dummy -- ignored */
#define VKI_SA_RESTORER 0x04000000
#define VKI_SS_ONSTACK 1
#define VKI_SS_DISABLE 2
struct vki_old_sigaction {
// [[Nb: a 'k' prefix is added to "sa_handler" because
// bits/sigaction.h (which gets dragged in somehow via signal.h)
// #defines it as something else. Since that is done for glibc's
// purposes, which we don't care about here, we use our own name.]]
unsigned long sa_flags;
__vki_sighandler_t ksa_handler;
vki_old_sigset_t sa_mask;
__vki_sigrestore_t sa_restorer;
};
struct vki_sigaction {
unsigned int sa_flags;
__vki_sighandler_t sa_handler;
vki_sigset_t sa_mask;
};
struct vki_sigaction_base {
// [[See comment about extra 'k' above]]
unsigned long sa_flags;
__vki_sighandler_t ksa_handler;
vki_sigset_t sa_mask; /* mask last for extensibility */
__vki_sigrestore_t sa_restorer;
};
/* On Linux we use the same type for passing sigactions to
and from the kernel. Hence: */
typedef struct vki_sigaction_base vki_sigaction_toK_t;
typedef struct vki_sigaction_base vki_sigaction_fromK_t;
typedef struct vki_sigaltstack {
void __user *ss_sp;
vki_size_t ss_size;
int ss_flags;
} vki_stack_t;
//----------------------------------------------------------------------
// From 2.6.35.5/include/asm-mips/sigcontext.h
//----------------------------------------------------------------------
struct _vki_fpreg {
unsigned short significand[4];
unsigned short exponent;
};
struct _vki_fpxreg {
unsigned short significand[4];
unsigned short exponent;
unsigned short padding[3];
};
struct _vki_xmmreg {
unsigned long element[4];
};
struct _vki_fpstate {
/* Regular FPU environment */
unsigned long cw;
unsigned long sw;
unsigned long tag;
unsigned long ipoff;
unsigned long cssel;
unsigned long dataoff;
unsigned long datasel;
struct _vki_fpreg _st[8];
unsigned short status;
unsigned short magic; /* 0xffff = regular FPU data only */
/* FXSR FPU environment */
unsigned long _fxsr_env[6]; /* FXSR FPU env is ignored */
unsigned long mxcsr;
unsigned long reserved;
struct _vki_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
struct _vki_xmmreg _xmm[8];
unsigned long padding[56];
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/sigcontext.h
//----------------------------------------------------------------------
struct vki_sigcontext {
unsigned int sc_regmask; /* Unused */
unsigned int sc_status; /* Unused */
unsigned long long sc_pc;
unsigned long long sc_regs[32];
unsigned long long sc_fpregs[32];
unsigned int sc_acx; /* Was sc_ownedfp */
unsigned int sc_fpc_csr;
unsigned int sc_fpc_eir; /* Unused */
unsigned int sc_used_math;
unsigned int sc_dsp; /* dsp status, was sc_ssflags */
unsigned long long sc_mdhi;
unsigned long long sc_mdlo;
unsigned long sc_hi1; /* Was sc_cause */
unsigned long sc_lo1; /* Was sc_badvaddr */
unsigned long sc_hi2; /* Was sc_sigset[4] */
unsigned long sc_lo2;
unsigned long sc_hi3;
unsigned long sc_lo3;
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/mman.h
//----------------------------------------------------------------------
#define VKI_PROT_NONE 0x0 /* No page permissions */
#define VKI_PROT_READ 0x1 /* page can be read */
#define VKI_PROT_WRITE 0x2 /* page can be written */
#define VKI_PROT_EXEC 0x4 /* page can be executed */
#define VKI_PROT_GROWSDOWN 0x01000000 /* mprotect flag: extend change to start of growsdown vma */
#define VKI_PROT_GROWSUP 0x02000000 /* mprotect flag: extend change to end of growsup vma */
#define VKI_MAP_SHARED 0x001 /* Share changes */
#define VKI_MAP_PRIVATE 0x002 /* Changes are private */
#define VKI_MAP_FIXED 0x010 /* Interpret addr exactly */
#define VKI_MAP_NORESERVE 0x0400 /* don't reserve swap pages */
/* These are linux-specific */
#define VKI_MAP_NORESERVE 0x0400 /* don't check for reservations */
#define VKI_MAP_ANONYMOUS 0x0800 /* don't use a file */
#define VKI_MAP_GROWSDOWN 0x1000 /* stack-like segment */
#define VKI_MAP_DENYWRITE 0x2000 /* ETXTBSY */
#define VKI_MAP_EXECUTABLE 0x4000 /* mark it as an executable */
#define VKI_MAP_LOCKED 0x8000 /* pages are locked */
#define VKI_MAP_POPULATE 0x10000 /* populate (prefault) pagetables */
#define VKI_MAP_NONBLOCK 0x20000 /* do not block on IO */
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/fcntl.h
//----------------------------------------------------------------------
#define VKI_O_RDONLY 00
#define VKI_O_WRONLY 01
#define VKI_O_RDWR 02
#define VKI_O_CREAT 0x0100 /* not fcntl */
#define VKI_O_EXCL 0x0400 /* not fcntl */
#define VKI_O_TRUNC 0x0200 /* not fcntl */
#define VKI_O_APPEND 0x0008
#define VKI_O_NONBLOCK 0x0080
#define VKI_O_LARGEFILE 0x2000
#define VKI_AT_FDCWD -100
#define VKI_F_DUPFD 0 /* dup */
#define VKI_F_GETFD 1 /* get close_on_exec */
#define VKI_F_SETFD 2 /* set/clear close_on_exec */
#define VKI_F_GETFL 3 /* get file->f_flags */
#define VKI_F_SETFL 4 /* set file->f_flags */
#define VKI_F_GETLK 14
#define VKI_F_SETLK 6
#define VKI_F_SETLKW 7
#define VKI_F_SETOWN 24 /* for sockets. */
#define VKI_F_GETOWN 23 /* for sockets. */
#define VKI_F_SETSIG 10 /* for sockets. */
#define VKI_F_GETSIG 11 /* for sockets. */
#define VKI_F_SETOWN_EX 15
#define VKI_F_GETOWN_EX 16
#define VKI_F_GETLK64 33 /* using 'struct flock64' */
#define VKI_F_SETLK64 34
#define VKI_F_SETLKW64 35
/* for F_[GET|SET]FL */
#define VKI_FD_CLOEXEC 1 /* actually anything with low bit set goes */
#define VKI_F_LINUX_SPECIFIC_BASE 1024
struct vki_f_owner_ex {
int type;
__vki_kernel_pid_t pid;
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/resource.h
//----------------------------------------------------------------------
#define VKI_RLIMIT_DATA 2 /* max data size */
#define VKI_RLIMIT_STACK 3 /* max stack size */
#define VKI_RLIMIT_CORE 4 /* max core file size */
#define VKI_RLIMIT_NOFILE 5 /* max number of open files */
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/socket.h
//----------------------------------------------------------------------
#define VKI_SOL_SOCKET 0xffff
#define VKI_SO_TYPE 0x1008
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-i386/sockios.h
//----------------------------------------------------------------------
#define VKI_SIOCSPGRP 0x8902
#define VKI_SIOCGPGRP 0x8904
#define VKI_SIOCGSTAMP 0x8906 /* Get stamp (timeval) */
#define VKI_SIOCGSTAMPNS 0x8907 /* Get stamp (timespec) */
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/stat.h
//----------------------------------------------------------------------
struct vki_stat {
unsigned st_dev;
long st_pad1[3]; /* Reserved for network id */
unsigned long st_ino;
unsigned int st_mode;
unsigned long st_nlink;
unsigned int st_uid;
unsigned int st_gid;
unsigned st_rdev;
long st_pad2[2];
long st_size;
long st_pad3;
/*
* Actually this should be timestruc_t st_atime, st_mtime and st_ctime
* but we don't have it under Linux.
*/
long st_atime;
long st_atime_nsec;
long st_mtime;
long st_mtime_nsec;
long st_ctime;
long st_ctime_nsec;
long st_blksize;
long st_blocks;
long st_pad4[14];
};
/*
* This matches struct stat64 in glibc2.1, hence the absolutely insane
* amounts of padding around dev_t's. The memory layout is the same as of
* struct stat of the 64-bit kernel.
*/
struct vki_stat64 {
unsigned long st_dev;
unsigned long st_pad0[3]; /* Reserved for st_dev expansion */
unsigned long long st_ino;
unsigned int st_mode;
unsigned long st_nlink;
unsigned int st_uid;
unsigned int st_gid;
unsigned long st_rdev;
unsigned long st_pad1[3]; /* Reserved for st_rdev expansion */
long long st_size;
/*
* Actually this should be timestruc_t st_atime, st_mtime and st_ctime
* but we don't have it under Linux.
*/
long st_atime;
unsigned long st_atime_nsec; /* Reserved for st_atime expansion */
long st_mtime;
unsigned long st_mtime_nsec; /* Reserved for st_mtime expansion */
long st_ctime;
unsigned long st_ctime_nsec; /* Reserved for st_ctime expansion */
unsigned long st_blksize;
unsigned long st_pad2;
long long st_blocks;
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/statfs.h
//----------------------------------------------------------------------
struct vki_statfs {
long f_type;
long f_bsize;
long f_frsize; /* Fragment size - unsupported */
long f_blocks;
long f_bfree;
long f_files;
long f_ffree;
long f_bavail;
/* Linux specials */
__vki_kernel_fsid_t f_fsid;
long f_namelen;
long f_spare[6];
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/termios.h
//----------------------------------------------------------------------
struct vki_winsize {
unsigned short ws_row;
unsigned short ws_col;
unsigned short ws_xpixel;
unsigned short ws_ypixel;
};
#define NCC 8
#define NCCS 23
struct vki_termio {
unsigned short c_iflag; /* input mode flags */
unsigned short c_oflag; /* output mode flags */
unsigned short c_cflag; /* control mode flags */
unsigned short c_lflag; /* local mode flags */
char c_line; /* line discipline */
unsigned char c_cc[NCCS]; /* control characters */
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/termbits.h
//----------------------------------------------------------------------
typedef unsigned char vki_cc_t;
typedef unsigned long vki_speed_t;
typedef unsigned long vki_tcflag_t;
struct vki_termios {
vki_tcflag_t c_iflag; /* input mode flags */
vki_tcflag_t c_oflag; /* output mode flags */
vki_tcflag_t c_cflag; /* control mode flags */
vki_tcflag_t c_lflag; /* local mode flags */
vki_cc_t c_line; /* line discipline */
vki_cc_t c_cc[NCCS]; /* control characters */
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/ioctl.h
//----------------------------------------------------------------------
#define _VKI_IOC_NRBITS 8
#define _VKI_IOC_TYPEBITS 8
#define _VKI_IOC_SIZEBITS 14
#define _VKI_IOC_DIRBITS 2
#define _VKI_IOC_NRMASK ((1 << _VKI_IOC_NRBITS)-1)
#define _VKI_IOC_TYPEMASK ((1 << _VKI_IOC_TYPEBITS)-1)
#define _VKI_IOC_SIZEMASK ((1 << _VKI_IOC_SIZEBITS)-1)
#define _VKI_IOC_DIRMASK ((1 << _VKI_IOC_DIRBITS)-1)
#define _VKI_IOC_NRSHIFT 0
#define _VKI_IOC_TYPESHIFT (_VKI_IOC_NRSHIFT+_VKI_IOC_NRBITS)
#define _VKI_IOC_SIZESHIFT (_VKI_IOC_TYPESHIFT+_VKI_IOC_TYPEBITS)
#define _VKI_IOC_DIRSHIFT (_VKI_IOC_SIZESHIFT+_VKI_IOC_SIZEBITS)
#define _VKI_IOC_NONE 1U
#define _VKI_IOC_WRITE 2U
#define _VKI_IOC_READ 4U
#define _VKI_IOC(dir,type,nr,size) \
(((dir) << _VKI_IOC_DIRSHIFT) | \
((type) << _VKI_IOC_TYPESHIFT) | \
((nr) << _VKI_IOC_NRSHIFT) | \
((size) << _VKI_IOC_SIZESHIFT))
/* provoke compile error for invalid uses of size argument */
extern unsigned int __VKI_invalid_size_argument_for_IOC;
/* used to create numbers */
#define _VKI_IO(type,nr) _VKI_IOC(_VKI_IOC_NONE,(type),(nr),0)
#define _VKI_IOR(type,nr,size) _VKI_IOC(_VKI_IOC_READ,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
#define _VKI_IOW(type,nr,size) _VKI_IOC(_VKI_IOC_WRITE,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
#define _VKI_IOWR(type,nr,size) _VKI_IOC(_VKI_IOC_READ|_VKI_IOC_WRITE,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
/* used to decode ioctl numbers.. */
#define _VKI_IOC_DIR(nr) (((nr) >> _VKI_IOC_DIRSHIFT) & _VKI_IOC_DIRMASK)
#define _VKI_IOC_TYPE(nr) (((nr) >> _VKI_IOC_TYPESHIFT) & _VKI_IOC_TYPEMASK)
#define _VKI_IOC_NR(nr) (((nr) >> _VKI_IOC_NRSHIFT) & _VKI_IOC_NRMASK)
#define _VKI_IOC_SIZE(nr) (((nr) >> _VKI_IOC_SIZESHIFT) & _VKI_IOC_SIZEMASK)
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/ioctls.h
//----------------------------------------------------------------------
#define VKI_TCGETA 0x5401
#define VKI_TCSETA 0x5402 /* Clashes with SNDCTL_TMR_START sound ioctl */
#define VKI_TCSETAW 0x5403
#define VKI_TCSETAF 0x5404
#define VKI_TCSBRK 0x5405
#define VKI_TCXONC 0x5406
#define VKI_TCFLSH 0x5407
#define VKI_TCGETS 0x540d
#define VKI_TCSETS 0x540e
#define VKI_TCSETSW 0x540f
#define VKI_TCSETSF 0x5410
#define VKI_TIOCEXCL 0x740d /* set exclusive use of tty */
#define VKI_TIOCNXCL 0x740e /* reset exclusive use of tty */
#define VKI_TIOCOUTQ 0x7472 /* output queue size */
#define VKI_TIOCSTI 0x5472 /* simulate terminal input */
#define VKI_TIOCMGET 0x741d /* get all modem bits */
#define VKI_TIOCMBIS 0x741b /* bis modem bits */
#define VKI_TIOCMBIC 0x741c /* bic modem bits */
#define VKI_TIOCMSET 0x741a /* set all modem bits */
#define VKI_TIOCPKT 0x5470 /* pty: set/clear packet mode */
#define VKI_TIOCPKT_DATA 0x00 /* data packet */
#define VKI_TIOCPKT_FLUSHREAD 0x01 /* flush packet */
#define VKI_TIOCPKT_FLUSHWRITE 0x02 /* flush packet */
#define VKI_TIOCPKT_STOP 0x04 /* stop output */
#define VKI_TIOCPKT_START 0x08 /* start output */
#define VKI_TIOCPKT_NOSTOP 0x10 /* no more ^S, ^Q */
#define VKI_TIOCPKT_DOSTOP 0x20 /* now do ^S ^Q */
/* #define TIOCPKT_IOCTL 0x40 state change of pty driver */
#define VKI_TIOCSWINSZ _VKI_IOW('t', 103, struct vki_winsize) /* set window size */
#define VKI_TIOCGWINSZ _VKI_IOR('t', 104, struct vki_winsize) /* get window size */
#define VKI_TIOCNOTTY 0x5471 /* void tty association */
#define VKI_TIOCSETD 0x7401
#define VKI_TIOCGETD 0x7400
#define VKI_FIOCLEX 0x6601
#define VKI_FIONCLEX 0x6602
#define VKI_FIOASYNC 0x667d
#define VKI_FIONBIO 0x667e
#define VKI_FIOQSIZE 0x667f
#define VKI_TIOCGLTC 0x7474 /* get special local chars */
#define VKI_TIOCSLTC 0x7475 /* set special local chars */
#define VKI_TIOCSPGRP _VKI_IOW('t', 118, int) /* set pgrp of tty */
#define VKI_TIOCGPGRP _VKI_IOR('t', 119, int) /* get pgrp of tty */
#define VKI_TIOCCONS _VKI_IOW('t', 120, int) /* become virtual console */
#define VKI_FIONREAD 0x467f
#define VKI_TIOCINQ FIONREAD
#define VKI_TIOCGETP 0x7408
#define VKI_TIOCSETP 0x7409
#define VKI_TIOCSETN 0x740a /* TIOCSETP wo flush */
#define VKI_TIOCSBRK 0x5427 /* BSD compatibility */
#define VKI_TIOCCBRK 0x5428 /* BSD compatibility */
#define VKI_TIOCGSID 0x7416 /* Return the session ID of FD */
#define VKI_TIOCGPTN _VKI_IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
#define VKI_TIOCSPTLCK _VKI_IOW('T',0x31, int) /* Lock/unlock Pty */
/* I hope the range from 0x5480 on is free ... */
#define VKI_TIOCSCTTY 0x5480 /* become controlling tty */
#define VKI_TIOCGSOFTCAR 0x5481
#define VKI_TIOCSSOFTCAR 0x5482
#define VKI_TIOCLINUX 0x5483
#define VKI_TIOCGSERIAL 0x5484
#define VKI_TIOCSSERIAL 0x5485
#define VKI_TCSBRKP 0x5486 /* Needed for POSIX tcsendbreak() */
#define VKI_TIOCSERCONFIG 0x5488
#define VKI_TIOCSERGWILD 0x5489
#define VKI_TIOCSERSWILD 0x548a
#define VKI_TIOCGLCKTRMIOS 0x548b
#define VKI_TIOCSLCKTRMIOS 0x548c
#define VKI_TIOCSERGSTRUCT 0x548d /* For debugging only */
#define VKI_TIOCSERGETLSR 0x548e /* Get line status register */
#define VKI_TIOCSERGETMULTI 0x548f /* Get multiport config */
#define VKI_TIOCSERSETMULTI 0x5490 /* Set multiport config */
#define VKI_TIOCMIWAIT 0x5491 /* wait for a change on serial input line(s) */
#define VKI_TIOCGICOUNT 0x5492 /* read serial port inline interrupt counts */
#define VKI_TIOCGHAYESESP 0x5493 /* Get Hayes ESP configuration */
#define VKI_TIOCSHAYESESP 0x5494 /* Set Hayes ESP configuration */
//----------------------------------------------------------------------
// From asm-generic/poll.h
//----------------------------------------------------------------------
/* These are specified by iBCS2 */
#define VKI_POLLIN 0x0001
struct vki_pollfd {
int fd;
short events;
short revents;
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/elf.h
//----------------------------------------------------------------------
#define VKI_ELF_NGREG 45 /* includes nip, msr, lr, etc. */
#define VKI_ELF_NFPREG 33 /* includes fpscr */
typedef unsigned long vki_elf_greg_t;
typedef vki_elf_greg_t vki_elf_gregset_t[VKI_ELF_NGREG];
typedef double vki_elf_fpreg_t;
typedef vki_elf_fpreg_t vki_elf_fpregset_t[VKI_ELF_NFPREG];
typedef struct vki_user_fxsr_struct vki_elf_fpxregset_t;
#define VKI_AT_SYSINFO 32
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/ucontext.h
//----------------------------------------------------------------------
struct vki_ucontext {
unsigned long uc_flags;
struct vki_ucontext *uc_link;
vki_stack_t uc_stack;
struct vki_sigcontext uc_mcontext;
vki_sigset_t uc_sigmask; /* mask last for extensibility */
};
// CAB: TODO
typedef void vki_modify_ldt_t;
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/ipcbuf.h
//----------------------------------------------------------------------
struct vki_ipc64_perm
{
__vki_kernel_key_t key;
__vki_kernel_uid_t uid;
__vki_kernel_gid_t gid;
__vki_kernel_uid_t cuid;
__vki_kernel_gid_t cgid;
__vki_kernel_mode_t mode;
unsigned short seq;
unsigned short __pad1;
unsigned long __unused1;
unsigned long __unused2;
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/sembuf.h
//----------------------------------------------------------------------
struct vki_semid64_ds {
struct vki_ipc64_perm sem_perm; /* permissions .. see ipc.h */
__vki_kernel_time_t sem_otime; /* last semop time */
__vki_kernel_time_t sem_ctime; /* last change time */
unsigned long sem_nsems; /* no. of semaphores in array */
unsigned long __unused1;
unsigned long __unused2;
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/msgbuf.h
//----------------------------------------------------------------------
struct vki_msqid64_ds {
struct vki_ipc64_perm msg_perm;
__vki_kernel_time_t msg_stime; /* last msgsnd time */
unsigned long __unused1;
__vki_kernel_time_t msg_rtime; /* last msgrcv time */
unsigned long __unused2;
__vki_kernel_time_t msg_ctime; /* last change time */
unsigned long __unused3;
unsigned long msg_cbytes; /* current number of bytes on queue */
unsigned long msg_qnum; /* number of messages in queue */
unsigned long msg_qbytes; /* max number of bytes on queue */
__vki_kernel_pid_t msg_lspid; /* pid of last msgsnd */
__vki_kernel_pid_t msg_lrpid; /* last receive pid */
unsigned long __unused4;
unsigned long __unused5;
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/ipc.h
//----------------------------------------------------------------------
struct vki_ipc_kludge {
struct vki_msgbuf __user *msgp;
long msgtyp;
};
#define VKI_SEMOP 1
#define VKI_SEMGET 2
#define VKI_SEMCTL 3
#define VKI_SEMTIMEDOP 4
#define VKI_MSGSND 11
#define VKI_MSGRCV 12
#define VKI_MSGGET 13
#define VKI_MSGCTL 14
#define VKI_SHMAT 21
#define VKI_SHMDT 22
#define VKI_SHMGET 23
#define VKI_SHMCTL 24
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/shmbuf.h
//----------------------------------------------------------------------
struct vki_shmid64_ds {
struct vki_ipc64_perm shm_perm; /* operation perms */
vki_size_t shm_segsz; /* size of segment (bytes) */
__vki_kernel_time_t shm_atime; /* last attach time */
__vki_kernel_time_t shm_dtime; /* last detach time */
__vki_kernel_time_t shm_ctime; /* last change time */
__vki_kernel_pid_t shm_cpid; /* pid of creator */
__vki_kernel_pid_t shm_lpid; /* pid of last operator */
unsigned long shm_nattch; /* no. of current attaches */
unsigned long __unused1;
unsigned long __unused2;
};
struct vki_shminfo64 {
unsigned long shmmax;
unsigned long shmmin;
unsigned long shmmni;
unsigned long shmseg;
unsigned long shmall;
unsigned long __unused1;
unsigned long __unused2;
unsigned long __unused3;
unsigned long __unused4;
};
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/ptrace.h
//----------------------------------------------------------------------
struct vki_pt_regs {
#ifdef CONFIG_32BIT
/* Pad bytes for argument save space on the stack. */
unsigned long pad0[6];
#endif
/* Saved main processor registers. */
unsigned long regs[32];
/* Saved special registers. */
unsigned long cp0_status;
unsigned long hi;
unsigned long lo;
#ifdef CONFIG_CPU_HAS_SMARTMIPS
unsigned long acx;
#endif
unsigned long cp0_badvaddr;
unsigned long cp0_cause;
unsigned long cp0_epc;
#ifdef CONFIG_MIPS_MT_SMTC
unsigned long cp0_tcstatus;
#endif /* CONFIG_MIPS_MT_SMTC */
#ifdef CONFIG_CPU_CAVIUM_OCTEON
unsigned long long mpl[3]; /* MTM{0,1,2} */
unsigned long long mtp[3]; /* MTP{0,1,2} */
#endif
} __attribute__ ((aligned (8)));
#define vki_user_regs_struct vki_pt_regs
#define MIPS_lo lo
#define MIPS_hi hi
//#define MIPS_pc regs[32]
#define MIPS_r31 regs[31]
#define MIPS_r30 regs[30]
#define MIPS_r29 regs[29]
#define MIPS_r28 regs[28]
#define MIPS_r27 regs[27]
#define MIPS_r26 regs[26]
#define MIPS_r25 regs[25]
#define MIPS_r24 regs[24]
#define MIPS_r23 regs[23]
#define MIPS_r22 regs[22]
#define MIPS_r21 regs[21]
#define MIPS_r20 regs[20]
#define MIPS_r19 regs[19]
#define MIPS_r18 regs[18]
#define MIPS_r17 regs[17]
#define MIPS_r16 regs[16]
#define MIPS_r15 regs[15]
#define MIPS_r14 regs[14]
#define MIPS_r13 regs[13]
#define MIPS_r12 regs[12]
#define MIPS_r11 regs[11]
#define MIPS_r10 regs[10]
#define MIPS_r9 regs[9]
#define MIPS_r8 regs[8]
#define MIPS_r7 regs[7]
#define MIPS_r6 regs[6]
#define MIPS_r5 regs[5]
#define MIPS_r4 regs[4]
#define MIPS_r3 regs[3]
#define MIPS_r2 regs[2]
#define MIPS_r1 regs[1]
#define MIPS_r0 regs[0]
#define VKI_PTRACE_GETREGS 12
#define VKI_PTRACE_SETREGS 13
#define VKI_PTRACE_GETFPREGS 14
#define VKI_PTRACE_SETFPREGS 15
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-generic/siginfo.h
//----------------------------------------------------------------------
#define HAVE_ARCH_SIGINFO_T
typedef union vki_sigval {
int sival_int;
void __user *sival_ptr;
} vki_sigval_t;
#ifndef __VKI_ARCH_SI_PREAMBLE_SIZE
#define __VKI_ARCH_SI_PREAMBLE_SIZE (3 * sizeof(int))
#endif
#define VKI_SI_MAX_SIZE 128
#ifndef VKI_SI_PAD_SIZE
#define VKI_SI_PAD_SIZE ((VKI_SI_MAX_SIZE - __VKI_ARCH_SI_PREAMBLE_SIZE) / sizeof(int))
#endif
#ifndef __VKI_ARCH_SI_UID_T
#define __VKI_ARCH_SI_UID_T vki_uid_t
#endif
#ifndef __VKI_ARCH_SI_BAND_T
#define __VKI_ARCH_SI_BAND_T long
#endif
typedef struct vki_siginfo {
int si_signo;
int si_code;
int si_errno;
int __pad0[VKI_SI_MAX_SIZE / sizeof(int) - VKI_SI_PAD_SIZE - 3];
union {
int _pad[VKI_SI_PAD_SIZE];
/* kill() */
struct {
vki_pid_t _pid; /* sender's pid */
__VKI_ARCH_SI_UID_T _uid; /* sender's uid */
} _kill;
/* POSIX.1b timers */
struct {
vki_timer_t _tid; /* timer id */
int _overrun; /* overrun count */
char _pad[sizeof( __VKI_ARCH_SI_UID_T) - sizeof(int)];
vki_sigval_t _sigval; /* same as below */
int _sys_private; /* not to be passed to user */
} _timer;
/* POSIX.1b signals */
struct {
vki_pid_t _pid; /* sender's pid */
__VKI_ARCH_SI_UID_T _uid; /* sender's uid */
vki_sigval_t _sigval;
} _rt;
/* SIGCHLD */
struct {
vki_pid_t _pid; /* which child */
__VKI_ARCH_SI_UID_T _uid; /* sender's uid */
int _status; /* exit code */
vki_clock_t _utime;
vki_clock_t _stime;
} _sigchld;
/* IRIX SIGCHLD */
struct {
vki_pid_t _pid; /* which child */
vki_clock_t _utime;
int _status; /* exit code */
vki_clock_t _stime;
} _irix_sigchld;
/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
struct {
void __user *_addr; /* faulting insn/memory ref. */
#ifdef __ARCH_SI_TRAPNO
int _trapno; /* TRAP # which caused the signal */
#endif
} _sigfault;
/* SIGPOLL, SIGXFSZ (To do ...) */
struct {
__VKI_ARCH_SI_BAND_T _band; /* POLL_IN, POLL_OUT, POLL_MSG */
int _fd;
} _sigpoll;
} _sifields;
} vki_siginfo_t;
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm/break.h
//----------------------------------------------------------------------
#define VKI_BRK_OVERFLOW 6 /* Overflow check */
#define VKI_BRK_DIVZERO 7 /* Divide by zero check */
#endif // __VKI_MIPS32_LINUX_H
/*--------------------------------------------------------------------*/
/*--- end vki-mips32-linux.h ---*/
/*--------------------------------------------------------------------*/

68
include/vki/vki-posixtypes-mips32-linux.h Normal file
View File

@ -0,0 +1,68 @@
/*--------------------------------------------------------------------*/
/*--- mips/Linux-specific kernel interface: posix types. ---*/
/*--- vki-posixtypes-mips32-linux.h ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2010-2012 RT-RK
mips-valgrind@rt-rk.com
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#ifndef __VKI_POSIXTYPES_MIPS32_LINUX_H
#define __VKI_POSIXTYPES_MIPS32_LINUX_H
//----------------------------------------------------------------------
// From linux-2.6.35.5/include/asm-mips/posix_types.h
//----------------------------------------------------------------------
typedef unsigned int __vki_kernel_mode_t;
typedef long __vki_kernel_off_t;
typedef int __vki_kernel_pid_t;
typedef int __vki_kernel_ipc_pid_t;
typedef unsigned int __vki_kernel_uid_t;
typedef unsigned int __vki_kernel_gid_t;
typedef unsigned int __vki_kernel_size_t;
typedef long __vki_kernel_time_t;
typedef long __vki_kernel_suseconds_t;
typedef long __vki_kernel_clock_t;
typedef int __vki_kernel_timer_t;
typedef int __vki_kernel_clockid_t;
typedef char * __vki_kernel_caddr_t;
typedef unsigned int __vki_kernel_uid32_t;
typedef unsigned int __vki_kernel_gid32_t;
typedef unsigned int __vki_kernel_old_uid_t;
typedef unsigned int __vki_kernel_old_gid_t;
typedef long long __vki_kernel_loff_t;
typedef struct {
int val[2];
} __vki_kernel_fsid_t;
#endif // __VKI_POSIXTYPES_MIPS32_LINUX_H
/*--------------------------------------------------------------------*/
/*--- end vki-posixtypes-mips32-linux.h ---*/
/*--------------------------------------------------------------------*/

390
include/vki/vki-scnums-mips32-linux.h Normal file
View File

@ -0,0 +1,390 @@
/*--------------------------------------------------------------------*/
/*--- System call numbers for mips32-linux. ---*/
/*--- vki-scnums-mips32-linux.h ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2010-2012 RT-RK
mips-valgrind@rt-rk.com
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#ifndef __VKI_SCNUMS_MIPS32_LINUX_H
#define __VKI_SCNUMS_MIPS32_LINUX_H
// From linux-2.6.35.5/include/asm-mips/unistd.h
/*
* Linux o32 style syscalls are in the range from 4000 to 4999.
*/
#define __NR_Linux 4000
#define __NR_syscall (__NR_Linux + 0)
#define __NR_exit (__NR_Linux + 1)
#define __NR_fork (__NR_Linux + 2)
#define __NR_read (__NR_Linux + 3)
#define __NR_write (__NR_Linux + 4)
#define __NR_open (__NR_Linux + 5)
#define __NR_close (__NR_Linux + 6)
#define __NR_waitpid (__NR_Linux + 7)
#define __NR_creat (__NR_Linux + 8)
#define __NR_link (__NR_Linux + 9)
#define __NR_unlink (__NR_Linux + 10)
#define __NR_execve (__NR_Linux + 11)
#define __NR_chdir (__NR_Linux + 12)
#define __NR_time (__NR_Linux + 13)
#define __NR_mknod (__NR_Linux + 14)
#define __NR_chmod (__NR_Linux + 15)
#define __NR_lchown (__NR_Linux + 16)
#define __NR_break (__NR_Linux + 17)
#define __NR_unused18 (__NR_Linux + 18)
#define __NR_lseek (__NR_Linux + 19)
#define __NR_getpid (__NR_Linux + 20)
#define __NR_mount (__NR_Linux + 21)
#define __NR_umount (__NR_Linux + 22)
#define __NR_setuid (__NR_Linux + 23)
#define __NR_getuid (__NR_Linux + 24)
#define __NR_stime (__NR_Linux + 25)
#define __NR_ptrace (__NR_Linux + 26)
#define __NR_alarm (__NR_Linux + 27)
#define __NR_unused28 (__NR_Linux + 28)
#define __NR_pause (__NR_Linux + 29)
#define __NR_utime (__NR_Linux + 30)
#define __NR_stty (__NR_Linux + 31)
#define __NR_gtty (__NR_Linux + 32)
#define __NR_access (__NR_Linux + 33)
#define __NR_nice (__NR_Linux + 34)
#define __NR_ftime (__NR_Linux + 35)
#define __NR_sync (__NR_Linux + 36)
#define __NR_kill (__NR_Linux + 37)
#define __NR_rename (__NR_Linux + 38)
#define __NR_mkdir (__NR_Linux + 39)
#define __NR_rmdir (__NR_Linux + 40)
#define __NR_dup (__NR_Linux + 41)
#define __NR_pipe (__NR_Linux + 42)
#define __NR_times (__NR_Linux + 43)
#define __NR_prof (__NR_Linux + 44)
#define __NR_brk (__NR_Linux + 45)
#define __NR_setgid (__NR_Linux + 46)
#define __NR_getgid (__NR_Linux + 47)
#define __NR_signal (__NR_Linux + 48)
#define __NR_geteuid (__NR_Linux + 49)
#define __NR_getegid (__NR_Linux + 50)
#define __NR_acct (__NR_Linux + 51)
#define __NR_umount2 (__NR_Linux + 52)
#define __NR_lock (__NR_Linux + 53)
#define __NR_ioctl (__NR_Linux + 54)
#define __NR_fcntl (__NR_Linux + 55)
#define __NR_mpx (__NR_Linux + 56)
#define __NR_setpgid (__NR_Linux + 57)
#define __NR_ulimit (__NR_Linux + 58)
#define __NR_unused59 (__NR_Linux + 59)
#define __NR_umask (__NR_Linux + 60)
#define __NR_chroot (__NR_Linux + 61)
#define __NR_ustat (__NR_Linux + 62)
#define __NR_dup2 (__NR_Linux + 63)
#define __NR_getppid (__NR_Linux + 64)
#define __NR_getpgrp (__NR_Linux + 65)
#define __NR_setsid (__NR_Linux + 66)
#define __NR_sigaction (__NR_Linux + 67)
#define __NR_sgetmask (__NR_Linux + 68)
#define __NR_ssetmask (__NR_Linux + 69)
#define __NR_setreuid (__NR_Linux + 70)
#define __NR_setregid (__NR_Linux + 71)
#define __NR_sigsuspend (__NR_Linux + 72)
#define __NR_sigpending (__NR_Linux + 73)
#define __NR_sethostname (__NR_Linux + 74)
#define __NR_setrlimit (__NR_Linux + 75)
#define __NR_getrlimit (__NR_Linux + 76)
#define __NR_getrusage (__NR_Linux + 77)
#define __NR_gettimeofday (__NR_Linux + 78)
#define __NR_settimeofday (__NR_Linux + 79)
#define __NR_getgroups (__NR_Linux + 80)
#define __NR_setgroups (__NR_Linux + 81)
#define __NR_reserved82 (__NR_Linux + 82)
#define __NR_symlink (__NR_Linux + 83)
#define __NR_unused84 (__NR_Linux + 84)
#define __NR_readlink (__NR_Linux + 85)
#define __NR_uselib (__NR_Linux + 86)
#define __NR_swapon (__NR_Linux + 87)
#define __NR_reboot (__NR_Linux + 88)
#define __NR_readdir (__NR_Linux + 89)
#define __NR_mmap (__NR_Linux + 90)
#define __NR_munmap (__NR_Linux + 91)
#define __NR_truncate (__NR_Linux + 92)
#define __NR_ftruncate (__NR_Linux + 93)
#define __NR_fchmod (__NR_Linux + 94)
#define __NR_fchown (__NR_Linux + 95)
#define __NR_getpriority (__NR_Linux + 96)
#define __NR_setpriority (__NR_Linux + 97)
#define __NR_profil (__NR_Linux + 98)
#define __NR_statfs (__NR_Linux + 99)
#define __NR_fstatfs (__NR_Linux + 100)
#define __NR_ioperm (__NR_Linux + 101)
#define __NR_socketcall (__NR_Linux + 102)
#define __NR_syslog (__NR_Linux + 103)
#define __NR_setitimer (__NR_Linux + 104)
#define __NR_getitimer (__NR_Linux + 105)
#define __NR_stat (__NR_Linux + 106)
#define __NR_lstat (__NR_Linux + 107)
#define __NR_fstat (__NR_Linux + 108)
#define __NR_unused109 (__NR_Linux + 109)
#define __NR_iopl (__NR_Linux + 110)
#define __NR_vhangup (__NR_Linux + 111)
#define __NR_idle (__NR_Linux + 112)
#define __NR_vm86 (__NR_Linux + 113)
#define __NR_wait4 (__NR_Linux + 114)
#define __NR_swapoff (__NR_Linux + 115)
#define __NR_sysinfo (__NR_Linux + 116)
#define __NR_ipc (__NR_Linux + 117)
#define __NR_fsync (__NR_Linux + 118)
#define __NR_sigreturn (__NR_Linux + 119)
#define __NR_clone (__NR_Linux + 120)
#define __NR_setdomainname (__NR_Linux + 121)
#define __NR_uname (__NR_Linux + 122)
#define __NR_modify_ldt (__NR_Linux + 123)
#define __NR_adjtimex (__NR_Linux + 124)
#define __NR_mprotect (__NR_Linux + 125)
#define __NR_sigprocmask (__NR_Linux + 126)
#define __NR_create_module (__NR_Linux + 127)
#define __NR_init_module (__NR_Linux + 128)
#define __NR_delete_module (__NR_Linux + 129)
#define __NR_get_kernel_syms (__NR_Linux + 130)
#define __NR_quotactl (__NR_Linux + 131)
#define __NR_getpgid (__NR_Linux + 132)
#define __NR_fchdir (__NR_Linux + 133)
#define __NR_bdflush (__NR_Linux + 134)
#define __NR_sysfs (__NR_Linux + 135)
#define __NR_personality (__NR_Linux + 136)
#define __NR_afs_syscall (__NR_Linux + 137)
#define __NR_setfsuid (__NR_Linux + 138)
#define __NR_setfsgid (__NR_Linux + 139)
#define __NR__llseek (__NR_Linux + 140)
#define __NR_getdents (__NR_Linux + 141)
#define __NR__newselect (__NR_Linux + 142)
#define __NR_flock (__NR_Linux + 143)
#define __NR_msync (__NR_Linux + 144)
#define __NR_readv (__NR_Linux + 145)
#define __NR_writev (__NR_Linux + 146)
#define __NR_cacheflush (__NR_Linux + 147)
#define __NR_cachectl (__NR_Linux + 148)
#define __NR_sysmips (__NR_Linux + 149)
#define __NR_unused150 (__NR_Linux + 150)
#define __NR_getsid (__NR_Linux + 151)
#define __NR_fdatasync (__NR_Linux + 152)
#define __NR__sysctl (__NR_Linux + 153)
#define __NR_mlock (__NR_Linux + 154)
#define __NR_munlock (__NR_Linux + 155)
#define __NR_mlockall (__NR_Linux + 156)
#define __NR_munlockall (__NR_Linux + 157)
#define __NR_sched_setparam (__NR_Linux + 158)
#define __NR_sched_getparam (__NR_Linux + 159)
#define __NR_sched_setscheduler (__NR_Linux + 160)
#define __NR_sched_getscheduler (__NR_Linux + 161)
#define __NR_sched_yield (__NR_Linux + 162)
#define __NR_sched_get_priority_max (__NR_Linux + 163)
#define __NR_sched_get_priority_min (__NR_Linux + 164)
#define __NR_sched_rr_get_interval (__NR_Linux + 165)
#define __NR_nanosleep (__NR_Linux + 166)
#define __NR_mremap (__NR_Linux + 167)
#define __NR_accept (__NR_Linux + 168)
#define __NR_bind (__NR_Linux + 169)
#define __NR_connect (__NR_Linux + 170)
#define __NR_getpeername (__NR_Linux + 171)
#define __NR_getsockname (__NR_Linux + 172)
#define __NR_getsockopt (__NR_Linux + 173)
#define __NR_listen (__NR_Linux + 174)
#define __NR_recv (__NR_Linux + 175)
#define __NR_recvfrom (__NR_Linux + 176)
#define __NR_recvmsg (__NR_Linux + 177)
#define __NR_send (__NR_Linux + 178)
#define __NR_sendmsg (__NR_Linux + 179)
#define __NR_sendto (__NR_Linux + 180)
#define __NR_setsockopt (__NR_Linux + 181)
#define __NR_shutdown (__NR_Linux + 182)
#define __NR_socket (__NR_Linux + 183)
#define __NR_socketpair (__NR_Linux + 184)
#define __NR_setresuid (__NR_Linux + 185)
#define __NR_getresuid (__NR_Linux + 186)
#define __NR_query_module (__NR_Linux + 187)
#define __NR_poll (__NR_Linux + 188)
#define __NR_nfsservctl (__NR_Linux + 189)
#define __NR_setresgid (__NR_Linux + 190)
#define __NR_getresgid (__NR_Linux + 191)
#define __NR_prctl (__NR_Linux + 192)
#define __NR_rt_sigreturn (__NR_Linux + 193)
#define __NR_rt_sigaction (__NR_Linux + 194)
#define __NR_rt_sigprocmask (__NR_Linux + 195)
#define __NR_rt_sigpending (__NR_Linux + 196)
#define __NR_rt_sigtimedwait (__NR_Linux + 197)
#define __NR_rt_sigqueueinfo (__NR_Linux + 198)
#define __NR_rt_sigsuspend (__NR_Linux + 199)
#define __NR_pread64 (__NR_Linux + 200)
#define __NR_pwrite64 (__NR_Linux + 201)
#define __NR_chown (__NR_Linux + 202)
#define __NR_getcwd (__NR_Linux + 203)
#define __NR_capget (__NR_Linux + 204)
#define __NR_capset (__NR_Linux + 205)
#define __NR_sigaltstack (__NR_Linux + 206)
#define __NR_sendfile (__NR_Linux + 207)
#define __NR_getpmsg (__NR_Linux + 208)
#define __NR_putpmsg (__NR_Linux + 209)
#define __NR_mmap2 (__NR_Linux + 210)
#define __NR_truncate64 (__NR_Linux + 211)
#define __NR_ftruncate64 (__NR_Linux + 212)
#define __NR_stat64 (__NR_Linux + 213)
#define __NR_lstat64 (__NR_Linux + 214)
#define __NR_fstat64 (__NR_Linux + 215)
#define __NR_pivot_root (__NR_Linux + 216)
#define __NR_mincore (__NR_Linux + 217)
#define __NR_madvise (__NR_Linux + 218)
#define __NR_getdents64 (__NR_Linux + 219)
#define __NR_fcntl64 (__NR_Linux + 220)
#define __NR_reserved221 (__NR_Linux + 221)
#define __NR_gettid (__NR_Linux + 222)
#define __NR_readahead (__NR_Linux + 223)
#define __NR_setxattr (__NR_Linux + 224)
#define __NR_lsetxattr (__NR_Linux + 225)
#define __NR_fsetxattr (__NR_Linux + 226)
#define __NR_getxattr (__NR_Linux + 227)
#define __NR_lgetxattr (__NR_Linux + 228)
#define __NR_fgetxattr (__NR_Linux + 229)
#define __NR_listxattr (__NR_Linux + 230)
#define __NR_llistxattr (__NR_Linux + 231)
#define __NR_flistxattr (__NR_Linux + 232)
#define __NR_removexattr (__NR_Linux + 233)
#define __NR_lremovexattr (__NR_Linux + 234)
#define __NR_fremovexattr (__NR_Linux + 235)
#define __NR_tkill (__NR_Linux + 236)
#define __NR_sendfile64 (__NR_Linux + 237)
#define __NR_futex (__NR_Linux + 238)
#define __NR_sched_setaffinity (__NR_Linux + 239)
#define __NR_sched_getaffinity (__NR_Linux + 240)
#define __NR_io_setup (__NR_Linux + 241)
#define __NR_io_destroy (__NR_Linux + 242)
#define __NR_io_getevents (__NR_Linux + 243)
#define __NR_io_submit (__NR_Linux + 244)
#define __NR_io_cancel (__NR_Linux + 245)
#define __NR_exit_group (__NR_Linux + 246)
#define __NR_lookup_dcookie (__NR_Linux + 247)
#define __NR_epoll_create (__NR_Linux + 248)
#define __NR_epoll_ctl (__NR_Linux + 249)
#define __NR_epoll_wait (__NR_Linux + 250)
#define __NR_remap_file_pages (__NR_Linux + 251)
#define __NR_set_tid_address (__NR_Linux + 252)
#define __NR_restart_syscall (__NR_Linux + 253)
#define __NR_fadvise64 (__NR_Linux + 254)
#define __NR_statfs64 (__NR_Linux + 255)
#define __NR_fstatfs64 (__NR_Linux + 256)
#define __NR_timer_create (__NR_Linux + 257)
#define __NR_timer_settime (__NR_Linux + 258)
#define __NR_timer_gettime (__NR_Linux + 259)
#define __NR_timer_getoverrun (__NR_Linux + 260)
#define __NR_timer_delete (__NR_Linux + 261)
#define __NR_clock_settime (__NR_Linux + 262)
#define __NR_clock_gettime (__NR_Linux + 263)
#define __NR_clock_getres (__NR_Linux + 264)
#define __NR_clock_nanosleep (__NR_Linux + 265)
#define __NR_tgkill (__NR_Linux + 266)
#define __NR_utimes (__NR_Linux + 267)
#define __NR_mbind (__NR_Linux + 268)
#define __NR_get_mempolicy (__NR_Linux + 269)
#define __NR_set_mempolicy (__NR_Linux + 270)
#define __NR_mq_open (__NR_Linux + 271)
#define __NR_mq_unlink (__NR_Linux + 272)
#define __NR_mq_timedsend (__NR_Linux + 273)
#define __NR_mq_timedreceive (__NR_Linux + 274)
#define __NR_mq_notify (__NR_Linux + 275)
#define __NR_mq_getsetattr (__NR_Linux + 276)
#define __NR_vserver (__NR_Linux + 277)
#define __NR_waitid (__NR_Linux + 278)
/* #define __NR_sys_setaltroot (__NR_Linux + 279) */
#define __NR_add_key (__NR_Linux + 280)
#define __NR_request_key (__NR_Linux + 281)
#define __NR_keyctl (__NR_Linux + 282)
#define __NR_set_thread_area (__NR_Linux + 283)
#define __NR_inotify_init (__NR_Linux + 284)
#define __NR_inotify_add_watch (__NR_Linux + 285)
#define __NR_inotify_rm_watch (__NR_Linux + 286)
#define __NR_migrate_pages (__NR_Linux + 287)
#define __NR_openat (__NR_Linux + 288)
#define __NR_mkdirat (__NR_Linux + 289)
#define __NR_mknodat (__NR_Linux + 290)
#define __NR_fchownat (__NR_Linux + 291)
#define __NR_futimesat (__NR_Linux + 292)
#define __NR_fstatat64 (__NR_Linux + 293)
#define __NR_unlinkat (__NR_Linux + 294)
#define __NR_renameat (__NR_Linux + 295)
#define __NR_linkat (__NR_Linux + 296)
#define __NR_symlinkat (__NR_Linux + 297)
#define __NR_readlinkat (__NR_Linux + 298)
#define __NR_fchmodat (__NR_Linux + 299)
#define __NR_faccessat (__NR_Linux + 300)
#define __NR_pselect6 (__NR_Linux + 301)
#define __NR_ppoll (__NR_Linux + 302)
#define __NR_unshare (__NR_Linux + 303)
#define __NR_splice (__NR_Linux + 304)
#define __NR_sync_file_range (__NR_Linux + 305)
#define __NR_tee (__NR_Linux + 306)
#define __NR_vmsplice (__NR_Linux + 307)
#define __NR_move_pages (__NR_Linux + 308)
#define __NR_set_robust_list (__NR_Linux + 309)
#define __NR_get_robust_list (__NR_Linux + 310)
#define __NR_kexec_load (__NR_Linux + 311)
#define __NR_getcpu (__NR_Linux + 312)
#define __NR_epoll_pwait (__NR_Linux + 313)
#define __NR_ioprio_set (__NR_Linux + 314)
#define __NR_ioprio_get (__NR_Linux + 315)
#define __NR_utimensat (__NR_Linux + 316)
#define __NR_signalfd (__NR_Linux + 317)
#define __NR_timerfd (__NR_Linux + 318)
#define __NR_eventfd (__NR_Linux + 319)
#define __NR_fallocate (__NR_Linux + 320)
#define __NR_timerfd_create (__NR_Linux + 321)
#define __NR_timerfd_gettime (__NR_Linux + 322)
#define __NR_timerfd_settime (__NR_Linux + 323)
#define __NR_signalfd4 (__NR_Linux + 324)
#define __NR_eventfd2 (__NR_Linux + 325)
#define __NR_epoll_create1 (__NR_Linux + 326)
#define __NR_dup3 (__NR_Linux + 327)
#define __NR_pipe2 (__NR_Linux + 328)
#define __NR_inotify_init1 (__NR_Linux + 329)
#define __NR_preadv (__NR_Linux + 330)
#define __NR_pwritev (__NR_Linux + 331)
#define __NR_rt_tgsigqueueinfo (__NR_Linux + 332)
#define __NR_perf_event_open (__NR_Linux + 333)
#define __NR_accept4 (__NR_Linux + 334)
/*
* Offset of the last Linux o32 flavoured syscall
*/
#define __NR_Linux_syscalls 334
#define __NR_O32_Linux 4000
#define __NR_O32_Linux_syscalls 334
#endif /* __VKI_SCNUMS_MIPS32_LINUX_H */
/*--------------------------------------------------------------------*/
/*--- end vki-scnums-mips32-linux.h ---*/
/*--------------------------------------------------------------------*/