Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f5caf621 authored by Josh Poimboeuf's avatar Josh Poimboeuf Committed by Ingo Molnar
Browse files

x86/asm: Fix inline asm call constraints for Clang 



For inline asm statements which have a CALL instruction, we list the
stack pointer as a constraint to convince GCC to ensure the frame
pointer is set up first:

  static inline void foo()
  {
	register void *__sp asm(_ASM_SP);
	asm("call bar" : "+r" (__sp))
  }

Unfortunately, that pattern causes Clang to corrupt the stack pointer.

The fix is easy: convert the stack pointer register variable to a global
variable.

It should be noted that the end result is different based on the GCC
version.  With GCC 6.4, this patch has exactly the same result as
before:

	defconfig	defconfig-nofp	distro		distro-nofp
 before	9820389		9491555		8816046		8516940
 after	9820389		9491555		8816046		8516940

With GCC 7.2, however, GCC's behavior has changed.  It now changes its
behavior based on the conversion of the register variable to a global.
That somehow convinces it to *always* set up the frame pointer before
inserting *any* inline asm.  (Therefore, listing the variable as an
output constraint is a no-op and is no longer necessary.)  It's a bit
overkill, but the performance impact should be negligible.  And in fact,
there's a nice improvement with frame pointers disabled:

	defconfig	defconfig-nofp	distro		distro-nofp
 before	9796316		9468236		9076191		8790305
 after	9796957		9464267		9076381		8785949

So in summary, while listing the stack pointer as an output constraint
is no longer necessary for newer versions of GCC, it's still needed for
older versions.

Suggested-by: default avatarAndrey Ryabinin <aryabinin@virtuozzo.com>
Reported-by: default avatarMatthias Kaehlcke <mka@chromium.org>
Signed-off-by: default avatarJosh Poimboeuf <jpoimboe@redhat.com>
Cc: Alexander Potapenko <glider@google.com>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Dmitriy Vyukov <dvyukov@google.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Miguel Bernal Marin <miguel.bernal.marin@linux.intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/3db862e970c432ae823cf515c52b54fec8270e0e.1505942196.git.jpoimboe@redhat.com


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent 0d0970ee

arch/x86/include/asm/alternative.h

+1 −2
Original line number Diff line number Diff line
@@ -218,10 +218,9 @@ static inline int alternatives_text_reserved(void *start, void *end) 
#define alternative_call_2(oldfunc, newfunc1, feature1, newfunc2, feature2,   \

			   output, input...)				      \

