gdb/auxv.c

   1 /* Auxiliary vector support for GDB, the GNU debugger.
   2
   3    Copyright (C) 2004-2019 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 "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 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 252    Return 0 if *READPTR is already at the end of the buffer.
 253    Return -1 if there is insufficient buffer for a whole entry.
 254    Return 1 if an entry was read into *TYPEP and *VALP.  */
 255 int
 256 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
 257                    gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 258 {
 259   const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
 260                                 / TARGET_CHAR_BIT;
 261   const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 262   gdb_byte *ptr = *readptr;
 263
 264   if (endptr == ptr)
 265     return 0;
 266
 267   if (endptr - ptr < sizeof_auxv_field * 2)
 268     return -1;
 269
 270   *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
 271   ptr += sizeof_auxv_field;
 272   *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
 273   ptr += sizeof_auxv_field;
 274
 275   *readptr = ptr;
 276   return 1;
 277 }
 278
 279 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 280    Return 0 if *READPTR is already at the end of the buffer.
 281    Return -1 if there is insufficient buffer for a whole entry.
 282    Return 1 if an entry was read into *TYPEP and *VALP.  */
 283 int
 284 target_auxv_parse (gdb_byte **readptr,
 285                    gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 286 {
 287   struct gdbarch *gdbarch = target_gdbarch();
 288
 289   if (gdbarch_auxv_parse_p (gdbarch))
 290     return gdbarch_auxv_parse (gdbarch, readptr, endptr, typep, valp);
 291
 292   return current_top_target ()->auxv_parse (readptr, endptr, typep, valp);
 293 }
 294
 295
 296 /* Per-inferior data key for auxv.  */
 297 static const struct inferior_data *auxv_inferior_data;
 298
 299 /*  Auxiliary Vector information structure.  This is used by GDB
 300     for caching purposes for each inferior.  This helps reduce the
 301     overhead of transfering data from a remote target to the local host.  */
 302 struct auxv_info
 303 {
 304   gdb::optional<gdb::byte_vector> data;
 305 };
 306
 307 /* Handles the cleanup of the auxv cache for inferior INF.  ARG is ignored.
 308    Frees whatever allocated space there is to be freed and sets INF's auxv cache
 309    data pointer to NULL.
 310
 311    This function is called when the following events occur: inferior_appeared,
 312    inferior_exit and executable_changed.  */
 313
 314 static void
 315 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
 316 {
 317   struct auxv_info *info;
 318
 319   info = (struct auxv_info *) inferior_data (inf, auxv_inferior_data);
 320   if (info != NULL)
 321     {
 322       delete info;
 323       set_inferior_data (inf, auxv_inferior_data, NULL);
 324     }
 325 }
 326
 327 /* Invalidate INF's auxv cache.  */
 328
 329 static void
 330 invalidate_auxv_cache_inf (struct inferior *inf)
 331 {
 332   auxv_inferior_data_cleanup (inf, NULL);
 333 }
 334
 335 /* Invalidate current inferior's auxv cache.  */
 336
 337 static void
 338 invalidate_auxv_cache (void)
 339 {
 340   invalidate_auxv_cache_inf (current_inferior ());
 341 }
 342
 343 /* Fetch the auxv object from inferior INF.  If auxv is cached already,
 344    return a pointer to the cache.  If not, fetch the auxv object from the
 345    target and cache it.  This function always returns a valid INFO pointer.  */
 346
 347 static struct auxv_info *
 348 get_auxv_inferior_data (struct target_ops *ops)
 349 {
 350   struct auxv_info *info;
 351   struct inferior *inf = current_inferior ();
 352
 353   info = (struct auxv_info *) inferior_data (inf, auxv_inferior_data);
 354   if (info == NULL)
 355     {
 356       info = new auxv_info;
 357       info->data = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL);
 358       set_inferior_data (inf, auxv_inferior_data, info);
 359     }
 360
 361   return info;
 362 }
 363
 364 /* Extract the auxiliary vector entry with a_type matching MATCH.
 365    Return zero if no such entry was found, or -1 if there was
 366    an error getting the information.  On success, return 1 after
 367    storing the entry's value field in *VALP.  */
 368 int
 369 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
 370 {
 371   CORE_ADDR type, val;
 372   auxv_info *info = get_auxv_inferior_data (ops);
 373
 374   if (!info->data)
 375     return -1;
 376
 377   gdb_byte *data = info->data->data ();
 378   gdb_byte *ptr = data;
 379   size_t len = info->data->size ();
 380
 381   while (1)
 382     switch (target_auxv_parse (&ptr, data + len, &type, &val))
 383       {
 384       case 1:                   /* Here's an entry, check it.  */
 385         if (type == match)
 386           {
 387             *valp = val;
 388             return 1;
 389           }
 390         break;
 391       case 0:                   /* End of the vector.  */
 392         return 0;
 393       default:                  /* Bogosity.  */
 394         return -1;
 395       }
 396
 397   /*NOTREACHED*/
 398 }
 399
 400
 401 /* Print the description of a single AUXV entry on the specified file.  */
 402
 403 void
 404 fprint_auxv_entry (struct ui_file *file, const char *name,
 405                    const char *description, enum auxv_format format,
 406                    CORE_ADDR type, CORE_ADDR val)
 407 {
 408   fprintf_filtered (file, ("%-4s %-20s %-30s "),
 409                     plongest (type), name, description);
 410   switch (format)
 411     {
 412     case AUXV_FORMAT_DEC:
 413       fprintf_filtered (file, ("%s\n"), plongest (val));
 414       break;
 415     case AUXV_FORMAT_HEX:
 416       fprintf_filtered (file, ("%s\n"), paddress (target_gdbarch (), val));
 417       break;
 418     case AUXV_FORMAT_STR:
 419       {
 420         struct value_print_options opts;
 421
 422         get_user_print_options (&opts);
 423         if (opts.addressprint)
 424           fprintf_filtered (file, ("%s "), paddress (target_gdbarch (), val));
 425         val_print_string (builtin_type (target_gdbarch ())->builtin_char,
 426                           NULL, val, -1, file, &opts);
 427         fprintf_filtered (file, ("\n"));
 428       }
 429       break;
 430     }
 431 }
 432
 433 /* The default implementation of gdbarch_print_auxv_entry.  */
 434
 435 void
 436 default_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
 437                           CORE_ADDR type, CORE_ADDR val)
 438 {
 439   const char *name = "???";
 440   const char *description = "";
 441   enum auxv_format format = AUXV_FORMAT_HEX;
 442
 443   switch (type)
 444     {
 445 #define TAG(tag, text, kind) \
 446       case tag: name = #tag; description = text; format = kind; break
 447       TAG (AT_NULL, _("End of vector"), AUXV_FORMAT_HEX);
 448       TAG (AT_IGNORE, _("Entry should be ignored"), AUXV_FORMAT_HEX);
 449       TAG (AT_EXECFD, _("File descriptor of program"), AUXV_FORMAT_DEC);
 450       TAG (AT_PHDR, _("Program headers for program"), AUXV_FORMAT_HEX);
 451       TAG (AT_PHENT, _("Size of program header entry"), AUXV_FORMAT_DEC);
 452       TAG (AT_PHNUM, _("Number of program headers"), AUXV_FORMAT_DEC);
 453       TAG (AT_PAGESZ, _("System page size"), AUXV_FORMAT_DEC);
 454       TAG (AT_BASE, _("Base address of interpreter"), AUXV_FORMAT_HEX);
 455       TAG (AT_FLAGS, _("Flags"), AUXV_FORMAT_HEX);
 456       TAG (AT_ENTRY, _("Entry point of program"), AUXV_FORMAT_HEX);
 457       TAG (AT_NOTELF, _("Program is not ELF"), AUXV_FORMAT_DEC);
 458       TAG (AT_UID, _("Real user ID"), AUXV_FORMAT_DEC);
 459       TAG (AT_EUID, _("Effective user ID"), AUXV_FORMAT_DEC);
 460       TAG (AT_GID, _("Real group ID"), AUXV_FORMAT_DEC);
 461       TAG (AT_EGID, _("Effective group ID"), AUXV_FORMAT_DEC);
 462       TAG (AT_CLKTCK, _("Frequency of times()"), AUXV_FORMAT_DEC);
 463       TAG (AT_PLATFORM, _("String identifying platform"), AUXV_FORMAT_STR);
 464       TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"),
 465            AUXV_FORMAT_HEX);
 466       TAG (AT_FPUCW, _("Used FPU control word"), AUXV_FORMAT_DEC);
 467       TAG (AT_DCACHEBSIZE, _("Data cache block size"), AUXV_FORMAT_DEC);
 468       TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), AUXV_FORMAT_DEC);
 469       TAG (AT_UCACHEBSIZE, _("Unified cache block size"), AUXV_FORMAT_DEC);
 470       TAG (AT_IGNOREPPC, _("Entry should be ignored"), AUXV_FORMAT_DEC);
 471       TAG (AT_BASE_PLATFORM, _("String identifying base platform"),
 472            AUXV_FORMAT_STR);
 473       TAG (AT_RANDOM, _("Address of 16 random bytes"), AUXV_FORMAT_HEX);
 474       TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
 475       TAG (AT_EXECFN, _("File name of executable"), AUXV_FORMAT_STR);
 476       TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC);
 477       TAG (AT_SYSINFO, _("Special system info/entry points"), AUXV_FORMAT_HEX);
 478       TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"),
 479            AUXV_FORMAT_HEX);
 480       TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"),
 481            AUXV_FORMAT_HEX);
 482       TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), AUXV_FORMAT_HEX);
 483       TAG (AT_L2_CACHESHAPE, _("L2 cache information"), AUXV_FORMAT_HEX);
 484       TAG (AT_L3_CACHESHAPE, _("L3 cache information"), AUXV_FORMAT_HEX);
 485       TAG (AT_SUN_UID, _("Effective user ID"), AUXV_FORMAT_DEC);
 486       TAG (AT_SUN_RUID, _("Real user ID"), AUXV_FORMAT_DEC);
 487       TAG (AT_SUN_GID, _("Effective group ID"), AUXV_FORMAT_DEC);
 488       TAG (AT_SUN_RGID, _("Real group ID"), AUXV_FORMAT_DEC);
 489       TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX);
 490       TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"),
 491            AUXV_FORMAT_HEX);
 492       TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"),
 493            AUXV_FORMAT_STR);
 494       TAG (AT_SUN_LPAGESZ, _("Large pagesize"), AUXV_FORMAT_DEC);
 495       TAG (AT_SUN_PLATFORM, _("Platform name string"), AUXV_FORMAT_STR);
 496       TAG (AT_SUN_CAP_HW1, _("Machine-dependent CPU capability hints"),
 497            AUXV_FORMAT_HEX);
 498       TAG (AT_SUN_IFLUSH, _("Should flush icache?"), AUXV_FORMAT_DEC);
 499       TAG (AT_SUN_CPU, _("CPU name string"), AUXV_FORMAT_STR);
 500       TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), AUXV_FORMAT_HEX);
 501       TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"),
 502            AUXV_FORMAT_DEC);
 503       TAG (AT_SUN_EXECNAME,
 504            _("Canonicalized file name given to execve"), AUXV_FORMAT_STR);
 505       TAG (AT_SUN_MMU, _("String for name of MMU module"), AUXV_FORMAT_STR);
 506       TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"),
 507            AUXV_FORMAT_HEX);
 508       TAG (AT_SUN_AUXFLAGS,
 509            _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX);
 510       TAG (AT_SUN_EMULATOR, _("Name of emulation binary for runtime linker"),
 511            AUXV_FORMAT_STR);
 512       TAG (AT_SUN_BRANDNAME, _("Name of brand library"), AUXV_FORMAT_STR);
 513       TAG (AT_SUN_BRAND_AUX1, _("Aux vector for brand modules 1"),
 514            AUXV_FORMAT_HEX);
 515       TAG (AT_SUN_BRAND_AUX2, _("Aux vector for brand modules 2"),
 516            AUXV_FORMAT_HEX);
 517       TAG (AT_SUN_BRAND_AUX3, _("Aux vector for brand modules 3"),
 518            AUXV_FORMAT_HEX);
 519       TAG (AT_SUN_CAP_HW2, _("Machine-dependent CPU capability hints 2"),
 520            AUXV_FORMAT_HEX);
 521     }
 522
 523   fprint_auxv_entry (file, name, description, format, type, val);
 524 }
 525
 526 /* Print the contents of the target's AUXV on the specified file.  */
 527
 528 int
 529 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
 530 {
 531   struct gdbarch *gdbarch = target_gdbarch ();
 532   CORE_ADDR type, val;
 533   int ents = 0;
 534   auxv_info *info = get_auxv_inferior_data (ops);
 535
 536   if (!info->data)
 537     return -1;
 538
 539   gdb_byte *data = info->data->data ();
 540   gdb_byte *ptr = data;
 541   size_t len = info->data->size ();
 542
 543   while (target_auxv_parse (&ptr, data + len, &type, &val) > 0)
 544     {
 545       gdbarch_print_auxv_entry (gdbarch, file, type, val);
 546       ++ents;
 547       if (type == AT_NULL)
 548         break;
 549     }
 550
 551   return ents;
 552 }
 553
 554 static void
 555 info_auxv_command (const char *cmd, int from_tty)
 556 {
 557   if (! target_has_stack)
 558     error (_("The program has no auxiliary information now."));
 559   else
 560     {
 561       int ents = fprint_target_auxv (gdb_stdout, current_top_target ());
 562
 563       if (ents < 0)
 564         error (_("No auxiliary vector found, or failed reading it."));
 565       else if (ents == 0)
 566         error (_("Auxiliary vector is empty."));
 567     }
 568 }
 569
 570 void
 571 _initialize_auxv (void)
 572 {
 573   add_info ("auxv", info_auxv_command,
 574             _("Display the inferior's auxiliary vector.\n\
 575 This is information provided by the operating system at program startup."));
 576
 577   /* Set an auxv cache per-inferior.  */
 578   auxv_inferior_data
 579     = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
 580
 581   /* Observers used to invalidate the auxv cache when needed.  */
 582   gdb::observers::inferior_exit.attach (invalidate_auxv_cache_inf);
 583   gdb::observers::inferior_appeared.attach (invalidate_auxv_cache_inf);
 584   gdb::observers::executable_changed.attach (invalidate_auxv_cache);
 585 }