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

#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
da2bc464 ME	1	#ifndef _ASM_POWERPC_HEAD_64_H
	2	#define _ASM_POWERPC_HEAD_64_H
	3
	4	#include <asm/cache.h>
	5
8c388514	6	#ifdef __ASSEMBLY__
57f26649 NP	7	/*
	8	* We can't do CPP stringification and concatination directly into the section
	9	* name for some reason, so these macros can do it for us.
	10	*/
	11	.macro define_ftsec name
	12	.section ".head.text.\name\()","ax",@progbits
	13	.endm
	14	.macro define_data_ftsec name
	15	.section ".head.data.\name\()","a",@progbits
	16	.endm
	17	.macro use_ftsec name
	18	.section ".head.text.\name\()"
	19	.endm
	20
	21	/*
	22	* Fixed (location) sections are used by opening fixed sections and emitting
	23	* fixed section entries into them before closing them. Multiple fixed sections
	24	* can be open at any time.
	25	*
	26	* Each fixed section created in a .S file must have corresponding linkage
	27	* directives including location, added to arch/powerpc/kernel/vmlinux.lds.S
	28	*
	29	* For each fixed section, code is generated into it in the order which it
	30	* appears in the source. Fixed section entries can be placed at a fixed
	31	* location within the section using _LOCATION postifx variants. These must
	32	* be ordered according to their relative placements within the section.
	33	*
	34	* OPEN_FIXED_SECTION(section_name, start_address, end_address)
	35	* FIXED_SECTION_ENTRY_BEGIN(section_name, label1)
	36	*
	37	* USE_FIXED_SECTION(section_name)
	38	* label3:
	39	* li r10,128
	40	* mv r11,r10
	41
1a6822d1 NP	42	* FIXED_SECTION_ENTRY_BEGIN_LOCATION(section_name, label2, start_address, size)
1a6822d1 NP	43	* FIXED_SECTION_ENTRY_END_LOCATION(section_name, label2, start_address, size)
57f26649 NP	44	* CLOSE_FIXED_SECTION(section_name)
	45	*
	46	* ZERO_FIXED_SECTION can be used to emit zeroed data.
	47	*
	48	* Troubleshooting:
	49	* - If the build dies with "Error: attempt to move .org backwards" at
	50	* CLOSE_FIXED_SECTION() or elsewhere, there may be something
	51	* unexpected being added there. Remove the '. = x_len' line, rebuild, and
	52	* check what is pushing the section down.
c494adef NP	53	* - If the build dies in linking, check arch/powerpc/tools/head_check.sh
c494adef NP	54	* comments.
57f26649 NP	55	* - If the kernel crashes or hangs in very early boot, it could be linker
	56	* stubs at the start of the main text.
	57	*/
	58
	59	#define OPEN_FIXED_SECTION(sname, start, end) \
	60	sname##_start = (start); \
	61	sname##_end = (end); \
	62	sname##_len = (end) - (start); \
	63	define_ftsec sname; \
	64	. = 0x0; \
	65	start_##sname:
	66
951eedeb NP	67	/*
	68	* .linker_stub_catch section is used to catch linker stubs from being
	69	* inserted in our .text section, above the start_text label (which breaks
	70	* the ABS_ADDR calculation). See kernel/vmlinux.lds.S and tools/head_check.sh
	71	* for more details. We would prefer to just keep a cacheline (0x80), but
	72	* 0x100 seems to be how the linker aligns branch stub groups.
	73	*/
	74	#ifdef CONFIG_LD_HEAD_STUB_CATCH
	75	#define OPEN_TEXT_SECTION(start) \
	76	.section ".linker_stub_catch","ax",@progbits; \
	77	linker_stub_catch: \
	78	. = 0x4; \
	79	text_start = (start) + 0x100; \
	80	.section ".text","ax",@progbits; \
	81	.balign 0x100; \
	82	start_text:
	83	#else
57f26649 NP	84	#define OPEN_TEXT_SECTION(start) \
	85	text_start = (start); \
	86	.section ".text","ax",@progbits; \
	87	. = 0x0; \
	88	start_text:
