[deliverable/linux.git] / arch / arm / kernel / kprobes-test.h

/*
 * arch/arm/kernel/kprobes-test.h
 *
 * Copyright (C) 2011 Jon Medhurst <tixy@yxit.co.uk>.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#define VERBOSE 0 /* Set to '1' for more logging of test cases */

#ifdef CONFIG_THUMB2_KERNEL
#define NORMAL_ISA "16"
#else
#define NORMAL_ISA "32"
#endif


/* Flags used in kprobe_test_flags */
#define TEST_FLAG_NO_ITBLOCK	(1<<0)
#define TEST_FLAG_FULL_ITBLOCK	(1<<1)
#define TEST_FLAG_NARROW_INSTR	(1<<2)

extern int kprobe_test_flags;
extern int kprobe_test_cc_position;


#define TEST_MEMORY_SIZE 256


/*
 * Test case structures.
 *
 * The arguments given to test cases can be one of three types.
 *
 *   ARG_TYPE_REG
 *	Load a register with the given value.
 *
 *   ARG_TYPE_PTR
 *	Load a register with a pointer into the stack buffer (SP + given value).
 *
 *   ARG_TYPE_MEM
 *	Store the given value into the stack buffer at [SP+index].
 *
 */

#define	ARG_TYPE_END	0
#define	ARG_TYPE_REG	1
#define	ARG_TYPE_PTR	2
#define	ARG_TYPE_MEM	3

#define ARG_FLAG_UNSUPPORTED	0x01
#define ARG_FLAG_SUPPORTED	0x02
#define ARG_FLAG_THUMB		0x10	/* Must be 16 so TEST_ISA can be used */
#define ARG_FLAG_ARM		0x20	/* Must be 32 so TEST_ISA can be used */

struct test_arg {
	u8	type;		/* ARG_TYPE_x */
	u8	_padding[7];
};

struct test_arg_regptr {
	u8	type;		/* ARG_TYPE_REG or ARG_TYPE_PTR */
	u8	reg;
	u8	_padding[2];
	u32	val;
};

struct test_arg_mem {
	u8	type;		/* ARG_TYPE_MEM */
	u8	index;
	u8	_padding[2];
	u32	val;
};

struct test_arg_end {
	u8	type;		/* ARG_TYPE_END */
	u8	flags;		/* ARG_FLAG_x */
	u16	code_offset;
	u16	branch_offset;
	u16	end_offset;
};


/*
 * Building blocks for test cases.
 *
 * Each test case is wrapped between TESTCASE_START and TESTCASE_END.
 *
 * To specify arguments for a test case the TEST_ARG_{REG,PTR,MEM} macros are
 * used followed by a terminating TEST_ARG_END.
 *
 * After this, the instruction to be tested is defined with TEST_INSTRUCTION.
 * Or for branches, TEST_BRANCH_B and TEST_BRANCH_F (branch forwards/backwards).
 *
 * Some specific test cases may make use of other custom constructs.
 */

#if VERBOSE
#define verbose(fmt, ...) pr_info(fmt, ##__VA_ARGS__)
#else
#define verbose(fmt, ...)
#endif

#define TEST_GROUP(title)					\
	verbose("\n");						\
	verbose(title"\n");					\
	verbose("---------------------------------------------------------\n");

