[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
 * EXC_COMMON_HV
 *
 * 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_PSERIES(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_PSERIES(start, realvec, name##_common);	\
	EXC_VIRT_END(name, start, size);

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

#define EXC_VIRT_MASKABLE(name, start, size, realvec)			\
	EXC_VIRT_BEGIN(name, start, size);				\
	MASKABLE_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \
	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_PSERIES_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)				\
	TRAMP_REAL_BEGIN(tramp_real_##name);				\
	MASKABLE_EXCEPTION_PSERIES_OOL(vec, name##_common);		\

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

#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)				\
	TRAMP_REAL_BEGIN(tramp_real_##name);				\
	MASKABLE_EXCEPTION_HV_OOL(vec, name##_common);			\

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

#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_PSERIES_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)			\
	TRAMP_VIRT_BEGIN(tramp_virt_##name);				\
	MASKABLE_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common);	\

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

#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)			\
	TRAMP_VIRT_BEGIN(tramp_virt_##name);				\
	MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common);	\

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

#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);		\

#define EXC_COMMON_HV(name, realvec, hdlr)				\
	EXC_COMMON_BEGIN(name);						\
	STD_EXCEPTION_COMMON(realvec + 0x2, 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)
	180	* TRAMP_KVM - KVM handlers that get put into real, unrelocated
	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
	214	* EXC_COMMON_HV
	215	*
	216	* TRAMP_REAL and TRAMP_VIRT can be used with BEGIN/END. KVM
	217	* and OOL handlers are implemented as types of TRAMP and TRAMP_VIRT handlers.
	218	*/
	219
1a6822d1 NP	220	#define EXC_REAL_BEGIN(name, start, size) \
1a6822d1 NP	221	FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##name, start, size)
da2bc464	222
1a6822d1 NP	223	#define EXC_REAL_END(name, start, size) \
1a6822d1 NP	224	FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##name, start, size)
da2bc464	225
1a6822d1 NP	226	#define EXC_VIRT_BEGIN(name, start, size) \
1a6822d1 NP	227	FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size)
da2bc464	228
1a6822d1 NP	229	#define EXC_VIRT_END(name, start, size) \
1a6822d1 NP	230	FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size)
da2bc464	231
852e5da9 NP	232	#define EXC_COMMON_BEGIN(name) \
	233	USE_TEXT_SECTION(); \
	234	.balign IFETCH_ALIGN_BYTES; \
	235	.global name; \
9a914aa6	236	_ASM_NOKPROBE_SYMBOL(name); \
852e5da9	237	DEFINE_FIXED_SYMBOL(name); \
da2bc464 ME	238	name:
	239
	240	#define TRAMP_REAL_BEGIN(name) \
57f26649 NP	241	FIXED_SECTION_ENTRY_BEGIN(real_trampolines, name)
	242
	243	#define TRAMP_VIRT_BEGIN(name) \
	244	FIXED_SECTION_ENTRY_BEGIN(virt_trampolines, name)
da2bc464 ME	245
da2bc464 ME	246	#ifdef CONFIG_KVM_BOOK3S_64_HANDLER
852e5da9	247	#define TRAMP_KVM_BEGIN(name) \
7ede5317	248	TRAMP_VIRT_BEGIN(name)
da2bc464 ME	249	#else
	250	#define TRAMP_KVM_BEGIN(name)
	251	#endif
	252
1a6822d1 NP	253	#define EXC_REAL_NONE(start, size) \
	254	FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##unused, start, size); \
	255	FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##unused, start, size)
da2bc464	256
1a6822d1 NP	257	#define EXC_VIRT_NONE(start, size) \
	258	FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size); \
	259	FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size);
da2bc464 ME	260
da2bc464 ME	261
1a6822d1 NP	262	#define EXC_REAL(name, start, size) \
1a6822d1 NP	263	EXC_REAL_BEGIN(name, start, size); \
da2bc464	264	STD_EXCEPTION_PSERIES(start, name##_common); \
1a6822d1	265	EXC_REAL_END(name, start, size);
da2bc464	266
1a6822d1 NP	267	#define EXC_VIRT(name, start, size, realvec) \
1a6822d1 NP	268	EXC_VIRT_BEGIN(name, start, size); \
da2bc464	269	STD_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \
1a6822d1	270	EXC_VIRT_END(name, start, size);
da2bc464	271
1a6822d1 NP	272	#define EXC_REAL_MASKABLE(name, start, size) \
1a6822d1 NP	273	EXC_REAL_BEGIN(name, start, size); \
da2bc464	274	MASKABLE_EXCEPTION_PSERIES(start, start, name##_common); \
1a6822d1	275	EXC_REAL_END(name, start, size);
da2bc464	276
1a6822d1 NP	277	#define EXC_VIRT_MASKABLE(name, start, size, realvec) \
1a6822d1 NP	278	EXC_VIRT_BEGIN(name, start, size); \
da2bc464	279	MASKABLE_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \
1a6822d1	280	EXC_VIRT_END(name, start, size);
da2bc464	281
1a6822d1 NP	282	#define EXC_REAL_HV(name, start, size) \
1a6822d1 NP	283	EXC_REAL_BEGIN(name, start, size); \
da2bc464	284	STD_EXCEPTION_HV(start, start, name##_common); \
1a6822d1	285	EXC_REAL_END(name, start, size);
da2bc464	286
1a6822d1 NP	287	#define EXC_VIRT_HV(name, start, size, realvec) \
1a6822d1 NP	288	EXC_VIRT_BEGIN(name, start, size); \
da2bc464	289	STD_RELON_EXCEPTION_HV(start, realvec, name##_common); \
1a6822d1	290	EXC_VIRT_END(name, start, size);
da2bc464	291
1a6822d1 NP	292	#define __EXC_REAL_OOL(name, start, size) \
1a6822d1 NP	293	EXC_REAL_BEGIN(name, start, size); \
da2bc464	294	__OOL_EXCEPTION(start, label, tramp_real_##name); \
1a6822d1	295	EXC_REAL_END(name, start, size);
da2bc464	296
852e5da9	297	#define __TRAMP_REAL_OOL(name, vec) \
da2bc464 ME	298	TRAMP_REAL_BEGIN(tramp_real_##name); \
	299	STD_EXCEPTION_PSERIES_OOL(vec, name##_common); \
	300
1a6822d1 NP	301	#define EXC_REAL_OOL(name, start, size) \
1a6822d1 NP	302	__EXC_REAL_OOL(name, start, size); \
852e5da9	303	__TRAMP_REAL_OOL(name, start);
57f26649	304
1a6822d1 NP	305	#define __EXC_REAL_OOL_MASKABLE(name, start, size) \
1a6822d1 NP	306	__EXC_REAL_OOL(name, start, size);
da2bc464	307
852e5da9	308	#define __TRAMP_REAL_OOL_MASKABLE(name, vec) \
da2bc464 ME	309	TRAMP_REAL_BEGIN(tramp_real_##name); \
	310	MASKABLE_EXCEPTION_PSERIES_OOL(vec, name##_common); \
	311
1a6822d1 NP	312	#define EXC_REAL_OOL_MASKABLE(name, start, size) \
1a6822d1 NP	313	__EXC_REAL_OOL_MASKABLE(name, start, size); \
852e5da9	314	__TRAMP_REAL_OOL_MASKABLE(name, start);
57f26649	315
1a6822d1 NP	316	#define __EXC_REAL_OOL_HV_DIRECT(name, start, size, handler) \
1a6822d1 NP	317	EXC_REAL_BEGIN(name, start, size); \
da2bc464	318	__OOL_EXCEPTION(start, label, handler); \
1a6822d1	319	EXC_REAL_END(name, start, size);
da2bc464	320
1a6822d1 NP	321	#define __EXC_REAL_OOL_HV(name, start, size) \
1a6822d1 NP	322	__EXC_REAL_OOL(name, start, size);
da2bc464	323
852e5da9	324	#define __TRAMP_REAL_OOL_HV(name, vec) \
da2bc464 ME	325	TRAMP_REAL_BEGIN(tramp_real_##name); \
	326	STD_EXCEPTION_HV_OOL(vec, name##_common); \
	327
1a6822d1 NP	328	#define EXC_REAL_OOL_HV(name, start, size) \
1a6822d1 NP	329	__EXC_REAL_OOL_HV(name, start, size); \
852e5da9	330	__TRAMP_REAL_OOL_HV(name, start);
57f26649	331
1a6822d1 NP	332	#define __EXC_REAL_OOL_MASKABLE_HV(name, start, size) \
1a6822d1 NP	333	__EXC_REAL_OOL(name, start, size);
da2bc464	334
852e5da9	335	#define __TRAMP_REAL_OOL_MASKABLE_HV(name, vec) \
da2bc464 ME	336	TRAMP_REAL_BEGIN(tramp_real_##name); \
	337	MASKABLE_EXCEPTION_HV_OOL(vec, name##_common); \
	338
1a6822d1 NP	339	#define EXC_REAL_OOL_MASKABLE_HV(name, start, size) \
1a6822d1 NP	340	__EXC_REAL_OOL_MASKABLE_HV(name, start, size); \
852e5da9	341	__TRAMP_REAL_OOL_MASKABLE_HV(name, start);
57f26649	342
1a6822d1 NP	343	#define __EXC_VIRT_OOL(name, start, size) \
1a6822d1 NP	344	EXC_VIRT_BEGIN(name, start, size); \
da2bc464	345	__OOL_EXCEPTION(start, label, tramp_virt_##name); \
1a6822d1	346	EXC_VIRT_END(name, start, size);
da2bc464	347
852e5da9 NP	348	#define __TRAMP_VIRT_OOL(name, realvec) \
852e5da9 NP	349	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
da2bc464 ME	350	STD_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common); \
da2bc464 ME	351
1a6822d1 NP	352	#define EXC_VIRT_OOL(name, start, size, realvec) \
1a6822d1 NP	353	__EXC_VIRT_OOL(name, start, size); \
852e5da9	354	__TRAMP_VIRT_OOL(name, realvec);
57f26649	355
1a6822d1 NP	356	#define __EXC_VIRT_OOL_MASKABLE(name, start, size) \
1a6822d1 NP	357	__EXC_VIRT_OOL(name, start, size);
da2bc464	358
852e5da9 NP	359	#define __TRAMP_VIRT_OOL_MASKABLE(name, realvec) \
852e5da9 NP	360	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
da2bc464 ME	361	MASKABLE_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common); \
da2bc464 ME	362
1a6822d1 NP	363	#define EXC_VIRT_OOL_MASKABLE(name, start, size, realvec) \
1a6822d1 NP	364	__EXC_VIRT_OOL_MASKABLE(name, start, size); \
852e5da9	365	__TRAMP_VIRT_OOL_MASKABLE(name, realvec);
57f26649	366
1a6822d1 NP	367	#define __EXC_VIRT_OOL_HV(name, start, size) \
1a6822d1 NP	368	__EXC_VIRT_OOL(name, start, size);
da2bc464	369
852e5da9 NP	370	#define __TRAMP_VIRT_OOL_HV(name, realvec) \
852e5da9 NP	371	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
da2bc464 ME	372	STD_RELON_EXCEPTION_HV_OOL(realvec, name##_common); \
da2bc464 ME	373
1a6822d1 NP	374	#define EXC_VIRT_OOL_HV(name, start, size, realvec) \
1a6822d1 NP	375	__EXC_VIRT_OOL_HV(name, start, size); \
852e5da9	376	__TRAMP_VIRT_OOL_HV(name, realvec);
57f26649	377
1a6822d1 NP	378	#define __EXC_VIRT_OOL_MASKABLE_HV(name, start, size) \
1a6822d1 NP	379	__EXC_VIRT_OOL(name, start, size);
da2bc464	380
852e5da9 NP	381	#define __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec) \
852e5da9 NP	382	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
da2bc464 ME	383	MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common); \
da2bc464 ME	384
1a6822d1 NP	385	#define EXC_VIRT_OOL_MASKABLE_HV(name, start, size, realvec) \
1a6822d1 NP	386	__EXC_VIRT_OOL_MASKABLE_HV(name, start, size); \
852e5da9	387	__TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec);
57f26649	388
da2bc464 ME	389	#define TRAMP_KVM(area, n) \
	390	TRAMP_KVM_BEGIN(do_kvm_##n); \
	391	KVM_HANDLER(area, EXC_STD, n); \
	392
	393	#define TRAMP_KVM_SKIP(area, n) \
	394	TRAMP_KVM_BEGIN(do_kvm_##n); \
	395	KVM_HANDLER_SKIP(area, EXC_STD, n); \
	396
57f26649 NP	397	/*
	398	* HV variant exceptions get the 0x2 bit added to their trap number.
	399	*/
da2bc464 ME	400	#define TRAMP_KVM_HV(area, n) \
	401	TRAMP_KVM_BEGIN(do_kvm_H##n); \
	402	KVM_HANDLER(area, EXC_HV, n + 0x2); \
	403
	404	#define TRAMP_KVM_HV_SKIP(area, n) \
	405	TRAMP_KVM_BEGIN(do_kvm_H##n); \
	406	KVM_HANDLER_SKIP(area, EXC_HV, n + 0x2); \
	407
852e5da9 NP	408	#define EXC_COMMON(name, realvec, hdlr) \
852e5da9 NP	409	EXC_COMMON_BEGIN(name); \
da2bc464 ME	410	STD_EXCEPTION_COMMON(realvec, name, hdlr); \
da2bc464 ME	411
852e5da9 NP	412	#define EXC_COMMON_ASYNC(name, realvec, hdlr) \
852e5da9 NP	413	EXC_COMMON_BEGIN(name); \
da2bc464 ME	414	STD_EXCEPTION_COMMON_ASYNC(realvec, name, hdlr); \
	415
	416	#define EXC_COMMON_HV(name, realvec, hdlr) \
852e5da9	417	EXC_COMMON_BEGIN(name); \
da2bc464 ME	418	STD_EXCEPTION_COMMON(realvec + 0x2, name, hdlr); \
da2bc464 ME	419
8c388514 NP	420	#endif /* __ASSEMBLY__ */
8c388514 NP	421
da2bc464	422	#endif /* _ASM_POWERPC_HEAD_64_H */