From patchwork Thu Aug 8 16:21:24 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Caleb Connolly X-Patchwork-Id: 817710 Delivered-To: patch@linaro.org Received: by 2002:a5d:4e11:0:b0:367:895a:4699 with SMTP id p17csp943591wrt; Thu, 8 Aug 2024 09:21:40 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUU02nLXFrkTDI3WrKNSpUJb7irfFWmwMcBcqujMJFowCbnAgeDZjF+xKTmmWYHC7lDvo1+QFGTYitw1wlKIqHI X-Google-Smtp-Source: AGHT+IGGWpt+KtjeFPDw4yaDr55g657ODp5UARYRaLv/hAyoWgvzNPhCL0uYlo2PEPFmLXNKbqp+ X-Received: by 2002:a05:6512:6d0:b0:52e:9f17:841a with SMTP id 2adb3069b0e04-530e5817c3amr1723707e87.6.1723134099950; Thu, 08 Aug 2024 09:21:39 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1723134099; cv=none; d=google.com; s=arc-20160816; b=phscQaqascvls72xUkB3KLbrReZiptmgv2qYORTj2XNdXO7EHAolxr+m1tbcMaMbrg rtVqm0mTF6/3Zwf1iMbY3jQc54wUvW+1j5f/txoxYRsz0il+C65OkiGneyVAonwqRBqR 2VxBZ/I3IWYVBZpsGMUbejBMJnGMF+E+ocz4Z4fahZAgc6vSMRs4y4giI/b2n1hSNj/p DILZ/PgVApgTstMN+6c6mcwt4YY38uZ1E1WshfYDb4K6YJVxc4vaHTD3EQS3cPCsBSzB 6ZUW74tR/9vFgY7fR5PtSG7WC6eB58/uIIHJy19/SpnscxinQnqIH1vLWut0GH2dsnyv iTew== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:cc:to:in-reply-to:references :message-id:content-transfer-encoding:mime-version:subject:date:from :dkim-signature; bh=Wg4jRVbd7gY6hlKT6oDl/Hpvk5ZDWRpDHWHmszoBOm0=; fh=tWp0SQOQ896cXmOREPWvRVz7nylodDMuGElA70rIR4k=; b=Qa/4hj5Gjko7AB3nvMhH/G365O5zFw3Pm189GOpG3UnY+tPVZIk9Gal5kV3ORKDg+b 4JYIU+HM4JoSDQSe2HC6h2lPFDOoAspLGeDdGCchCKtuGOpoz4RVseK7am4Z+Pr35v5I Tiu9p5/uVtsdp/QGCFqdzoorb5SohAGTNeRML/AZ3WeDj4oeutVZ4h1djc676O0/JTQy BLAAH3VsfH4FT8BSk7FVrxsW2FBUKqFiICkOsbY1g4Mp6R//Ast6cjBZqx3IHvTTsQ4r mWuxsjyV19slFrbxvH9qYY9gZJJPcD2cEqnYbZJTw7m4sERvikoTdfbMdWQvkqEr/qJw n68Q==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=FzHkte2l; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [2a01:238:438b:c500:173d:9f52:ddab:ee01]) by mx.google.com with ESMTPS id a640c23a62f3a-a7dc9c16796si788769066b.225.2024.08.08.09.21.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 08 Aug 2024 09:21:39 -0700 (PDT) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) client-ip=2a01:238:438b:c500:173d:9f52:ddab:ee01; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=FzHkte2l; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 2a01:238:438b:c500:173d:9f52:ddab:ee01 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id 682D688BAD; Thu, 8 Aug 2024 18:21:32 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="FzHkte2l"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id BA03288BD1; Thu, 8 Aug 2024 18:21:31 +0200 (CEST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-lj1-x234.google.com (mail-lj1-x234.google.com [IPv6:2a00:1450:4864:20::234]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id F3CFA88BBD for ; Thu, 8 Aug 2024 18:21:28 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=caleb.connolly@linaro.org Received: by mail-lj1-x234.google.com with SMTP id 38308e7fff4ca-2f15dd0b489so14529381fa.3 for ; Thu, 08 Aug 2024 09:21:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1723134088; x=1723738888; darn=lists.denx.de; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=Wg4jRVbd7gY6hlKT6oDl/Hpvk5ZDWRpDHWHmszoBOm0=; b=FzHkte2lOrPaesciIfz/wUAihPdSbjbzDdVpUkL/SScQqBPJjZta5LJ1Jw3OoRm6p6 R5f4g8kD8OdMkFpy3Keu6spc42bSrNEMUlnbjOtuRVXeMZfaEkVSuRG+W3K+DWaIzbbJ tYnKSHsANU5rZdf4sHF/dFU4T5hYoY1/dJ2zGzbPdNbfEf9SjxOpxaQ4EV0z+RlkCUDo qsrHywSVKyyHVvhCEdCB1WQncB/+/13Kjq6hKUHa450QnyXg3uLiyqXlg0RW/mvcgn/m EDmcWuhDu0PsTR588YFm+yrWJo07IOTs4EzfDq4UlfqGuzOn6qy2hIOT4qW5EzPrKiH9 muEw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1723134088; x=1723738888; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Wg4jRVbd7gY6hlKT6oDl/Hpvk5ZDWRpDHWHmszoBOm0=; b=ez3nBjpuzj08oINNfxhcHlmmzst7+XWoo2AP6VVcc9c8w0vl7T3+kQz0FMS9XVTuYY zakZPC/32vuhke6r5eKAxCPeYmepYIrrfmesxsh/uMWEQYUwYn7gqbPI7E9VSRwPZkt6 gD6OKBA4iP57MzCbR3ERZjwnx5SgiML9vBl853pKVo+qj4ZMhfRX0tv1EqW6FaVssWXf WeDt2q7u9LeitbewXKF4DHg/lATCIW9xsbsKTIC1fl01F5RagBigFRrTzsIqs9Z0G/5D 5RpUdkKv4dNuAopNhrjZwIorlvvcu1GhaeTVpSwLOj+TEYo819m5O9zfnvPNMpjz9non MPsQ== X-Forwarded-Encrypted: i=1; AJvYcCVX+IzTGbe0QD/Wv9uPBS8TZmORhNjnmXzWkMq/5uoh2HrJ8gbrnWOxphKIc7YHb3G0ZclTU8k+J+0JUqnRv22uHkoZ0Q== X-Gm-Message-State: AOJu0YzAiUeYNZt+mVDJel8HWxP+W1Y+t9zJlhCW51cyR1FKE2QiyB6Y 7qIwOFdt0YogNhYGfDEMIIxQ1DnBbnPk6T76MbS0rrRMpGAqiPYANp0kuOII8F/xbspcfn1tsKR aj24= X-Received: by 2002:a05:6512:3350:b0:530:ea60:7e07 with SMTP id 2adb3069b0e04-530ea607f49mr174887e87.58.1723134087905; Thu, 08 Aug 2024 09:21:27 -0700 (PDT) Received: from [192.168.0.113] ([2a02:8109:aa0d:be00::7424]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5bbb2e5d76dsm770396a12.80.2024.08.08.09.21.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 08 Aug 2024 09:21:27 -0700 (PDT) From: Caleb Connolly Date: Thu, 08 Aug 2024 18:21:24 +0200 Subject: [PATCH v2 1/3] drop unused kallsyms support MIME-Version: 1.0 Message-Id: <20240808-arm64-backtrace-v2-1-29665a2265cf@linaro.org> References: <20240808-arm64-backtrace-v2-0-29665a2265cf@linaro.org> In-Reply-To: <20240808-arm64-backtrace-v2-0-29665a2265cf@linaro.org> To: Tom Rini , Simon Glass , Ilias Apalodimas Cc: Marek Vasut , Mattijs Korpershoek , Neil Armstrong , u-boot@lists.denx.de, Caleb Connolly X-Mailer: b4 0.14-dev X-Developer-Signature: v=1; a=openpgp-sha256; l=3591; i=caleb.connolly@linaro.org; h=from:subject:message-id; bh=NO+PQveNYqHmlAO0iaQ7OWDTVqeT99W0zzS1ortQgtk=; b=owEBbQKS/ZANAwAIAQWDMSsZX2S2AcsmYgBmtPCF8YP+F9JuLYlyoVOVEFlY+xhOLodfx+MOP PxCe1Vy0YqJAjMEAAEIAB0WIQS2UaFGPGq+0GkMVc0FgzErGV9ktgUCZrTwhQAKCRAFgzErGV9k tm2ND/9dp157mQR51q0wfFGrf1LSHN0/U1zAWIYytYKmX0nuvyvaRILyd+S5fzmIiRoWr5aLMxi 5PNcHBiAwpLfNW/jIOtd13dI6zyILA8tIYCi14NyoKFq+Rc37J5au5xqG1+kHgIiB5ZeuWeJQvO 58IVexqYbViGdpP/kgzx5Hln/oMN2JS4W+PUQsk5F16GWgd6KSyWcn6AAQ7/90dgEGpQgrhkYU7 Fz3Q388mHolAVoLE3MnttnmWgGXMdOk9ijCX5rtXI9hCi0QY28XhaRow/YcoMfz1k/V7uhKYiIZ Q8UZxTVZOGppgxzSqYTZjdljTkrtFSfyUnwCqxAPICLa75SaV9rp1c4qtgRgPszeWaywEjUgbpP HQKWLZ1YNY3nIDtGQjallo9hcAwdrBTDJotL1sJeceb6dKLf+neceALe2LBgzOCkIE5BaZ9941p v2mcjQzeYQbWkvgDn5Z+0pfKZxIWv9lxaJTUUW2C8kh762F6LRjkEkvWB3BPMof1/2GCqIjCfFB iS3OPlC8y3Y0j3SdrJv/HKjiTDLcQPqNdD7R7Tgtfo5g/+pzhIzec085Y+Rw70dVKsIOsJ4JTIH a8rqh2aFwYl/0Ms/2wTfeR/5VwdjkteWBlHV81Dnf/8DnXjynPsAT925t+9ET1HN9btxB5X+Hop w64km1IfV4qCg7A== X-Developer-Key: i=caleb.connolly@linaro.org; a=openpgp; fpr=83B24DA7FE145076BC38BB250CD904EB673A7C47 X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.39 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.8 at phobos.denx.de X-Virus-Status: Clean There was some very old code floating around for decoding symbols, it's incomplete and is never built. Remove it so we can add a new implementation. Reviewed-by: Tom Rini Reviewed-by: Ilias Apalodimas Signed-off-by: Caleb Connolly --- Makefile | 11 ----------- common/Makefile | 1 - common/kallsyms.c | 43 ------------------------------------------- common/system_map.c | 8 -------- 4 files changed, 63 deletions(-) diff --git a/Makefile b/Makefile index f5b2512f3690..fcb9565d2fff 100644 --- a/Makefile +++ b/Makefile @@ -1786,21 +1786,10 @@ quiet_cmd_u-boot__ ?= LD $@ $(PLATFORM_LIBS) -Map u-boot.map; \ $(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true) endif -quiet_cmd_smap = GEN common/system_map.o -cmd_smap = \ - smap=`$(call SYSTEM_MAP,u-boot) | \ - awk '$$2 ~ /[tTwW]/ {printf $$1 $$3 "\\\\000"}'` ; \ - $(CC) $(c_flags) -DSYSTEM_MAP="\"$${smap}\"" \ - -c $(srctree)/common/system_map.c -o common/system_map.o - u-boot: $(u-boot-init) $(u-boot-main) $(u-boot-keep-syms-lto) u-boot.lds FORCE +$(call if_changed,u-boot__) -ifeq ($(CONFIG_KALLSYMS),y) - $(call cmd,smap) - $(call cmd,u-boot__) common/system_map.o -endif ifeq ($(CONFIG_RISCV),y) @tools/prelink-riscv $@ endif diff --git a/common/Makefile b/common/Makefile index e98354734206..bca02e4c362f 100644 --- a/common/Makefile +++ b/common/Makefile @@ -34,9 +34,8 @@ obj-$(CONFIG_USB_ONBOARD_HUB) += usb_onboard_hub.o obj-$(CONFIG_CONSOLE_MUX) += iomux.o obj-$(CONFIG_MTD_NOR_FLASH) += flash.o obj-$(CONFIG_CMD_KGDB) += kgdb.o kgdb_stubs.o obj-$(CONFIG_I2C_EDID) += edid.o -obj-$(CONFIG_KALLSYMS) += kallsyms.o obj-y += splash.o obj-$(CONFIG_SPLASH_SOURCE) += splash_source.o obj-$(CONFIG_MENU) += menu.o obj-$(CONFIG_UPDATE_COMMON) += update.o diff --git a/common/kallsyms.c b/common/kallsyms.c deleted file mode 100644 index 49b3897078ae..000000000000 --- a/common/kallsyms.c +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Helper functions for working with the builtin symbol table - * - * Copyright (c) 2008-2009 Analog Devices Inc. - * Licensed under the GPL-2 or later. - */ - - -/* We need the weak marking as this symbol is provided specially */ -extern const char system_map[] __attribute__((weak)); - -/* Given an address, return a pointer to the symbol name and store - * the base address in caddr. So if the symbol map had an entry: - * 03fb9b7c_spi_cs_deactivate - * Then the following call: - * unsigned long base; - * const char *sym = symbol_lookup(0x03fb9b80, &base); - * Would end up setting the variables like so: - * base = 0x03fb9b7c; - * sym = "_spi_cs_deactivate"; - */ -const char *symbol_lookup(unsigned long addr, unsigned long *caddr) -{ - const char *sym, *csym; - char *esym; - unsigned long sym_addr; - - sym = system_map; - csym = NULL; - *caddr = 0; - - while (*sym) { - sym_addr = hextoul(sym, &esym); - sym = esym; - if (sym_addr > addr) - break; - *caddr = sym_addr; - csym = sym; - sym += strlen(sym) + 1; - } - - return csym; -} diff --git a/common/system_map.c b/common/system_map.c deleted file mode 100644 index 8307293bf3ae..000000000000 --- a/common/system_map.c +++ /dev/null @@ -1,8 +0,0 @@ -/* - * The builtin symbol table for use with kallsyms - * - * Copyright (c) 2008-2009 Analog Devices Inc. - * Licensed under the GPL-2 or later. - */ - -const char const system_map[] = SYSTEM_MAP; From patchwork Thu Aug 8 16:21:25 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Caleb Connolly X-Patchwork-Id: 817711 Delivered-To: patch@linaro.org Received: by 2002:a5d:4e11:0:b0:367:895a:4699 with SMTP id p17csp943674wrt; Thu, 8 Aug 2024 09:21:51 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCX/JCH7Ex7HD0lT5Tg0NvJAKsZTD5Hx451LYcucAvmcG9STbWBM9B3cYAwwWNyPvvrZano1/+DKB+S/VEGHyD6u X-Google-Smtp-Source: AGHT+IHCfkFh7V8nToFdge2xq7HBZi3SEP8TDnvOHu/ZjgCFeV+bI9HZcjEoLYt062VpKJf/Hexi X-Received: by 2002:a05:6402:35cb:b0:5b9:462d:c538 with SMTP id 4fb4d7f45d1cf-5bbb2182261mr2009657a12.3.1723134111033; Thu, 08 Aug 2024 09:21:51 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1723134111; cv=none; d=google.com; s=arc-20160816; b=sRvuMWjR8RGl7iMcWx2WSqGEZuoJ88DyKjcyhl0Afvzro6YZ/oVV8OxQxbk8/ooFWi yI0+c4vr1tdq6+gGYVzFMmKvp/ghDfEQMC3S7hC09f9AVAYT8bJS+AID6/byIHWp2ydy tD+gWbnUeetfNWt//EdAT0PvJYQvgRSuqqr0isjZPRaAjCW02Nu7X9XXMsd4aeSIYbJH pH8zu1touQ2XjYD/6BCGKZlUNmEd6uFQCV3TTrnBPRGJ/XEOdTOIqzEK9IG8lK5mBNEk cHlD4s0OGjIYYzFssjf8iuC+Q0bZLpPzqTgdx3ns21GtpCJSbavrc+mCia00Wda9dKYc 5IXg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:cc:to:in-reply-to:references :message-id:content-transfer-encoding:mime-version:subject:date:from :dkim-signature; bh=2XSlx5D/5kntp42gAfktd0vIE+NpL/jLi/DqR3jSrRM=; fh=p83FTJcYz+fp8Qf7bhwSH+R8QquFg06L6zIj9ZUvgmc=; b=FY2U7Q6DEQYXoqcX4wB6yNTvuPX5qBXAkSLVixWgjBVZo6d6KCWUZDz9BLM7lT+QoZ UPEznwDCvTPNiEjYV7QjKpHNP0K9CibKQSmqHz7BvNt83JuBDtF0Wo9ojxnTWo0xZSNn hFZLBu5b8F2eod2vYEeVNCgRKG2PPbg9tny49FDS4/aNBGpUMAxqKdMuP7xEQQkPKZyx vqNILtIZGPvLPNIbQnmBocs8PBe0i/p1hto+LiJTBlzvnqls/D9dB+ZYub3FNDCQxkAX ZN95wA2U+PX8DDnqqf8GncQpy8P+SrNW3pDSEpCNA3WtwbSIXas5MxQ7h7l2cJOz2aBF swow==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=hejzVJHD; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [85.214.62.61]) by mx.google.com with ESMTPS id 4fb4d7f45d1cf-5bbb2d21175si960040a12.346.2024.08.08.09.21.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 08 Aug 2024 09:21:51 -0700 (PDT) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) client-ip=85.214.62.61; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=hejzVJHD; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id CBEA488BB7; Thu, 8 Aug 2024 18:21:35 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="hejzVJHD"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id 58C2D88B9E; Thu, 8 Aug 2024 18:21:34 +0200 (CEST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-lf1-x131.google.com (mail-lf1-x131.google.com [IPv6:2a00:1450:4864:20::131]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id 7D29688B9E for ; Thu, 8 Aug 2024 18:21:30 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=caleb.connolly@linaro.org Received: by mail-lf1-x131.google.com with SMTP id 2adb3069b0e04-530ad969360so1163860e87.0 for ; Thu, 08 Aug 2024 09:21:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1723134089; x=1723738889; darn=lists.denx.de; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=2XSlx5D/5kntp42gAfktd0vIE+NpL/jLi/DqR3jSrRM=; b=hejzVJHDFn1sMyqynhUY/nPZZklL3BLvwQf5F+/F5kaaW509VkL/OP09H1eqC2mDY1 VWDONi19BlG7Ht86LazXv0EPoM9qyLD45U/kaAb2fexZ9Z7bqUV2RwSBy5gEPPnRmPoM YGgpx9u58ipyFrTVqJtH0LZJFHq8Nt55zfcVI6/ICMqFoqjfnAobGfaM/Dz+PfxhSijD mVFRaLUC8M7RX0fDauQmbAfYiFgekcHLrxBJ5+itdk6zcTi0BJ1B/6HhUThV4i+9c+Dj jFB4TqAB/o2RF9cLzDallM9IdJdyvRUeW0h5zj2paNbc9RqAU5aqO+ncxpT9r8sklLqx zfDA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1723134089; x=1723738889; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=2XSlx5D/5kntp42gAfktd0vIE+NpL/jLi/DqR3jSrRM=; b=oE0rdh+jEA0kvTlROAittwQgroWk6kUHX09epvUcA/XBDK9ryBWJoL3ggALBVVpFpR p6SUJ/CqBCHTW9Hp5G6RUzGY349uMOx0L6m0HdGyeDuRXYw74/JRMYmY1paY0VZnz/aT 0opmKtsbPuklVSz9i/8sZO7o4CuQ3VElXrtoGHQl/r56VcCXfBHq+r4oaUyKAdh3DLK4 rv8/JjhcjWom5lsWctgs4wcRMD4bR352ah9IrExm1gK9ma9+eiHxh9i8q0wamAhQlyMz 2a/TRjil6ukkLQHF9q2P7uy+nX0I+sOgU8PNzw8/nU66u2Bgn5dZMUZ9E1g/t2F2rKJz auWw== X-Forwarded-Encrypted: i=1; AJvYcCWZD4j8DOeLy0vEXrhxiIMG2Vy1+8qN/lqwSVjjEyNygr83BZ7S4EAjY3E9Lcf3B/hyZ6scjk17FQlIi98fB9QuZiOzDA== X-Gm-Message-State: AOJu0YyA3qEEBvq4DGFowEg10wfVs/BcvSjl96AtkkzD+jpJMWqeE7QU DpoN6nI9CmR+aH7BQLfQDSaOP9lADOlq5oZgcT8d7RZnI1f48N0eY8CRnRJn3XNyqrdhP4bqZh6 0EBk= X-Received: by 2002:a05:6512:2346:b0:530:aa05:eb7c with SMTP id 2adb3069b0e04-530e588cd7amr1603459e87.38.1723134089072; Thu, 08 Aug 2024 09:21:29 -0700 (PDT) Received: from [192.168.0.113] ([2a02:8109:aa0d:be00::7424]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5bbb2e5d76dsm770396a12.80.2024.08.08.09.21.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 08 Aug 2024 09:21:28 -0700 (PDT) From: Caleb Connolly Date: Thu, 08 Aug 2024 18:21:25 +0200 Subject: [PATCH v2 2/3] add support for symbol lookups MIME-Version: 1.0 Message-Id: <20240808-arm64-backtrace-v2-2-29665a2265cf@linaro.org> References: <20240808-arm64-backtrace-v2-0-29665a2265cf@linaro.org> In-Reply-To: <20240808-arm64-backtrace-v2-0-29665a2265cf@linaro.org> To: Tom Rini , Simon Glass , Ilias Apalodimas Cc: Marek Vasut , Mattijs Korpershoek , Neil Armstrong , u-boot@lists.denx.de, Caleb Connolly X-Mailer: b4 0.14-dev X-Developer-Signature: v=1; a=openpgp-sha256; l=25148; i=caleb.connolly@linaro.org; h=from:subject:message-id; bh=22j+V7Jey1SMi4w+FcwIbBe/pnoVa71Oj4aa9DAxi/A=; b=owEBbQKS/ZANAwAIAQWDMSsZX2S2AcsmYgBmtPCFS2Lg0V1ex0GQMOHwHHIfD62FdUVngO6/M +6/H5vjqwCJAjMEAAEIAB0WIQS2UaFGPGq+0GkMVc0FgzErGV9ktgUCZrTwhQAKCRAFgzErGV9k tv3XD/9BdSI6Qm5ZyAXrPw/UZl3prsNqLqCBNnHvGLypjXA8NVKBZdvUGjbth43l+Hexvzl8UVK +oRoVcCyZgXl0pakXCLGYTkF3roslCg+fbEaOMYSfWZrr2loBDVBzg5qzybOxWyeenkeR34F8f7 kuHYv6u7gidCjyyDG6bQwyqdeFnYzM5HHD2fxoV9l2DeI02vnsN0f8I+4JRnvUZyJDo+/tFFJzp drVq5FHlYxGJlS8R2F3HW6qI3gYQHBftQ9TWhvv9J+/4GQMlSjEDw0rNduNl8N5EVQ4wPNQowNp Bnio4krnE5HVi5s1wSzDqN4YGHl5z/Ws8PpZVI7WdkRRSnqC0kWtS+Hio74x6f6ibBdNuG7jxcz VR0RwAbjLFOGqvRun4nErj1XffpmexBqqrxExcRz01Ye62ftIgMrmENFDg3Hjdz83nTas4kyU7I aSWJEj+jg1LQAf4wBUZbAPCKFHWApHTTK8m0G1ZqljQsFgXDoCwwKmenRX1wq3rZosC9RlGjLOi 21/tb80m+96m2qWTf1uEQfTltmZ2oksBRPEBIO6J3cw1OTnIjKsqpgX/3kTZILCJDooYuSnJtin vI2S5Towk8KZhI/qYErRW8MwvzErv1Ww0TsKorzj0MZKNRSUayzMtco/Pl1vz6S5PMBpOSi7exx bWA+1v4afpP+0Cg== X-Developer-Key: i=caleb.connolly@linaro.org; a=openpgp; fpr=83B24DA7FE145076BC38BB250CD904EB673A7C47 X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.39 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.8 at phobos.denx.de X-Virus-Status: Clean This is mostly a port of the Xen hypervisor implementation. The U-Boot binary is built as normal, then its symbol table is fed into tools/symbols to generate an optimised lookup table. U-Boot is rebuilt with the symbol table and handling code in lib/symbols.c. Based on code from Xen at c20850540ad6("x86/altcall: always use a temporary parameter stashing variable") Signed-off-by: Caleb Connolly --- Makefile | 15 +- include/symbols.h | 19 ++ lib/Kconfig | 8 + lib/symbols.c | 126 +++++++++++ tools/Makefile | 3 + tools/symbols.c | 646 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 816 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index fcb9565d2fff..52a11d586d43 100644 --- a/Makefile +++ b/Makefile @@ -1781,16 +1781,29 @@ quiet_cmd_u-boot__ ?= LD $@ cmd_u-boot__ ?= $(LD) $(KBUILD_LDFLAGS) $(LDFLAGS_u-boot) -o $@ \ -T u-boot.lds $(u-boot-init) \ --whole-archive \ $(u-boot-main) \ + $(if $(shell [ "$@" = "u-boot" ] && echo "true"),lib/symbols.o u-boot.sym.o,) \ --no-whole-archive \ $(PLATFORM_LIBS) -Map u-boot.map; \ $(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true) endif -u-boot: $(u-boot-init) $(u-boot-main) $(u-boot-keep-syms-lto) u-boot.lds FORCE +u-boot.nosyms: $(u-boot-init) $(u-boot-main) $(u-boot-keep-syms-lto) u-boot.lds FORCE +$(call if_changed,u-boot__) +ifeq ($(CONFIG_SYMBOL_LOOKUP),y) +u-boot: u-boot.nosyms FORCE + @$(NM) -n -pa --format=sysv u-boot.nosyms | tools/symbols --all-symbols --sysv --sort > u-boot.sym.S + @$(CC) $(c_flags) -c $(srctree)/lib/symbols.c -o lib/symbols.o + @$(AS) u-boot.sym.S -o u-boot.sym.o + @$(call cmd,u-boot__) +else +u-boot: u-boot.nosyms FORCE + +$(call if_changed,copy) +endif + + ifeq ($(CONFIG_RISCV),y) @tools/prelink-riscv $@ endif diff --git a/include/symbols.h b/include/symbols.h new file mode 100644 index 000000000000..b17f122be339 --- /dev/null +++ b/include/symbols.h @@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ + +#include +#include + +#define KSYM_NAME_LEN 127 + +#if IS_ENABLED(CONFIG_SYMBOL_LOOKUP) +const char * __attribute__((weak)) symbols_lookup(unsigned long addr, unsigned long *symaddr, unsigned long *offset, + char *namebuf); +#else +static inline const char *symbols_lookup(unsigned long addr, unsigned long *symaddr, unsigned long *offset, + char *namebuf) +{ + strcpy(namebuf, "???"); + namebuf[3] = '\0'; + return namebuf; +} +#endif diff --git a/lib/Kconfig b/lib/Kconfig index b3baa4b85b07..2eb61fe6177a 100644 --- a/lib/Kconfig +++ b/lib/Kconfig @@ -977,8 +977,16 @@ config VPL_OF_LIBFDT_ASSUME_MASK are made, and libfdt is able to deal with malicious data. A value of 0xff means all assumptions are made and any invalid data may cause unsafe execution. See FDT_ASSUME_PERFECT, etc. in libfdt_internal.h +config SYMBOL_LOOKUP + bool "Enable symbol lookup" + depends on ARM64 + help + This enables support for looking up symbol names from addresses. When + enabled U-Boot will print stack traces with function names when an + exception occurs. + menu "System tables" depends on (!EFI && !SYS_COREBOOT) || (ARM && EFI_LOADER) config BLOBLIST_TABLES diff --git a/lib/symbols.c b/lib/symbols.c new file mode 100644 index 000000000000..167da4e00766 --- /dev/null +++ b/lib/symbols.c @@ -0,0 +1,126 @@ +/* + * symbols.c: in-kernel printing of symbolic oopses and stack traces. + * Ported from Xen hypervisor + * + * Copyright 2002 Rusty Russell IBM Corporation + * + * ChangeLog: + * + * (25/Aug/2004) Paulo Marques + * Changed the compression method from stem compression to "table lookup" + * compression (see tools/symbols.c for a more complete description) + */ + +#include +#include +#include +#include +#include +#include +#include + +extern const uint64_t symbols_offsets[]; +extern const unsigned int symbols_num_syms; +extern const u8 symbols_names[]; +extern const u8 symbols_token_table[]; +extern const u16 symbols_token_index[]; +extern const unsigned int symbols_markers[]; + +#define symbols_address(n) (symbols_offsets[n] + 0UL) + +/* + * expand a compressed symbol data into the resulting uncompressed string, + * given the offset to where the symbol is in the compressed stream. + */ +static unsigned int symbols_expand_symbol(unsigned int off, char *result) +{ + int len, skipped_first = 0; + const u8 *tptr, *data; + + /* get the compressed symbol length from the first symbol byte */ + data = &symbols_names[off]; + len = *data; + data++; + + /* update the offset to return the offset for the next symbol on + * the compressed stream */ + off += len + 1; + + /* for every byte on the compressed symbol data, copy the table + * entry for that byte */ + while (len) { + tptr = &symbols_token_table[symbols_token_index[*data]]; + data++; + len--; + + while (*tptr) { + if (skipped_first) { + *result = *tptr; + result++; + } else + skipped_first = 1; + tptr++; + } + } + + *result = '\0'; + + /* return to offset to the next symbol */ + return off; +} + +/* find the offset on the compressed stream given and index in the + * symbols array */ +static unsigned int get_symbol_offset(unsigned long pos) +{ + const u8 *name; + int i; + + /* use the closest marker we have. We have markers every 256 positions, + * so that should be close enough */ + name = &symbols_names[symbols_markers[pos >> 8]]; + + /* sequentially scan all the symbols up to the point we're searching for. + * Every symbol is stored in a [][ bytes of data] format, so we + * just need to add the len to the current pointer for every symbol we + * wish to skip */ + for (i = 0; i < (pos & 0xFF); i++) + name = name + (*name) + 1; + + return name - symbols_names; +} + +const char *symbols_lookup(unsigned long addr, unsigned long *symaddr, unsigned long *offset, char *namebuf) +{ + unsigned long low, high, mid; + + addr -= (unsigned long)_start; + + namebuf[KSYM_NAME_LEN] = 0; + namebuf[0] = 0; + + /* do a binary search on the sorted symbols_addresses array */ + low = 0; + high = symbols_num_syms; + + while (high - low > 1) { + mid = (low + high) / 2; + if (symbols_address(mid) <= addr) { + low = mid; + } else { + high = mid; + } + } + + /* search for the first aliased symbol. Aliased symbols are + * symbols with the same address */ + while (low && symbols_address(low - 1) == symbols_address(low)) + --low; + + /* Grab name */ + symbols_expand_symbol(get_symbol_offset(low), namebuf); + + *symaddr = symbols_address(low); + *offset = addr - symbols_address(low); + return namebuf; +} diff --git a/tools/Makefile b/tools/Makefile index 6a4280e3668f..278539ea77be 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -225,8 +225,11 @@ hostprogs-$(CONFIG_ARCH_MVEBU) += kwboot hostprogs-y += proftool proftool-objs = proftool.o generated/lib/abuf.o +HOSTCFLAGS_symbols.o += -DCONFIG_TEXT_BASE=$(CONFIG_TEXT_BASE) +hostprogs-$(CONFIG_SYMBOL_LOOKUP) += symbols + hostprogs-$(CONFIG_STATIC_RELA) += relocate-rela hostprogs-$(CONFIG_RISCV) += prelink-riscv hostprogs-$(CONFIG_ARCH_OCTEON) += update_octeon_header diff --git a/tools/symbols.c b/tools/symbols.c new file mode 100644 index 000000000000..9e3c4f62cf24 --- /dev/null +++ b/tools/symbols.c @@ -0,0 +1,646 @@ +/* Generate assembler source containing symbol information + * + * Copyright 2002 by Kai Germaschewski + * + * Based on Xen implementation as of March 2024 + * c20850540ad6 ("x86/altcall: always use a temporary parameter stashing variable") + * + * Simplified and adjusted for U-Boot, notably the generated ASM is simplified with the + * text offset applied at runtime to better support U-Boot relocation. + * + * This software may be used and distributed according to the terms + * of the GNU General Public License, incorporated herein by reference. + * + * Usage: nm -n vmlinux | scripts/symbols [--all-symbols] > symbols.S + * + * ChangeLog: + * + * (25/Aug/2004) Paulo Marques + * Changed the compression method from stem compression to "table lookup" + * compression + * + * Table compression uses all the unused char codes on the symbols and + * maps these to the most used substrings (tokens). For instance, it might + * map char code 0xF7 to represent "write_" and then in every symbol where + * "write_" appears it can be replaced by 0xF7, saving 5 bytes. + * The used codes themselves are also placed in the table so that the + * decompresion can work without "special cases". + * Applied to kernel symbols, this usually produces a compression ratio + * of about 50%. + * + */ + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include +#include +#include +#include +#include +#include + +#define KSYM_NAME_LEN 127 + + +struct sym_entry { + unsigned long long addr; + unsigned int len; + unsigned char *sym; + char *orig_symbol; + unsigned int addr_idx; + unsigned int stream_offset; + unsigned char type; +}; +#define SYMBOL_NAME(s) ((char *)(s)->sym + 1) + +static struct sym_entry *table; +static unsigned int table_size, table_cnt; +static unsigned long long _stext, _etext, _sinittext, _einittext, _sextratext, _eextratext; +static int all_symbols = 0; +static int sort_by_name = 0; +static int map_only = 0; +static char symbol_prefix_char = '\0'; +static enum { fmt_bsd, fmt_sysv } input_format; +static int compare_name(const void *p1, const void *p2); + +int token_profit[0x10000]; + +/* the table that holds the result of the compression */ +unsigned char best_table[256][2]; +unsigned char best_table_len[256]; + + +static void usage(void) +{ + fprintf(stderr, "Usage: symbols [--all-symbols] [--symbol-prefix=] < in.map > out.S\n"); + exit(1); +} + +/* + * This ignores the intensely annoying "mapping symbols" found + * in ARM ELF files: $a, $t and $d. + */ +static inline int is_arm_mapping_symbol(const char *str) +{ + return str[0] == '$' && strchr("atd", str[1]) + && (str[2] == '\0' || str[2] == '.'); +} + +static int read_symbol(FILE *in, struct sym_entry *s) +{ + char str[500], type[20] = ""; + char *sym, stype; + static char *filename = NULL; + int rc = -1; + + switch (input_format) { + case fmt_bsd: + rc = fscanf(in, "%llx %c %499s\n", &s->addr, &stype, str); + break; + case fmt_sysv: + while (fscanf(in, "\n") == 1) + /* nothing */; + rc = fscanf(in, "%499[^ |] |%llx | %c |", + str, &s->addr, &stype); + if (rc == 3 && fscanf(in, " %19[^ |] |", type) != 1) + *type = '\0'; + break; + } + if (rc != 3) { + if (rc != EOF) { + /* skip line */ + if (fgets(str, 500, in) == NULL) + return -1; /* must check fgets result */ + + //printf("SKIP: %s\n", str); + } + return -1; + } + + sym = strrchr(str, '.'); + if (strcasecmp(type, "FILE") == 0 || + (/* + * GNU nm prior to binutils commit 552e55ed06 (expected to + * appear in 2.27) doesn't produce a type for EFI binaries. + */ + input_format == fmt_sysv && !*type && stype == '?' && sym && + sym[1] && strchr("cSsoh", sym[1]) && !sym[2])) { + free(filename); + //filename = *str ? strdup(str) : NULL; + goto skip_tail; + } + + /* + * Keep all symbols relative to TEXT_BASE, it gets added back at runtime. + * this simplifies handling relocation. + */ + s->addr -= CONFIG_TEXT_BASE; + + rc = -1; + + sym = str; + /* skip prefix char */ + if (symbol_prefix_char && str[0] == symbol_prefix_char) + sym++; + + /* Ignore most absolute/undefined (?) symbols. */ + if (strcmp(sym, "_stext") == 0) + _stext = s->addr; + else if (strcmp(sym, "_etext") == 0) + _etext = s->addr; + else if (strcmp(sym, "_sinittext") == 0) + _sinittext = s->addr; + else if (strcmp(sym, "_einittext") == 0) + _einittext = s->addr; + else if (strcmp(sym, "_sextratext") == 0) + _sextratext = s->addr; + else if (strcmp(sym, "_eextratext") == 0) + _eextratext = s->addr; + else if (toupper((uint8_t)stype) == 'A') + { + /* Keep these useful absolute symbols */ + if (strcmp(sym, "__gp")) + goto skip_tail; + } + else if (toupper((uint8_t)stype) == 'U' || + toupper((uint8_t)stype) == 'N' || + is_arm_mapping_symbol(sym)) + goto skip_tail; + /* exclude also MIPS ELF local symbols ($L123 instead of .L123) */ + else if (str[0] == '$') + goto skip_tail; + + /* include the type field in the symbol name, so that it gets + * compressed together */ + s->len = strlen(str) + 1; + if (islower((unsigned char)stype) && filename) + s->len += strlen(filename) + 1; + s->sym = malloc(s->len + 1); + sym = SYMBOL_NAME(s); + if (islower((unsigned char)stype) && filename) { + sym = stpcpy(sym, filename); + *sym++ = ':'; + } + strcpy(sym, str); + if (sort_by_name || map_only) { + s->orig_symbol = strdup(SYMBOL_NAME(s)); + s->type = stype; /* As s->sym[0] ends mangled. */ + } + s->sym[0] = stype; + rc = 0; + + skip_tail: + if ((input_format == fmt_sysv) && fgets(str, 500, in) == NULL) + /* ignore errors while discarding rest of line */; + + return rc; +} + +static int symbol_valid(struct sym_entry *s) +{ + int offset = 1; + + /* skip prefix char */ + if (symbol_prefix_char && *(s->sym + 1) == symbol_prefix_char) + offset++; + + /* if --all-symbols is not specified, then symbols outside the text + * and inittext sections are discarded */ + if (!all_symbols) { + if ((s->addr < _stext || s->addr > _etext) + && (s->addr < _sinittext || s->addr > _einittext) + && (s->addr < _sextratext || s->addr > _eextratext)) + return 0; + /* Corner case. Discard any symbols with the same value as + * _etext _einittext or _eextratext; they can move between pass + * 1 and 2 when the symbols data are added. If these symbols + * move then they may get dropped in pass 2, which breaks the + * symbols rules. + */ + if ((s->addr == _etext && strcmp((char*)s->sym + offset, "_etext")) || + (s->addr == _einittext && strcmp((char*)s->sym + offset, "_einittext")) || + (s->addr == _eextratext && strcmp((char*)s->sym + offset, "_eextratext"))) + return 0; + } + + /* Exclude symbols which vary between passes. */ + if (strstr((char *)s->sym + offset, "_compiled.")) + return 0; + + return 1; +} + +static void read_map(FILE *in) +{ + while (!feof(in)) { + if (table_cnt >= table_size) { + table_size += 10000; + table = realloc(table, sizeof(*table) * table_size); + if (!table) { + fprintf(stderr, "out of memory\n"); + exit (1); + } + } + if (read_symbol(in, &table[table_cnt]) == 0) + table_cnt++; + } +} + +static void output_label(char *label) +{ + if (symbol_prefix_char) + printf(".globl %c%s\n", symbol_prefix_char, label); + else + printf(".globl %s\n", label); + printf("\t.align 8\n"); + if (symbol_prefix_char) + printf("%c%s:\n", symbol_prefix_char, label); + else + printf("%s:\n", label); +} + +/* uncompress a compressed symbol. When this function is called, the best table + * might still be compressed itself, so the function needs to be recursive */ +static int expand_symbol(unsigned char *data, int len, char *result) +{ + int c, rlen, total=0; + + while (len) { + c = *data; + /* if the table holds a single char that is the same as the one + * we are looking for, then end the search */ + if (best_table[c][0]==c && best_table_len[c]==1) { + *result++ = c; + total++; + } else { + /* if not, recurse and expand */ + rlen = expand_symbol(best_table[c], best_table_len[c], result); + total += rlen; + result += rlen; + } + data++; + len--; + } + *result=0; + + return total; +} + +/* Sort by original (non mangled) symbol name, then type. */ +static int compare_name_orig(const void *p1, const void *p2) +{ + const struct sym_entry *sym1 = p1; + const struct sym_entry *sym2 = p2; + int rc; + + rc = strcmp(sym1->orig_symbol, sym2->orig_symbol); + + if (!rc) + rc = sym1->type - sym2->type; + + return rc; +} + +static void write_src(void) +{ + unsigned int i, k, off; + unsigned int best_idx[256]; + unsigned int *markers; + char buf[KSYM_NAME_LEN+1]; + + if (map_only) { + for (i = 0; i < table_cnt; i++) + printf("%#llx %c %s\n", table[i].addr, table[i].type, + table[i].orig_symbol); + + return; + } + printf("\t.section .rodata, \"a\"\n"); + + output_label("symbols_offsets"); + for (i = 0; i < table_cnt; i++) { + printf("\t.quad\t%#llx\n", table[i].addr); + } + printf("\n"); + + output_label("symbols_num_syms"); + printf("\t.long\t%d\n", table_cnt); + printf("\n"); + + /* table of offset markers, that give the offset in the compressed stream + * every 256 symbols */ + markers = (unsigned int *) malloc(sizeof(unsigned int) * ((table_cnt + 255) / 256)); + + output_label("symbols_names"); + off = 0; + for (i = 0; i < table_cnt; i++) { + if ((i & 0xFF) == 0) + markers[i >> 8] = off; + + printf("\t.byte 0x%02x", table[i].len); + for (k = 0; k < table[i].len; k++) + printf(", 0x%02x", table[i].sym[k]); + printf("\n"); + + table[i].stream_offset = off; + off += table[i].len + 1; + } + printf("\n"); + + output_label("symbols_markers"); + for (i = 0; i < ((table_cnt + 255) >> 8); i++) + printf("\t.long\t%d\n", markers[i]); + printf("\n"); + + + output_label("symbols_token_table"); + off = 0; + for (i = 0; i < 256; i++) { + best_idx[i] = off; + expand_symbol(best_table[i], best_table_len[i], buf); + printf("\t.asciz\t\"%s\"\n", buf); + off += strlen(buf) + 1; + } + printf("\n"); + + output_label("symbols_token_index"); + for (i = 0; i < 256; i++) + printf("\t.short\t%d\n", best_idx[i]); + printf("\n"); + + if (!sort_by_name) { + free(markers); + return; + } + + /* Sorted by original symbol names and type. */ + qsort(table, table_cnt, sizeof(*table), compare_name_orig); + + output_label("symbols_sorted_offsets"); + /* A fixed sized array with two entries: offset in the + * compressed stream (for symbol name), and offset in + * symbols_addresses (or symbols_offset). */ + for (i = 0; i < table_cnt; i++) { + printf("\t.long %u, %u\n", table[i].stream_offset, table[i].addr_idx); + } + printf("\n"); + + free(markers); +} + + +/* table lookup compression functions */ + +/* count all the possible tokens in a symbol */ +static void learn_symbol(unsigned char *symbol, int len) +{ + int i; + + for (i = 0; i < len - 1; i++) + token_profit[ symbol[i] + (symbol[i + 1] << 8) ]++; +} + +/* decrease the count for all the possible tokens in a symbol */ +static void forget_symbol(unsigned char *symbol, int len) +{ + int i; + + for (i = 0; i < len - 1; i++) + token_profit[ symbol[i] + (symbol[i + 1] << 8) ]--; +} + +/* remove all the invalid symbols from the table and do the initial token count */ +static void build_initial_tok_table(void) +{ + unsigned int i, pos; + + pos = 0; + for (i = 0; i < table_cnt; i++) { + if ( symbol_valid(&table[i]) ) { + if (pos != i) + table[pos] = table[i]; + learn_symbol(table[pos].sym, table[pos].len); + pos++; + } + } + table_cnt = pos; +} + +static void *memmem_pvt(void *h, size_t hlen, void *n, size_t nlen) +{ + char *p; + for (p = h; (p - (char *)h) <= (long)(hlen - nlen); p++) + if (!memcmp(p, n, nlen)) return p; + return NULL; +} + +/* replace a given token in all the valid symbols. Use the sampled symbols + * to update the counts */ +static void compress_symbols(unsigned char *str, int idx) +{ + unsigned int i, len, size; + unsigned char *p1, *p2; + + for (i = 0; i < table_cnt; i++) { + + len = table[i].len; + p1 = table[i].sym; + + table[i].addr_idx = i; + /* find the token on the symbol */ + p2 = memmem_pvt(p1, len, str, 2); + if (!p2) continue; + + /* decrease the counts for this symbol's tokens */ + forget_symbol(table[i].sym, len); + + size = len; + + do { + *p2 = idx; + p2++; + size -= (p2 - p1); + memmove(p2, p2 + 1, size); + p1 = p2; + len--; + + if (size < 2) break; + + /* find the token on the symbol */ + p2 = memmem_pvt(p1, size, str, 2); + + } while (p2); + + table[i].len = len; + + /* increase the counts for this symbol's new tokens */ + learn_symbol(table[i].sym, len); + } +} + +/* search the token with the maximum profit */ +static int find_best_token(void) +{ + int i, best, bestprofit; + + bestprofit=-10000; + best = 0; + + for (i = 0; i < 0x10000; i++) { + if (token_profit[i] > bestprofit) { + best = i; + bestprofit = token_profit[i]; + } + } + return best; +} + +/* this is the core of the algorithm: calculate the "best" table */ +static void optimize_result(void) +{ + int i, best; + + /* using the '\0' symbol last allows compress_symbols to use standard + * fast string functions */ + for (i = 255; i >= 0; i--) { + + /* if this table slot is empty (it is not used by an actual + * original char code */ + if (!best_table_len[i]) { + + /* find the token with the breates profit value */ + best = find_best_token(); + if (token_profit[best] == 0) + break; + + /* place it in the "best" table */ + best_table_len[i] = 2; + best_table[i][0] = best & 0xFF; + best_table[i][1] = (best >> 8) & 0xFF; + + /* replace this token in all the valid symbols */ + compress_symbols(best_table[i], i); + } + } +} + +/* start by placing the symbols that are actually used on the table */ +static void insert_real_symbols_in_table(void) +{ + unsigned int i, j, c; + + memset(best_table, 0, sizeof(best_table)); + memset(best_table_len, 0, sizeof(best_table_len)); + + for (i = 0; i < table_cnt; i++) { + for (j = 0; j < table[i].len; j++) { + c = table[i].sym[j]; + best_table[c][0]=c; + best_table_len[c]=1; + } + } +} + +static void optimize_token_table(void) +{ + build_initial_tok_table(); + + insert_real_symbols_in_table(); + + /* When valid symbol is not registered, exit to error */ + if (!table_cnt) { + fprintf(stderr, "No valid symbol.\n"); + exit(1); + } + + optimize_result(); +} + +static int compare_value(const void *p1, const void *p2) +{ + const struct sym_entry *sym1 = p1; + const struct sym_entry *sym2 = p2; + + if (sym1->addr < sym2->addr) + return -1; + if (sym1->addr > sym2->addr) + return +1; + /* Prefer global symbols. */ + if (isupper(*sym1->sym)) + return -1; + if (isupper(*sym2->sym)) + return +1; + return 0; +} + +static int compare_name(const void *p1, const void *p2) +{ + const struct sym_entry *sym1 = p1; + const struct sym_entry *sym2 = p2; + + return strcmp(SYMBOL_NAME(sym1), SYMBOL_NAME(sym2)); +} + +int main(int argc, char **argv) +{ + unsigned int i; + bool unsorted = false, warn_dup = false, error_dup = false, found_dup = false; + + if (argc >= 2) { + for (i = 1; i < argc; i++) { + if(strcmp(argv[i], "--all-symbols") == 0) + all_symbols = 1; + else if (strncmp(argv[i], "--symbol-prefix=", 16) == 0) { + char *p = &argv[i][16]; + /* skip quote */ + if ((*p == '"' && *(p+2) == '"') || (*p == '\'' && *(p+2) == '\'')) + p++; + symbol_prefix_char = *p; + } else if (strcmp(argv[i], "--sysv") == 0) + input_format = fmt_sysv; + else if (strcmp(argv[i], "--sort") == 0) + unsorted = true; + else if (strcmp(argv[i], "--sort-by-name") == 0) + sort_by_name = 1; + else if (strcmp(argv[i], "--warn-dup") == 0) + warn_dup = true; + else if (strcmp(argv[i], "--error-dup") == 0) + warn_dup = error_dup = true; + else if (strcmp(argv[i], "--xensyms") == 0) + map_only = true; + else + usage(); + } + } else if (argc != 1) + usage(); + + read_map(stdin); + + if (warn_dup) { + qsort(table, table_cnt, sizeof(*table), compare_name); + for (i = 1; i < table_cnt; ++i) + if (strcmp(SYMBOL_NAME(table + i - 1), + SYMBOL_NAME(table + i)) == 0 && + table[i - 1].addr != table[i].addr) { + fprintf(stderr, + "Duplicate symbol '%s' (%llx != %llx)\n", + SYMBOL_NAME(table + i), + table[i].addr, table[i - 1].addr); + found_dup = true; + } + unsorted = true; + } + + if (error_dup && found_dup) + exit(1); + + if (unsorted) + qsort(table, table_cnt, sizeof(*table), compare_value); + + optimize_token_table(); + write_src(); + + return 0; +} From patchwork Thu Aug 8 16:21:26 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Caleb Connolly X-Patchwork-Id: 817712 Delivered-To: patch@linaro.org Received: by 2002:a5d:4e11:0:b0:367:895a:4699 with SMTP id p17csp943744wrt; Thu, 8 Aug 2024 09:22:03 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUoaluJaRsNtTk1X4eQiBpNfByCCYFyqTXb0B6b4uZO86Rbfq4rGTZYisdN8rA9aUQFp+dh0oyrTA5efcinOFJc X-Google-Smtp-Source: AGHT+IGdTYLKneD6r58T+YUiA1E/bdFpAiIHlAcVs6XJEhrYhlyRLRcCcxmJ8mKKmdhN0A+N4jFh X-Received: by 2002:a17:907:9484:b0:a7d:c464:d5f3 with SMTP id a640c23a62f3a-a8091efe51emr230223466b.11.1723134122947; Thu, 08 Aug 2024 09:22:02 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1723134122; cv=none; d=google.com; s=arc-20160816; b=c9BSOLhaUE+djEQFR0kyPO2QN3Zn/gw0bm3sPTDVD/hLgHDjbSmu23eVAffo4UGeVK 5+VuMa46AV/h1pLjWIjnfT3lrOHfhC92UO19TldL44l7v3uovToxieXR4HC+lqKzBptv g4ixb1THrTeS6u6XBhMu1cVvLyDjozXSAR91kOeueuj9k5l2B7IMbyUbIdTq04zDKjEc /k/mgU5cbYIevTqQQPU6fReNMXNMp/sQgtHa4EGV/+U2+XSNXnuz+FLZC97GwL/levFF 7Lclf7awcQYYw4Ux89OCuDK/9qTNDweKi+I9T3519UclvEiJbjHimfHhFs2ouBQxA9Yg xQzA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:cc:to:in-reply-to:references :message-id:content-transfer-encoding:mime-version:subject:date:from :dkim-signature; bh=uYOu2ipHwEssxBvLgdYj44u05DMcnmXqyOAokHDVQis=; fh=BPDNNfX9gK5EZTOKMrai3f7xkwOIybOZoWb+3Kz6i7E=; b=c/x4zICox9Q80wmXScT18m9P17szX6aZSkvxsv/oSecHh8Ovsku7/c68fPiAn1ctJ6 S2OojKmdiA4astK3DNS99e7kmBw1Q+wahRpYPsER9Q1zed7PwAHwrvuMuQ0oQGJCxIi5 Y8hLU87GzBU1hhjfsN00gdvzjefFPixoTg3+iWCUXdEfub9HK/0GjnsPnnI+AZOwaJlJ sxec8EM+g9IowTWMo2zZ/GIQucW6ZKzg0V9i4BYfCLIuqfDMsumCgGPUsMyEAQ5TWVVR 5w7cTslfPccYr5z4e1KwyNWdKwUEV7OxsHrNc1MkWD/0WerjWWFPvNANw6EyDsWEi3IR IZMQ==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=FpZsFDYd; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Return-Path: Received: from phobos.denx.de (phobos.denx.de. [85.214.62.61]) by mx.google.com with ESMTPS id a640c23a62f3a-a7dc9bd099fsi854029866b.192.2024.08.08.09.22.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 08 Aug 2024 09:22:02 -0700 (PDT) Received-SPF: pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) client-ip=85.214.62.61; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=FpZsFDYd; spf=pass (google.com: domain of u-boot-bounces@lists.denx.de designates 85.214.62.61 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id 36D6A88BD6; Thu, 8 Aug 2024 18:21:36 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="FpZsFDYd"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id D493188BD3; Thu, 8 Aug 2024 18:21:34 +0200 (CEST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on phobos.denx.de X-Spam-Level: X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 Received: from mail-ed1-x52b.google.com (mail-ed1-x52b.google.com [IPv6:2a00:1450:4864:20::52b]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id 01A7088BC9 for ; Thu, 8 Aug 2024 18:21:31 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=caleb.connolly@linaro.org Received: by mail-ed1-x52b.google.com with SMTP id 4fb4d7f45d1cf-5b8c2a6135eso1739062a12.0 for ; Thu, 08 Aug 2024 09:21:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1723134090; x=1723738890; darn=lists.denx.de; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=uYOu2ipHwEssxBvLgdYj44u05DMcnmXqyOAokHDVQis=; b=FpZsFDYdLL9O9Zd1A3+5PxWrD8GDRssZEGzfre7tiTTJluHaPgXW+XKmCcMxwCiwrb kkwCqAG1DzUAfTQp1ib8iTlGU/7TAXraPd4Nwlk5NXuGRE513iDH505FVi2k6ltWIF/M uKZPx9aHUx5XhuXPaOqDug6ywtXuqQl3yi4yH+8EsGwvT7I9/3DTSBN8qLcj8gKgm+tr 54JYD0haQ3tiHnqTOyZVrpooD84YAey7tGd8uzHRUamZsIxKbeJd2ZvmOV9sbtcKvGSw 0XsfnpK4bKdJNu51RN11Kfhl+au2lL+WX2lTRSexSeNEOe6Kzl4jkeqxhek4O1x3Wrnv qB5w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1723134090; x=1723738890; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=uYOu2ipHwEssxBvLgdYj44u05DMcnmXqyOAokHDVQis=; b=GygHDn7hEi6vgHsSacr99xQviwxYsyKyd8znpVaw53lN6fXKWVUYCteoJndvsE/QDR 18pv5WdvojvA0rQ2pd7n75N4LwQStmyXHkSWBQ8PNZp/wLqUMjQQPkwrHV36OX+hsNJE 0KGpWXqX0rcSzGaKOUPVigv9K8cVbd3VKFWaN6UXK5yxlWRv57ACuZ88RVoddBGS/Zh/ vhZ7pA8We0W4x+FKMrsNYwsyXEQpwzjNydQ63bKz3/vfDmG/KZmNi8xZOiSc62Jz5hMI nBylsFzZIe7sd164C9WVu+Sobx2hbE4EraOukmWAb7FdXccTcaNAiZlGr1fnDu9BkiZm d4RQ== X-Forwarded-Encrypted: i=1; AJvYcCU/fAFp2EgqkFvlfpxBwCAtG/CSgstaGSUPlie2p1R4mLojlGkedis6uxPMpzTTF2Cya5m5a4Xi6E8Nv35zMrexqNQhmg== X-Gm-Message-State: AOJu0YwYRv92YgLoYJNZzIbxLK9hdnb2F00sBUoLsUBauXEjMBB0g12l qghYdsMc59dnvSc3Pyvh/RpSBXpmOx6xda4Bx9l0x8Tj61OrrlEcpOghV3H2qTaCWjNjz+QKMJt 99KA= X-Received: by 2002:a05:6402:51d1:b0:57d:d59:461b with SMTP id 4fb4d7f45d1cf-5bbb3d0f9e8mr2071748a12.13.1723134090088; Thu, 08 Aug 2024 09:21:30 -0700 (PDT) Received: from [192.168.0.113] ([2a02:8109:aa0d:be00::7424]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5bbb2e5d76dsm770396a12.80.2024.08.08.09.21.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 08 Aug 2024 09:21:29 -0700 (PDT) From: Caleb Connolly Date: Thu, 08 Aug 2024 18:21:26 +0200 Subject: [PATCH v2 3/3] arm64: unwind stack on exception MIME-Version: 1.0 Message-Id: <20240808-arm64-backtrace-v2-3-29665a2265cf@linaro.org> References: <20240808-arm64-backtrace-v2-0-29665a2265cf@linaro.org> In-Reply-To: <20240808-arm64-backtrace-v2-0-29665a2265cf@linaro.org> To: Tom Rini , Simon Glass , Ilias Apalodimas Cc: Marek Vasut , Mattijs Korpershoek , Neil Armstrong , u-boot@lists.denx.de, Caleb Connolly X-Mailer: b4 0.14-dev X-Developer-Signature: v=1; a=openpgp-sha256; l=4150; i=caleb.connolly@linaro.org; h=from:subject:message-id; bh=auYxX8CvKRKTJfLQF3ngQ7IDS2XoN11jACinYgvIZoM=; b=owEBbQKS/ZANAwAIAQWDMSsZX2S2AcsmYgBmtPCFzIqckL0VC5YQUzGcj+p0eZlCLoSTbXejp fOR8qQNTqqJAjMEAAEIAB0WIQS2UaFGPGq+0GkMVc0FgzErGV9ktgUCZrTwhQAKCRAFgzErGV9k tp1CD/4nS7BOfDLN6mjWJTs+gS8Sf1H21qHbV4wzCyTlouJKP1nbBeEmJDINSlsEH4P1gxc7dZG JqVMwNiO7wkcVI+nrbdiZqm900kxLx6u8l4HcdzOwJyF6wfKosD216h8Z3KyyiaT/oWX5QS4OPU JBj4pEPaajKPAP1F4NWagObJwhPNEQK/OVgRXvRvxNS+6GZkj0SJryr+ytFOYoiaSBObEUylnAs KZ5Pck+KH5T+tNnbuCVU/gqr/9v/WT0qdKkAYZgiFex5BWjDzhPlLRh2OiqNoYXmLfz0DnAuTXV d6B2UFcJFcb3euCG2z2iZU2OuXdW4GT7Nv9PGrl9GOXHgCL3e8I27/b9TaWGf49BTfV8RWBtVj5 5xslKs+safHoES5ZcpFqd8+YkmOMoM+bhcAT3B5Rw+aKXMRi8eHk5YYVothqSzN0E0GWFDUsag4 uGSXp/hhtWmgqydejCaAVugpRF/uXJ6T1x91qZkZpyzySqTF8tE2OO3pjAMloyEmEjAow8G0beo dDThiZ8lTyms/8aJOMLui8SuRjavI77nM/tWG1xY1uTX9R8tFyEjG1ADYJTYiWIQ7j/GVMoK7uw ZjmhpfHCTz0KPux3igpGoOvw+OyOQ/sAVQnNWRo5pSslw51dr24l9ckUG1Hl1qfAt7AKyapPbss KpTGFjfdMUTdpwQ== X-Developer-Key: i=caleb.connolly@linaro.org; a=openpgp; fpr=83B24DA7FE145076BC38BB250CD904EB673A7C47 X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.39 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.8 at phobos.denx.de X-Virus-Status: Clean We already build arm64 images with frame pointers. Let's finally make use of them in tandem with the new symbol lookup support by unwinding the stack when an exception occurs, producing a backtrace similar to those emitted by Linux. In addition, introduce a dedicated unwind_stack() function which can be called from anywhere to print a backtrace. Signed-off-by: Caleb Connolly --- arch/arm/include/asm/ptrace.h | 2 ++ arch/arm/lib/interrupts_64.c | 75 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 77 insertions(+) diff --git a/arch/arm/include/asm/ptrace.h b/arch/arm/include/asm/ptrace.h index a836f6cc60db..d4a971211843 100644 --- a/arch/arm/include/asm/ptrace.h +++ b/arch/arm/include/asm/ptrace.h @@ -22,8 +22,10 @@ #ifdef __KERNEL__ extern void show_regs(struct pt_regs *); +void unwind_stack(void); + #define predicate(x) (x & 0xf0000000) #define PREDICATE_ALWAYS 0xe0000000 #endif diff --git a/arch/arm/lib/interrupts_64.c b/arch/arm/lib/interrupts_64.c index b3024ba514ec..bae823cb2feb 100644 --- a/arch/arm/lib/interrupts_64.c +++ b/arch/arm/lib/interrupts_64.c @@ -3,15 +3,17 @@ * (C) Copyright 2013 * David Feng */ +#include #include #include #include #include #include #include #include +#include DECLARE_GLOBAL_DATA_PTR; int interrupt_init(void) @@ -80,8 +82,76 @@ static void dump_instr(struct pt_regs *regs) printf(i == 0 ? "(%08x) " : "%08x ", addr[i]); printf("\n"); } +#if IS_ENABLED(CONFIG_SYMBOL_LOOKUP) + +static void print_sym(unsigned long symaddr, const char *symname, unsigned long offset) +{ + if (symaddr > (unsigned long)__bss_end) + printf("\t<%#016lx> ???\n", symaddr); + else + printf("\t<%#016lx> %s+%#lx\n", symaddr, symname, offset); +} + +/* Stack frames automatically generated by compiler emitted code */ +struct stack_frame { + struct stack_frame *prev_ptr; /* Alays a bigger address on ARM64 */ + unsigned long lr; + char data[]; +}; + +static void __unwind_stack(unsigned long lr, unsigned long x29) +{ + char symname[KSYM_NAME_LEN+1] = { 0 }; + unsigned long addr, offset; + struct stack_frame *fp; + + /* + * Either the place where unwind_stack() was called, or the + * instruction that caused an exception + */ + symbols_lookup(lr, &addr, &offset, symname); + print_sym(lr, symname, offset); + + fp = (struct stack_frame *)x29; + while (fp && fp->prev_ptr > fp) { + symbols_lookup(fp->lr, &addr, &offset, symname); + /* + * _start is used over gd->relocaddr because it will be correct + * if U-Boot was built as relocatable and loaded at an arbitrary + * address (both pre and post-relocation). + */ + print_sym(fp->lr, symname, offset); + fp = (struct stack_frame *)(u64)fp->prev_ptr; + } +} + +/** + * unwind_stack() - Unwind the callstack and print a backtrace. + * + * This function can be called for debugging purposes to walk backwards through + * stack frames, printing the function name and offset of the branch instruction. + * + * It reads out the link register (x30) which contains the return address of the + * caller, and x29 which contains the frame pointer of the caller. + */ +void unwind_stack(void) +{ + unsigned long x29, x30; + + asm("mov %0, x29" : "=r" (x29)); + asm("mov %0, x30" : "=r" (x30)); + + __unwind_stack(x30, x29); +} + +#else + +#define __unwind_stack(lr, x29) do {} while (0) + +#endif + void show_regs(struct pt_regs *regs) { int i; @@ -95,8 +165,13 @@ void show_regs(struct pt_regs *regs) printf("x%-2d: %016lx x%-2d: %016lx\n", i, regs->regs[i], i+1, regs->regs[i+1]); printf("\n"); dump_instr(regs); + + if (IS_ENABLED(CONFIG_SYMBOL_LOOKUP)) { + printf("\nBacktrace:\n"); + __unwind_stack(regs->elr, regs->regs[29]); + } } /* * Try to "emulate" a semihosting call in the event that we don't have a