951eedeb	89	#endif
57f26649 NP	90
	91	#define ZERO_FIXED_SECTION(sname, start, end) \
	92	sname##_start = (start); \
	93	sname##_end = (end); \
	94	sname##_len = (end) - (start); \
	95	define_data_ftsec sname; \
	96	. = 0x0; \
	97	. = sname##_len;
	98
	99	#define USE_FIXED_SECTION(sname) \
	100	fs_label = start_##sname; \
	101	fs_start = sname##_start; \
	102	use_ftsec sname;
	103
	104	#define USE_TEXT_SECTION() \
	105	fs_label = start_text; \
	106	fs_start = text_start; \
	107	.text
	108
	109	#define CLOSE_FIXED_SECTION(sname) \
	110	USE_FIXED_SECTION(sname); \
	111	. = sname##_len; \
	112	end_##sname:
	113
	114
	115	#define __FIXED_SECTION_ENTRY_BEGIN(sname, name, __align) \
	116	USE_FIXED_SECTION(sname); \
f4329f2e	117	.balign __align; \
57f26649 NP	118	.global name; \
	119	name:
	120
	121	#define FIXED_SECTION_ENTRY_BEGIN(sname, name) \
f4329f2e	122	__FIXED_SECTION_ENTRY_BEGIN(sname, name, IFETCH_ALIGN_BYTES)
57f26649	123
1a6822d1	124	#define FIXED_SECTION_ENTRY_BEGIN_LOCATION(sname, name, start, size) \
57f26649 NP	125	USE_FIXED_SECTION(sname); \
57f26649 NP	126	name##_start = (start); \
1a6822d1 NP	127	.if ((start) % (size) != 0); \
	128	.error "Fixed section exception vector misalignment"; \
	129	.endif; \
	130	.if ((size) != 0x20) && ((size) != 0x80) && ((size) != 0x100); \
	131	.error "Fixed section exception vector bad size"; \
	132	.endif; \
57f26649 NP	133	.if (start) < sname##_start; \
	134	.error "Fixed section underflow"; \
	135	.abort; \
	136	.endif; \
	137	. = (start) - sname##_start; \
	138	.global name; \
	139	name:
	140
1a6822d1 NP	141	#define FIXED_SECTION_ENTRY_END_LOCATION(sname, name, start, size) \
1a6822d1 NP	142	.if (start) + (size) > sname##_end; \
57f26649 NP	143	.error "Fixed section overflow"; \
	144	.abort; \
	145	.endif; \
