mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Mikulas Patocka](/assets/img/avatar_default.png)
The new ORC unwinder breaks the build of a 64-bit kernel on a 32-bit
host. Building the kernel on a i386 or x32 host fails with:
orc_dump.c: In function 'orc_dump':
orc_dump.c:105:26: error: passing argument 2 of 'elf_getshdrnum' from incompatible pointer type [-Werror=incompatible-pointer-types]
if (elf_getshdrnum(elf, &nr_sections)) {
^
In file included from /usr/local/include/gelf.h:32:0,
from elf.h:22,
from warn.h:26,
from orc_dump.c:20:
/usr/local/include/libelf.h:304:12: note: expected 'size_t * {aka unsigned int *}' but argument is of type 'long unsigned int *'
extern int elf_getshdrnum (Elf *__elf, size_t *__dst);
^~~~~~~~~~~~~~
orc_dump.c:190:17: error: format '%lx' expects argument of type 'long unsigned int', but argument 3 has type 'Elf64_Sxword {aka long long int}' [-Werror=format=]
printf("%s+%lx:", name, rela.r_addend);
~~^ ~~~~~~~~~~~~~
%llx
Fix the build failure.
Another problem is that if the user specifies HOSTCC or HOSTLD
variables, they are ignored in the objtool makefile. Change the
Makefile to respect these variables.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Sven Joachim <svenjoac@gmx.de>
Cc: Thomas Gleixner <tglx@linutronix.de>
Fixes: 627fce1480
("objtool: Add ORC unwind table generation")
Link: http://lkml.kernel.org/r/19f0e64d8e07e30a7b307cd010eb780c404fe08d.1512252895.git.jpoimboe@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
213 lines
4.3 KiB
C
213 lines
4.3 KiB
C
/*
|
|
* Copyright (C) 2017 Josh Poimboeuf <jpoimboe@redhat.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <unistd.h>
|
|
#include "orc.h"
|
|
#include "warn.h"
|
|
|
|
static const char *reg_name(unsigned int reg)
|
|
{
|
|
switch (reg) {
|
|
case ORC_REG_PREV_SP:
|
|
return "prevsp";
|
|
case ORC_REG_DX:
|
|
return "dx";
|
|
case ORC_REG_DI:
|
|
return "di";
|
|
case ORC_REG_BP:
|
|
return "bp";
|
|
case ORC_REG_SP:
|
|
return "sp";
|
|
case ORC_REG_R10:
|
|
return "r10";
|
|
case ORC_REG_R13:
|
|
return "r13";
|
|
case ORC_REG_BP_INDIRECT:
|
|
return "bp(ind)";
|
|
case ORC_REG_SP_INDIRECT:
|
|
return "sp(ind)";
|
|
default:
|
|
return "?";
|
|
}
|
|
}
|
|
|
|
static const char *orc_type_name(unsigned int type)
|
|
{
|
|
switch (type) {
|
|
case ORC_TYPE_CALL:
|
|
return "call";
|
|
case ORC_TYPE_REGS:
|
|
return "regs";
|
|
case ORC_TYPE_REGS_IRET:
|
|
return "iret";
|
|
default:
|
|
return "?";
|
|
}
|
|
}
|
|
|
|
static void print_reg(unsigned int reg, int offset)
|
|
{
|
|
if (reg == ORC_REG_BP_INDIRECT)
|
|
printf("(bp%+d)", offset);
|
|
else if (reg == ORC_REG_SP_INDIRECT)
|
|
printf("(sp%+d)", offset);
|
|
else if (reg == ORC_REG_UNDEFINED)
|
|
printf("(und)");
|
|
else
|
|
printf("%s%+d", reg_name(reg), offset);
|
|
}
|
|
|
|
int orc_dump(const char *_objname)
|
|
{
|
|
int fd, nr_entries, i, *orc_ip = NULL, orc_size = 0;
|
|
struct orc_entry *orc = NULL;
|
|
char *name;
|
|
size_t nr_sections;
|
|
Elf64_Addr orc_ip_addr = 0;
|
|
size_t shstrtab_idx;
|
|
Elf *elf;
|
|
Elf_Scn *scn;
|
|
GElf_Shdr sh;
|
|
GElf_Rela rela;
|
|
GElf_Sym sym;
|
|
Elf_Data *data, *symtab = NULL, *rela_orc_ip = NULL;
|
|
|
|
|
|
objname = _objname;
|
|
|
|
elf_version(EV_CURRENT);
|
|
|
|
fd = open(objname, O_RDONLY);
|
|
if (fd == -1) {
|
|
perror("open");
|
|
return -1;
|
|
}
|
|
|
|
elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
|
|
if (!elf) {
|
|
WARN_ELF("elf_begin");
|
|
return -1;
|
|
}
|
|
|
|
if (elf_getshdrnum(elf, &nr_sections)) {
|
|
WARN_ELF("elf_getshdrnum");
|
|
return -1;
|
|
}
|
|
|
|
if (elf_getshdrstrndx(elf, &shstrtab_idx)) {
|
|
WARN_ELF("elf_getshdrstrndx");
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < nr_sections; i++) {
|
|
scn = elf_getscn(elf, i);
|
|
if (!scn) {
|
|
WARN_ELF("elf_getscn");
|
|
return -1;
|
|
}
|
|
|
|
if (!gelf_getshdr(scn, &sh)) {
|
|
WARN_ELF("gelf_getshdr");
|
|
return -1;
|
|
}
|
|
|
|
name = elf_strptr(elf, shstrtab_idx, sh.sh_name);
|
|
if (!name) {
|
|
WARN_ELF("elf_strptr");
|
|
return -1;
|
|
}
|
|
|
|
data = elf_getdata(scn, NULL);
|
|
if (!data) {
|
|
WARN_ELF("elf_getdata");
|
|
return -1;
|
|
}
|
|
|
|
if (!strcmp(name, ".symtab")) {
|
|
symtab = data;
|
|
} else if (!strcmp(name, ".orc_unwind")) {
|
|
orc = data->d_buf;
|
|
orc_size = sh.sh_size;
|
|
} else if (!strcmp(name, ".orc_unwind_ip")) {
|
|
orc_ip = data->d_buf;
|
|
orc_ip_addr = sh.sh_addr;
|
|
} else if (!strcmp(name, ".rela.orc_unwind_ip")) {
|
|
rela_orc_ip = data;
|
|
}
|
|
}
|
|
|
|
if (!symtab || !orc || !orc_ip)
|
|
return 0;
|
|
|
|
if (orc_size % sizeof(*orc) != 0) {
|
|
WARN("bad .orc_unwind section size");
|
|
return -1;
|
|
}
|
|
|
|
nr_entries = orc_size / sizeof(*orc);
|
|
for (i = 0; i < nr_entries; i++) {
|
|
if (rela_orc_ip) {
|
|
if (!gelf_getrela(rela_orc_ip, i, &rela)) {
|
|
WARN_ELF("gelf_getrela");
|
|
return -1;
|
|
}
|
|
|
|
if (!gelf_getsym(symtab, GELF_R_SYM(rela.r_info), &sym)) {
|
|
WARN_ELF("gelf_getsym");
|
|
return -1;
|
|
}
|
|
|
|
scn = elf_getscn(elf, sym.st_shndx);
|
|
if (!scn) {
|
|
WARN_ELF("elf_getscn");
|
|
return -1;
|
|
}
|
|
|
|
if (!gelf_getshdr(scn, &sh)) {
|
|
WARN_ELF("gelf_getshdr");
|
|
return -1;
|
|
}
|
|
|
|
name = elf_strptr(elf, shstrtab_idx, sh.sh_name);
|
|
if (!name || !*name) {
|
|
WARN_ELF("elf_strptr");
|
|
return -1;
|
|
}
|
|
|
|
printf("%s+%llx:", name, (unsigned long long)rela.r_addend);
|
|
|
|
} else {
|
|
printf("%llx:", (unsigned long long)(orc_ip_addr + (i * sizeof(int)) + orc_ip[i]));
|
|
}
|
|
|
|
|
|
printf(" sp:");
|
|
|
|
print_reg(orc[i].sp_reg, orc[i].sp_offset);
|
|
|
|
printf(" bp:");
|
|
|
|
print_reg(orc[i].bp_reg, orc[i].bp_offset);
|
|
|
|
printf(" type:%s\n", orc_type_name(orc[i].type));
|
|
}
|
|
|
|
elf_end(elf);
|
|
close(fd);
|
|
|
|
return 0;
|
|
}
|