gdb/auxv.c

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