[linux-2.6-block.git] / arch / powerpc / include / asm / head-64.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _ASM_POWERPC_HEAD_64_H
#define _ASM_POWERPC_HEAD_64_H

#include <asm/cache.h>

#ifdef __ASSEMBLY__
/*
 * We can't do CPP stringification and concatination directly into the section
 * name for some reason, so these macros can do it for us.
 */
.macro define_ftsec name
	.section ".head.text.\name\()","ax",@progbits
.endm
.macro define_data_ftsec name
	.section ".head.data.\name\()","a",@progbits
.endm
.macro use_ftsec name
	.section ".head.text.\name\()"
.endm

/*
 * Fixed (location) sections are used by opening fixed sections and emitting
 * fixed section entries into them before closing them. Multiple fixed sections
 * can be open at any time.
 *
 * Each fixed section created in a .S file must have corresponding linkage
 * directives including location, added to  arch/powerpc/kernel/vmlinux.lds.S
 *
 * For each fixed section, code is generated into it in the order which it
 * appears in the source.  Fixed section entries can be placed at a fixed
 * location within the section using _LOCATION postifx variants. These must
 * be ordered according to their relative placements within the section.
 *
 * OPEN_FIXED_SECTION(section_name, start_address, end_address)
 * FIXED_SECTION_ENTRY_BEGIN(section_name, label1)
 *
 * USE_FIXED_SECTION(section_name)
 * label3:
 *     li  r10,128
 *     mv  r11,r10

 * FIXED_SECTION_ENTRY_BEGIN_LOCATION(section_name, label2, start_address, size)
 * FIXED_SECTION_ENTRY_END_LOCATION(section_name, label2, start_address, size)
 * CLOSE_FIXED_SECTION(section_name)
 *
 * ZERO_FIXED_SECTION can be used to emit zeroed data.
 *
 * Troubleshooting:
 * - If the build dies with "Error: attempt to move .org backwards" at
 *   CLOSE_FIXED_SECTION() or elsewhere, there may be something
 *   unexpected being added there. Remove the '. = x_len' line, rebuild, and
 *   check what is pushing the section down.
 * - If the build dies in linking, check arch/powerpc/tools/head_check.sh
 *   comments.
 * - If the kernel crashes or hangs in very early boot, it could be linker
 *   stubs at the start of the main text.
 */

#define OPEN_FIXED_SECTION(sname, start, end)			\
	sname##_start = (start);				\
	sname##_end = (end);					\
	sname##_len = (end) - (start);				\
	define_ftsec sname;					\
	. = 0x0;						\
start_##sname:

/*
 * .linker_stub_catch section is used to catch linker stubs from being
 * inserted in our .text section, above the start_text label (which breaks
 * the ABS_ADDR calculation). See kernel/vmlinux.lds.S and tools/head_check.sh
 * for more details. We would prefer to just keep a cacheline (0x80), but
 * 0x100 seems to be how the linker aligns branch stub groups.
 */
#ifdef CONFIG_LD_HEAD_STUB_CATCH
#define OPEN_TEXT_SECTION(start)				\
	.section ".linker_stub_catch","ax",@progbits;		\
linker_stub_catch:						\
	. = 0x4;						\
	text_start = (start) + 0x100;				\
	.section ".text","ax",@progbits;			\
	.balign 0x100;						\
start_text:
#else
#define OPEN_TEXT_SECTION(start)				\
	text_start = (start);					\
	.section ".text","ax",@progbits;			\
	. = 0x0;						\
start_text:
#endif

#define ZERO_FIXED_SECTION(sname, start, end)			\
	sname##_start = (start);				\
	sname##_end = (end);					\
	sname##_len = (end) - (start);				\
	define_data_ftsec sname;				\
	. = 0x0;						\
	. = sname##_len;

#define USE_FIXED_SECTION(sname)				\
	fs_label = start_##sname;				\
	fs_start = sname##_start;				\
	use_ftsec sname;

#define USE_TEXT_SECTION()					\
	fs_label = start_text;					\
	fs_start = text_start;					\
	.text

#define CLOSE_FIXED_SECTION(sname)				\
	USE_FIXED_SECTION(sname);				\
	. = sname##_len;					\
end_##sname:


#define __FIXED_SECTION_ENTRY_BEGIN(sname, name, __align)	\
	USE_FIXED_SECTION(sname);				\
	.balign __align;					\
	.global name;						\
name:

#define FIXED_SECTION_ENTRY_BEGIN(sname, name)			\
	__FIXED_SECTION_ENTRY_BEGIN(sname, name, IFETCH_ALIGN_BYTES)

#define FIXED_SECTION_ENTRY_BEGIN_LOCATION(sname, name, start, size) \
	USE_FIXED_SECTION(sname);				\
	name##_start = (start);					\
	.if ((start) % (size) != 0);				\
	.error "Fixed section exception vector misalignment";	\
	.endif;							\
	.if ((size) != 0x20) && ((size) != 0x80) && ((size) != 0x100); \
	.error "Fixed section exception vector bad size";	\
	.endif;							\
	.if (start) < sname##_start;				\
	.error "Fixed section underflow";			\
	.abort;							\
	.endif;							\
	. = (start) - sname##_start;				\
	.global name;						\
