OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [auxv.c] - Blame information for rev 233

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Auxiliary vector support for GDB, the GNU debugger.
2
 
3
   Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
 
20
#include "defs.h"
21
#include "target.h"
22
#include "gdbtypes.h"
23
#include "command.h"
24
#include "inferior.h"
25
#include "valprint.h"
26
#include "gdb_assert.h"
27
 
28
#include "auxv.h"
29
#include "elf/common.h"
30
 
31
#include <unistd.h>
32
#include <fcntl.h>
33
 
34
 
35
/* This function is called like a to_xfer_partial hook,
36
   but must be called with TARGET_OBJECT_AUXV.
37
   It handles access via /proc/PID/auxv, which is the common method.
38
   This function is appropriate for doing:
39
           #define NATIVE_XFER_AUXV     procfs_xfer_auxv
40
   for a native target that uses inftarg.c's child_xfer_partial hook.  */
41
 
42
LONGEST
43
procfs_xfer_auxv (struct target_ops *ops,
44
                  int /* enum target_object */ object,
45
                  const char *annex,
46
                  gdb_byte *readbuf,
47
                  const gdb_byte *writebuf,
48
                  ULONGEST offset,
49
                  LONGEST len)
50
{
51
  char *pathname;
52
  int fd;
53
  LONGEST n;
54
 
55
  gdb_assert (object == TARGET_OBJECT_AUXV);
56
  gdb_assert (readbuf || writebuf);
57
 
58
  pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid));
59
  fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY);
60
  xfree (pathname);
61
  if (fd < 0)
62
    return -1;
63
 
64
  if (offset != (ULONGEST) 0
65
      && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
66
    n = -1;
67
  else if (readbuf != NULL)
68
    n = read (fd, readbuf, len);
69
  else
70
    n = write (fd, writebuf, len);
71
 
72
  (void) close (fd);
73
 
74
  return n;
75
}
76
 
77
/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
78
   Return 0 if *READPTR is already at the end of the buffer.
79
   Return -1 if there is insufficient buffer for a whole entry.
80
   Return 1 if an entry was read into *TYPEP and *VALP.  */
81
int
82
target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
83
                   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
84
{
85
  const int sizeof_auxv_field = TYPE_LENGTH (builtin_type_void_data_ptr);
86
  gdb_byte *ptr = *readptr;
87
 
88
  if (endptr == ptr)
89
    return 0;
90
 
91
  if (endptr - ptr < sizeof_auxv_field * 2)
92
    return -1;
93
 
94
  *typep = extract_unsigned_integer (ptr, sizeof_auxv_field);
95
  ptr += sizeof_auxv_field;
96
  *valp = extract_unsigned_integer (ptr, sizeof_auxv_field);
97
  ptr += sizeof_auxv_field;
98
 
99
  *readptr = ptr;
100
  return 1;
101
}
102
 
103
/* Extract the auxiliary vector entry with a_type matching MATCH.
104
   Return zero if no such entry was found, or -1 if there was
105
   an error getting the information.  On success, return 1 after
106
   storing the entry's value field in *VALP.  */
107
int
108
target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
109
{
110
  CORE_ADDR type, val;
111
  gdb_byte *data;
112
  LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data);
113
  gdb_byte *ptr = data;
114
  int ents = 0;
115
 
116
  if (n <= 0)
117
    return n;
118
 
119
  while (1)
120
    switch (target_auxv_parse (ops, &ptr, data + n, &type, &val))
121
      {
122
      case 1:                   /* Here's an entry, check it.  */
123
        if (type == match)
124
          {
125
            xfree (data);
126
            *valp = val;
127
            return 1;
128
          }
129
        break;
130
      case 0:                    /* End of the vector.  */
131
        xfree (data);
132
        return 0;
133
      default:                  /* Bogosity.  */
134
        xfree (data);
135
        return -1;
136
      }
137
 
138
  /*NOTREACHED*/
139
}
140
 
141
 
142
/* Print the contents of the target's AUXV on the specified file. */
143
int
144
fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
145
{
146
  CORE_ADDR type, val;
147
  gdb_byte *data;
148
  LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL,
149
                                   &data);
150
  gdb_byte *ptr = data;
