+struct core_fns
+ {
+
+ /* BFD flavour that a core file handler is prepared to read. This
+ can be used by the handler's core tasting function as a first
+ level filter to reject BFD's that don't have the right
+ flavour. */
+
+ enum bfd_flavour core_flavour;
+
+ /* Core file handler function to call to recognize corefile
+ formats that BFD rejects. Some core file format just don't fit
+ into the BFD model, or may require other resources to identify
+ them, that simply aren't available to BFD (such as symbols from
+ another file). Returns nonzero if the handler recognizes the
+ format, zero otherwise. */
+
+ int (*check_format) (bfd *);
+
+ /* Core file handler function to call to ask if it can handle a
+ given core file format or not. Returns zero if it can't,
+ nonzero otherwise. */
+
+ int (*core_sniffer) (struct core_fns *, bfd *);
+
+ /* Extract the register values out of the core file and supply them
+ into REGCACHE.
+
+ CORE_REG_SECT points to the register values themselves, read into
+ memory.
+
+ CORE_REG_SIZE is the size of that area.
+
+ WHICH says which set of registers we are handling:
+ 0 --- integer registers
+ 2 --- floating-point registers, on machines where they are
+ discontiguous
+ 3 --- extended floating-point registers, on machines where
+ these are present in yet a third area. (GNU/Linux uses
+ this to get at the SSE registers.)
+
+ REG_ADDR is the offset from u.u_ar0 to the register values relative to
+ core_reg_sect. This is used with old-fashioned core files to locate the
+ registers in a large upage-plus-stack ".reg" section. Original upage
+ address X is at location core_reg_sect+x+reg_addr. */
+
+ void (*core_read_registers) (struct regcache *regcache,
+ char *core_reg_sect,
+ unsigned core_reg_size,
+ int which, CORE_ADDR reg_addr);
+
+ /* Finds the next struct core_fns. They are allocated and
+ initialized in whatever module implements the functions pointed
+ to; an initializer calls deprecated_add_core_fns to add them to
+ the global chain. */
+
+ struct core_fns *next;
+
+ };
+
+/* Build either a single-thread or multi-threaded section name for
+ PTID.
+
+ If ptid's lwp member is zero, we want to do the single-threaded
+ thing: look for a section named NAME (as passed to the
+ constructor). If ptid's lwp member is non-zero, we'll want do the
+ multi-threaded thing: look for a section named "NAME/LWP", where
+ LWP is the shortest ASCII decimal representation of ptid's lwp
+ member. */
+
+class thread_section_name
+{
+public:
+ /* NAME is the single-threaded section name. If PTID represents an
+ LWP, then the build section name is "NAME/LWP", otherwise it's
+ just "NAME" unmodified. */
+ thread_section_name (const char *name, ptid_t ptid)
+ {
+ if (ptid.lwp_p ())
+ {
+ m_storage = string_printf ("%s/%ld", name, ptid.lwp ());
+ m_section_name = m_storage.c_str ();
+ }
+ else
+ m_section_name = name;
+ }
+
+ /* Return the computed section name. The result is valid as long as
+ this thread_section_name object is live. */
+ const char *c_str () const
+ { return m_section_name; }
+
+ DISABLE_COPY_AND_ASSIGN (thread_section_name);
+
+private:
+ /* Either a pointer into M_STORAGE, or a pointer to the name passed
+ as parameter to the constructor. */
+ const char *m_section_name;
+ /* If we need to build a new section name, this is where we store
+ it. */
+ std::string m_storage;