name:

#define FIXED_SECTION_ENTRY_END_LOCATION(sname, name, start, size) \
	.if (start) + (size) > sname##_end;			\
	.error "Fixed section overflow";			\
	.abort;							\
	.endif;							\
	.if (. - name > (start) + (size) - name##_start);	\
	.error "Fixed entry overflow";				\
	.abort;							\
	.endif;							\
	. = ((start) + (size) - sname##_start);			\


/*
 * These macros are used to change symbols in other fixed sections to be
 * absolute or related to our current fixed section.
 *
 * - DEFINE_FIXED_SYMBOL / FIXED_SYMBOL_ABS_ADDR is used to find the
 *   absolute address of a symbol within a fixed section, from any section.
 *
 * - ABS_ADDR is used to find the absolute address of any symbol, from within
 *   a fixed section.
 */
#define DEFINE_FIXED_SYMBOL(label)				\
	label##_absolute = (label - fs_label + fs_start)

#define FIXED_SYMBOL_ABS_ADDR(label)				\
	(label##_absolute)

#define ABS_ADDR(label) (label - fs_label + fs_start)

/*
 * Following are the BOOK3S exception handler helper macros.
 * Handlers come in a number of types, and each type has a number of varieties.
 *
 * EXC_REAL_*     - real, unrelocated exception vectors
 * EXC_VIRT_*     - virt (AIL), unrelocated exception vectors
 * TRAMP_REAL_*   - real, unrelocated helpers (virt can call these)
 * TRAMP_VIRT_*   - virt, unreloc helpers (in practice, real can use)
 * TRAMP_KVM      - KVM handlers that get put into real, unrelocated
 * EXC_COMMON     - virt, relocated common handlers
 *
 * The EXC handlers are given a name, and branch to name_common, or the
 * appropriate KVM or masking function. Vector handler verieties are as
 * follows:
 *
 * EXC_{REAL|VIRT}_BEGIN/END - used to open-code the exception
 *
 * EXC_{REAL|VIRT}  - standard exception
 *
 * EXC_{REAL|VIRT}_suffix
 *     where _suffix is:
 *   - _MASKABLE               - maskable exception
 *   - _OOL                    - out of line with trampoline to common handler
 *   - _HV                     - HV exception
 *
 * There can be combinations, e.g., EXC_VIRT_OOL_MASKABLE_HV
 *
 * The one unusual case is __EXC_REAL_OOL_HV_DIRECT, which is
 * an OOL vector that branches to a specified handler rather than the usual
 * trampoline that goes to common. It, and other underscore macros, should
 * be used with care.
 *
 * KVM handlers come in the following verieties:
 * TRAMP_KVM
 * TRAMP_KVM_SKIP
 * TRAMP_KVM_HV
 * TRAMP_KVM_HV_SKIP
 *
 * COMMON handlers come in the following verieties:
 * EXC_COMMON_BEGIN/END - used to open-code the handler
 * EXC_COMMON
 * EXC_COMMON_ASYNC
 *
 * TRAMP_REAL and TRAMP_VIRT can be used with BEGIN/END. KVM
 * and OOL handlers are implemented as types of TRAMP and TRAMP_VIRT handlers.
 */

#define EXC_REAL_BEGIN(name, start, size)			\
	FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##name, start, size)

#define EXC_REAL_END(name, start, size)				\
	FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##name, start, size)

#define EXC_VIRT_BEGIN(name, start, size)			\
	FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size)

#define EXC_VIRT_END(name, start, size)				\
	FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size)

#define EXC_COMMON_BEGIN(name)					\
	USE_TEXT_SECTION();					\
	.balign IFETCH_ALIGN_BYTES;				\
	.global name;						\
	_ASM_NOKPROBE_SYMBOL(name);				\
	DEFINE_FIXED_SYMBOL(name);				\
name:

#define TRAMP_REAL_BEGIN(name)					\
	FIXED_SECTION_ENTRY_BEGIN(real_trampolines, name)

#define TRAMP_VIRT_BEGIN(name)					\
	FIXED_SECTION_ENTRY_BEGIN(virt_trampolines, name)

#ifdef CONFIG_KVM_BOOK3S_64_HANDLER
#define TRAMP_KVM_BEGIN(name)					\
	TRAMP_VIRT_BEGIN(name)
#else
#define TRAMP_KVM_BEGIN(name)
#endif

#define EXC_REAL_NONE(start, size)				\
	FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##unused, start, size); \
	FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##unused, start, size)

#define EXC_VIRT_NONE(start, size)				\
	FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size); \
	FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size);


