Merge branch 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull x86 fixes from Ingo Molnar:
 "Another round of CR3/PCID related fixes (I think this addresses all
  but one of the known problems with PCID support), an objtool fix plus
  a Clang fix that (finally) solves all Clang quirks to build a bootable
  x86 kernel as-is"

* 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  x86/asm: Fix inline asm call constraints for Clang
  objtool: Handle another GCC stack pointer adjustment bug
  x86/mm/32: Load a sane CR3 before cpu_init() on secondary CPUs
  x86/mm/32: Move setup_clear_cpu_cap(X86_FEATURE_PCID) earlier
  x86/mm/64: Stop using CR3.PCID == 0 in ASID-aware code
  x86/mm: Factor out CR3-building code

3 files changed, 35 insertions, 20 deletions

diff --git a/tools/objtool/Documentation/stack-validation.txt b/tools/objtool/Documentation/stack-validation.txt
index 6a1af43862df..3995735a878f 100644
--- a/tools/objtool/Documentation/stack-validation.txt
+++ b/tools/objtool/Documentation/stack-validation.txt
@@ -194,10 +194,10 @@ they mean, and suggestions for how to fix them.
    If it's a GCC-compiled .c file, the error may be because the function
    uses an inline asm() statement which has a "call" instruction.  An
    asm() statement with a call instruction must declare the use of the
-   stack pointer in its output operand.  For example, on x86_64:
+   stack pointer in its output operand.  On x86_64, this means adding
+   the ASM_CALL_CONSTRAINT as an output constraint:
 
-     register void *__sp asm("rsp");
-     asm volatile("call func" : "+r" (__sp));
+     asm volatile("call func" : ASM_CALL_CONSTRAINT);
 
    Otherwise the stack frame may not get created before the call.
 
diff --git a/tools/objtool/arch/x86/decode.c b/tools/objtool/arch/x86/decode.c
index 0e8c8ec4fd4e..0f22768c0d4d 100644
--- a/tools/objtool/arch/x86/decode.c
+++ b/tools/objtool/arch/x86/decode.c
@@ -208,14 +208,14 @@ int arch_decode_instruction(struct elf *elf, struct section *sec,
                 break;
 
         case 0x89:
-                if (rex == 0x48 && modrm == 0xe5) {
+                if (rex_w && !rex_r && modrm_mod == 3 && modrm_reg == 4) {
 
-                        /* mov %rsp, %rbp */
+                        /* mov %rsp, reg */
                         *type = INSN_STACK;
                         op->src.type = OP_SRC_REG;
                         op->src.reg = CFI_SP;
                         op->dest.type = OP_DEST_REG;
-                        op->dest.reg = CFI_BP;
+                        op->dest.reg = op_to_cfi_reg[modrm_rm][rex_b];
                         break;
                 }
 
diff --git a/tools/objtool/check.c b/tools/objtool/check.c
index f744617c9946..a0c518ecf085 100644
--- a/tools/objtool/check.c
+++ b/tools/objtool/check.c
@@ -1203,24 +1203,39 @@ static int update_insn_state(struct instruction *insn, struct insn_state *state)
                 switch (op->src.type) {
 
                 case OP_SRC_REG:
-                        if (op->src.reg == CFI_SP && op->dest.reg == CFI_BP) {
+                        if (op->src.reg == CFI_SP && op->dest.reg == CFI_BP &&
+                            cfa->base == CFI_SP &&
+                            regs[CFI_BP].base == CFI_CFA &&
+                            regs[CFI_BP].offset == -cfa->offset) {
+
+                                /* mov %rsp, %rbp */
+                                cfa->base = op->dest.reg;
+                                state->bp_scratch = false;
+                        }
 
-                                if (cfa->base == CFI_SP &&
-                                    regs[CFI_BP].base == CFI_CFA &&
-                                    regs[CFI_BP].offset == -cfa->offset) {
+                        else if (op->src.reg == CFI_SP &&
+                                 op->dest.reg == CFI_BP && state->drap) {
 
-                                        /* mov %rsp, %rbp */
-                                        cfa->base = op->dest.reg;
-                                        state->bp_scratch = false;
-                                }
+                                /* drap: mov %rsp, %rbp */
+                                regs[CFI_BP].base = CFI_BP;
+                                regs[CFI_BP].offset = -state->stack_size;
+                                state->bp_scratch = false;
+                        }
 
-                                else if (state->drap) {
+                        else if (op->src.reg == CFI_SP && cfa->base == CFI_SP) {
 
-                                        /* drap: mov %rsp, %rbp */
-                                        regs[CFI_BP].base = CFI_BP;
-                                        regs[CFI_BP].offset = -state->stack_size;
-                                        state->bp_scratch = false;
-                                }
+                                /*
+                                 * mov %rsp, %reg
+                                 *
+                                 * This is needed for the rare case where GCC
+                                 * does:
+                                 *
+                                 *   mov    %rsp, %rax
+                                 *   ...
+                                 *   mov    %rax, %rsp
+                                 */
+                                state->vals[op->dest.reg].base = CFI_CFA;
+                                state->vals[op->dest.reg].offset = -state->stack_size;
                         }
 
                         else if (op->dest.reg == cfa->base) {