151
  int ents = 0;
152
 
153
  if (len <= 0)
154
    return len;
155
 
156
  while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0)
157
    {
158
      extern int addressprint;
159
      const char *name = "???";
160
      const char *description = "";
161
      enum { dec, hex, str } flavor = hex;
162
 
163
      switch (type)
164
        {
165
#define TAG(tag, text, kind) \
166
        case tag: name = #tag; description = text; flavor = kind; break
167
          TAG (AT_NULL, _("End of vector"), hex);
168
          TAG (AT_IGNORE, _("Entry should be ignored"), hex);
169
          TAG (AT_EXECFD, _("File descriptor of program"), dec);
170
          TAG (AT_PHDR, _("Program headers for program"), hex);
171
          TAG (AT_PHENT, _("Size of program header entry"), dec);
172
          TAG (AT_PHNUM, _("Number of program headers"), dec);
173
          TAG (AT_PAGESZ, _("System page size"), dec);
174
          TAG (AT_BASE, _("Base address of interpreter"), hex);
175
          TAG (AT_FLAGS, _("Flags"), hex);
176
          TAG (AT_ENTRY, _("Entry point of program"), hex);
177
          TAG (AT_NOTELF, _("Program is not ELF"), dec);
178
          TAG (AT_UID, _("Real user ID"), dec);
179
          TAG (AT_EUID, _("Effective user ID"), dec);
180
          TAG (AT_GID, _("Real group ID"), dec);
181
          TAG (AT_EGID, _("Effective group ID"), dec);
182
          TAG (AT_CLKTCK, _("Frequency of times()"), dec);
183
          TAG (AT_PLATFORM, _("String identifying platform"), str);
184
          TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
185
          TAG (AT_FPUCW, _("Used FPU control word"), dec);
186
          TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
187
          TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
188
          TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
189
          TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
190
          TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
191
          TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
192
          TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
193
          TAG (AT_SUN_UID, _("Effective user ID"), dec);
194
          TAG (AT_SUN_RUID, _("Real user ID"), dec);
195
          TAG (AT_SUN_GID, _("Effective group ID"), dec);
196
          TAG (AT_SUN_RGID, _("Real group ID"), dec);
197
          TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
198
          TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
199
          TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
200
          TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
201
          TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
202
          TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
203
          TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
204
          TAG (AT_SUN_CPU, _("CPU name string"), str);
205
          TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
206
          TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
207
          TAG (AT_SUN_EXECNAME,
208
               _("Canonicalized file name given to execve"), str);
209
          TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
210
          TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
211
          TAG (AT_SUN_AUXFLAGS,
212
               _("AF_SUN_ flags passed from the kernel"), hex);
213
        }
214
 
215
      fprintf_filtered (file, "%-4s %-20s %-30s ",
216
                        paddr_d (type), name, description);
217
      switch (flavor)
218
        {
219
        case dec:
220
          fprintf_filtered (file, "%s\n", paddr_d (val));
221
          break;
222
        case hex:
223
          fprintf_filtered (file, "0x%s\n", paddr_nz (val));
224
          break;
225
        case str:
226
          if (addressprint)
227
            fprintf_filtered (file, "0x%s", paddr_nz (val));
228
          val_print_string (val, -1, 1, file);
229
          fprintf_filtered (file, "\n");
230
          break;
231
        }
232
      ++ents;
233
    }
234
 
235
  xfree (data);
236
 
237
  return ents;
238
}
239
 
240
static void
241
info_auxv_command (char *cmd, int from_tty)
242
{
243
  if (! target_has_stack)
244
    error (_("The program has no auxiliary information now."));
245
  else
246
    {
247
      int ents = fprint_target_auxv (gdb_stdout, &current_target);
248
      if (ents < 0)
249
        error (_("No auxiliary vector found, or failed reading it."));
250
      else if (ents == 0)
251
        error (_("Auxiliary vector is empty."));
252
    }
253
}
254
 
255
 
256
extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
257
 
258
void
259
_initialize_auxv (void)
260
{
261
  add_info ("auxv", info_auxv_command,
262
            _("Display the inferior's auxiliary vector.\n\
263
This is information provided by the operating system at program startup."));
264
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.