mirror of
https://github.com/torvalds/linux.git
synced 2024-11-12 23:23:03 +00:00
60253f100c
The currently supported minimum gcc version is 5.1. Before that, the PIC register, when generating Position Independent Code, was considered "fixed" in the sense that it wasn't in the set of registers available to the compiler's register allocator. Which, on x86-32, is already a very small set. What is more, the register allocator was unable to satisfy extended asm "=b" constraints. (Yes, PIC code uses %ebx on 32-bit as the base reg.) With gcc 5.1: "Reuse of the PIC hard register, instead of using a fixed register, was implemented on x86/x86-64 targets. This improves generated PIC code performance as more hard registers can be used. Shared libraries can significantly benefit from this optimization. Currently it is switched on only for x86/x86-64 targets. As RA infrastructure is already implemented for PIC register reuse, other targets might follow this in the future." (from: https://gcc.gnu.org/gcc-5/changes.html) which basically means that the register allocator has a higher degree of freedom when handling %ebx, including reloading it with the correct value before a PIC access. Furthermore: arch/x86/Makefile: # Never want PIC in a 32-bit kernel, prevent breakage with GCC built # with nonstandard options KBUILD_CFLAGS += -fno-pic $ gcc -Wp,-MMD,arch/x86/boot/.cpuflags.o.d ... -fno-pic ... -D__KBUILD_MODNAME=kmod_cpuflags -c -o arch/x86/boot/cpuflags.o arch/x86/boot/cpuflags.c so the 32-bit workaround in cpuid_count() is fixing exactly nothing because 32-bit configs don't even allow PIC builds. As to 64-bit builds: they're done using -mcmodel=kernel which produces RIP-relative addressing for PIC builds and thus does not apply here either. So get rid of the thing and make cpuid_count() nice and simple. There should be no functional changes resulting from this. [ bp: Expand commit message. ] Signed-off-by: Uros Bizjak <ubizjak@gmail.com> Signed-off-by: Borislav Petkov <bp@suse.de> Link: https://lore.kernel.org/r/20221104124546.196077-1-ubizjak@gmail.com
120 lines
2.6 KiB
C
120 lines
2.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <linux/types.h>
|
|
#include "bitops.h"
|
|
|
|
#include <asm/processor-flags.h>
|
|
#include <asm/required-features.h>
|
|
#include <asm/msr-index.h>
|
|
#include "cpuflags.h"
|
|
|
|
struct cpu_features cpu;
|
|
u32 cpu_vendor[3];
|
|
|
|
static bool loaded_flags;
|
|
|
|
static int has_fpu(void)
|
|
{
|
|
u16 fcw = -1, fsw = -1;
|
|
unsigned long cr0;
|
|
|
|
asm volatile("mov %%cr0,%0" : "=r" (cr0));
|
|
if (cr0 & (X86_CR0_EM|X86_CR0_TS)) {
|
|
cr0 &= ~(X86_CR0_EM|X86_CR0_TS);
|
|
asm volatile("mov %0,%%cr0" : : "r" (cr0));
|
|
}
|
|
|
|
asm volatile("fninit ; fnstsw %0 ; fnstcw %1"
|
|
: "+m" (fsw), "+m" (fcw));
|
|
|
|
return fsw == 0 && (fcw & 0x103f) == 0x003f;
|
|
}
|
|
|
|
/*
|
|
* For building the 16-bit code we want to explicitly specify 32-bit
|
|
* push/pop operations, rather than just saying 'pushf' or 'popf' and
|
|
* letting the compiler choose. But this is also included from the
|
|
* compressed/ directory where it may be 64-bit code, and thus needs
|
|
* to be 'pushfq' or 'popfq' in that case.
|
|
*/
|
|
#ifdef __x86_64__
|
|
#define PUSHF "pushfq"
|
|
#define POPF "popfq"
|
|
#else
|
|
#define PUSHF "pushfl"
|
|
#define POPF "popfl"
|
|
#endif
|
|
|
|
int has_eflag(unsigned long mask)
|
|
{
|
|
unsigned long f0, f1;
|
|
|
|
asm volatile(PUSHF " \n\t"
|
|
PUSHF " \n\t"
|
|
"pop %0 \n\t"
|
|
"mov %0,%1 \n\t"
|
|
"xor %2,%1 \n\t"
|
|
"push %1 \n\t"
|
|
POPF " \n\t"
|
|
PUSHF " \n\t"
|
|
"pop %1 \n\t"
|
|
POPF
|
|
: "=&r" (f0), "=&r" (f1)
|
|
: "ri" (mask));
|
|
|
|
return !!((f0^f1) & mask);
|
|
}
|
|
|
|
void cpuid_count(u32 id, u32 count, u32 *a, u32 *b, u32 *c, u32 *d)
|
|
{
|
|
asm volatile("cpuid"
|
|
: "=a" (*a), "=b" (*b), "=c" (*c), "=d" (*d)
|
|
: "0" (id), "2" (count)
|
|
);
|
|
}
|
|
|
|
#define cpuid(id, a, b, c, d) cpuid_count(id, 0, a, b, c, d)
|
|
|
|
void get_cpuflags(void)
|
|
{
|
|
u32 max_intel_level, max_amd_level;
|
|
u32 tfms;
|
|
u32 ignored;
|
|
|
|
if (loaded_flags)
|
|
return;
|
|
loaded_flags = true;
|
|
|
|
if (has_fpu())
|
|
set_bit(X86_FEATURE_FPU, cpu.flags);
|
|
|
|
if (has_eflag(X86_EFLAGS_ID)) {
|
|
cpuid(0x0, &max_intel_level, &cpu_vendor[0], &cpu_vendor[2],
|
|
&cpu_vendor[1]);
|
|
|
|
if (max_intel_level >= 0x00000001 &&
|
|
max_intel_level <= 0x0000ffff) {
|
|
cpuid(0x1, &tfms, &ignored, &cpu.flags[4],
|
|
&cpu.flags[0]);
|
|
cpu.level = (tfms >> 8) & 15;
|
|
cpu.family = cpu.level;
|
|
cpu.model = (tfms >> 4) & 15;
|
|
if (cpu.level >= 6)
|
|
cpu.model += ((tfms >> 16) & 0xf) << 4;
|
|
}
|
|
|
|
if (max_intel_level >= 0x00000007) {
|
|
cpuid_count(0x00000007, 0, &ignored, &ignored,
|
|
&cpu.flags[16], &ignored);
|
|
}
|
|
|
|
cpuid(0x80000000, &max_amd_level, &ignored, &ignored,
|
|
&ignored);
|
|
|
|
if (max_amd_level >= 0x80000001 &&
|
|
max_amd_level <= 0x8000ffff) {
|
|
cpuid(0x80000001, &ignored, &ignored, &cpu.flags[6],
|
|
&cpu.flags[1]);
|
|
}
|
|
}
|
|
}
|