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 = ptr_type->length ();
  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 (msym.minsym->size () != 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 = msym.value_address ();
 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)
 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, const gdb_byte **readptr,
 254                     const 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 = ptr_type->length ();
 259   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 260   const 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, const gdb_byte **readptr,
 285                     const 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 = ptr_type->length ();
 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, const gdb_byte **readptr,
 299                  const 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 = int_type->length ();
 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
 310    Use the auxv_parse method from GDBARCH, if defined, else use the auxv_parse
 311    method of OPS.
 312
 313    Return 0 if *READPTR is already at the end of the buffer.
 314    Return -1 if there is insufficient buffer for a whole entry.
 315    Return 1 if an entry was read into *TYPEP and *VALP.  */
 316
 317 static int
 318 parse_auxv (target_ops *ops, gdbarch *gdbarch, const gdb_byte **readptr,
 319             const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 320 {
 321   if (gdbarch_auxv_parse_p (gdbarch))
 322     return gdbarch_auxv_parse (gdbarch, readptr, endptr, typep, valp);
 323
 324   return ops->auxv_parse (readptr, endptr, 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 registry<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 /* See auxv.h.  */
 356
 357 gdb::optional<gdb::byte_vector>
 358 target_read_auxv ()
 359 {
 360   inferior *inf = current_inferior ();
 361   auxv_info *info = auxv_inferior_data.get (inf);
 362
 363   if (info == nullptr)
 364     {
 365       info = auxv_inferior_data.emplace (inf);
 366       info->data = target_read_auxv_raw (inf->top_target ());
 367     }
 368
 369   return info->data;
 370 }
 371
 372 /* See auxv.h.  */
 373
 374 gdb::optional<gdb::byte_vector>
 375 target_read_auxv_raw (target_ops *ops)
 376 {
 377   return target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL);
 378 }
 379
 380 /* See auxv.h.  */
 381
 382 int
 383 target_auxv_search (const gdb::byte_vector &auxv, target_ops *ops,
 384                     gdbarch *gdbarch, CORE_ADDR match, CORE_ADDR *valp)
 385 {
 386   CORE_ADDR type, val;
 387   const gdb_byte *data = auxv.data ();
 388   const gdb_byte *ptr = data;
 389   size_t len = auxv.size ();
 390
 391   while (1)
 392     switch (parse_auxv (ops, gdbarch, &ptr, data + len, &type, &val))
 393       {
 394       case 1:                   /* Here's an entry, check it.  */
 395         if (type == match)
 396           {
 397             *valp = val;
 398             return 1;
 399           }
 400         break;
 401       case 0:                   /* End of the vector.  */
 402         return 0;
 403       default:                  /* Bogosity.  */
 404         return -1;
 405       }
 406 }
 407
 408 /* See auxv.h.  */
 409
 410 int
 411 target_auxv_search (CORE_ADDR match, CORE_ADDR *valp)
 412 {
 413   gdb::optional<gdb::byte_vector> auxv = target_read_auxv ();
 414
 415   if (!auxv.has_value ())
 416     return -1;
 417
 418   return target_auxv_search (*auxv, current_inferior ()->top_target (),
 419                              current_inferior ()->gdbarch, match, valp);
 420 }
 421
 422 /* Print the description of a single AUXV entry on the specified file.  */
 423
 424 void
 425 fprint_auxv_entry (struct ui_file *file, const char *name,
 426                    const char *description, enum auxv_format format,
 427                    CORE_ADDR type, CORE_ADDR val)
 428 {
 429   gdb_printf (file, ("%-4s %-20s %-30s "),
 430               plongest (type), name, description);
 431   switch (format)
 432     {
 433     case AUXV_FORMAT_DEC:
 434       gdb_printf (file, ("%s\n"), plongest (val));
 435       break;
 436     case AUXV_FORMAT_HEX:
 437       gdb_printf (file, ("%s\n"), paddress (target_gdbarch (), val));
 438       break;
 439     case AUXV_FORMAT_STR:
 440       {
 441         struct value_print_options opts;
 442
 443         get_user_print_options (&opts);
 444         if (opts.addressprint)
 445           gdb_printf (file, ("%s "), paddress (target_gdbarch (), val));
 446         val_print_string (builtin_type (target_gdbarch ())->builtin_char,
 447                           NULL, val, -1, file, &opts);
 448         gdb_printf (file, ("\n"));
 449       }
 450       break;
 451     }
 452 }
 453
 454 /* The default implementation of gdbarch_print_auxv_entry.  */
 455
 456 void
 457 default_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
 458                           CORE_ADDR type, CORE_ADDR val)
 459 {
 460   const char *name = "???";
 461   const char *description = "";
 462   enum auxv_format format = AUXV_FORMAT_HEX;
 463
 464   switch (type)
 465     {
 466 #define TAG(tag, text, kind) \
 467       case tag: name = #tag; description = text; format = kind; break
 468       TAG (AT_NULL, _("End of vector"), AUXV_FORMAT_HEX);
 469       TAG (AT_IGNORE, _("Entry should be ignored"), AUXV_FORMAT_HEX);
 470       TAG (AT_EXECFD, _("File descriptor of program"), AUXV_FORMAT_DEC);
 471       TAG (AT_PHDR, _("Program headers for program"), AUXV_FORMAT_HEX);
 472       TAG (AT_PHENT, _("Size of program header entry"), AUXV_FORMAT_DEC);
 473       TAG (AT_PHNUM, _("Number of program headers"), AUXV_FORMAT_DEC);
 474       TAG (AT_PAGESZ, _("System page size"), AUXV_FORMAT_DEC);
 475       TAG (AT_BASE, _("Base address of interpreter"), AUXV_FORMAT_HEX);
 476       TAG (AT_FLAGS, _("Flags"), AUXV_FORMAT_HEX);
 477       TAG (AT_ENTRY, _("Entry point of program"), AUXV_FORMAT_HEX);
 478       TAG (AT_NOTELF, _("Program is not ELF"), AUXV_FORMAT_DEC);
 479       TAG (AT_UID, _("Real user ID"), AUXV_FORMAT_DEC);
 480       TAG (AT_EUID, _("Effective user ID"), AUXV_FORMAT_DEC);
 481       TAG (AT_GID, _("Real group ID"), AUXV_FORMAT_DEC);
 482       TAG (AT_EGID, _("Effective group ID"), AUXV_FORMAT_DEC);
 483       TAG (AT_CLKTCK, _("Frequency of times()"), AUXV_FORMAT_DEC);
 484       TAG (AT_PLATFORM, _("String identifying platform"), AUXV_FORMAT_STR);
 485       TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"),
 486            AUXV_FORMAT_HEX);
 487       TAG (AT_FPUCW, _("Used FPU control word"), AUXV_FORMAT_DEC);
 488       TAG (AT_DCACHEBSIZE, _("Data cache block size"), AUXV_FORMAT_DEC);
 489       TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), AUXV_FORMAT_DEC);
 490       TAG (AT_UCACHEBSIZE, _("Unified cache block size"), AUXV_FORMAT_DEC);
 491       TAG (AT_IGNOREPPC, _("Entry should be ignored"), AUXV_FORMAT_DEC);
 492       TAG (AT_BASE_PLATFORM, _("String identifying base platform"),
 493            AUXV_FORMAT_STR);
 494       TAG (AT_RANDOM, _("Address of 16 random bytes"), AUXV_FORMAT_HEX);
 495       TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
 496       TAG (AT_EXECFN, _("File name of executable"), AUXV_FORMAT_STR);
 497       TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC);
 498       TAG (AT_SYSINFO, _("Special system info/entry points"), AUXV_FORMAT_HEX);
 499       TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"),
 500            AUXV_FORMAT_HEX);
 501       TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"),
 502            AUXV_FORMAT_HEX);
 503       TAG (AT_L1I_CACHESIZE, _("L1 Instruction cache size"), AUXV_FORMAT_HEX);
 504       TAG (AT_L1I_CACHEGEOMETRY, _("L1 Instruction cache geometry"),
 505            AUXV_FORMAT_HEX);
 506       TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), AUXV_FORMAT_HEX);
 507       TAG (AT_L1D_CACHESIZE, _("L1 Data cache size"), AUXV_FORMAT_HEX);
 508       TAG (AT_L1D_CACHEGEOMETRY, _("L1 Data cache geometry"),
 509            AUXV_FORMAT_HEX);
 510       TAG (AT_L2_CACHESHAPE, _("L2 cache information"), AUXV_FORMAT_HEX);
 511       TAG (AT_L2_CACHESIZE, _("L2 cache size"), AUXV_FORMAT_HEX);
 512       TAG (AT_L2_CACHEGEOMETRY, _("L2 cache geometry"), AUXV_FORMAT_HEX);
 513       TAG (AT_L3_CACHESHAPE, _("L3 cache information"), AUXV_FORMAT_HEX);
 514       TAG (AT_L3_CACHESIZE, _("L3 cache size"), AUXV_FORMAT_HEX);
 515       TAG (AT_L3_CACHEGEOMETRY, _("L3 cache geometry"), AUXV_FORMAT_HEX);
 516       TAG (AT_MINSIGSTKSZ, _("Minimum stack size for signal delivery"),
 517            AUXV_FORMAT_HEX);
 518       TAG (AT_SUN_UID, _("Effective user ID"), AUXV_FORMAT_DEC);
 519       TAG (AT_SUN_RUID, _("Real user ID"), AUXV_FORMAT_DEC);
 520       TAG (AT_SUN_GID, _("Effective group ID"), AUXV_FORMAT_DEC);
 521       TAG (AT_SUN_RGID, _("Real group ID"), AUXV_FORMAT_DEC);
 522       TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX);
 523       TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"),
 524            AUXV_FORMAT_HEX);
 525       TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"),
 526            AUXV_FORMAT_STR);
 527       TAG (AT_SUN_LPAGESZ, _("Large pagesize"), AUXV_FORMAT_DEC);
 528       TAG (AT_SUN_PLATFORM, _("Platform name string"), AUXV_FORMAT_STR);
 529       TAG (AT_SUN_CAP_HW1, _("Machine-dependent CPU capability hints"),
 530            AUXV_FORMAT_HEX);
 531       TAG (AT_SUN_IFLUSH, _("Should flush icache?"), AUXV_FORMAT_DEC);
 532       TAG (AT_SUN_CPU, _("CPU name string"), AUXV_FORMAT_STR);
 533       TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), AUXV_FORMAT_HEX);
 534       TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"),
 535            AUXV_FORMAT_DEC);
 536       TAG (AT_SUN_EXECNAME,
 537            _("Canonicalized file name given to execve"), AUXV_FORMAT_STR);
 538       TAG (AT_SUN_MMU, _("String for name of MMU module"), AUXV_FORMAT_STR);
 539       TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"),
 540            AUXV_FORMAT_HEX);
 541       TAG (AT_SUN_AUXFLAGS,
 542            _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX);
 543       TAG (AT_SUN_EMULATOR, _("Name of emulation binary for runtime linker"),
 544            AUXV_FORMAT_STR);
 545       TAG (AT_SUN_BRANDNAME, _("Name of brand library"), AUXV_FORMAT_STR);
 546       TAG (AT_SUN_BRAND_AUX1, _("Aux vector for brand modules 1"),
 547            AUXV_FORMAT_HEX);
 548       TAG (AT_SUN_BRAND_AUX2, _("Aux vector for brand modules 2"),
 549            AUXV_FORMAT_HEX);
 550       TAG (AT_SUN_BRAND_AUX3, _("Aux vector for brand modules 3"),
 551            AUXV_FORMAT_HEX);
 552       TAG (AT_SUN_CAP_HW2, _("Machine-dependent CPU capability hints 2"),
 553            AUXV_FORMAT_HEX);
 554     }
 555
 556   fprint_auxv_entry (file, name, description, format, type, val);
 557 }
 558
 559 /* Print the contents of the target's AUXV on the specified file.  */
 560
 561 static int
 562 fprint_target_auxv (struct ui_file *file)
 563 {
 564   struct gdbarch *gdbarch = target_gdbarch ();
 565   CORE_ADDR type, val;
 566   int ents = 0;
 567   gdb::optional<gdb::byte_vector> auxv = target_read_auxv ();
 568
 569   if (!auxv.has_value ())
 570     return -1;
 571
 572   const gdb_byte *data = auxv->data ();
 573   const gdb_byte *ptr = data;
 574   size_t len = auxv->size ();
 575
 576   while (parse_auxv (current_inferior ()->top_target (),
 577                      current_inferior ()->gdbarch,
 578                      &ptr, data + len, &type, &val) > 0)
 579     {
 580       gdbarch_print_auxv_entry (gdbarch, file, type, val);
 581       ++ents;
 582       if (type == AT_NULL)
 583         break;
 584     }
 585
 586   return ents;
 587 }
 588
 589 static void
 590 info_auxv_command (const char *cmd, int from_tty)
 591 {
 592   if (! target_has_stack ())
 593     error (_("The program has no auxiliary information now."));
 594   else
 595     {
 596       int ents = fprint_target_auxv (gdb_stdout);
 597
 598       if (ents < 0)
 599         error (_("No auxiliary vector found, or failed reading it."));
 600       else if (ents == 0)
 601         error (_("Auxiliary vector is empty."));
 602     }
 603 }
 604
 605 void _initialize_auxv ();
 606 void
 607 _initialize_auxv ()
 608 {
 609   add_info ("auxv", info_auxv_command,
 610             _("Display the inferior's auxiliary vector.\n\
 611 This is information provided by the operating system at program startup."));
 612
 613   /* Observers used to invalidate the auxv cache when needed.  */
 614   gdb::observers::inferior_exit.attach (invalidate_auxv_cache_inf, "auxv");
 615   gdb::observers::inferior_appeared.attach (invalidate_auxv_cache_inf, "auxv");
 616   gdb::observers::executable_changed.attach (invalidate_auxv_cache, "auxv");
 617 }