1a6822d1	146	.if (. - name > (start) + (size) - name##_start); \
57f26649 NP	147	.error "Fixed entry overflow"; \
	148	.abort; \
	149	.endif; \
1a6822d1	150	. = ((start) + (size) - sname##_start); \
57f26649 NP	151
	152
	153	/*
	154	* These macros are used to change symbols in other fixed sections to be
	155	* absolute or related to our current fixed section.
	156	*
	157	* - DEFINE_FIXED_SYMBOL / FIXED_SYMBOL_ABS_ADDR is used to find the
	158	* absolute address of a symbol within a fixed section, from any section.
	159	*
	160	* - ABS_ADDR is used to find the absolute address of any symbol, from within
	161	* a fixed section.
	162	*/
	163	#define DEFINE_FIXED_SYMBOL(label) \
	164	label##_absolute = (label - fs_label + fs_start)
	165
	166	#define FIXED_SYMBOL_ABS_ADDR(label) \
	167	(label##_absolute)
	168
	169	#define ABS_ADDR(label) (label - fs_label + fs_start)
	170
	171	/*
	172	* Following are the BOOK3S exception handler helper macros.
	173	* Handlers come in a number of types, and each type has a number of varieties.
	174	*
852e5da9 NP	175	* EXC_REAL_* - real, unrelocated exception vectors
852e5da9 NP	176	* EXC_VIRT_* - virt (AIL), unrelocated exception vectors
57f26649	177	* TRAMP_REAL_* - real, unrelocated helpers (virt can call these)
852e5da9 NP	178	* TRAMP_VIRT_* - virt, unreloc helpers (in practice, real can use)
	179	* TRAMP_KVM - KVM handlers that get put into real, unrelocated
	180	* EXC_COMMON_* - virt, relocated common handlers
57f26649 NP	181	*
	182	* The EXC handlers are given a name, and branch to name_common, or the
	183	* appropriate KVM or masking function. Vector handler verieties are as
	184	* follows:
	185	*
	186	* EXC_{REAL\|VIRT}_BEGIN/END - used to open-code the exception
	187	*
	188	* EXC_{REAL\|VIRT} - standard exception
	189	*
	190	* EXC_{REAL\|VIRT}_suffix
	191	* where _suffix is:
	192	* - _MASKABLE - maskable exception
	193	* - _OOL - out of line with trampoline to common handler
	194	* - _HV - HV exception
	195	*
	196	* There can be combinations, e.g., EXC_VIRT_OOL_MASKABLE_HV
	197	*
	198	* The one unusual case is __EXC_REAL_OOL_HV_DIRECT, which is
	199	* an OOL vector that branches to a specified handler rather than the usual
	200	* trampoline that goes to common. It, and other underscore macros, should
	201	* be used with care.
	202	*
	203	* KVM handlers come in the following verieties:
	204	* TRAMP_KVM
	205	* TRAMP_KVM_SKIP
	206	* TRAMP_KVM_HV
	207	* TRAMP_KVM_HV_SKIP
	208	*
	209	* COMMON handlers come in the following verieties:
	210	* EXC_COMMON_BEGIN/END - used to open-code the handler
	211	* EXC_COMMON
	212	* EXC_COMMON_ASYNC
	213	* EXC_COMMON_HV
	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); \
da2bc464	263	STD_EXCEPTION_PSERIES(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); \
da2bc464	268	STD_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \
1a6822d1	269	EXC_VIRT_END(name, start, size);
da2bc464	270
1a6822d1 NP	271	#define EXC_REAL_MASKABLE(name, start, size) \
1a6822d1 NP	272	EXC_REAL_BEGIN(name, start, size); \
da2bc464	273	MASKABLE_EXCEPTION_PSERIES(start, start, name##_common); \
1a6822d1	274	EXC_REAL_END(name, start, size);
da2bc464	275
1a6822d1 NP	276	#define EXC_VIRT_MASKABLE(name, start, size, realvec) \
1a6822d1 NP	277	EXC_VIRT_BEGIN(name, start, size); \
da2bc464	278	MASKABLE_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \
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 ME	297	TRAMP_REAL_BEGIN(tramp_real_##name); \
	298	STD_EXCEPTION_PSERIES_OOL(vec, name##_common); \
	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
852e5da9	307	#define __TRAMP_REAL_OOL_MASKABLE(name, vec) \
da2bc464 ME	308	TRAMP_REAL_BEGIN(tramp_real_##name); \
	309	MASKABLE_EXCEPTION_PSERIES_OOL(vec, name##_common); \
	310
1a6822d1 NP	311	#define EXC_REAL_OOL_MASKABLE(name, start, size) \
1a6822d1 NP	312	__EXC_REAL_OOL_MASKABLE(name, start, size); \
852e5da9	313	__TRAMP_REAL_OOL_MASKABLE(name, start);
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
852e5da9	334	#define __TRAMP_REAL_OOL_MASKABLE_HV(name, vec) \
da2bc464 ME	335	TRAMP_REAL_BEGIN(tramp_real_##name); \
	336	MASKABLE_EXCEPTION_HV_OOL(vec, name##_common); \
	337
1a6822d1 NP	338	#define EXC_REAL_OOL_MASKABLE_HV(name, start, size) \
1a6822d1 NP	339	__EXC_REAL_OOL_MASKABLE_HV(name, start, size); \
852e5da9	340	__TRAMP_REAL_OOL_MASKABLE_HV(name, start);
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); \
da2bc464 ME	349	STD_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common); \
da2bc464 ME	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
852e5da9 NP	358	#define __TRAMP_VIRT_OOL_MASKABLE(name, realvec) \
852e5da9 NP	359	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
da2bc464 ME	360	MASKABLE_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common); \
da2bc464 ME	361
1a6822d1 NP	362	#define EXC_VIRT_OOL_MASKABLE(name, start, size, realvec) \
1a6822d1 NP	363	__EXC_VIRT_OOL_MASKABLE(name, start, size); \
852e5da9	364	__TRAMP_VIRT_OOL_MASKABLE(name, realvec);
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
852e5da9 NP	380	#define __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec) \
852e5da9 NP	381	TRAMP_VIRT_BEGIN(tramp_virt_##name); \
da2bc464 ME	382	MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common); \
da2bc464 ME	383
1a6822d1 NP	384	#define EXC_VIRT_OOL_MASKABLE_HV(name, start, size, realvec) \
1a6822d1 NP	385	__EXC_VIRT_OOL_MASKABLE_HV(name, start, size); \
852e5da9	386	__TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec);
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); \
	414
	415	#define EXC_COMMON_HV(name, realvec, hdlr) \
852e5da9	416	EXC_COMMON_BEGIN(name); \
da2bc464 ME	417	STD_EXCEPTION_COMMON(realvec + 0x2, name, hdlr); \
da2bc464 ME	418
8c388514 NP	419	#endif /* __ASSEMBLY__ */
8c388514 NP	420
da2bc464	421	#endif /* _ASM_POWERPC_HEAD_64_H */