From patchwork Tue Feb 18 12:43:39 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Strasuns, Mihails" X-Patchwork-Id: 38207 Received: (qmail 114181 invoked by alias); 18 Feb 2020 12:42:56 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 114118 invoked by uid 89); 18 Feb 2020 12:42:56 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT autolearn=ham version=3.3.1 spammy= X-HELO: mga03.intel.com Received: from mga03.intel.com (HELO mga03.intel.com) (134.134.136.65) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 18 Feb 2020 12:42:53 +0000 Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga103.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 18 Feb 2020 04:42:52 -0800 Received: from labpc7920x-08.iul.intel.com (HELO localhost) ([172.28.49.153]) by fmsmga001-auth.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 18 Feb 2020 04:42:51 -0800 From: Mihails Strasuns To: gdb-patches@sourceware.org Cc: Mihails Strasuns Subject: [PATCH 7/7] [gdb/testsuite] add jit-elf-util.h and run jit function Date: Tue, 18 Feb 2020 13:43:39 +0100 Message-Id: <20200218124339.11270-8-mihails.strasuns@intel.com> In-Reply-To: <20200218124339.11270-1-mihails.strasuns@intel.com> References: <20200218124339.11270-1-mihails.strasuns@intel.com> MIME-Version: 1.0 X-IsSubscribed: yes Splits ELF related symbols into a separate jit-elf-util.h header and enhances it with a few more. Intention is to make adding new JIT tests possible without repeating most of the common boilerplate. As a test enhancement, jit-elf-main.c now calls the renamed function after registering the jit object and ensures it returns an expected result. gdb/testsuite/ChangeLog: 2020-02-18 Mihails Strasuns * gdb.base/jit-elf-util.h: new header file * gdb.base/jit-elf-main.c: use jit-elf-util.h, add a call to the renamed JIT function to verify its result Change-Id: I9ac35ff2d610a57536f8afd33794c2feb6f40e25 Signed-off-by: Mihails Strasuns --- gdb/testsuite/gdb.base/jit-elf-main.c | 88 +++------------- gdb/testsuite/gdb.base/jit-elf-util.h | 145 ++++++++++++++++++++++++++ 2 files changed, 162 insertions(+), 71 deletions(-) create mode 100644 gdb/testsuite/gdb.base/jit-elf-util.h diff --git a/gdb/testsuite/gdb.base/jit-elf-main.c b/gdb/testsuite/gdb.base/jit-elf-main.c index 09b9a90ada..b11a3e1410 100644 --- a/gdb/testsuite/gdb.base/jit-elf-main.c +++ b/gdb/testsuite/gdb.base/jit-elf-main.c @@ -30,19 +30,7 @@ #include #include "jit-protocol.h" - -/* ElfW is coming from linux. On other platforms it does not exist. - Let us define it here. */ -#ifndef ElfW -# if (defined (_LP64) || defined (__LP64__)) -# define WORDSIZE 64 -# else -# define WORDSIZE 32 -# endif /* _LP64 || __LP64__ */ -#define ElfW(type) _ElfW (Elf, WORDSIZE, type) -#define _ElfW(e,w,t) _ElfW_1 (e, w, _##t) -#define _ElfW_1(e,w,t) e##w##t -#endif /* !ElfW */ +#include "jit-elf-util.h" static void usage () @@ -51,35 +39,6 @@ usage () exit (1); } -/* Rename jit_function_XXXX to match idx */ - -static void -update_name (const void *const addr, int idx) -{ - const ElfW (Ehdr) *const ehdr = (ElfW (Ehdr) *)addr; - ElfW (Shdr) *const shdr = (ElfW (Shdr) *)((char *)addr + ehdr->e_shoff); - ElfW (Phdr) *const phdr = (ElfW (Phdr) *)((char *)addr + ehdr->e_phoff); - int i; - - for (i = 0; i < ehdr->e_shnum; ++i) - { - if (shdr[i].sh_type == SHT_STRTAB) - { - /* Note: we update both .strtab and .dynstr. The latter would - not be correct if this were a regular shared library (.hash - would be wrong), but this is a simulation -- the library is - never exposed to the dynamic loader, so it all ends up ok. */ - char *const strtab = (char *)((ElfW (Addr))addr + shdr[i].sh_offset); - char *const strtab_end = strtab + shdr[i].sh_size; - char *p; - - for (p = strtab; p < strtab_end; p += strlen (p) + 1) - if (strcmp (p, "jit_function_XXXX") == 0) - sprintf (p, "jit_function_%04d", idx); - } - } -} - /* Defined by the .exp file if testing attach. */ #ifndef ATTACH #define ATTACH 0 @@ -122,39 +81,20 @@ MAIN (int argc, char *argv[]) for (i = 1; i < argc; ++i) { - struct stat st; - int fd; - - printf ("%s:%d: libname = %s, i = %d\n", __FILE__, __LINE__, argv[i], i); - if ((fd = open (argv[i], O_RDONLY)) == -1) - { - fprintf (stderr, "open (\"%s\", O_RDONLY): %s\n", argv[i], - strerror (errno)); - exit (1); - } - - if (fstat (fd, &st) != 0) - { - fprintf (stderr, "fstat (\"%d\"): %s\n", fd, strerror (errno)); - exit (1); - } - - void* load_addr = (void*) (size_t) (LOAD_ADDRESS + (i-1) * LOAD_INCREMENT); - const void *const addr = mmap (load_addr, st.st_size, PROT_READ|PROT_WRITE, - MAP_PRIVATE, fd, 0); - struct jit_code_entry *const entry = calloc (1, sizeof (*entry)); - - if (addr == MAP_FAILED) - { - fprintf (stderr, "mmap: %s\n", strerror (errno)); - exit (1); - } - + size_t obj_size; + ElfW (Addr) load_addr = LOAD_ADDRESS + (i-1) * LOAD_INCREMENT; + printf("Loading %s as JIT at %p\n", argv[i], (void*) load_addr); + ElfW (Addr) addr = load_elf (argv[i], &obj_size, load_addr); update_name (addr, i); + char name[32]; + sprintf (name, "jit_function_%04d", i); + int (*jit_function) () = (int (*) ()) load_symbol (addr, name); + /* Link entry at the end of the list. */ + struct jit_code_entry *const entry = calloc (1, sizeof (*entry)); entry->symfile_addr = (const char *)addr; - entry->symfile_size = st.st_size; + entry->symfile_size = obj_size; entry->prev_entry = __jit_debug_descriptor.relevant_entry; __jit_debug_descriptor.relevant_entry = entry; @@ -166,6 +106,12 @@ MAIN (int argc, char *argv[]) /* Notify GDB. */ __jit_debug_descriptor.action_flag = JIT_REGISTER; __jit_debug_register_code (); + + if (jit_function () != 42) + { + fprintf (stderr, "unexpected return value\n"); + exit (1); + } } WAIT_FOR_GDB; i = 0; /* gdb break here 1 */ diff --git a/gdb/testsuite/gdb.base/jit-elf-util.h b/gdb/testsuite/gdb.base/jit-elf-util.h new file mode 100644 index 0000000000..ad5041fa74 --- /dev/null +++ b/gdb/testsuite/gdb.base/jit-elf-util.h @@ -0,0 +1,145 @@ +/* This test program is part of GDB, the GNU debugger. + + Copyright 2020 Free Software Foundation, Inc. + + 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 3 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 . */ + +/* Simulates loading of JIT code by memory mapping a compiled + shared library binary and doing minimal post-processing. */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* ElfW is coming from linux. On other platforms it does not exist. + Let us define it here. */ +#ifndef ElfW +#if (defined(_LP64) || defined(__LP64__)) +#define WORDSIZE 64 +#else +#define WORDSIZE 32 +#endif /* _LP64 || __LP64__ */ +#define ElfW(type) _ElfW (Elf, WORDSIZE, type) +#define _ElfW(e, w, t) _ElfW_1 (e, w, _##t) +#define _ElfW_1(e, w, t) e##w##t +#endif /* !ElfW */ + +/* Looks into string tables for entry + "jit_function_XXXX" and updates it to use `rename_num`. */ +static void +update_name (ElfW (Addr) addr, int rename_num) +{ + const ElfW (Ehdr) *const ehdr = (ElfW (Ehdr) *) addr; + ElfW (Shdr) *const shdr = (ElfW (Shdr) *) ((char *) addr + ehdr->e_shoff); + ElfW (Phdr) *const phdr = (ElfW (Phdr) *) ((char *) addr + ehdr->e_phoff); + + for (int i = 0; i < ehdr->e_shnum; ++i) + { + if (shdr[i].sh_type == SHT_STRTAB) + { + /* Note: we update both .strtab and .dynstr. The latter would + not be correct if this were a regular shared library (.hash + would be wrong), but this is a simulation -- the library is + never exposed to the dynamic loader, so it all ends up ok. */ + char *const strtab = (char *) (addr + shdr[i].sh_offset); + char *const strtab_end = strtab + shdr[i].sh_size; + char *p; + + for (p = strtab; p < strtab_end; p += strlen (p) + 1) + if (strcmp (p, "jit_function_XXXX") == 0) + sprintf (p, "jit_function_%04d", rename_num); + } + } +} + +/* Find symbol with the name `sym_name`. */ +static ElfW (Addr) +load_symbol (ElfW (Addr) addr, const char *sym_name) +{ + const ElfW (Ehdr) *const ehdr = (ElfW (Ehdr) *) addr; + ElfW (Shdr) *const shdr = (ElfW (Shdr) *) ((char *) addr + ehdr->e_shoff); + + ElfW (Addr) sym_old_addr = 0; + ElfW (Addr) sym_new_addr = 0; + + /* Find `func_name` in symbol_table and adjust it from the addr. */ + + for (int i = 0; i < ehdr->e_shnum; ++i) + { + if (shdr[i].sh_type == SHT_SYMTAB) + { + ElfW (Sym) *symtab = (ElfW (Sym) *) (addr + shdr[i].sh_offset); + ElfW (Sym) *symtab_end + = (ElfW (Sym) *) (addr + shdr[i].sh_offset + shdr[i].sh_size); + char *const strtab + = (char *) (addr + shdr[shdr[i].sh_link].sh_offset); + + for (ElfW (Sym) *p = symtab; p < symtab_end; ++p) + { + const char *s = strtab + p->st_name; + if (strcmp (s, sym_name) == 0) + return p->st_value; + } + } + } + + fprintf (stderr, "symbol '%s' not found\n", sym_name); + exit (1); + return 0; +} + +/* Open an elf binary file and memory map it with execution flag enabled. */ +ElfW (Addr) +load_elf (const char *libname, size_t *size, ElfW (Addr) load_addr) +{ + int fd; + struct stat st; + + if ((fd = open (libname, O_RDONLY)) == -1) + { + fprintf (stderr, "open (\"%s\", O_RDONLY): %s\n", libname, + strerror (errno)); + exit (1); + } + + if (fstat (fd, &st) != 0) + { + fprintf (stderr, "fstat (\"%d\"): %s\n", fd, strerror (errno)); + exit (1); + } + + void *addr = mmap ((void *) load_addr, st.st_size, + PROT_READ | PROT_WRITE | PROT_EXEC, + load_addr ? MAP_PRIVATE | MAP_FIXED : MAP_PRIVATE, fd, 0); + close (fd); + + if (addr == MAP_FAILED) + { + fprintf (stderr, "mmap: %s\n", strerror (errno)); + exit (1); + } + + if (size != NULL) + *size = st.st_size; + + return (ElfW (Addr)) addr; +} \ No newline at end of file