552 lines
9.8 KiB
C
552 lines
9.8 KiB
C
/* This testcase is part of GDB, the GNU debugger.
|
|
|
|
Copyright 2015-2016 Free Software Foundation, Inc.
|
|
|
|
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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
typedef void (*testcase_ftype)(void);
|
|
|
|
/* Each function checks the correctness of the instruction being
|
|
relocated due to a fast tracepoint. Call function pass if it is
|
|
correct, otherwise call function fail. GDB sets a breakpoints on
|
|
pass and fail in order to check the correctness. */
|
|
|
|
static void
|
|
pass (void)
|
|
{
|
|
}
|
|
|
|
static void
|
|
fail (void)
|
|
{
|
|
}
|
|
|
|
#if (defined __x86_64__ || defined __i386__)
|
|
|
|
#ifdef SYMBOL_PREFIX
|
|
#define SYMBOL(str) SYMBOL_PREFIX #str
|
|
#else
|
|
#define SYMBOL(str) #str
|
|
#endif
|
|
|
|
/* Make sure we can relocate a CALL instruction. CALL instructions are
|
|
5 bytes long so we can always set a fast tracepoints on them.
|
|
|
|
JMP set_point0
|
|
f:
|
|
MOV $1, %[ok]
|
|
JMP end
|
|
set_point0:
|
|
CALL f ; tracepoint here.
|
|
end:
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_call (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" .global " SYMBOL (set_point0) "\n"
|
|
" jmp " SYMBOL (set_point0) "\n"
|
|
"0:\n"
|
|
" mov $1, %[ok]\n"
|
|
" jmp 1f\n"
|
|
SYMBOL (set_point0) ":\n"
|
|
" call 0b\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok));
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate a JMP instruction. We need the JMP
|
|
instruction to be 5 bytes long in order to set a fast tracepoint on
|
|
it. To do this, we emit the opcode directly.
|
|
|
|
JMP next ; tracepoint here.
|
|
next:
|
|
MOV $1, %[ok]
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_jump (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" .global " SYMBOL (set_point1) "\n"
|
|
SYMBOL (set_point1) ":\n"
|
|
".byte 0xe9\n" /* jmp */
|
|
".byte 0x00\n"
|
|
".byte 0x00\n"
|
|
".byte 0x00\n"
|
|
".byte 0x00\n"
|
|
" mov $1, %[ok]\n"
|
|
: [ok] "=r" (ok));
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
#elif (defined __aarch64__)
|
|
|
|
/* Make sure we can relocate a B instruction.
|
|
|
|
B set_point0
|
|
set_ok:
|
|
MOV %[ok], #1
|
|
B end
|
|
set_point0:
|
|
B set_ok ; tracepoint here.
|
|
MOV %[ok], #0
|
|
end
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_b (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" b set_point0\n"
|
|
"0:\n"
|
|
" mov %[ok], #1\n"
|
|
" b 1f\n"
|
|
"set_point0:\n"
|
|
" b 0b\n"
|
|
" mov %[ok], #0\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok));
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate a B.cond instruction.
|
|
|
|
MOV x0, #8
|
|
TST x0, #8 ; Clear the Z flag.
|
|
B set_point1
|
|
set_ok:
|
|
MOV %[ok], #1
|
|
B end
|
|
set_point1:
|
|
B.NE set_ok ; tracepoint here.
|
|
MOV %[ok], #0
|
|
end
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_bcond_true (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" mov x0, #8\n"
|
|
" tst x0, #8\n"
|
|
" b set_point1\n"
|
|
"0:\n"
|
|
" mov %[ok], #1\n"
|
|
" b 1f\n"
|
|
"set_point1:\n"
|
|
" b.ne 0b\n"
|
|
" mov %[ok], #0\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok)
|
|
:
|
|
: "0", "cc");
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate a CBZ instruction.
|
|
|
|
MOV x0, #0
|
|
B set_point2
|
|
set_ok:
|
|
MOV %[ok], #1
|
|
B end
|
|
set_point2:
|
|
CBZ x0, set_ok ; tracepoint here.
|
|
MOV %[ok], #0
|
|
end
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_cbz (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" mov x0, #0\n"
|
|
" b set_point2\n"
|
|
"0:\n"
|
|
" mov %[ok], #1\n"
|
|
" b 1f\n"
|
|
"set_point2:\n"
|
|
" cbz x0, 0b\n"
|
|
" mov %[ok], #0\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok)
|
|
:
|
|
: "0");
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate a CBNZ instruction.
|
|
|
|
MOV x0, #8
|
|
B set_point3
|
|
set_ok:
|
|
MOV %[ok], #1
|
|
B end
|
|
set_point3:
|
|
CBNZ x0, set_ok ; tracepoint here.
|
|
MOV %[ok], #0
|
|
end
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_cbnz (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" mov x0, #8\n"
|
|
" b set_point3\n"
|
|
"0:\n"
|
|
" mov %[ok], #1\n"
|
|
" b 1f\n"
|
|
"set_point3:\n"
|
|
" cbnz x0, 0b\n"
|
|
" mov %[ok], #0\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok)
|
|
:
|
|
: "0");
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate a TBZ instruction.
|
|
|
|
MOV x0, #8
|
|
MVN x0, x0 ; Clear bit 3.
|
|
B set_point4
|
|
set_ok:
|
|
MOV %[ok], #1
|
|
B end
|
|
set_point4:
|
|
TBZ x0, #3, set_ok ; tracepoint here.
|
|
MOV %[ok], #0
|
|
end
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_tbz (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" mov x0, #8\n"
|
|
" mvn x0, x0\n"
|
|
" b set_point4\n"
|
|
"0:\n"
|
|
" mov %[ok], #1\n"
|
|
" b 1f\n"
|
|
"set_point4:\n"
|
|
" tbz x0, #3, 0b\n"
|
|
" mov %[ok], #0\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok)
|
|
:
|
|
: "0");
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate a TBNZ instruction.
|
|
|
|
MOV x0, #8 ; Set bit 3.
|
|
B set_point5
|
|
set_ok:
|
|
MOV %[ok], #1
|
|
B end
|
|
set_point5:
|
|
TBNZ x0, #3, set_ok ; tracepoint here.
|
|
MOV %[ok], #0
|
|
end
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_tbnz (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" mov x0, #8\n"
|
|
" b set_point5\n"
|
|
"0:\n"
|
|
" mov %[ok], #1\n"
|
|
" b 1f\n"
|
|
"set_point5:\n"
|
|
" tbnz x0, #3, 0b\n"
|
|
" mov %[ok], #0\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok)
|
|
:
|
|
: "0");
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate an ADR instruction with a positive offset.
|
|
|
|
set_point6:
|
|
ADR x0, target ; tracepoint here.
|
|
BR x0 ; jump to target
|
|
MOV %[ok], #0
|
|
B end
|
|
target:
|
|
MOV %[ok], #1
|
|
end
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_adr_forward (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm ("set_point6:\n"
|
|
" adr x0, 0f\n"
|
|
" br x0\n"
|
|
" mov %[ok], #0\n"
|
|
" b 1f\n"
|
|
"0:\n"
|
|
" mov %[ok], #1\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok)
|
|
:
|
|
: "0");
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate an ADR instruction with a negative offset.
|
|
|
|
B set_point7
|
|
target:
|
|
MOV %[ok], #1
|
|
B end
|
|
set_point7:
|
|
ADR x0, target ; tracepoint here.
|
|
BR x0 ; jump to target
|
|
MOV %[ok], #0
|
|
end
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_adr_backward (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm ("b set_point7\n"
|
|
"0:\n"
|
|
" mov %[ok], #1\n"
|
|
" b 1f\n"
|
|
"set_point7:\n"
|
|
" adr x0, 0b\n"
|
|
" br x0\n"
|
|
" mov %[ok], #0\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok)
|
|
:
|
|
: "0");
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate an ADRP instruction.
|
|
|
|
set_point8:
|
|
ADRP %[addr], set_point8 ; tracepoint here.
|
|
ADR %[pc], set_point8
|
|
|
|
ADR computes the address of the given label. While ADRP gives us its
|
|
page, on a 4K boundary. We can check ADRP executed normally by
|
|
making sure the result of ADR and ADRP are equivalent, except for the
|
|
12 lowest bits which should be cleared.
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_adrp (void)
|
|
{
|
|
uintptr_t page;
|
|
uintptr_t pc;
|
|
|
|
asm ("set_point8:\n"
|
|
" adrp %[page], set_point8\n"
|
|
" adr %[pc], set_point8\n"
|
|
: [page] "=r" (page), [pc] "=r" (pc));
|
|
|
|
if (page == (pc & ~0xfff))
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate an LDR instruction, where the memory to
|
|
read is an offset from the current PC.
|
|
|
|
B set_point9
|
|
data:
|
|
.word 0x0cabba9e
|
|
set_point9:
|
|
LDR %[result], data ; tracepoint here.
|
|
|
|
*/
|
|
|
|
static void
|
|
can_relocate_ldr (void)
|
|
{
|
|
uint32_t result = 0;
|
|
|
|
asm ("b set_point9\n"
|
|
"0:\n"
|
|
" .word 0x0cabba9e\n"
|
|
"set_point9:\n"
|
|
" ldr %w[result], 0b\n"
|
|
: [result] "=r" (result));
|
|
|
|
if (result == 0x0cabba9e)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
/* Make sure we can relocate a B.cond instruction and condition is false. */
|
|
|
|
static void
|
|
can_relocate_bcond_false (void)
|
|
{
|
|
int ok = 0;
|
|
|
|
asm (" mov x0, #8\n"
|
|
" tst x0, #8\n" /* Clear the Z flag. */
|
|
"set_point10:\n" /* Set tracepoint here. */
|
|
" b.eq 0b\n" /* Condition is false. */
|
|
" mov %[ok], #1\n"
|
|
" b 1f\n"
|
|
"0:\n"
|
|
" mov %[ok], #0\n"
|
|
"1:\n"
|
|
: [ok] "=r" (ok)
|
|
:
|
|
: "0", "cc");
|
|
|
|
if (ok == 1)
|
|
pass ();
|
|
else
|
|
fail ();
|
|
}
|
|
|
|
static void
|
|
foo (void)
|
|
{
|
|
}
|
|
|
|
/* Make sure we can relocate a BL instruction. */
|
|
|
|
static void
|
|
can_relocate_bl (void)
|
|
{
|
|
asm ("set_point11:\n"
|
|
" bl foo\n"
|
|
" bl pass\n"); /* Test that LR is updated correctly. */
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Functions testing relocations need to be placed here. GDB will read
|
|
n_testcases to know how many fast tracepoints to place. It will look
|
|
for symbols in the form of 'set_point\[0-9\]+' so each functions
|
|
needs one, starting at 0. */
|
|
|
|
static testcase_ftype testcases[] = {
|
|
#if (defined __x86_64__ || defined __i386__)
|
|
can_relocate_call,
|
|
can_relocate_jump
|
|
#elif (defined __aarch64__)
|
|
can_relocate_b,
|
|
can_relocate_bcond_true,
|
|
can_relocate_cbz,
|
|
can_relocate_cbnz,
|
|
can_relocate_tbz,
|
|
can_relocate_tbnz,
|
|
can_relocate_adr_forward,
|
|
can_relocate_adr_backward,
|
|
can_relocate_adrp,
|
|
can_relocate_ldr,
|
|
can_relocate_bcond_false,
|
|
can_relocate_bl,
|
|
#endif
|
|
};
|
|
|
|
static size_t n_testcases = (sizeof (testcases) / sizeof (testcase_ftype));
|
|
|
|
int
|
|
main ()
|
|
{
|
|
int i = 0;
|
|
|
|
for (i = 0; i < n_testcases; i++)
|
|
testcases[i] ();
|
|
|
|
return 0;
|
|
}
|