From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 7398 invoked by alias); 30 Apr 2019 22:57:20 -0000 Mailing-List: contact binutils-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: binutils-owner@sourceware.org Received: (qmail 7303 invoked by uid 89); 30 Apr 2019 22:57:20 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-24.2 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,SPF_HELO_PASS,UNPARSEABLE_RELAY autolearn=ham version=3.3.1 spammy=elem X-HELO: aserp2130.oracle.com Received: from aserp2130.oracle.com (HELO aserp2130.oracle.com) (141.146.126.79) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 30 Apr 2019 22:57:17 +0000 Received: from pps.filterd (aserp2130.oracle.com [127.0.0.1]) by aserp2130.oracle.com (8.16.0.27/8.16.0.27) with SMTP id x3UMsXZ2090661 for ; Tue, 30 Apr 2019 22:57:15 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2018-07-02; bh=xHhHFx5eZX1d7Nj0tKFPHZtlhY3g+2ccHNJdQnSuR4o=; b=b8jn7rYeridXZuJO3esp3b0RWL5wgQxilmx7ToVVhV5bpE6GbwxDEMHnCyqrO0gb1bBP IqfVJNBzf0sqijSxSKvKCsEcVJz86+vf9VTRobptXxxqS9scsD1HszfZ1pVjKWdxQ4WB aNyDHtarXN0oN+kb54r2JNA2Fr+WBD1mCHYggXHrXrqM4riEobxU3jucqKVxAaYEzuAV BTPlMMKXr+OMbkA3Z1Y+PZI6gac0moONeBDw3jt/1821qcpd5cxHQLfXWV+Ab3gSIloR npUwSGE3ritNl8OElZPhcmfC3dpQRrXwISd4bEHPfni9K8zBrtfhGBynyKXAuflgKqH7 Tw== Received: from aserp3020.oracle.com (aserp3020.oracle.com [141.146.126.70]) by aserp2130.oracle.com with ESMTP id 2s6xhy871s-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Tue, 30 Apr 2019 22:57:15 +0000 Received: from pps.filterd (aserp3020.oracle.com [127.0.0.1]) by aserp3020.oracle.com (8.16.0.27/8.16.0.27) with SMTP id x3UMujFR006192 for ; Tue, 30 Apr 2019 22:57:15 GMT Received: from userv0121.oracle.com (userv0121.oracle.com [156.151.31.72]) by aserp3020.oracle.com with ESMTP id 2s6xhg0q6e-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Tue, 30 Apr 2019 22:57:15 +0000 Received: from abhmp0020.oracle.com (abhmp0020.oracle.com [141.146.116.26]) by userv0121.oracle.com (8.14.4/8.13.8) with ESMTP id x3UMvE2b006633 for ; Tue, 30 Apr 2019 22:57:14 GMT Received: from loom.srvr.nix (/81.187.191.129) by default (Oracle Beehive Gateway v4.0) with ESMTP ; Tue, 30 Apr 2019 15:57:14 -0700 From: Nick Alcock To: binutils@sourceware.org Subject: [PATCH 04/19] libctf: low-level list manipulation and helper utilities Date: Tue, 30 Apr 2019 22:57:00 -0000 Message-Id: <20190430225706.159422-5-nick.alcock@oracle.com> In-Reply-To: <20190430225706.159422-1-nick.alcock@oracle.com> References: <20190430225706.159422-1-nick.alcock@oracle.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-IsSubscribed: yes X-SW-Source: 2019-04/txt/msg00276.txt.bz2 These utilities are a bit of a ragbag of small things needed by more than one TU: list manipulation, ELF32->64 translators, routines to look up strings in string tables, dynamically-allocated string appenders, and routines to set the specialized errno values previously committed in . Notes for reviewers: The distinction betweern this file and ctf-subr.c is lost in the mists of time: perhaps it was originally that ctf-subr.c contained nothing but wrappers. I am quite amenable to combining the two, and also to splitting the errno-setting stuff out into ctf-error.c with the error fetchers. libctf/ * ctf-util.c: New file. * ctf-impl.h: Add definitions. --- libctf/ctf-impl.h | 32 +++++++++ libctf/ctf-util.c | 176 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 208 insertions(+) create mode 100644 libctf/ctf-util.c diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h index 108c89d2c5..d4d71fbfdc 100644 --- a/libctf/ctf-impl.h +++ b/libctf/ctf-impl.h @@ -24,6 +24,13 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include #ifdef __cplusplus extern "C" @@ -52,6 +59,25 @@ extern "C" #endif +typedef struct ctf_list +{ + struct ctf_list *l_prev; /* Previous pointer or tail pointer. */ + struct ctf_list *l_next; /* Next pointer or head pointer. */ +} ctf_list_t; + +#define ctf_list_prev(elem) ((void *)(((ctf_list_t *)(elem))->l_prev)) +#define ctf_list_next(elem) ((void *)(((ctf_list_t *)(elem))->l_next)) + +extern void ctf_list_append (ctf_list_t *, void *); +extern void ctf_list_prepend (ctf_list_t *, void *); +extern void ctf_list_delete (ctf_list_t *, void *); + +extern const char *ctf_strraw (ctf_file_t *, uint32_t); +extern const char *ctf_strptr (ctf_file_t *, uint32_t); + +extern ctf_file_t *ctf_set_open_errno (int *, int); +extern long ctf_set_errno (ctf_file_t *, int); + extern void *ctf_data_alloc (size_t); extern void ctf_data_free (void *, size_t); extern void ctf_data_protect (void *, size_t); @@ -59,9 +85,15 @@ extern void ctf_data_protect (void *, size_t); extern void *ctf_alloc (size_t); extern void ctf_free (void *, size_t); +extern char *ctf_strdup (const char *); +extern char *ctf_str_append (char *, const char *); +extern const char *ctf_strerror (int); + _libctf_printflike_ (1, 2) extern void ctf_dprintf (const char *, ...); +extern Elf64_Sym *ctf_sym_to_gelf (const Elf32_Sym *src, Elf64_Sym *dst); + extern int _libctf_debug; /* debugging messages enabled */ #ifdef __cplusplus diff --git a/libctf/ctf-util.c b/libctf/ctf-util.c new file mode 100644 index 0000000000..a3a8d05dd3 --- /dev/null +++ b/libctf/ctf-util.c @@ -0,0 +1,176 @@ +/* Miscellaneous utilities. + Copyright (C) 2005-2018 Free Software Foundation, Inc. + + This file is part of libctf. + + libctf 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, 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; see the file COPYING. If not see + . */ + +#include +#include + +/* Simple doubly-linked list append routine. This implementation assumes that + each list element contains an embedded ctf_list_t as the first member. + An additional ctf_list_t is used to store the head (l_next) and tail + (l_prev) pointers. The current head and tail list elements have their + previous and next pointers set to NULL, respectively. */ + +void +ctf_list_append (ctf_list_t *lp, void *new) +{ + ctf_list_t *p = lp->l_prev; /* p = tail list element. */ + ctf_list_t *q = new; /* q = new list element. */ + + lp->l_prev = q; + q->l_prev = p; + q->l_next = NULL; + + if (p != NULL) + p->l_next = q; + else + lp->l_next = q; +} + +/* Prepend the specified existing element to the given ctf_list_t. The + existing pointer should be pointing at a struct with embedded ctf_list_t. */ + +void +ctf_list_prepend (ctf_list_t * lp, void *new) +{ + ctf_list_t *p = new; /* p = new list element. */ + ctf_list_t *q = lp->l_next; /* q = head list element. */ + + lp->l_next = p; + p->l_prev = NULL; + p->l_next = q; + + if (q != NULL) + q->l_prev = p; + else + lp->l_prev = p; +} + +/* Delete the specified existing element from the given ctf_list_t. The + existing pointer should be pointing at a struct with embedded ctf_list_t. */ + +void +ctf_list_delete (ctf_list_t *lp, void *existing) +{ + ctf_list_t *p = existing; + + if (p->l_prev != NULL) + p->l_prev->l_next = p->l_next; + else + lp->l_next = p->l_next; + + if (p->l_next != NULL) + p->l_next->l_prev = p->l_prev; + else + lp->l_prev = p->l_prev; +} + +/* Convert a 32-bit ELF symbol into GElf (Elf64) and return a pointer to it. */ + +Elf64_Sym * +ctf_sym_to_gelf (const Elf32_Sym *src, Elf64_Sym *dst) +{ + dst->st_name = src->st_name; + dst->st_value = src->st_value; + dst->st_size = src->st_size; + dst->st_info = src->st_info; + dst->st_other = src->st_other; + dst->st_shndx = src->st_shndx; + + return dst; +} + +/* Convert an encoded CTF string name into a pointer to a C string by looking + up the appropriate string table buffer and then adding the offset. */ + +const char * +ctf_strraw (ctf_file_t *fp, uint32_t name) +{ + ctf_strs_t *ctsp = &fp->ctf_str[CTF_NAME_STID (name)]; + + if (ctsp->cts_strs != NULL && CTF_NAME_OFFSET (name) < ctsp->cts_len) + return (ctsp->cts_strs + CTF_NAME_OFFSET (name)); + + /* String table not loaded or corrupt offset. */ + return NULL; +} + +const char * +ctf_strptr (ctf_file_t *fp, uint32_t name) +{ + const char *s = ctf_strraw (fp, name); + return (s != NULL ? s : "(?)"); +} + +/* Same as strdup(3C), but use ctf_alloc() to do the memory allocation. */ + +char * +ctf_strdup (const char *s1) +{ + char *s2 = ctf_alloc (strlen (s1) + 1); + + if (s2 != NULL) + (void) strcpy (s2, s1); + + return s2; +} + +/* A string appender working on dynamic strings. */ + +char * +ctf_str_append (char *s, const char *append) +{ + size_t s_len = 0; + + if (append == NULL) + return s; + + if (s != NULL) + s_len = strlen (s); + + size_t append_len = strlen (append); + + if ((s = realloc (s, s_len + append_len + 1)) == NULL) + return NULL; + + memcpy (s + s_len, append, append_len); + s[s_len + append_len] = '\0'; + + return s; +} + +/* Store the specified error code into errp if it is non-NULL, and then + return NULL for the benefit of the caller. */ + +ctf_file_t * +ctf_set_open_errno (int *errp, int error) +{ + if (errp != NULL) + *errp = error; + return NULL; +} + +/* Store the specified error code into the CTF container, and then return + CTF_ERR for the benefit of the caller. */ + +long +ctf_set_errno (ctf_file_t * fp, int err) +{ + fp->ctf_errno = err; + return CTF_ERR; +} -- 2.21.0.237.gd0cfaa883d