1/* Miscellaneous utilities.
2   Copyright (C) 2019-2020 Free Software Foundation, Inc.
3
4   This file is part of libctf.
5
6   libctf is free software; you can redistribute it and/or modify it under
7   the terms of the GNU General Public License as published by the Free
8   Software Foundation; either version 3, or (at your option) any later
9   version.
10
11   This program is distributed in the hope that it will be useful, but
12   WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14   See the GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program; see the file COPYING.  If not see
18   <http://www.gnu.org/licenses/>.  */
19
20#include <ctf-impl.h>
21#include <string.h>
22
23/* Simple doubly-linked list append routine.  This implementation assumes that
24   each list element contains an embedded ctf_list_t as the first member.
25   An additional ctf_list_t is used to store the head (l_next) and tail
26   (l_prev) pointers.  The current head and tail list elements have their
27   previous and next pointers set to NULL, respectively.  */
28
29void
30ctf_list_append (ctf_list_t *lp, void *newp)
31{
32  ctf_list_t *p = lp->l_prev;	/* p = tail list element.  */
33  ctf_list_t *q = newp;		/* q = new list element.  */
34
35  lp->l_prev = q;
36  q->l_prev = p;
37  q->l_next = NULL;
38
39  if (p != NULL)
40    p->l_next = q;
41  else
42    lp->l_next = q;
43}
44
45/* Prepend the specified existing element to the given ctf_list_t.  The
46   existing pointer should be pointing at a struct with embedded ctf_list_t.  */
47
48void
49ctf_list_prepend (ctf_list_t * lp, void *newp)
50{
51  ctf_list_t *p = newp;		/* p = new list element.  */
52  ctf_list_t *q = lp->l_next;	/* q = head list element.  */
53
54  lp->l_next = p;
55  p->l_prev = NULL;
56  p->l_next = q;
57
58  if (q != NULL)
59    q->l_prev = p;
60  else
61    lp->l_prev = p;
62}
63
64/* Delete the specified existing element from the given ctf_list_t.  The
65   existing pointer should be pointing at a struct with embedded ctf_list_t.  */
66
67void
68ctf_list_delete (ctf_list_t *lp, void *existing)
69{
70  ctf_list_t *p = existing;
71
72  if (p->l_prev != NULL)
73    p->l_prev->l_next = p->l_next;
74  else
75    lp->l_next = p->l_next;
76
77  if (p->l_next != NULL)
78    p->l_next->l_prev = p->l_prev;
79  else
80    lp->l_prev = p->l_prev;
81}
82
83/* Return 1 if the list is empty.  */
84
85int
86ctf_list_empty_p (ctf_list_t *lp)
87{
88  return (lp->l_next == NULL && lp->l_prev == NULL);
89}
90
91/* Convert a 32-bit ELF symbol into Elf64 and return a pointer to it.  */
92
93Elf64_Sym *
94ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst)
95{
96  dst->st_name = src->st_name;
97  dst->st_value = src->st_value;
98  dst->st_size = src->st_size;
99  dst->st_info = src->st_info;
100  dst->st_other = src->st_other;
101  dst->st_shndx = src->st_shndx;
102
103  return dst;
104}
105
106/* A string appender working on dynamic strings.  Returns NULL on OOM.  */
107
108char *
109ctf_str_append (char *s, const char *append)
110{
111  size_t s_len = 0;
112
113  if (append == NULL)
114    return s;
115
116  if (s != NULL)
117    s_len = strlen (s);
118
119  size_t append_len = strlen (append);
120
121  if ((s = realloc (s, s_len + append_len + 1)) == NULL)
122    return NULL;
123
124  memcpy (s + s_len, append, append_len);
125  s[s_len + append_len] = '\0';
126
127  return s;
128}
129
130/* A version of ctf_str_append that returns the old string on OOM.  */
131
132char *
133ctf_str_append_noerr (char *s, const char *append)
134{
135  char *new_s;
136
137  new_s = ctf_str_append (s, append);
138  if (!new_s)
139    return s;
140  return new_s;
141}
142
143/* A realloc() that fails noisily if called with any ctf_str_num_users.  */
144void *
145ctf_realloc (ctf_file_t *fp, void *ptr, size_t size)
146{
147  if (fp->ctf_str_num_refs > 0)
148    {
149      ctf_dprintf ("%p: attempt to realloc() string table with %lu active refs\n",
150		   (void *) fp, (unsigned long) fp->ctf_str_num_refs);
151      return NULL;
152    }
153  return realloc (ptr, size);
154}
155
156/* Store the specified error code into errp if it is non-NULL, and then
157   return NULL for the benefit of the caller.  */
158
159void *
160ctf_set_open_errno (int *errp, int error)
161{
162  if (errp != NULL)
163    *errp = error;
164  return NULL;
165}
166
167/* Store the specified error code into the CTF container, and then return
168   CTF_ERR / -1 for the benefit of the caller. */
169
170unsigned long
171ctf_set_errno (ctf_file_t * fp, int err)
172{
173  fp->ctf_errno = err;
174  return CTF_ERR;
175}
176