{									      \

	register void *__sp asm(_ASM_SP);				      \

	asm volatile (ALTERNATIVE_2("call %P[old]", "call %P[new1]", feature1,\

		"call %P[new2]", feature2)				      \

		: output, "+r" (__sp)					      \

		: output, ASM_CALL_CONSTRAINT				      \

		: [old] "i" (oldfunc), [new1] "i" (newfunc1),		      \

		  [new2] "i" (newfunc2), ## input);			      \

}

arch/x86/include/asm/asm.h

+11 −0
Original line number Diff line number Diff line
@@ -132,4 +132,15 @@ 
/* For C file, we already have NOKPROBE_SYMBOL macro */

#endif



#ifndef __ASSEMBLY__

/*

 * This output constraint should be used for any inline asm which has a "call"

 * instruction.  Otherwise the asm may be inserted before the frame pointer

 * gets set up by the containing function.  If you forget to do this, objtool

 * may print a "call without frame pointer save/setup" warning.

 */

register unsigned int __asm_call_sp asm("esp");

#define ASM_CALL_CONSTRAINT "+r" (__asm_call_sp)

#endif



#endif /* _ASM_X86_ASM_H */

arch/x86/include/asm/mshyperv.h

+4 −6
Original line number Diff line number Diff line
@@ -179,7 +179,6 @@ static inline u64 hv_do_hypercall(u64 control, void *input, void *output) 
	u64 input_address = input ? virt_to_phys(input) : 0;

	u64 output_address = output ? virt_to_phys(output) : 0;

	u64 hv_status;

	register void *__sp asm(_ASM_SP);



#ifdef CONFIG_X86_64

	if (!hv_hypercall_pg)
@@ -187,7 +186,7 @@ static inline u64 hv_do_hypercall(u64 control, void *input, void *output) 


	__asm__ __volatile__("mov %4, %%r8\n"

			     "call *%5"

			     : "=a" (hv_status), "+r" (__sp),

			     : "=a" (hv_status), ASM_CALL_CONSTRAINT,

			       "+c" (control), "+d" (input_address)

			     :  "r" (output_address), "m" (hv_hypercall_pg)

			     : "cc", "memory", "r8", "r9", "r10", "r11");
@@ -202,7 +201,7 @@ static inline u64 hv_do_hypercall(u64 control, void *input, void *output) 


	__asm__ __volatile__("call *%7"

			     : "=A" (hv_status),

			       "+c" (input_address_lo), "+r" (__sp)

			       "+c" (input_address_lo), ASM_CALL_CONSTRAINT

			     : "A" (control),

			       "b" (input_address_hi),

			       "D"(output_address_hi), "S"(output_address_lo),
@@ -224,12 +223,11 @@ static inline u64 hv_do_hypercall(u64 control, void *input, void *output) 
static inline u64 hv_do_fast_hypercall8(u16 code, u64 input1)

{

	u64 hv_status, control = (u64)code | HV_HYPERCALL_FAST_BIT;

	register void *__sp asm(_ASM_SP);



#ifdef CONFIG_X86_64

	{

		__asm__ __volatile__("call *%4"

				     : "=a" (hv_status), "+r" (__sp),

				     : "=a" (hv_status), ASM_CALL_CONSTRAINT,

				       "+c" (control), "+d" (input1)

				     : "m" (hv_hypercall_pg)

				     : "cc", "r8", "r9", "r10", "r11");
@@ -242,7 +240,7 @@ static inline u64 hv_do_fast_hypercall8(u16 code, u64 input1) 
		__asm__ __volatile__ ("call *%5"

				      : "=A"(hv_status),

					"+c"(input1_lo),

					"+r"(__sp)

					ASM_CALL_CONSTRAINT

				      :	"A" (control),

					"b" (input1_hi),

					"m" (hv_hypercall_pg)

arch/x86/include/asm/paravirt_types.h

+7 −7
Original line number Diff line number Diff line
@@ -459,8 +459,8 @@ int paravirt_disable_iospace(void); 
 */

#ifdef CONFIG_X86_32

#define PVOP_VCALL_ARGS							\

	unsigned long __eax = __eax, __edx = __edx, __ecx = __ecx;	\

	register void *__sp asm("esp")

	unsigned long __eax = __eax, __edx = __edx, __ecx = __ecx;



#define PVOP_CALL_ARGS			PVOP_VCALL_ARGS



#define PVOP_CALL_ARG1(x)		"a" ((unsigned long)(x))
@@ -480,8 +480,8 @@ int paravirt_disable_iospace(void); 
/* [re]ax isn't an arg, but the return val */

#define PVOP_VCALL_ARGS						\

	unsigned long __edi = __edi, __esi = __esi,		\

		__edx = __edx, __ecx = __ecx, __eax = __eax;	\

	register void *__sp asm("rsp")

		__edx = __edx, __ecx = __ecx, __eax = __eax;



#define PVOP_CALL_ARGS		PVOP_VCALL_ARGS



#define PVOP_CALL_ARG1(x)		"D" ((unsigned long)(x))
@@ -532,7 +532,7 @@ int paravirt_disable_iospace(void); 
			asm volatile(pre				\

				     paravirt_alt(PARAVIRT_CALL)	\

				     post				\

				     : call_clbr, "+r" (__sp)		\

				     : call_clbr, ASM_CALL_CONSTRAINT	\

				     : paravirt_type(op),		\

				       paravirt_clobber(clbr),		\

				       ##__VA_ARGS__			\
@@ -542,7 +542,7 @@ int paravirt_disable_iospace(void); 
			asm volatile(pre				\

				     paravirt_alt(PARAVIRT_CALL)	\

				     post				\

				     : call_clbr, "+r" (__sp)		\

				     : call_clbr, ASM_CALL_CONSTRAINT	\

				     : paravirt_type(op),		\

				       paravirt_clobber(clbr),		\

				       ##__VA_ARGS__			\
@@ -569,7 +569,7 @@ int paravirt_disable_iospace(void); 
		asm volatile(pre					\

			     paravirt_alt(PARAVIRT_CALL)		\

			     post					\

			     : call_clbr, "+r" (__sp)			\

			     : call_clbr, ASM_CALL_CONSTRAINT		\

			     : paravirt_type(op),			\

			       paravirt_clobber(clbr),			\

			       ##__VA_ARGS__				\

arch/x86/include/asm/preempt.h

+5 −10
Original line number Diff line number Diff line
@@ -101,18 +101,13 @@ static __always_inline bool should_resched(int preempt_offset) 
#ifdef CONFIG_PREEMPT

  extern asmlinkage void ___preempt_schedule(void);

# define __preempt_schedule() \

({								\

	register void *__sp asm(_ASM_SP);			\

	asm volatile ("call ___preempt_schedule" : "+r"(__sp));	\

})

	asm volatile ("call ___preempt_schedule" : ASM_CALL_CONSTRAINT)



  extern asmlinkage void preempt_schedule(void);

  extern asmlinkage void ___preempt_schedule_notrace(void);

# define __preempt_schedule_notrace() \

({									\

	register void *__sp asm(_ASM_SP);				\

	asm volatile ("call ___preempt_schedule_notrace" : "+r"(__sp));	\

})

	asm volatile ("call ___preempt_schedule_notrace" : ASM_CALL_CONSTRAINT)



  extern asmlinkage void preempt_schedule_notrace(void);

#endif