gdb/auxv.c

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