#define EXC_REAL(name, start, size)					\
	EXC_REAL_BEGIN(name, start, size);				\
	STD_EXCEPTION(start, name##_common);				\
	EXC_REAL_END(name, start, size);

#define EXC_VIRT(name, start, size, realvec)				\
	EXC_VIRT_BEGIN(name, start, size);				\
	STD_RELON_EXCEPTION(start, realvec, name##_common);		\
	EXC_VIRT_END(name, start, size);

#define EXC_REAL_MASKABLE(name, start, size, bitmask)			\
	EXC_REAL_BEGIN(name, start, size);				\
	MASKABLE_EXCEPTION(start, name##_common, bitmask);		\
	EXC_REAL_END(name, start, size);

#define EXC_VIRT_MASKABLE(name, start, size, realvec, bitmask)		\
	EXC_VIRT_BEGIN(name, start, size);				\
	MASKABLE_RELON_EXCEPTION(realvec, name##_common, bitmask);	\
	EXC_VIRT_END(name, start, size);

#define EXC_REAL_HV(name, start, size)					\
	EXC_REAL_BEGIN(name, start, size);				\
	STD_EXCEPTION_HV(start, start, name##_common);			\
	EXC_REAL_END(name, start, size);

#define EXC_VIRT_HV(name, start, size, realvec)				\
	EXC_VIRT_BEGIN(name, start, size);				\
	STD_RELON_EXCEPTION_HV(start, realvec, name##_common);		\
	EXC_VIRT_END(name, start, size);

#define __EXC_REAL_OOL(name, start, size)				\
	EXC_REAL_BEGIN(name, start, size);				\
	__OOL_EXCEPTION(start, label, tramp_real_##name);		\
	EXC_REAL_END(name, start, size);

#define __TRAMP_REAL_OOL(name, vec)					\
	TRAMP_REAL_BEGIN(tramp_real_##name);				\
	STD_EXCEPTION_OOL(vec, name##_common);

#define EXC_REAL_OOL(name, start, size)					\
	__EXC_REAL_OOL(name, start, size);				\
	__TRAMP_REAL_OOL(name, start);

#define __EXC_REAL_OOL_MASKABLE(name, start, size)			\
	__EXC_REAL_OOL(name, start, size);

#define __TRAMP_REAL_OOL_MASKABLE(name, vec, bitmask)			\
	TRAMP_REAL_BEGIN(tramp_real_##name);				\
	MASKABLE_EXCEPTION_OOL(vec, name##_common, bitmask);

#define EXC_REAL_OOL_MASKABLE(name, start, size, bitmask)		\
	__EXC_REAL_OOL_MASKABLE(name, start, size);			\
	__TRAMP_REAL_OOL_MASKABLE(name, start, bitmask);

#define __EXC_REAL_OOL_HV_DIRECT(name, start, size, handler)		\
	EXC_REAL_BEGIN(name, start, size);				\
	__OOL_EXCEPTION(start, label, handler);				\
	EXC_REAL_END(name, start, size);

#define __EXC_REAL_OOL_HV(name, start, size)				\
	__EXC_REAL_OOL(name, start, size);

#define __TRAMP_REAL_OOL_HV(name, vec)					\
	TRAMP_REAL_BEGIN(tramp_real_##name);				\
	STD_EXCEPTION_HV_OOL(vec, name##_common);			\

#define EXC_REAL_OOL_HV(name, start, size)				\
	__EXC_REAL_OOL_HV(name, start, size);				\
	__TRAMP_REAL_OOL_HV(name, start);

#define __EXC_REAL_OOL_MASKABLE_HV(name, start, size)			\
	__EXC_REAL_OOL(name, start, size);

#define __TRAMP_REAL_OOL_MASKABLE_HV(name, vec, bitmask)		\
	TRAMP_REAL_BEGIN(tramp_real_##name);				\
	MASKABLE_EXCEPTION_HV_OOL(vec, name##_common, bitmask);		\

#define EXC_REAL_OOL_MASKABLE_HV(name, start, size, bitmask)		\
	__EXC_REAL_OOL_MASKABLE_HV(name, start, size);			\
	__TRAMP_REAL_OOL_MASKABLE_HV(name, start, bitmask);

#define __EXC_VIRT_OOL(name, start, size)				\
	EXC_VIRT_BEGIN(name, start, size);				\
	__OOL_EXCEPTION(start, label, tramp_virt_##name);		\
	EXC_VIRT_END(name, start, size);

#define __TRAMP_VIRT_OOL(name, realvec)					\
	TRAMP_VIRT_BEGIN(tramp_virt_##name);				\
	STD_RELON_EXCEPTION_OOL(realvec, name##_common);

#define EXC_VIRT_OOL(name, start, size, realvec)			\
	__EXC_VIRT_OOL(name, start, size);				\
	__TRAMP_VIRT_OOL(name, realvec);

#define __EXC_VIRT_OOL_MASKABLE(name, start, size)			\
	__EXC_VIRT_OOL(name, start, size);

#define __TRAMP_VIRT_OOL_MASKABLE(name, realvec, bitmask)		\
	TRAMP_VIRT_BEGIN(tramp_virt_##name);				\
	MASKABLE_RELON_EXCEPTION_OOL(realvec, name##_common, bitmask);

#define EXC_VIRT_OOL_MASKABLE(name, start, size, realvec, bitmask)	\
	__EXC_VIRT_OOL_MASKABLE(name, start, size);			\
	__TRAMP_VIRT_OOL_MASKABLE(name, realvec, bitmask);

#define __EXC_VIRT_OOL_HV(name, start, size)				\
	__EXC_VIRT_OOL(name, start, size);

#define __TRAMP_VIRT_OOL_HV(name, realvec)				\
	TRAMP_VIRT_BEGIN(tramp_virt_##name);				\
	STD_RELON_EXCEPTION_HV_OOL(realvec, name##_common);		\

#define EXC_VIRT_OOL_HV(name, start, size, realvec)			\
	__EXC_VIRT_OOL_HV(name, start, size);				\
	__TRAMP_VIRT_OOL_HV(name, realvec);

#define __EXC_VIRT_OOL_MASKABLE_HV(name, start, size)			\
	__EXC_VIRT_OOL(name, start, size);

#define __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec, bitmask)		\
	TRAMP_VIRT_BEGIN(tramp_virt_##name);				\
	MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common, bitmask);\

#define EXC_VIRT_OOL_MASKABLE_HV(name, start, size, realvec, bitmask)	\
	__EXC_VIRT_OOL_MASKABLE_HV(name, start, size);			\
	__TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec, bitmask);

#define TRAMP_KVM(area, n)						\
	TRAMP_KVM_BEGIN(do_kvm_##n);					\
	KVM_HANDLER(area, EXC_STD, n);					\

#define TRAMP_KVM_SKIP(area, n)						\
	TRAMP_KVM_BEGIN(do_kvm_##n);					\
	KVM_HANDLER_SKIP(area, EXC_STD, n);				\

/*
 * HV variant exceptions get the 0x2 bit added to their trap number.
 */
#define TRAMP_KVM_HV(area, n)						\
	TRAMP_KVM_BEGIN(do_kvm_H##n);					\
	KVM_HANDLER(area, EXC_HV, n + 0x2);				\

#define TRAMP_KVM_HV_SKIP(area, n)					\
	TRAMP_KVM_BEGIN(do_kvm_H##n);					\
	KVM_HANDLER_SKIP(area, EXC_HV, n + 0x2);			\

#define EXC_COMMON(name, realvec, hdlr)					\
	EXC_COMMON_BEGIN(name);						\
	STD_EXCEPTION_COMMON(realvec, name, hdlr);			\

#define EXC_COMMON_ASYNC(name, realvec, hdlr)				\
	EXC_COMMON_BEGIN(name);						\
	STD_EXCEPTION_COMMON_ASYNC(realvec, name, hdlr);		\

#endif /* __ASSEMBLY__ */

#endif	/* _ASM_POWERPC_HEAD_64_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
da2bc464 ME	2	#ifndef _ASM_POWERPC_HEAD_64_H
	3	#define _ASM_POWERPC_HEAD_64_H
	4
	5	#include <asm/cache.h>
	6
8c388514	7	#ifdef __ASSEMBLY__
57f26649 NP	8	/*
	9	* We can't do CPP stringification and concatination directly into the section
	10	* name for some reason, so these macros can do it for us.
	11	*/
	12	.macro define_ftsec name
	13	.section ".head.text.\name\()","ax",@progbits
	14	.endm
	15	.macro define_data_ftsec name
	16	.section ".head.data.\name\()","a",@progbits
	17	.endm
	18	.macro use_ftsec name
	19	.section ".head.text.\name\()"
	20	.endm
	21
	22	/*
	23	* Fixed (location) sections are used by opening fixed sections and emitting
	24	* fixed section entries into them before closing them. Multiple fixed sections
	25	* can be open at any time.
	26	*
	27	* Each fixed section created in a .S file must have corresponding linkage
	28	* directives including location, added to arch/powerpc/kernel/vmlinux.lds.S
	29	*
	30	* For each fixed section, code is generated into it in the order which it
	31	* appears in the source. Fixed section entries can be placed at a fixed
	32	* location within the section using _LOCATION postifx variants. These must
	33	* be ordered according to their relative placements within the section.
	34	*
	35	* OPEN_FIXED_SECTION(section_name, start_address, end_address)
	36	* FIXED_SECTION_ENTRY_BEGIN(section_name, label1)
	37	*
	38	* USE_FIXED_SECTION(section_name)
	39	* label3:
	40	* li r10,128
	41	* mv r11,r10
	42
1a6822d1 NP	43	* FIXED_SECTION_ENTRY_BEGIN_LOCATION(section_name, label2, start_address, size)
1a6822d1 NP	44	* FIXED_SECTION_ENTRY_END_LOCATION(section_name, label2, start_address, size)
57f26649 NP	45	* CLOSE_FIXED_SECTION(section_name)
	46	*
	47	* ZERO_FIXED_SECTION can be used to emit zeroed data.
	48	*
	49	* Troubleshooting:
	50	* - If the build dies with "Error: attempt to move .org backwards" at
	51	* CLOSE_FIXED_SECTION() or elsewhere, there may be something
	52	* unexpected being added there. Remove the '. = x_len' line, rebuild, and
	53	* check what is pushing the section down.
c494adef NP	54	* - If the build dies in linking, check arch/powerpc/tools/head_check.sh
c494adef NP	55	* comments.
57f26649 NP	56	* - If the kernel crashes or hangs in very early boot, it could be linker
	57	* stubs at the start of the main text.
	58	*/
	59
	60	#define OPEN_FIXED_SECTION(sname, start, end) \
	61	sname##_start = (start); \
	62	sname##_end = (end); \
	63	sname##_len = (end) - (start); \
	64	define_ftsec sname; \
	65	. = 0x0; \
	66	start_##sname:
	67
951eedeb NP	68	/*
	69	* .linker_stub_catch section is used to catch linker stubs from being
	70	* inserted in our .text section, above the start_text label (which breaks
	71	* the ABS_ADDR calculation). See kernel/vmlinux.lds.S and tools/head_check.sh
	72	* for more details. We would prefer to just keep a cacheline (0x80), but
	73	* 0x100 seems to be how the linker aligns branch stub groups.
	74	*/
	75	#ifdef CONFIG_LD_HEAD_STUB_CATCH
	76	#define OPEN_TEXT_SECTION(start) \
	77	.section ".linker_stub_catch","ax",@progbits; \
	78	linker_stub_catch: \
	79	. = 0x4; \
	80	text_start = (start) + 0x100; \
	81	.section ".text","ax",@progbits; \
	82	.balign 0x100; \
	83	start_text:
	84	#else
57f26649 NP	85	#define OPEN_TEXT_SECTION(start) \
	86	text_start = (start); \
	87	.section ".text","ax",@progbits; \
	88	. = 0x0; \
	89	start_text:
951eedeb	90	#endif
57f26649 NP	91
	92	#define ZERO_FIXED_SECTION(sname, start, end) \
	93	sname##_start = (start); \
	94	sname##_end = (end); \
	95	sname##_len = (end) - (start); \
	96	define_data_ftsec sname; \
	97	. = 0x0; \
	98	. = sname##_len;
	99
	100	#define USE_FIXED_SECTION(sname) \
	101	fs_label = start_##sname; \
	102	fs_start = sname##_start; \
	103	use_ftsec sname;
	104
	105	#define USE_TEXT_SECTION() \
	106	fs_label = start_text; \
	107	fs_start = text_start; \
	108	.text
	109
	110	#define CLOSE_FIXED_SECTION(sname) \
	111	USE_FIXED_SECTION(sname); \
	112	. = sname##_len; \
	113	end_##sname:
	114
	115
	116	#define __FIXED_SECTION_ENTRY_BEGIN(sname, name, __align) \
	117	USE_FIXED_SECTION(sname); \
f4329f2e	118	.balign __align; \
57f26649 NP	119	.global name; \
	120	name:
	121
	122	#define FIXED_SECTION_ENTRY_BEGIN(sname, name) \
f4329f2e	123	__FIXED_SECTION_ENTRY_BEGIN(sname, name, IFETCH_ALIGN_BYTES)
57f26649	124
1a6822d1	125	#define FIXED_SECTION_ENTRY_BEGIN_LOCATION(sname, name, start, size) \
57f26649 NP	126	USE_FIXED_SECTION(sname); \
57f26649 NP	127	name##_start = (start); \
1a6822d1 NP	128	.if ((start) % (size) != 0); \
	129	.error "Fixed section exception vector misalignment"; \
	130	.endif; \
	131	.if ((size) != 0x20) && ((size) != 0x80) && ((size) != 0x100); \
	132	.error "Fixed section exception vector bad size"; \
	133	.endif; \
57f26649 NP	134	.if (start) < sname##_start; \
	135	.error "Fixed section underflow"; \
	136	.abort; \
	137	.endif; \
	138	. = (start) - sname##_start; \
	139	.global name; \
	140	name:
	141
1a6822d1 NP	142	#define FIXED_SECTION_ENTRY_END_LOCATION(sname, name, start, size) \
1a6822d1 NP	143	.if (start) + (size) > sname##_end; \
57f26649 NP	144	.error "Fixed section overflow"; \
	145	.abort; \
	146	.endif; \
1a6822d1	147	.if (. - name > (start) + (size) - name##_start); \
57f26649 NP	148	.error "Fixed entry overflow"; \
	149	.abort; \
	150	.endif; \
1a6822d1	151	. = ((start) + (size) - sname##_start); \
57f26649 NP	152
	153
	154	/*
	155	* These macros are used to change symbols in other fixed sections to be
	156	* absolute or related to our current fixed section.
	157	*
	158	* - DEFINE_FIXED_SYMBOL / FIXED_SYMBOL_ABS_ADDR is used to find the
	159	* absolute address of a symbol within a fixed section, from any section.
	160	*
	161	* - ABS_ADDR is used to find the absolute address of any symbol, from within
	162	* a fixed section.
	163	*/
	164	#define DEFINE_FIXED_SYMBOL(label) \
	165	label##_absolute = (label - fs_label + fs_start)
	166
	167	#define FIXED_SYMBOL_ABS_ADDR(label) \
	168	(label##_absolute)
	169
	170	#define ABS_ADDR(label) (label - fs_label + fs_start)
	171
	172	/*
	173	* Following are the BOOK3S exception handler helper macros.
	174	* Handlers come in a number of types, and each type has a number of varieties.
	175	*
852e5da9 NP	176	* EXC_REAL_* - real, unrelocated exception vectors
852e5da9 NP	177	* EXC_VIRT_* - virt (AIL), unrelocated exception vectors
57f26649	178	* TRAMP_REAL_* - real, unrelocated helpers (virt can call these)
852e5da9 NP	179	* TRAMP_VIRT_* - virt, unreloc helpers (in practice, real can use)
852e5da9 NP	180	* TRAMP_KVM - KVM handlers that get put into real, unrelocated
872e2ae4	181	* EXC_COMMON - virt, relocated common handlers
57f26649 NP	182	*
	183	* The EXC handlers are given a name, and branch to name_common, or the
	184	* appropriate KVM or masking function. Vector handler verieties are as
	185	* follows:
	186	*
	187	* EXC_{REAL\|VIRT}_BEGIN/END - used to open-code the exception
	188	*
	189	* EXC_{REAL\|VIRT} - standard exception
	190	*
	191	* EXC_{REAL\|VIRT}_suffix
	192	* where _suffix is:
	193	* - _MASKABLE - maskable exception
	194	* - _OOL - out of line with trampoline to common handler
	195	* - _HV - HV exception
	196	*
	197	* There can be combinations, e.g., EXC_VIRT_OOL_MASKABLE_HV
	198	*
	199	* The one unusual case is __EXC_REAL_OOL_HV_DIRECT, which is
	200	* an OOL vector that branches to a specified handler rather than the usual
	201	* trampoline that goes to common. It, and other underscore macros, should
	202	* be used with care.
	203	*
	204	* KVM handlers come in the following verieties:
	205	* TRAMP_KVM
	206	* TRAMP_KVM_SKIP
	207	* TRAMP_KVM_HV
	208	* TRAMP_KVM_HV_SKIP
	209	*
	210	* COMMON handlers come in the following verieties:
	211	* EXC_COMMON_BEGIN/END - used to open-code the handler
	212	* EXC_COMMON
	213	* EXC_COMMON_ASYNC
57f26649 NP	214	*
	215	* TRAMP_REAL and TRAMP_VIRT can be used with BEGIN/END. KVM
	216	* and OOL handlers are implemented as types of TRAMP and TRAMP_VIRT handlers.
	217	*/
	218
1a6822d1 NP	219	#define EXC_REAL_BEGIN(name, start, size) \
1a6822d1 NP	220	FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##name, start, size)
da2bc464	221
1a6822d1 NP	222	#define EXC_REAL_END(name, start, size) \
1a6822d1 NP	223	FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##name, start, size)
da2bc464	224
1a6822d1 NP	225	#define EXC_VIRT_BEGIN(name, start, size) \
1a6822d1 NP	226	FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size)
da2bc464	227
1a6822d1 NP	228	#define EXC_VIRT_END(name, start, size) \
1a6822d1 NP	229	FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size)
da2bc464	230
852e5da9 NP	231	#define EXC_COMMON_BEGIN(name) \
	232	USE_TEXT_SECTION(); \
	233	.balign IFETCH_ALIGN_BYTES; \
	234	.global name; \
9a914aa6	235	_ASM_NOKPROBE_SYMBOL(name); \
852e5da9	236	DEFINE_FIXED_SYMBOL(name); \
da2bc464 ME	237	name:
	238
	239	#define TRAMP_REAL_BEGIN(name) \
57f26649 NP	240	FIXED_SECTION_ENTRY_BEGIN(real_trampolines, name)
	241
	242	#define TRAMP_VIRT_BEGIN(name) \
	243	FIXED_SECTION_ENTRY_BEGIN(virt_trampolines, name)
da2bc464 ME	244
da2bc464 ME	245	#ifdef CONFIG_KVM_BOOK3S_64_HANDLER
852e5da9	246	#define TRAMP_KVM_BEGIN(name) \
7ede5317	247	TRAMP_VIRT_BEGIN(name)
da2bc464 ME	248	#else
	249	#define TRAMP_KVM_BEGIN(name)
	250	#endif
	251
1a6822d1 NP	252	#define EXC_REAL_NONE(start, size) \
	253	FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##unused, start, size); \
	254	FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##unused, start, size)
da2bc464	255
1a6822d1 NP	256	#define EXC_VIRT_NONE(start, size) \
	257	FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size); \
	258	FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size);
da2bc464 ME	259
da2bc464 ME	260
1a6822d1 NP	261	#define EXC_REAL(name, start, size) \
1a6822d1 NP	262	EXC_REAL_BEGIN(name, start, size); \
e899fce5	263	STD_EXCEPTION(start, name##_common); \
1a6822d1	264	EXC_REAL_END(name, start, size);
da2bc464	265
1a6822d1 NP	266	#define EXC_VIRT(name, start, size, realvec) \
1a6822d1 NP	267	EXC_VIRT_BEGIN(name, start, size); \
e42389c5	268	STD_RELON_EXCEPTION(start, realvec, name##_common); \
1a6822d1	269	EXC_VIRT_END(name, start, size);
da2bc464	270
f14e953b	271	#define EXC_REAL_MASKABLE(name, start, size, bitmask) \
1a6822d1	272	EXC_REAL_BEGIN(name, start, size); \
b536da7c	273	MASKABLE_EXCEPTION(start, name##_common, bitmask); \
1a6822d1	274	EXC_REAL_END(name, start, size);
da2bc464	275
f14e953b	276	#define EXC_VIRT_MASKABLE(name, start, size, realvec, bitmask) \
1a6822d1	277	EXC_VIRT_BEGIN(name, start, size); \
b536da7c	278	MASKABLE_RELON_EXCEPTION(realvec, name##_common, bitmask); \
1a6822d1	279	EXC_VIRT_END(name, start, size);
da2bc464	280
1a6822d1 NP	281	#define EXC_REAL_HV(name, start, size) \
1a6822d1 NP	282	EXC_REAL_BEGIN(name, start, size); \
da2bc464	283	STD_EXCEPTION_HV(start, start, name##_common); \
1a6822d1	284	EXC_REAL_END(name, start, size);
da2bc464	285
1a6822d1 NP	286	#define EXC_VIRT_HV(name, start, size, realvec) \
1a6822d1 NP	287	EXC_VIRT_BEGIN(name, start, size); \
da2bc464	288	STD_RELON_EXCEPTION_HV(start, realvec, name##_common); \
1a6822d1	289	EXC_VIRT_END(name, start, size);
da2bc464	290
1a6822d1 NP	291	#define __EXC_REAL_OOL(name, start, size) \
1a6822d1 NP	292	EXC_REAL_BEGIN(name, start, size); \
da2bc464	293	__OOL_EXCEPTION(start, label, tramp_real_##name); \
1a6822d1	294	EXC_REAL_END(name, start, size);
da2bc464	295
852e5da9	296	#define __TRAMP_REAL_OOL(name, vec) \
da2bc464	297	TRAMP_REAL_BEGIN(tramp_real_##name); \
75e8bef3	298	STD_EXCEPTION_OOL(vec, name##_common);
da2bc464	299
1a6822d1 NP	300	#define EXC_REAL_OOL(name, start, size) \
1a6822d1 NP	301	__EXC_REAL_OOL(name, start, size); \
852e5da9	302	__TRAMP_REAL_OOL(name, start);
57f26649	303
1a6822d1 NP	304	#define __EXC_REAL_OOL_MASKABLE(name, start, size) \
1a6822d1 NP	305	__EXC_REAL_OOL(name, start, size);
da2bc464	306
f14e953b	307	#define __TRAMP_REAL_OOL_MASKABLE(name, vec, bitmask) \
da2bc464	308	TRAMP_REAL_BEGIN(tramp_real_##name); \
0a55c241	309	MASKABLE_EXCEPTION_OOL(vec, name##_common, bitmask);
da2bc464	310
f14e953b	311	#define EXC_REAL_OOL_MASKABLE(name, start, size, bitmask) \
1a6822d1	312	__EXC_REAL_OOL_MASKABLE(name, start, size); \
f14e953b	313	__TRAMP_REAL_OOL_MASKABLE(name, start, bitmask);
57f26649	314
1a6822d1 NP	315	#define __EXC_REAL_OOL_HV_DIRECT(name, start, size, handler) \
1a6822d1 NP	316	EXC_REAL_BEGIN(name, start, size); \
da2bc464	317	__OOL_EXCEPTION(start, label, handler); \
1a6822d1	318	EXC_REAL_END(name, start, size);
da2bc464	319
1a6822d1 NP	320	#define __EXC_REAL_OOL_HV(name, start, size) \
1a6822d1 NP	321	__EXC_REAL_OOL(name, start, size);
da2bc464	322
852e5da9	323	#define __TRAMP_REAL_OOL_HV(name, vec) \
da2bc464 ME	324	TRAMP_REAL_BEGIN(tramp_real_##name); \
	325	STD_EXCEPTION_HV_OOL(vec, name##_common); \
	326
1a6822d1 NP	327	#define EXC_REAL_OOL_HV(name, start, size) \
1a6822d1 NP	328	__EXC_REAL_OOL_HV(name, start, size); \
852e5da9	329	__TRAMP_REAL_OOL_HV(name, start);
57f26649	330
1a6822d1 NP	331	#define __EXC_REAL_OOL_MASKABLE_HV(name, start, size) \
1a6822d1 NP	332	__EXC_REAL_OOL(name, start, size);
da2bc464	333
f14e953b	334	#define __TRAMP_REAL_OOL_MASKABLE_HV(name, vec, bitmask) \
da2bc464	335	TRAMP_REAL_BEGIN(tramp_real_##name); \
f14e953b	336	MASKABLE_EXCEPTION_HV_OOL(vec, name##_common, bitmask); \
da2bc464	337
f14e953b	338	#define EXC_REAL_OOL_MASKABLE_HV(name, start, size, bitmask) \
1a6822d1	339	__EXC_REAL_OOL_MASKABLE_HV(name, start, size); \
f14e953b	340	__TRAMP_REAL_OOL_MASKABLE_HV(name, start, bitmask);
57f26649	341
1a6822d1 NP	342	#define __EXC_VIRT_OOL(name, start, size) \
1a6822d1 NP	343	EXC_VIRT_BEGIN(name, start, size); \
da2bc464	344	__OOL_EXCEPTION(start, label, tramp_virt_##name); \
1a6822d1	345	EXC_VIRT_END(name, start, size);
da2bc464	346
852e5da9 NP	347	#define __TRAMP_VIRT_OOL(name, realvec) \
852e5da9 NP	348	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
b706f423	349	STD_RELON_EXCEPTION_OOL(realvec, name##_common);
da2bc464	350
1a6822d1 NP	351	#define EXC_VIRT_OOL(name, start, size, realvec) \
1a6822d1 NP	352	__EXC_VIRT_OOL(name, start, size); \
852e5da9	353	__TRAMP_VIRT_OOL(name, realvec);
57f26649	354
1a6822d1 NP	355	#define __EXC_VIRT_OOL_MASKABLE(name, start, size) \
1a6822d1 NP	356	__EXC_VIRT_OOL(name, start, size);
da2bc464	357
f14e953b	358	#define __TRAMP_VIRT_OOL_MASKABLE(name, realvec, bitmask) \
852e5da9	359	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
0a55c241	360	MASKABLE_RELON_EXCEPTION_OOL(realvec, name##_common, bitmask);
da2bc464	361
f14e953b	362	#define EXC_VIRT_OOL_MASKABLE(name, start, size, realvec, bitmask) \
1a6822d1	363	__EXC_VIRT_OOL_MASKABLE(name, start, size); \
f14e953b	364	__TRAMP_VIRT_OOL_MASKABLE(name, realvec, bitmask);
57f26649	365
1a6822d1 NP	366	#define __EXC_VIRT_OOL_HV(name, start, size) \
1a6822d1 NP	367	__EXC_VIRT_OOL(name, start, size);
da2bc464	368
852e5da9 NP	369	#define __TRAMP_VIRT_OOL_HV(name, realvec) \
852e5da9 NP	370	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
da2bc464 ME	371	STD_RELON_EXCEPTION_HV_OOL(realvec, name##_common); \
da2bc464 ME	372
1a6822d1 NP	373	#define EXC_VIRT_OOL_HV(name, start, size, realvec) \
1a6822d1 NP	374	__EXC_VIRT_OOL_HV(name, start, size); \
852e5da9	375	__TRAMP_VIRT_OOL_HV(name, realvec);
57f26649	376
1a6822d1 NP	377	#define __EXC_VIRT_OOL_MASKABLE_HV(name, start, size) \
1a6822d1 NP	378	__EXC_VIRT_OOL(name, start, size);
da2bc464	379
f14e953b	380	#define __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec, bitmask) \
852e5da9	381	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
f14e953b	382	MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common, bitmask);\
da2bc464	383
f14e953b	384	#define EXC_VIRT_OOL_MASKABLE_HV(name, start, size, realvec, bitmask) \
1a6822d1	385	__EXC_VIRT_OOL_MASKABLE_HV(name, start, size); \
f14e953b	386	__TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec, bitmask);
57f26649	387
da2bc464 ME	388	#define TRAMP_KVM(area, n) \
	389	TRAMP_KVM_BEGIN(do_kvm_##n); \
	390	KVM_HANDLER(area, EXC_STD, n); \
	391
	392	#define TRAMP_KVM_SKIP(area, n) \
	393	TRAMP_KVM_BEGIN(do_kvm_##n); \
	394	KVM_HANDLER_SKIP(area, EXC_STD, n); \
	395
57f26649 NP	396	/*
	397	* HV variant exceptions get the 0x2 bit added to their trap number.
	398	*/
da2bc464 ME	399	#define TRAMP_KVM_HV(area, n) \
	400	TRAMP_KVM_BEGIN(do_kvm_H##n); \
	401	KVM_HANDLER(area, EXC_HV, n + 0x2); \
	402
	403	#define TRAMP_KVM_HV_SKIP(area, n) \
	404	TRAMP_KVM_BEGIN(do_kvm_H##n); \
	405	KVM_HANDLER_SKIP(area, EXC_HV, n + 0x2); \
	406
852e5da9 NP	407	#define EXC_COMMON(name, realvec, hdlr) \
852e5da9 NP	408	EXC_COMMON_BEGIN(name); \
da2bc464 ME	409	STD_EXCEPTION_COMMON(realvec, name, hdlr); \
da2bc464 ME	410
852e5da9 NP	411	#define EXC_COMMON_ASYNC(name, realvec, hdlr) \
852e5da9 NP	412	EXC_COMMON_BEGIN(name); \
da2bc464 ME	413	STD_EXCEPTION_COMMON_ASYNC(realvec, name, hdlr); \
da2bc464 ME	414
8c388514 NP	415	#endif /* __ASSEMBLY__ */
8c388514 NP	416
da2bc464	417	#endif /* _ASM_POWERPC_HEAD_64_H */