From patchwork Wed Apr 2 16:12:01 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Remus X-Patchwork-Id: 109724 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 607AA3858C50 for ; Wed, 2 Apr 2025 16:18:29 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 607AA3858C50 Authentication-Results: sourceware.org; dkim=pass (2048-bit key, unprotected) header.d=ibm.com header.i=@ibm.com header.a=rsa-sha256 header.s=pp1 header.b=QI5ZwXfZ X-Original-To: binutils@sourceware.org Delivered-To: binutils@sourceware.org Received: from mx0a-001b2d01.pphosted.com (mx0a-001b2d01.pphosted.com [148.163.156.1]) by sourceware.org (Postfix) with ESMTPS id 4C2463856951 for ; Wed, 2 Apr 2025 16:12:20 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 4C2463856951 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=linux.ibm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=linux.ibm.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 4C2463856951 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=148.163.156.1 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1743610340; cv=none; b=lxetgNUNtk0qsllGNM/3eR4K0OQFQkrf4qct+2MfRejhY1IUOk1ZZV407+LJ7kcABEO6eyRL5TvG1nsRahV2d/OnBmtx9ndcCMprVhaCTJ4IcHeiP4aRKRPokLUpg9OSYK5rwtKJdSqtIedTyUNXW3y5ags/GrLJPS2+jLUy1fs= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1743610340; c=relaxed/simple; bh=YZpKVDWgpH9k+bfpnpE2eF/KFl84YrAuE+8+FRMdOxc=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=YRH+Y6o5pVirSg/3kLAN9d3cMrjzg7KeP8ANXN6KkkeTVOCLdbva4FxIt+gj9V+mphFpd7kTzc85gY/4iYgkWGwyNqT9ITHx27eJKLsClaKrOlDoBa7ZaWs0BN88zv42yHDbDQN/rwgFAvxDmPwqwbETVSxLIg7I8lj/OKIid5U= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 4C2463856951 Received: from pps.filterd (m0356517.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 532Fvs0E031709; Wed, 2 Apr 2025 16:12:14 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ibm.com; h=cc :content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=pp1; bh=EMT+17tGSQUSVu1af SKS2RWUKUUcDOA1bY4dcGHRKfE=; b=QI5ZwXfZ3tM0bIjWVX94PBMbII4Fr+LQz v5p+kP+7ISYVrDeV+T9iKBO8DxMH5e/W6/r9dg/Z+wzrjGrO0+mpBP3xNHOrO6TX iULihXay3zBg8BQo9Id3pusIUip9szbqWVXHEqXkLy4Cfh5kh3lkluCROBrz7Y98 +TmFPe7G5/wV5TwZ8njeQGgYicPtzf9NHl9HBnL0EreKNy+GqCbCNddFVaQLPyqB d+AhOymRrTQLHfTFsOlgBbwtEX2TMneKYFKsF+OH2hgRDnWaguowQxrA18/vpzbT myX8irsF0/C98ccZK/8A2Ffh9Y1QiHGy+bgo2+lX91gk/akmD/SIw== Received: from ppma11.dal12v.mail.ibm.com (db.9e.1632.ip4.static.sl-reverse.com [50.22.158.219]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 45s6nqgnmq-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 02 Apr 2025 16:12:14 +0000 (GMT) Received: from pps.filterd (ppma11.dal12v.mail.ibm.com [127.0.0.1]) by ppma11.dal12v.mail.ibm.com (8.18.1.2/8.18.1.2) with ESMTP id 532DrIXo005420; Wed, 2 Apr 2025 16:12:13 GMT Received: from smtprelay07.fra02v.mail.ibm.com ([9.218.2.229]) by ppma11.dal12v.mail.ibm.com (PPS) with ESMTPS id 45pww2gc5v-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 02 Apr 2025 16:12:13 +0000 Received: from smtpav07.fra02v.mail.ibm.com (smtpav07.fra02v.mail.ibm.com [10.20.54.106]) by smtprelay07.fra02v.mail.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 532GC6vI47645028 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Wed, 2 Apr 2025 16:12:06 GMT Received: from smtpav07.fra02v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id BE4DE20043; Wed, 2 Apr 2025 16:12:06 +0000 (GMT) Received: from smtpav07.fra02v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 8E8192004B; Wed, 2 Apr 2025 16:12:06 +0000 (GMT) Received: from tuxmaker.lnxne.boe (unknown [9.152.85.9]) by smtpav07.fra02v.mail.ibm.com (Postfix) with ESMTP; Wed, 2 Apr 2025 16:12:06 +0000 (GMT) From: Jens Remus To: binutils@sourceware.org, Indu Bhagat , Andreas Krebbel Cc: Jens Remus , Ilya Leoshkevich , Claudiu Zissulescu-Ianculescu Subject: [PATCH 6/8] s390: Add SFrame stack trace information for .plt section Date: Wed, 2 Apr 2025 18:12:01 +0200 Message-ID: <20250402161203.2935633-7-jremus@linux.ibm.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20250402161203.2935633-1-jremus@linux.ibm.com> References: <20250402161203.2935633-1-jremus@linux.ibm.com> MIME-Version: 1.0 X-TM-AS-GCONF: 00 X-Proofpoint-ORIG-GUID: 1cUrMTvUi0QTFy2usGh-8ew1jGPrqUEh X-Proofpoint-GUID: 1cUrMTvUi0QTFy2usGh-8ew1jGPrqUEh X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1095,Hydra:6.0.680,FMLib:17.12.68.34 definitions=2025-04-02_06,2025-04-02_03,2024-11-22_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 mlxlogscore=999 priorityscore=1501 mlxscore=0 clxscore=1015 suspectscore=0 bulkscore=0 phishscore=0 impostorscore=0 adultscore=0 malwarescore=0 lowpriorityscore=0 spamscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.19.0-2502280000 definitions=main-2504020101 X-Spam-Status: No, score=-12.2 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H5, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: binutils@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Binutils mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: binutils-bounces~patchwork=sourceware.org@sourceware.org Enable SFrame stack tracing through PLT entries. Based on x86-64. On s390x both PLT0 and PLTn entries are 32-bytes in size. Their code neither alters the stack pointer (SP), frame pointer (FP), nor return address (RA) registers. Therefore the PLT0 can be represented using a SFrame FDE of type PCINC with a SFrame "null" FRE and the PLTn can be represented using a SFrame FDE of type PCMASK, with a repetition block size of 32 (PLTn size), and a SFrame "null" FRE. Note that as both the PLT0 entry and the PLTn entries have equal size and can both be represented using the identical SFrame "null" FRE, the whole .plt section on s390x could be represented using a single SFrame FDE of type PCMASK, with a repetition block size of 32 (PLT0 and PLTn size), and a single SFrame "null" FRE. Keep the x86-64 logic with separate SFrame FDEs for PLT0 and PLTn, to ease potential generalization of the .sframe for .plt generation logic among architectures. bfd/ * elf64-s390.c: Include sframe.h and sframe-api.h. (PLT_SFRAME_FDE_START_OFFSET, SFRAME_PLT0_MAX_NUM_FRES, SFRAME_PLTN_MAX_NUM_FRES, elf_s390x_sframe_plt_fre, elf_s390x_sframe_plt): New .sframe template for .plt section. (elf_s390_link_hash_table): Add plt_cfe_ctx, plt_sframe, and sframe_plt fields. (_bfd_s390x_elf_create_sframe_plt): New function. Fill in .sframe section for .plt section. (_bfd_s390x_elf_write_sframe_plt): New function. Write .sframe section. (elf_s390_create_dynamic_sections): Create .sframe section for .plt section. (elf_s390_late_size_sections): Call _bfd_s390x_elf_create_sframe_plt and _bfd_s390x_elf_write_sframe_plt. (elf_s390_finish_dynamic_sections): Write .plt section start into .sframe FDE covering .plt section. Call _bfd_elf_merge_section_sframe on htab->plt_sframe. ld/ * NEWS: Add news entry. ld/testsuite/ * ld-s390/s390.exp: Add new test. * ld-s390/sframe-plt-1.d: New linker-generated .sframe for .plt test. * ld-s390/sframe-simple-1.d: Adjust expected test output due to linker-generated .sframe for .plt. Signed-off-by: Jens Remus --- bfd/elf64-s390.c | 259 +++++++++++++++++++++++++ ld/NEWS | 4 + ld/testsuite/ld-s390/s390.exp | 1 + ld/testsuite/ld-s390/sframe-plt-1.d | 28 +++ ld/testsuite/ld-s390/sframe-simple-1.d | 9 +- 5 files changed, 297 insertions(+), 4 deletions(-) create mode 100644 ld/testsuite/ld-s390/sframe-plt-1.d diff --git a/bfd/elf64-s390.c b/bfd/elf64-s390.c index 259ad13be51f..478d5b86ebb0 100644 --- a/bfd/elf64-s390.c +++ b/bfd/elf64-s390.c @@ -27,6 +27,8 @@ #include "elf/s390.h" #include "elf-s390.h" #include "dwarf2.h" +#include "sframe.h" +#include "sframe-api.h" #include /* In case we're on a 32-bit machine, construct a 64-bit "-1" value @@ -594,6 +596,49 @@ static const bfd_byte elf_s390x_eh_frame_plt[] = DW_CFA_nop, DW_CFA_nop, DW_CFA_nop }; +/* .sframe covering the .plt section. */ + +/* This must be the same as sframe_get_hdr_size (sfh). For s390x, this value + is the same as sizeof (sframe_header) because there is no SFrame auxilliary + header. */ +#define PLT_SFRAME_FDE_START_OFFSET sizeof (sframe_header) + +#define SFRAME_PLT0_MAX_NUM_FRES 1 +#define SFRAME_PLTN_MAX_NUM_FRES 1 + +struct elf_s390x_sframe_plt +{ + unsigned int plt0_entry_size; + unsigned int plt0_num_fres; + const sframe_frame_row_entry *plt0_fres[SFRAME_PLT0_MAX_NUM_FRES]; + + unsigned int pltn_entry_size; + unsigned int pltn_num_fres; + const sframe_frame_row_entry *pltn_fres[SFRAME_PLTN_MAX_NUM_FRES]; +}; + +/* .sframe FRE covering the PLT0/PLTn .plt section entry. */ +static const sframe_frame_row_entry elf_s390x_sframe_plt_fre = +{ + 0, /* SFrame FRE start address. */ + {0, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* 12 bytes. */ + SFRAME_V1_FRE_INFO (SFRAME_BASE_REG_SP, 1, SFRAME_FRE_OFFSET_2B) /* FRE info. */ +}; + +/* SFrame helper object for PLT. */ +static const struct elf_s390x_sframe_plt elf_s390x_sframe_plt = +{ + PLT_FIRST_ENTRY_SIZE, + 1, /* Number of FREs for PLT0. */ + /* Array of SFrame FREs for PLT0. */ + { &elf_s390x_sframe_plt_fre }, + + PLT_ENTRY_SIZE, + 1, /* Number of FREs for PLTn. */ + /* Array of SFrame FREs for PLTn. */ + { &elf_s390x_sframe_plt_fre }, +}; + /* s390 ELF linker hash entry. */ @@ -688,6 +733,11 @@ struct elf_s390_link_hash_table asection *irelifunc; asection *plt_eh_frame; + sframe_encoder_ctx *plt_cfe_ctx; + asection *plt_sframe; + /* The .sframe helper object for .plt section. */ + const struct elf_s390x_sframe_plt *sframe_plt; + union { bfd_signed_vma refcount; bfd_vma offset; @@ -1513,6 +1563,137 @@ elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info, return _bfd_elf_adjust_dynamic_copy (info, h, s); } +/* Create SFrame stack trace info for the PLT entries in the .plt section. */ + +static bool +_bfd_s390x_elf_create_sframe_plt (struct bfd_link_info *info) +{ + struct elf_s390_link_hash_table *htab; + + unsigned int plt0_entry_size; + unsigned char func_info; + uint32_t fre_type; + /* The dynamic plt section for which .sframe stack trace information is being + created. */ + asection *dpltsec; + + int err = 0; + + sframe_encoder_ctx **ectx = NULL; + unsigned plt_entry_size = 0; + unsigned int num_pltn_fres = 0; + unsigned int num_pltn_entries = 0; + const sframe_frame_row_entry * const *pltn_fres; + + htab = elf_s390_hash_table (info); + ectx = &htab->plt_cfe_ctx; + dpltsec = htab->elf.splt; + + plt0_entry_size = htab->sframe_plt->plt0_entry_size; + plt_entry_size = htab->sframe_plt->pltn_entry_size; + pltn_fres = htab->sframe_plt->pltn_fres; + num_pltn_fres = htab->sframe_plt->pltn_num_fres; + num_pltn_entries = (dpltsec->size - plt0_entry_size) / plt_entry_size; + + *ectx = sframe_encode (SFRAME_VERSION_2, + 0, + SFRAME_ABI_S390_ENDIAN_BIG, + SFRAME_CFA_FIXED_FP_INVALID, + SFRAME_CFA_FIXED_RA_INVALID, + &err); + + /* FRE type is dependent on the size of the function. */ + fre_type = sframe_calc_fre_type (dpltsec->size); + func_info = sframe_fde_create_func_info (fre_type, SFRAME_FDE_TYPE_PCINC); + + /* Add SFrame FDE and the associated FREs for PLT0 if PLT0 has been + generated. */ + if (plt0_entry_size) + { + /* Add SFrame FDE for PLT0, the function start address is updated later + at _bfd_elf_merge_section_sframe time. */ + sframe_encoder_add_funcdesc_v2 (*ectx, + 0, /* func start addr. */ + plt0_entry_size, + func_info, + 0, /* Rep block size. */ + 0 /* Num FREs. */); + sframe_frame_row_entry plt0_fre; + unsigned int num_plt0_fres = htab->sframe_plt->plt0_num_fres; + for (unsigned int j = 0; j < num_plt0_fres; j++) + { + plt0_fre = *(htab->sframe_plt->plt0_fres[j]); + sframe_encoder_add_fre (*ectx, 0, &plt0_fre); + } + } + + if (num_pltn_entries) + { + /* PLTn entries use an SFrame FDE of type + SFRAME_FDE_TYPE_PCMASK to exploit the repetitive + pattern of the instructions in these entries. Using this SFrame FDE + type helps in keeping the SFrame stack trace info for PLTn entries + compact. */ + func_info = sframe_fde_create_func_info (fre_type, + SFRAME_FDE_TYPE_PCMASK); + /* Add the SFrame FDE for all PCs starting at the first PLTn entry (hence, + function start address = plt0_entry_size. As usual, this will be + updated later at _bfd_elf_merge_section_sframe, by when the + sections are relocated. */ + sframe_encoder_add_funcdesc_v2 (*ectx, + plt0_entry_size, /* func start addr. */ + dpltsec->size - plt0_entry_size, + func_info, + plt_entry_size, + 0 /* Num FREs. */); + + sframe_frame_row_entry pltn_fre; + /* Now add the FREs for PLTn. Simply adding the FREs suffices due + to the usage of SFRAME_FDE_TYPE_PCMASK above. */ + for (unsigned int j = 0; j < num_pltn_fres; j++) + { + unsigned int func_idx = plt0_entry_size ? 1 : 0; + pltn_fre = *(pltn_fres[j]); + sframe_encoder_add_fre (*ectx, func_idx, &pltn_fre); + } + } + + return true; +} + +/* Write contents of the .sframe section. */ + +static bool +_bfd_s390x_elf_write_sframe_plt (struct bfd_link_info *info) +{ + struct elf_s390_link_hash_table *htab; + sframe_encoder_ctx *ectx; + size_t sec_size; + asection *sec; + bfd *dynobj; + + int err = 0; + + htab = elf_s390_hash_table (info); + dynobj = htab->elf.dynobj; + + ectx = htab->plt_cfe_ctx; + sec = htab->plt_sframe; + + BFD_ASSERT (ectx); + + void *contents = sframe_encoder_write (ectx, &sec_size, &err); + + sec->size = (bfd_size_type) sec_size; + sec->contents = (unsigned char *) bfd_zalloc (dynobj, sec->size); + sec->alloced = 1; + memcpy (sec->contents, contents, sec_size); + + sframe_encoder_free (&ectx); + + return true; +} + /* Allocate space in .plt, .got and associated reloc sections for dynamic relocs. */ @@ -1892,6 +2073,25 @@ elf_s390_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, htab->plt_eh_frame->size = sizeof (elf_s390x_eh_frame_plt); } + /* No need to size the .sframe section explicitly because the write-out + mechanism is different. Simply prep up the FDE/FRE for the + .plt section. */ + if (_bfd_elf_sframe_present (info)) + { + if (htab->plt_sframe != NULL + && htab->elf.splt != NULL + && htab->elf.splt->size != 0 + && !bfd_is_abs_section (htab->elf.splt->output_section)) + { + _bfd_s390x_elf_create_sframe_plt (info); + /* FIXME - Dirty Hack. Set the size to something non-zero for now, + so that the section does not get stripped out below. The precise + size of this section is known only when the contents are + serialized in _bfd_s390x_elf_write_sframe_plt. */ + htab->plt_sframe->size = sizeof (sframe_header) + 1; + } + } + /* We now have determined the sizes of the various dynamic sections. Allocate memory for them. */ relocs = false; @@ -1904,6 +2104,7 @@ elf_s390_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, || s == htab->elf.sgot || s == htab->elf.sgotplt || s == htab->plt_eh_frame + || s == htab->plt_sframe || s == htab->elf.sdynbss || s == htab->elf.sdynrelro || s == htab->elf.iplt @@ -1960,6 +2161,11 @@ elf_s390_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, if ((s->flags & SEC_HAS_CONTENTS) == 0) continue; + /* Skip allocating contents for .sframe section as it is written + out differently. See below. */ + if (s == htab->plt_sframe) + continue; + /* Allocate memory for the section contents. We use bfd_zalloc here in case unused entries are not reclaimed before the section's contents are written out. This should not happen, @@ -1981,6 +2187,15 @@ elf_s390_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET); } + if (_bfd_elf_sframe_present (info)) + { + if (htab->plt_sframe != NULL + && htab->elf.splt != NULL + && htab->elf.splt->size != 0 + && htab->plt_sframe->contents == NULL) + _bfd_s390x_elf_write_sframe_plt (info); + } + return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs); } @@ -3786,6 +4001,34 @@ elf_s390_finish_dynamic_sections (bfd *output_bfd, } } + /* Make any adjustment if necessary and merge .sframe section to + create the final .sframe section for output_bfd. */ + if (htab->plt_sframe != NULL + && htab->plt_sframe->contents != NULL) + { + if (htab->elf.splt != NULL + && htab->elf.splt->size != 0 + && (htab->elf.splt->flags & SEC_EXCLUDE) == 0 + && htab->elf.splt->output_section != NULL + && htab->plt_sframe->output_section != NULL) + { + bfd_vma plt_start = htab->elf.splt->output_section->vma; + bfd_vma sframe_start = htab->plt_sframe->output_section->vma + + htab->plt_sframe->output_offset + + PLT_SFRAME_FDE_START_OFFSET; + bfd_put_signed_32 (dynobj, plt_start - sframe_start, + htab->plt_sframe->contents + + PLT_SFRAME_FDE_START_OFFSET); + } + if (htab->plt_sframe->sec_info_type == SEC_INFO_TYPE_SFRAME) + { + if (! _bfd_elf_merge_section_sframe (output_bfd, info, + htab->plt_sframe, + htab->plt_sframe->contents)) + return NULL; + } + } + return true; } @@ -4026,6 +4269,8 @@ elf_s390_create_dynamic_sections (bfd *dynobj, if (htab == NULL) return false; + htab->sframe_plt = &elf_s390x_sframe_plt; + if (htab->elf.splt != NULL) { /* Create .eh_frame section for .plt section. */ @@ -4046,6 +4291,20 @@ elf_s390_create_dynamic_sections (bfd *dynobj, return false; } } + + /* Create .sframe section for .plt section. */ + if (!info->no_ld_generated_unwind_info) + { + flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY + | SEC_HAS_CONTENTS | SEC_IN_MEMORY + | SEC_LINKER_CREATED); + + htab->plt_sframe = bfd_make_section_anyway_with_flags (dynobj, + ".sframe", + flags); + if (htab->plt_sframe == NULL) + return false; + } } return true; diff --git a/ld/NEWS b/ld/NEWS index 7b5e2e47c07b..f59f5e181a65 100644 --- a/ld/NEWS +++ b/ld/NEWS @@ -1,5 +1,9 @@ -*- text -*- +* On s390, generate SFrame stack trace information (.sframe) for the linker + generated .plt section. Enabled by default. Can be disabled using linker + option --no-ld-generated-unwind-info. + * The linker's --stats option can take an optional argument which if used is interpreted as a filename into which resource usage information should be stored. As an alternative mechanism the LD_STATS environment variable can diff --git a/ld/testsuite/ld-s390/s390.exp b/ld/testsuite/ld-s390/s390.exp index cf3a904481f8..38758cfa9ea9 100644 --- a/ld/testsuite/ld-s390/s390.exp +++ b/ld/testsuite/ld-s390/s390.exp @@ -141,5 +141,6 @@ if [istarget "s390x-*-*"] { if { ![skip_sframe_tests] } { run_dump_test "sframe-simple-1" + run_dump_test "sframe-plt-1" } } diff --git a/ld/testsuite/ld-s390/sframe-plt-1.d b/ld/testsuite/ld-s390/sframe-plt-1.d new file mode 100644 index 000000000000..67b11bd3dcf4 --- /dev/null +++ b/ld/testsuite/ld-s390/sframe-plt-1.d @@ -0,0 +1,28 @@ +#as: --gsframe +#source: sframe-foo.s +#source: sframe-bar.s +#objdump: --sframe=.sframe +#ld: -shared --no-rosegment +#name: SFrame for plt0 and pltN + +.*: +file format .* + +Contents of the SFrame section .sframe: + Header : + + Version: SFRAME_VERSION_2 + Flags: SFRAME_F_FDE_SORTED + Num FDEs: 4 + Num FREs: 8 + + Function Index : + + func idx \[0\]: pc = 0x1e8, size = 32 bytes + STARTPC +CFA +FP +RA + + 0+1e8 +sp\+160 +u +u + + + func idx \[1\]: pc = 0x208, size = 32 bytes + STARTPC\[m\] +CFA +FP +RA + + 0+0 +sp\+160 +u +u + + +#... diff --git a/ld/testsuite/ld-s390/sframe-simple-1.d b/ld/testsuite/ld-s390/sframe-simple-1.d index 4df5d492f01e..2967278e9f86 100644 --- a/ld/testsuite/ld-s390/sframe-simple-1.d +++ b/ld/testsuite/ld-s390/sframe-simple-1.d @@ -12,16 +12,17 @@ Contents of the SFrame section .sframe: Version: SFRAME_VERSION_2 Flags: SFRAME_F_FDE_SORTED - Num FDEs: 2 - Num FREs: 6 + Num FDEs: 4 + Num FREs: 8 Function Index : - func idx \[0\]: pc = 0x228, size = 8 bytes +#... + func idx \[2\]: pc = 0x228, size = 8 bytes STARTPC +CFA +FP +RA + 0+228 +sp\+160 +u +u + - func idx \[1\]: pc = 0x230, size = 42 bytes + func idx \[3\]: pc = 0x230, size = 42 bytes STARTPC +CFA +FP +RA + 0+230 +sp\+160 +u +u + 0+236 +sp\+160 +u +c-48 +