#define TESTCASE_START(title)					\
	__asm__ __volatile__ (					\
	"bl	__kprobes_test_case_start		\n\t"	\
	/* don't use .asciz here as 'title' may be */		\
	/* multiple strings to be concatenated.  */		\
	".ascii "#title"				\n\t"	\
	".byte	0					\n\t"	\
	".align	2					\n\t"

#define	TEST_ARG_REG(reg, val)					\
	".byte	"__stringify(ARG_TYPE_REG)"		\n\t"	\
	".byte	"#reg"					\n\t"	\
	".short	0					\n\t"	\
	".word	"#val"					\n\t"

#define	TEST_ARG_PTR(reg, val)					\
	".byte	"__stringify(ARG_TYPE_PTR)"		\n\t"	\
	".byte	"#reg"					\n\t"	\
	".short	0					\n\t"	\
	".word	"#val"					\n\t"

#define	TEST_ARG_MEM(index, val)				\
	".byte	"__stringify(ARG_TYPE_MEM)"		\n\t"	\
	".byte	"#index"				\n\t"	\
	".short	0					\n\t"	\
	".word	"#val"					\n\t"

#define	TEST_ARG_END(flags)					\
	".byte	"__stringify(ARG_TYPE_END)"		\n\t"	\
	".byte	"TEST_ISA flags"			\n\t"	\
	".short	50f-0f					\n\t"	\
	".short	2f-0f					\n\t"	\
	".short	99f-0f					\n\t"	\
	".code "TEST_ISA"				\n\t"	\
	"0:						\n\t"

#define TEST_INSTRUCTION(instruction)				\
	"50:	nop					\n\t"	\
	"1:	"instruction"				\n\t"	\
	"	nop					\n\t"

#define TEST_BRANCH_F(instruction, xtra_dist)			\
	TEST_INSTRUCTION(instruction)				\
	".if "#xtra_dist"				\n\t"	\
	"	b	99f				\n\t"	\
	".space "#xtra_dist"				\n\t"	\
	".endif						\n\t"	\
	"	b	99f				\n\t"	\
	"2:	nop					\n\t"

#define TEST_BRANCH_B(instruction, xtra_dist)			\
	"	b	50f				\n\t"	\
	"	b	99f				\n\t"	\
	"2:	nop					\n\t"	\
	"	b	99f				\n\t"	\
	".if "#xtra_dist"				\n\t"	\
	".space "#xtra_dist"				\n\t"	\
	".endif						\n\t"	\
	TEST_INSTRUCTION(instruction)

#define TESTCASE_END						\
	"2:						\n\t"	\
	"99:						\n\t"	\
	"	bl __kprobes_test_case_end_"TEST_ISA"	\n\t"	\
	".code "NORMAL_ISA"				\n\t"	\
	: :							\
	: "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc"	\
	);


/*
 * Macros to define test cases.
 *
 * Those of the form TEST_{R,P,M}* can be used to define test cases
 * which take combinations of the three basic types of arguments. E.g.
 *
 *   TEST_R	One register argument
 *   TEST_RR	Two register arguments
 *   TEST_RPR	A register, a pointer, then a register argument
 *
 * For testing instructions which may branch, there are macros TEST_BF_*
 * and TEST_BB_* for branching forwards and backwards.
 *
 * TEST_SUPPORTED and TEST_UNSUPPORTED don't cause the code to be executed,
 * the just verify that a kprobe is or is not allowed on the given instruction.
 */

#define TEST(code)				\
	TESTCASE_START(code)			\
	TEST_ARG_END("")			\
	TEST_INSTRUCTION(code)			\
	TESTCASE_END

#define TEST_UNSUPPORTED(code)					\
	TESTCASE_START(code)					\
	TEST_ARG_END("|"__stringify(ARG_FLAG_UNSUPPORTED))	\
	TEST_INSTRUCTION(code)					\
	TESTCASE_END

#define TEST_SUPPORTED(code)					\
	TESTCASE_START(code)					\
	TEST_ARG_END("|"__stringify(ARG_FLAG_SUPPORTED))	\
	TEST_INSTRUCTION(code)					\
	TESTCASE_END

#define TEST_R(code1, reg, val, code2)			\
	TESTCASE_START(code1 #reg code2)		\
	TEST_ARG_REG(reg, val)				\
	TEST_ARG_END("")				\
	TEST_INSTRUCTION(code1 #reg code2)		\
	TESTCASE_END

#define TEST_RR(code1, reg1, val1, code2, reg2, val2, code3)	\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3)		\
	TEST_ARG_REG(reg1, val1)				\
	TEST_ARG_REG(reg2, val2)				\
	TEST_ARG_END("")					\
	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)		\
	TESTCASE_END

#define TEST_RRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
	TEST_ARG_REG(reg1, val1)						\
	TEST_ARG_REG(reg2, val2)						\
	TEST_ARG_REG(reg3, val3)						\
	TEST_ARG_END("")							\
	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
	TESTCASE_END

#define TEST_RRRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4, reg4, val4)	\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4)		\
	TEST_ARG_REG(reg1, val1)						\
	TEST_ARG_REG(reg2, val2)						\
	TEST_ARG_REG(reg3, val3)						\
	TEST_ARG_REG(reg4, val4)						\
	TEST_ARG_END("")							\
	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4)	\
	TESTCASE_END

