Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / auxv.c
1 /* Auxiliary vector support for GDB, the GNU debugger.
2
3    Copyright (C) 2004-2013 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 #include "gdbcore.h"
28 #include "observer.h"
29
30 #include "auxv.h"
31 #include "elf/common.h"
32
33 #include <unistd.h>
34 #include <fcntl.h>
35
36
37 /* This function handles access via /proc/PID/auxv, which is a common
38    method for native targets.  */
39
40 static LONGEST
41 procfs_xfer_auxv (gdb_byte *readbuf,
42                   const gdb_byte *writebuf,
43                   ULONGEST offset,
44                   LONGEST len)
45 {
46   char *pathname;
47   int fd;
48   LONGEST n;
49
50   pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid));
51   fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY);
52   xfree (pathname);
53   if (fd < 0)
54     return -1;
55
56   if (offset != (ULONGEST) 0
57       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
58     n = -1;
59   else if (readbuf != NULL)
60     n = read (fd, readbuf, len);
61   else
62     n = write (fd, writebuf, len);
63
64   (void) close (fd);
65
66   return n;
67 }
68
69 /* This function handles access via ld.so's symbol `_dl_auxv'.  */
70
71 static LONGEST
72 ld_so_xfer_auxv (gdb_byte *readbuf,
73                  const gdb_byte *writebuf,
74                  ULONGEST offset,
75                  LONGEST len)
76 {
77   struct minimal_symbol *msym;
78   CORE_ADDR data_address, pointer_address;
79   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
80   size_t ptr_size = TYPE_LENGTH (ptr_type);
81   size_t auxv_pair_size = 2 * ptr_size;
82   gdb_byte *ptr_buf = alloca (ptr_size);
83   LONGEST retval;
84   size_t block;
85
86   msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
87   if (msym == NULL)
88     return -1;
89
90   if (MSYMBOL_SIZE (msym) != ptr_size)
91     return -1;
92
93   /* POINTER_ADDRESS is a location where the `_dl_auxv' variable
94      resides.  DATA_ADDRESS is the inferior value present in
95      `_dl_auxv', therefore the real inferior AUXV address.  */
96
97   pointer_address = SYMBOL_VALUE_ADDRESS (msym);
98
99   /* The location of the _dl_auxv symbol may no longer be correct if
100      ld.so runs at a different address than the one present in the
101      file.  This is very common case - for unprelinked ld.so or with a
102      PIE executable.  PIE executable forces random address even for
103      libraries already being prelinked to some address.  PIE
104      executables themselves are never prelinked even on prelinked
105      systems.  Prelinking of a PIE executable would block their
106      purpose of randomizing load of everything including the
107      executable.
108
109      If the memory read fails, return -1 to fallback on another
110      mechanism for retrieving the AUXV.
111
112      In most cases of a PIE running under valgrind there is no way to
113      find out the base addresses of any of ld.so, executable or AUXV
114      as everything is randomized and /proc information is not relevant
115      for the virtual executable running under valgrind.  We think that
116      we might need a valgrind extension to make it work.  This is PR
117      11440.  */
118
119   if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
120     return -1;
121
122   data_address = extract_typed_address (ptr_buf, ptr_type);
123
124   /* Possibly still not initialized such as during an inferior
125      startup.  */
126   if (data_address == 0)
127     return -1;
128
129   data_address += offset;
130
131   if (writebuf != NULL)
132     {
133       if (target_write_memory (data_address, writebuf, len) == 0)
134         return len;
135       else
136         return -1;
137     }
138
139   /* Stop if trying to read past the existing AUXV block.  The final
140      AT_NULL was already returned before.  */
141
142   if (offset >= auxv_pair_size)
143     {
144       if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
145                               ptr_size) != 0)
146         return -1;
147
148       if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
149         return 0;
150     }
151
152   retval = 0;
153   block = 0x400;
154   gdb_assert (block % auxv_pair_size == 0);
155
156   while (len > 0)
157     {
158       if (block > len)
159         block = len;
160
161       /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
162          Tails unaligned to AUXV_PAIR_SIZE will not be read during a
163          call (they should be completed during next read with
164          new/extended buffer).  */
165
166       block &= -auxv_pair_size;
167       if (block == 0)
168         return retval;
169
170       if (target_read_memory (data_address, readbuf, block) != 0)
171         {
172           if (block <= auxv_pair_size)
173             return retval;
174
175           block = auxv_pair_size;
176           continue;
177         }
178
179       data_address += block;
180       len -= block;
181
182       /* Check terminal AT_NULL.  This function is being called
183          indefinitely being extended its READBUF until it returns EOF
184          (0).  */
185
186       while (block >= auxv_pair_size)
187         {
188           retval += auxv_pair_size;
189
190           if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
191             return retval;
192
193           readbuf += auxv_pair_size;
194           block -= auxv_pair_size;
195         }
196     }
197
198   return retval;
199 }
200
201 /* This function is called like a to_xfer_partial hook, but must be
202    called with TARGET_OBJECT_AUXV.  It handles access to AUXV.  */
203
204 LONGEST
205 memory_xfer_auxv (struct target_ops *ops,
206                   enum target_object object,
207                   const char *annex,
208                   gdb_byte *readbuf,
209                   const gdb_byte *writebuf,
210                   ULONGEST offset,
211                   LONGEST len)
212 {
213   gdb_assert (object == TARGET_OBJECT_AUXV);
214   gdb_assert (readbuf || writebuf);
215
216    /* ld_so_xfer_auxv is the only function safe for virtual
217       executables being executed by valgrind's memcheck.  Using
218       ld_so_xfer_auxv during inferior startup is problematic, because
219       ld.so symbol tables have not yet been relocated.  So GDB uses
220       this function only when attaching to a process.
221       */
222
223   if (current_inferior ()->attach_flag != 0)
224     {
225       LONGEST retval;
226
227       retval = ld_so_xfer_auxv (readbuf, writebuf, offset, len);
228       if (retval != -1)
229         return retval;
230     }
231
232   return procfs_xfer_auxv (readbuf, writebuf, offset, len);
233 }
234
235 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
236    Return 0 if *READPTR is already at the end of the buffer.
237    Return -1 if there is insufficient buffer for a whole entry.
238    Return 1 if an entry was read into *TYPEP and *VALP.  */
239 static int
240 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
241                    gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
242 {
243   const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
244                                 / TARGET_CHAR_BIT;
245   const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
246   gdb_byte *ptr = *readptr;
247
248   if (endptr == ptr)
249     return 0;
250
251   if (endptr - ptr < sizeof_auxv_field * 2)
252     return -1;
253
254   *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
255   ptr += sizeof_auxv_field;
256   *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
257   ptr += sizeof_auxv_field;
258
259   *readptr = ptr;
260   return 1;
261 }
262
263 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
264    Return 0 if *READPTR is already at the end of the buffer.
265    Return -1 if there is insufficient buffer for a whole entry.
266    Return 1 if an entry was read into *TYPEP and *VALP.  */
267 int
268 target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
269                   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
270 {
271   struct target_ops *t;
272
273   for (t = ops; t != NULL; t = t->beneath)
274     if (t->to_auxv_parse != NULL)
275       return t->to_auxv_parse (t, readptr, endptr, typep, valp);
276   
277   return default_auxv_parse (ops, readptr, endptr, typep, valp);
278 }
279
280
281 /* Per-inferior data key for auxv.  */
282 static const struct inferior_data *auxv_inferior_data;
283
284 /*  Auxiliary Vector information structure.  This is used by GDB
285     for caching purposes for each inferior.  This helps reduce the
286     overhead of transfering data from a remote target to the local host.  */
287 struct auxv_info
288 {
289   LONGEST length;
290   gdb_byte *data;
291 };
292
293 /* Handles the cleanup of the auxv cache for inferior INF.  ARG is ignored.
294    Frees whatever allocated space there is to be freed and sets INF's auxv cache
295    data pointer to NULL.
296
297    This function is called when the following events occur: inferior_appeared,
298    inferior_exit and executable_changed.  */
299
300 static void
301 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
302 {
303   struct auxv_info *info;
304
305   info = inferior_data (inf, auxv_inferior_data);
306   if (info != NULL)
307     {
308       xfree (info->data);
309       xfree (info);
310       set_inferior_data (inf, auxv_inferior_data, NULL);
311     }
312 }
313
314 /* Invalidate INF's auxv cache.  */
315
316 static void
317 invalidate_auxv_cache_inf (struct inferior *inf)
318 {
319   auxv_inferior_data_cleanup (inf, NULL);
320 }
321
322 /* Invalidate current inferior's auxv cache.  */
323
324 static void
325 invalidate_auxv_cache (void)
326 {
327   invalidate_auxv_cache_inf (current_inferior ());
328 }
329
330 /* Fetch the auxv object from inferior INF.  If auxv is cached already,
331    return a pointer to the cache.  If not, fetch the auxv object from the
332    target and cache it.  This function always returns a valid INFO pointer.  */
333
334 static struct auxv_info *
335 get_auxv_inferior_data (struct target_ops *ops)
336 {
337   struct auxv_info *info;
338   struct inferior *inf = current_inferior ();
339
340   info = inferior_data (inf, auxv_inferior_data);
341   if (info == NULL)
342     {
343       info = XZALLOC (struct auxv_info);
344       info->length = target_read_alloc (ops, TARGET_OBJECT_AUXV,
345                                         NULL, &info->data);
346       set_inferior_data (inf, auxv_inferior_data, info);
347     }
348
349   return info;
350 }
351
352 /* Extract the auxiliary vector entry with a_type matching MATCH.
353    Return zero if no such entry was found, or -1 if there was
354    an error getting the information.  On success, return 1 after
355    storing the entry's value field in *VALP.  */
356 int
357 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
358 {
359   CORE_ADDR type, val;
360   gdb_byte *data;
361   gdb_byte *ptr;
362   struct auxv_info *info;
363
364   info = get_auxv_inferior_data (ops);
365
366   data = info->data;
367   ptr = data;
368
369   if (info->length <= 0)
370     return info->length;
371
372   while (1)
373     switch (target_auxv_parse (ops, &ptr, data + info->length, &type, &val))
374       {
375       case 1:                   /* Here's an entry, check it.  */
376         if (type == match)
377           {
378             *valp = val;
379             return 1;
380           }
381         break;
382       case 0:                   /* End of the vector.  */
383         return 0;
384       default:                  /* Bogosity.  */
385         return -1;
386       }
387
388   /*NOTREACHED*/
389 }
390
391
392 /* Print the contents of the target's AUXV on the specified file.  */
393 int
394 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
395 {
396   CORE_ADDR type, val;
397   gdb_byte *data;
398   gdb_byte *ptr;
399   struct auxv_info *info;
400   int ents = 0;
401
402   info = get_auxv_inferior_data (ops);
403
404   data = info->data;
405   ptr = data;
406   if (info->length <= 0)
407     return info->length;
408
409   while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
410     {
411       const char *name = "???";
412       const char *description = "";
413       enum { dec, hex, str } flavor = hex;
414
415       switch (type)
416         {
417 #define TAG(tag, text, kind) \
418         case tag: name = #tag; description = text; flavor = kind; break
419           TAG (AT_NULL, _("End of vector"), hex);
420           TAG (AT_IGNORE, _("Entry should be ignored"), hex);
421           TAG (AT_EXECFD, _("File descriptor of program"), dec);
422           TAG (AT_PHDR, _("Program headers for program"), hex);
423           TAG (AT_PHENT, _("Size of program header entry"), dec);
424           TAG (AT_PHNUM, _("Number of program headers"), dec);
425           TAG (AT_PAGESZ, _("System page size"), dec);
426           TAG (AT_BASE, _("Base address of interpreter"), hex);
427           TAG (AT_FLAGS, _("Flags"), hex);
428           TAG (AT_ENTRY, _("Entry point of program"), hex);
429           TAG (AT_NOTELF, _("Program is not ELF"), dec);
430           TAG (AT_UID, _("Real user ID"), dec);
431           TAG (AT_EUID, _("Effective user ID"), dec);
432           TAG (AT_GID, _("Real group ID"), dec);
433           TAG (AT_EGID, _("Effective group ID"), dec);
434           TAG (AT_CLKTCK, _("Frequency of times()"), dec);
435           TAG (AT_PLATFORM, _("String identifying platform"), str);
436           TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
437           TAG (AT_FPUCW, _("Used FPU control word"), dec);
438           TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
439           TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
440           TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
441           TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
442           TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
443           TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
444           TAG (AT_EXECFN, _("File name of executable"), str);
445           TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
446           TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
447           TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
448           TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"), hex);
449           TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), hex);
450           TAG (AT_L2_CACHESHAPE, _("L2 cache information"), hex);
451           TAG (AT_L3_CACHESHAPE, _("L3 cache information"), hex);
452           TAG (AT_SUN_UID, _("Effective user ID"), dec);
453           TAG (AT_SUN_RUID, _("Real user ID"), dec);
454           TAG (AT_SUN_GID, _("Effective group ID"), dec);
455           TAG (AT_SUN_RGID, _("Real group ID"), dec);
456           TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
457           TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
458           TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
459           TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
460           TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
461           TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
462           TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
463           TAG (AT_SUN_CPU, _("CPU name string"), str);
464           TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
465           TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
466           TAG (AT_SUN_EXECNAME,
467                _("Canonicalized file name given to execve"), str);
468           TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
469           TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
470           TAG (AT_SUN_AUXFLAGS,
471                _("AF_SUN_ flags passed from the kernel"), hex);
472         }
473
474       fprintf_filtered (file, "%-4s %-20s %-30s ",
475                         plongest (type), name, description);
476       switch (flavor)
477         {
478         case dec:
479           fprintf_filtered (file, "%s\n", plongest (val));
480           break;
481         case hex:
482           fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
483           break;
484         case str:
485           {
486             struct value_print_options opts;
487
488             get_user_print_options (&opts);
489             if (opts.addressprint)
490               fprintf_filtered (file, "%s ", paddress (target_gdbarch (), val));
491             val_print_string (builtin_type (target_gdbarch ())->builtin_char,
492                               NULL, val, -1, file, &opts);
493             fprintf_filtered (file, "\n");
494           }
495           break;
496         }
497       ++ents;
498       if (type == AT_NULL)
499         break;
500     }
501
502   return ents;
503 }
504
505 static void
506 info_auxv_command (char *cmd, int from_tty)
507 {
508   if (! target_has_stack)
509     error (_("The program has no auxiliary information now."));
510   else
511     {
512       int ents = fprint_target_auxv (gdb_stdout, &current_target);
513
514       if (ents < 0)
515         error (_("No auxiliary vector found, or failed reading it."));
516       else if (ents == 0)
517         error (_("Auxiliary vector is empty."));
518     }
519 }
520
521
522 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
523
524 void
525 _initialize_auxv (void)
526 {
527   add_info ("auxv", info_auxv_command,
528             _("Display the inferior's auxiliary vector.\n\
529 This is information provided by the operating system at program startup."));
530
531   /* Set an auxv cache per-inferior.  */
532   auxv_inferior_data
533     = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
534
535   /* Observers used to invalidate the auxv cache when needed.  */
536   observer_attach_inferior_exit (invalidate_auxv_cache_inf);
537   observer_attach_inferior_appeared (invalidate_auxv_cache_inf);
538   observer_attach_executable_changed (invalidate_auxv_cache);
539 }