#define TEST_P(code1, reg1, val1, code2)	\
	TESTCASE_START(code1 #reg1 code2)	\
	TEST_ARG_PTR(reg1, val1)		\
	TEST_ARG_END("")			\
	TEST_INSTRUCTION(code1 #reg1 code2)	\
	TESTCASE_END

#define TEST_PR(code1, reg1, val1, code2, reg2, val2, code3)	\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3)		\
	TEST_ARG_PTR(reg1, val1)				\
	TEST_ARG_REG(reg2, val2)				\
	TEST_ARG_END("")					\
	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)		\
	TESTCASE_END

#define TEST_RP(code1, reg1, val1, code2, reg2, val2, code3)	\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3)		\
	TEST_ARG_REG(reg1, val1)				\
	TEST_ARG_PTR(reg2, val2)				\
	TEST_ARG_END("")					\
	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)		\
	TESTCASE_END

#define TEST_PRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
	TEST_ARG_PTR(reg1, val1)						\
	TEST_ARG_REG(reg2, val2)						\
	TEST_ARG_REG(reg3, val3)						\
	TEST_ARG_END("")							\
	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
	TESTCASE_END

#define TEST_RPR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
	TEST_ARG_REG(reg1, val1)						\
	TEST_ARG_PTR(reg2, val2)						\
	TEST_ARG_REG(reg3, val3)						\
	TEST_ARG_END("")							\
	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
	TESTCASE_END

#define TEST_RRP(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
	TEST_ARG_REG(reg1, val1)						\
	TEST_ARG_REG(reg2, val2)						\
	TEST_ARG_PTR(reg3, val3)						\
	TEST_ARG_END("")							\
	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
	TESTCASE_END

#define TEST_BF_P(code1, reg1, val1, code2)	\
	TESTCASE_START(code1 #reg1 code2)	\
	TEST_ARG_PTR(reg1, val1)		\
	TEST_ARG_END("")			\
	TEST_BRANCH_F(code1 #reg1 code2, 0)	\
	TESTCASE_END

#define TEST_BF_X(code, xtra_dist)		\
	TESTCASE_START(code)			\
	TEST_ARG_END("")			\
	TEST_BRANCH_F(code, xtra_dist)		\
	TESTCASE_END

#define TEST_BB_X(code, xtra_dist)		\
	TESTCASE_START(code)			\
	TEST_ARG_END("")			\
	TEST_BRANCH_B(code, xtra_dist)		\
	TESTCASE_END

#define TEST_BF_RX(code1, reg, val, code2, xtra_dist)	\
	TESTCASE_START(code1 #reg code2)		\
	TEST_ARG_REG(reg, val)				\
	TEST_ARG_END("")				\
	TEST_BRANCH_F(code1 #reg code2, xtra_dist)	\
	TESTCASE_END

#define TEST_BB_RX(code1, reg, val, code2, xtra_dist)	\
	TESTCASE_START(code1 #reg code2)		\
	TEST_ARG_REG(reg, val)				\
	TEST_ARG_END("")				\
	TEST_BRANCH_B(code1 #reg code2, xtra_dist)	\
	TESTCASE_END

#define TEST_BF(code)	TEST_BF_X(code, 0)
#define TEST_BB(code)	TEST_BB_X(code, 0)

#define TEST_BF_R(code1, reg, val, code2) TEST_BF_RX(code1, reg, val, code2, 0)
#define TEST_BB_R(code1, reg, val, code2) TEST_BB_RX(code1, reg, val, code2, 0)

#define TEST_BF_RR(code1, reg1, val1, code2, reg2, val2, code3)	\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3)		\
	TEST_ARG_REG(reg1, val1)				\
	TEST_ARG_REG(reg2, val2)				\
	TEST_ARG_END("")					\
	TEST_BRANCH_F(code1 #reg1 code2 #reg2 code3, 0)		\
	TESTCASE_END

#define TEST_X(code, codex)			\
	TESTCASE_START(code)			\
	TEST_ARG_END("")			\
	TEST_INSTRUCTION(code)			\
	"	b	99f		\n\t"	\
	"	"codex"			\n\t"	\
	TESTCASE_END

#define TEST_RX(code1, reg, val, code2, codex)		\
	TESTCASE_START(code1 #reg code2)		\
	TEST_ARG_REG(reg, val)				\
	TEST_ARG_END("")				\
	TEST_INSTRUCTION(code1 __stringify(reg) code2)	\
	"	b	99f		\n\t"		\
	"	"codex"			\n\t"		\
	TESTCASE_END

#define TEST_RRX(code1, reg1, val1, code2, reg2, val2, code3, codex)		\
	TESTCASE_START(code1 #reg1 code2 #reg2 code3)				\
	TEST_ARG_REG(reg1, val1)						\
	TEST_ARG_REG(reg2, val2)						\
	TEST_ARG_END("")							\
	TEST_INSTRUCTION(code1 __stringify(reg1) code2 __stringify(reg2) code3)	\
	"	b	99f		\n\t"					\
	"	"codex"			\n\t"					\
	TESTCASE_END


/* Various values used in test cases... */
#define N(val)	(val ^ 0xffffffff)
#define VAL1	0x12345678
#define VAL2	N(VAL1)
#define VAL3	0xa5f801
#define VAL4	N(VAL3)
#define VALM	0x456789ab
#define VALR	0xdeaddead
#define HH1	0x0123fecb
#define HH2	0xa9874567


#ifdef CONFIG_THUMB2_KERNEL
void kprobe_thumb16_test_cases(void);
void kprobe_thumb32_test_cases(void);
#else
void kprobe_arm_test_cases(void);
#endif
Commit	Line	Data
a43bc69b JM	1	/*
	2	* arch/arm/kernel/kprobes-test.h
	3	*
	4	* Copyright (C) 2011 Jon Medhurst <tixy@yxit.co.uk>.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
	11	#define VERBOSE 0 /* Set to '1' for more logging of test cases */
	12
	13	#ifdef CONFIG_THUMB2_KERNEL
	14	#define NORMAL_ISA "16"
	15	#else
	16	#define NORMAL_ISA "32"
	17	#endif
	18
	19
	20	/* Flags used in kprobe_test_flags */
	21	#define TEST_FLAG_NO_ITBLOCK (1<<0)
	22	#define TEST_FLAG_FULL_ITBLOCK (1<<1)
	23	#define TEST_FLAG_NARROW_INSTR (1<<2)
	24
	25	extern int kprobe_test_flags;
	26	extern int kprobe_test_cc_position;
	27
	28
	29	#define TEST_MEMORY_SIZE 256
	30
	31
	32	/*
	33	* Test case structures.
	34	*
	35	* The arguments given to test cases can be one of three types.
	36	*
	37	* ARG_TYPE_REG
	38	* Load a register with the given value.
	39	*
	40	* ARG_TYPE_PTR
	41	* Load a register with a pointer into the stack buffer (SP + given value).
	42	*
	43	* ARG_TYPE_MEM
	44	* Store the given value into the stack buffer at [SP+index].
	45	*
	46	*/
	47
	48	#define ARG_TYPE_END 0
	49	#define ARG_TYPE_REG 1
	50	#define ARG_TYPE_PTR 2
	51	#define ARG_TYPE_MEM 3
	52
	53	#define ARG_FLAG_UNSUPPORTED 0x01
	54	#define ARG_FLAG_SUPPORTED 0x02
	55	#define ARG_FLAG_THUMB 0x10 /* Must be 16 so TEST_ISA can be used */
	56	#define ARG_FLAG_ARM 0x20 /* Must be 32 so TEST_ISA can be used */
	57
	58	struct test_arg {
	59	u8 type; /* ARG_TYPE_x */
	60	u8 _padding[7];
	61	};
	62
	63	struct test_arg_regptr {
	64	u8 type; /* ARG_TYPE_REG or ARG_TYPE_PTR */
65	u8 reg;
66	u8 _padding[2];
67	u32 val;
68	};
69
70	struct test_arg_mem {
71	u8 type; /* ARG_TYPE_MEM */
72	u8 index;
73	u8 _padding[2];
74	u32 val;
75	};
76
77	struct test_arg_end {
78	u8 type; /* ARG_TYPE_END */
79	u8 flags; /* ARG_FLAG_x */
80	u16 code_offset;
81	u16 branch_offset;
82	u16 end_offset;
83	};
84
85
86	/*
87	* Building blocks for test cases.
88	*
89	* Each test case is wrapped between TESTCASE_START and TESTCASE_END.
90	*
91	* To specify arguments for a test case the TEST_ARG_{REG,PTR,MEM} macros are
92	* used followed by a terminating TEST_ARG_END.
93	*
94	* After this, the instruction to be tested is defined with TEST_INSTRUCTION.
95	* Or for branches, TEST_BRANCH_B and TEST_BRANCH_F (branch forwards/backwards).
96	*
97	* Some specific test cases may make use of other custom constructs.
98	*/
99
100	#if VERBOSE
101	#define verbose(fmt, ...) pr_info(fmt, ##__VA_ARGS__)
102	#else
103	#define verbose(fmt, ...)
104	#endif
105
106	#define TEST_GROUP(title) \
107	verbose("\n"); \
108	verbose(title"\n"); \
109	verbose("---------------------------------------------------------\n");
110
111	#define TESTCASE_START(title) \
112	__asm__ __volatile__ ( \
113	"bl __kprobes_test_case_start \n\t" \
114	/* don't use .asciz here as 'title' may be */ \
115	/* multiple strings to be concatenated. */ \
116	".ascii "#title" \n\t" \
117	".byte 0 \n\t" \
118	".align 2 \n\t"
119
120	#define TEST_ARG_REG(reg, val) \
121	".byte "__stringify(ARG_TYPE_REG)" \n\t" \
122	".byte "#reg" \n\t" \
123	".short 0 \n\t" \
124	".word "#val" \n\t"
125
126	#define TEST_ARG_PTR(reg, val) \
127	".byte "__stringify(ARG_TYPE_PTR)" \n\t" \
128	".byte "#reg" \n\t" \
129	".short 0 \n\t" \
130	".word "#val" \n\t"
131
132	#define TEST_ARG_MEM(index, val) \
133	".byte "__stringify(ARG_TYPE_MEM)" \n\t" \
134	".byte "#index" \n\t" \
135	".short 0 \n\t" \
136	".word "#val" \n\t"
137
138	#define TEST_ARG_END(flags) \
139	".byte "__stringify(ARG_TYPE_END)" \n\t" \
140	".byte "TEST_ISA flags" \n\t" \
141	".short 50f-0f \n\t" \
142	".short 2f-0f \n\t" \
143	".short 99f-0f \n\t" \
144	".code "TEST_ISA" \n\t" \
145	"0: \n\t"
146
147	#define TEST_INSTRUCTION(instruction) \
148	"50: nop \n\t" \
149	"1: "instruction" \n\t" \
150	" nop \n\t"
151
152	#define TEST_BRANCH_F(instruction, xtra_dist) \
153	TEST_INSTRUCTION(instruction) \
154	".if "#xtra_dist" \n\t" \
155	" b 99f \n\t" \
156	".space "#xtra_dist" \n\t" \
157	".endif \n\t" \
158	" b 99f \n\t" \
159	"2: nop \n\t"
160
161	#define TEST_BRANCH_B(instruction, xtra_dist) \
162	" b 50f \n\t" \
163	" b 99f \n\t" \
164	"2: nop \n\t" \
165	" b 99f \n\t" \
166	".if "#xtra_dist" \n\t" \
167	".space "#xtra_dist" \n\t" \
168	".endif \n\t" \
169	TEST_INSTRUCTION(instruction)
170
171	#define TESTCASE_END \
172	"2: \n\t" \
173	"99: \n\t" \
174	" bl __kprobes_test_case_end_"TEST_ISA" \n\t" \
175	".code "NORMAL_ISA" \n\t" \
176	: : \
177	: "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc" \
178	);
179
180
181	/*
182	* Macros to define test cases.
183	*
184	* Those of the form TEST_{R,P,M}* can be used to define test cases
185	* which take combinations of the three basic types of arguments. E.g.
186	*
187	* TEST_R One register argument
188	* TEST_RR Two register arguments
189	* TEST_RPR A register, a pointer, then a register argument
190	*
191	* For testing instructions which may branch, there are macros TEST_BF_*
192	* and TEST_BB_* for branching forwards and backwards.
193	*
194	* TEST_SUPPORTED and TEST_UNSUPPORTED don't cause the code to be executed,
195	* the just verify that a kprobe is or is not allowed on the given instruction.
196	*/
197
198	#define TEST(code) \
199	TESTCASE_START(code) \
200	TEST_ARG_END("") \
201	TEST_INSTRUCTION(code) \
202	TESTCASE_END
203
204	#define TEST_UNSUPPORTED(code) \
205	TESTCASE_START(code) \
206	TEST_ARG_END("\|"__stringify(ARG_FLAG_UNSUPPORTED)) \
207	TEST_INSTRUCTION(code) \
208	TESTCASE_END
209
210	#define TEST_SUPPORTED(code) \
211	TESTCASE_START(code) \
212	TEST_ARG_END("\|"__stringify(ARG_FLAG_SUPPORTED)) \
213	TEST_INSTRUCTION(code) \
214	TESTCASE_END
215
216	#define TEST_R(code1, reg, val, code2) \
217	TESTCASE_START(code1 #reg code2) \
218	TEST_ARG_REG(reg, val) \
219	TEST_ARG_END("") \
220	TEST_INSTRUCTION(code1 #reg code2) \
221	TESTCASE_END
222
223	#define TEST_RR(code1, reg1, val1, code2, reg2, val2, code3) \
224	TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
225	TEST_ARG_REG(reg1, val1) \
226	TEST_ARG_REG(reg2, val2) \
227	TEST_ARG_END("") \
228	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
229	TESTCASE_END
230
231	#define TEST_RRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
232	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
233	TEST_ARG_REG(reg1, val1) \
234	TEST_ARG_REG(reg2, val2) \
235	TEST_ARG_REG(reg3, val3) \
236	TEST_ARG_END("") \
237	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
238	TESTCASE_END
239
240	#define TEST_RRRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4, reg4, val4) \
241	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4) \
242	TEST_ARG_REG(reg1, val1) \
243	TEST_ARG_REG(reg2, val2) \
244	TEST_ARG_REG(reg3, val3) \
245	TEST_ARG_REG(reg4, val4) \
246	TEST_ARG_END("") \
247	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4) \
248	TESTCASE_END
249
250	#define TEST_P(code1, reg1, val1, code2) \
251	TESTCASE_START(code1 #reg1 code2) \
252	TEST_ARG_PTR(reg1, val1) \
253	TEST_ARG_END("") \
254	TEST_INSTRUCTION(code1 #reg1 code2) \
255	TESTCASE_END
256
257	#define TEST_PR(code1, reg1, val1, code2, reg2, val2, code3) \
258	TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
259	TEST_ARG_PTR(reg1, val1) \
260	TEST_ARG_REG(reg2, val2) \
261	TEST_ARG_END("") \
262	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
263	TESTCASE_END
264
265	#define TEST_RP(code1, reg1, val1, code2, reg2, val2, code3) \
266	TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
267	TEST_ARG_REG(reg1, val1) \
268	TEST_ARG_PTR(reg2, val2) \
269	TEST_ARG_END("") \
270	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
271	TESTCASE_END
272
273	#define TEST_PRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
274	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
275	TEST_ARG_PTR(reg1, val1) \
276	TEST_ARG_REG(reg2, val2) \
277	TEST_ARG_REG(reg3, val3) \
278	TEST_ARG_END("") \
279	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
280	TESTCASE_END
281
282	#define TEST_RPR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
283	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
284	TEST_ARG_REG(reg1, val1) \
285	TEST_ARG_PTR(reg2, val2) \
286	TEST_ARG_REG(reg3, val3) \
287	TEST_ARG_END("") \
288	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
289	TESTCASE_END
290
291	#define TEST_RRP(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
292	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
293	TEST_ARG_REG(reg1, val1) \
294	TEST_ARG_REG(reg2, val2) \
295	TEST_ARG_PTR(reg3, val3) \
296	TEST_ARG_END("") \
297	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
298	TESTCASE_END
299
300	#define TEST_BF_P(code1, reg1, val1, code2) \
301	TESTCASE_START(code1 #reg1 code2) \
302	TEST_ARG_PTR(reg1, val1) \
303	TEST_ARG_END("") \
304	TEST_BRANCH_F(code1 #reg1 code2, 0) \
305	TESTCASE_END
306
307	#define TEST_BF_X(code, xtra_dist) \
308	TESTCASE_START(code) \
309	TEST_ARG_END("") \
310	TEST_BRANCH_F(code, xtra_dist) \
311	TESTCASE_END
312
313	#define TEST_BB_X(code, xtra_dist) \
314	TESTCASE_START(code) \
315	TEST_ARG_END("") \
316	TEST_BRANCH_B(code, xtra_dist) \
317	TESTCASE_END
318
319	#define TEST_BF_RX(code1, reg, val, code2, xtra_dist) \
320	TESTCASE_START(code1 #reg code2) \
321	TEST_ARG_REG(reg, val) \
322	TEST_ARG_END("") \
323	TEST_BRANCH_F(code1 #reg code2, xtra_dist) \
324	TESTCASE_END
325
326	#define TEST_BB_RX(code1, reg, val, code2, xtra_dist) \
327	TESTCASE_START(code1 #reg code2) \
328	TEST_ARG_REG(reg, val) \
329	TEST_ARG_END("") \
330	TEST_BRANCH_B(code1 #reg code2, xtra_dist) \
331	TESTCASE_END
332
333	#define TEST_BF(code) TEST_BF_X(code, 0)
334	#define TEST_BB(code) TEST_BB_X(code, 0)
335
336	#define TEST_BF_R(code1, reg, val, code2) TEST_BF_RX(code1, reg, val, code2, 0)
337	#define TEST_BB_R(code1, reg, val, code2) TEST_BB_RX(code1, reg, val, code2, 0)
338
339	#define TEST_BF_RR(code1, reg1, val1, code2, reg2, val2, code3) \
340	TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
341	TEST_ARG_REG(reg1, val1) \
342	TEST_ARG_REG(reg2, val2) \
343	TEST_ARG_END("") \
344	TEST_BRANCH_F(code1 #reg1 code2 #reg2 code3, 0) \
345	TESTCASE_END
346
347	#define TEST_X(code, codex) \
348	TESTCASE_START(code) \
349	TEST_ARG_END("") \
350	TEST_INSTRUCTION(code) \
351	" b 99f \n\t" \
352	" "codex" \n\t" \
353	TESTCASE_END
354
355	#define TEST_RX(code1, reg, val, code2, codex) \
356	TESTCASE_START(code1 #reg code2) \
357	TEST_ARG_REG(reg, val) \
358	TEST_ARG_END("") \
359	TEST_INSTRUCTION(code1 __stringify(reg) code2) \
360	" b 99f \n\t" \
361	" "codex" \n\t" \
362	TESTCASE_END
363
364	#define TEST_RRX(code1, reg1, val1, code2, reg2, val2, code3, codex) \
365	TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
366	TEST_ARG_REG(reg1, val1) \
367	TEST_ARG_REG(reg2, val2) \
368	TEST_ARG_END("") \
369	TEST_INSTRUCTION(code1 __stringify(reg1) code2 __stringify(reg2) code3) \
370	" b 99f \n\t" \
371	" "codex" \n\t" \
372	TESTCASE_END
373
374
375	/* Various values used in test cases... */
376	#define N(val) (val ^ 0xffffffff)
377	#define VAL1 0x12345678
378	#define VAL2 N(VAL1)
379	#define VAL3 0xa5f801
380	#define VAL4 N(VAL3)
381	#define VALM 0x456789ab
382	#define VALR 0xdeaddead
383	#define HH1 0x0123fecb
384	#define HH2 0xa9874567
c7054aad JM	385
	386
	387	#ifdef CONFIG_THUMB2_KERNEL
	388	void kprobe_thumb16_test_cases(void);
	389	void kprobe_thumb32_test_cases(void);
c0cc6df1 JM	390	#else
c0cc6df1 JM	391	void kprobe_arm_test_cases(void);
c7054aad	392	#endif