[thirdparty/gcc.git] / libbacktrace / internal.h

/* internal.h -- Internal header file for stack backtrace library.
   Copyright (C) 2012-2019 Free Software Foundation, Inc.
   Written by Ian Lance Taylor, Google.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

    (1) Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    (2) Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in
    the documentation and/or other materials provided with the
    distribution.

    (3) The name of the author may not be used to
    endorse or promote products derived from this software without
    specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.  */

#ifndef BACKTRACE_INTERNAL_H
#define BACKTRACE_INTERNAL_H

/* We assume that <sys/types.h> and "backtrace.h" have already been
   included.  */

#ifndef GCC_VERSION
# define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
#endif

#if (GCC_VERSION < 2007)
# define __attribute__(x)
#endif

#ifndef ATTRIBUTE_UNUSED
# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
#endif

#ifndef ATTRIBUTE_MALLOC
# if (GCC_VERSION >= 2096)
#  define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
# else
#  define ATTRIBUTE_MALLOC
# endif
#endif

#ifndef HAVE_SYNC_FUNCTIONS

/* Define out the sync functions.  These should never be called if
   they are not available.  */

#define __sync_bool_compare_and_swap(A, B, C) (abort(), 1)
#define __sync_lock_test_and_set(A, B) (abort(), 0)
#define __sync_lock_release(A) abort()

#endif /* !defined (HAVE_SYNC_FUNCTIONS) */

#ifdef HAVE_ATOMIC_FUNCTIONS

/* We have the atomic builtin functions.  */

#define backtrace_atomic_load_pointer(p) \
    __atomic_load_n ((p), __ATOMIC_ACQUIRE)
#define backtrace_atomic_load_int(p) \
    __atomic_load_n ((p), __ATOMIC_ACQUIRE)
#define backtrace_atomic_store_pointer(p, v) \
    __atomic_store_n ((p), (v), __ATOMIC_RELEASE)
#define backtrace_atomic_store_size_t(p, v) \
    __atomic_store_n ((p), (v), __ATOMIC_RELEASE)
#define backtrace_atomic_store_int(p, v) \
    __atomic_store_n ((p), (v), __ATOMIC_RELEASE)

#else /* !defined (HAVE_ATOMIC_FUNCTIONS) */
#ifdef HAVE_SYNC_FUNCTIONS

/* We have the sync functions but not the atomic functions.  Define
   the atomic ones in terms of the sync ones.  */

extern void *backtrace_atomic_load_pointer (void *);
extern int backtrace_atomic_load_int (int *);
extern void backtrace_atomic_store_pointer (void *, void *);
extern void backtrace_atomic_store_size_t (size_t *, size_t);
extern void backtrace_atomic_store_int (int *, int);

#else /* !defined (HAVE_SYNC_FUNCTIONS) */

/* We have neither the sync nor the atomic functions.  These will
   never be called.  */

#define backtrace_atomic_load_pointer(p) (abort(), (void *) NULL)
#define backtrace_atomic_load_int(p) (abort(), 0)
#define backtrace_atomic_store_pointer(p, v) abort()
#define backtrace_atomic_store_size_t(p, v) abort()
#define backtrace_atomic_store_int(p, v) abort()

#endif /* !defined (HAVE_SYNC_FUNCTIONS) */
#endif /* !defined (HAVE_ATOMIC_FUNCTIONS) */

/* The type of the function that collects file/line information.  This
   is like backtrace_pcinfo.  */

typedef int (*fileline) (struct backtrace_state *state, uintptr_t pc,
			 backtrace_full_callback callback,
			 backtrace_error_callback error_callback, void *data);

/* The type of the function that collects symbol information.  This is
   like backtrace_syminfo.  */

typedef void (*syminfo) (struct backtrace_state *state, uintptr_t pc,
			 backtrace_syminfo_callback callback,
			 backtrace_error_callback error_callback, void *data);

/* What the backtrace state pointer points to.  */

struct backtrace_state
{
  /* The name of the executable.  */
  const char *filename;
  /* Non-zero if threaded.  */
  int threaded;
  /* The master lock for fileline_fn, fileline_data, syminfo_fn,
     syminfo_data, fileline_initialization_failed and everything the
     data pointers point to.  */
  void *lock;
  /* The function that returns file/line information.  */
  fileline fileline_fn;
  /* The data to pass to FILELINE_FN.  */
  void *fileline_data;
  /* The function that returns symbol information.  */
  syminfo syminfo_fn;
  /* The data to pass to SYMINFO_FN.  */
  void *syminfo_data;
  /* Whether initializing the file/line information failed.  */
  int fileline_initialization_failed;
  /* The lock for the freelist.  */
  int lock_alloc;
  /* The freelist when using mmap.  */
  struct backtrace_freelist_struct *freelist;
};

/* Open a file for reading.  Returns -1 on error.  If DOES_NOT_EXIST
   is not NULL, *DOES_NOT_EXIST will be set to 0 normally and set to 1
   if the file does not exist.  If the file does not exist and
   DOES_NOT_EXIST is not NULL, the function will return -1 and will
   not call ERROR_CALLBACK.  On other errors, or if DOES_NOT_EXIST is
   NULL, the function will call ERROR_CALLBACK before returning.  */
extern int backtrace_open (const char *filename,
			   backtrace_error_callback error_callback,
			   void *data,
			   int *does_not_exist);

/* A view of the contents of a file.  This supports mmap when
   available.  A view will remain in memory even after backtrace_close
   is called on the file descriptor from which the view was
   obtained.  */

struct backtrace_view
{
  /* The data that the caller requested.  */
  const void *data;
  /* The base of the view.  */
  void *base;
  /* The total length of the view.  */
  size_t len;
};

/* Create a view of SIZE bytes from DESCRIPTOR at OFFSET.  Store the
   result in *VIEW.  Returns 1 on success, 0 on error.  */
extern int backtrace_get_view (struct backtrace_state *state, int descriptor,
			       off_t offset, uint64_t size,
			       backtrace_error_callback error_callback,
			       void *data, struct backtrace_view *view);

/* Release a view created by backtrace_get_view.  */
extern void backtrace_release_view (struct backtrace_state *state,
				    struct backtrace_view *view,
				    backtrace_error_callback error_callback,
				    void *data);

/* Close a file opened by backtrace_open.  Returns 1 on success, 0 on
   error.  */

extern int backtrace_close (int descriptor,
			    backtrace_error_callback error_callback,
			    void *data);

/* Sort without using memory.  */

extern void backtrace_qsort (void *base, size_t count, size_t size,
			     int (*compar) (const void *, const void *));

/* Allocate memory.  This is like malloc.  If ERROR_CALLBACK is NULL,
   this does not report an error, it just returns NULL.  */

extern void *backtrace_alloc (struct backtrace_state *state, size_t size,
			      backtrace_error_callback error_callback,
			      void *data) ATTRIBUTE_MALLOC;

/* Free memory allocated by backtrace_alloc.  If ERROR_CALLBACK is
   NULL, this does not report an error.  */

extern void backtrace_free (struct backtrace_state *state, void *mem,
			    size_t size,
			    backtrace_error_callback error_callback,
			    void *data);

/* A growable vector of some struct.  This is used for more efficient
   allocation when we don't know the final size of some group of data
   that we want to represent as an array.  */

struct backtrace_vector
{
  /* The base of the vector.  */
  void *base;
  /* The number of bytes in the vector.  */
  size_t size;
  /* The number of bytes available at the current allocation.  */
  size_t alc;
};

/* Grow VEC by SIZE bytes.  Return a pointer to the newly allocated
   bytes.  Note that this may move the entire vector to a new memory
   location.  Returns NULL on failure.  */

extern void *backtrace_vector_grow (struct backtrace_state *state, size_t size,
				    backtrace_error_callback error_callback,
				    void *data,
				    struct backtrace_vector *vec);

/* Finish the current allocation on VEC.  Prepare to start a new
   allocation.  The finished allocation will never be freed.  Returns
   a pointer to the base of the finished entries, or NULL on
   failure.  */

extern void* backtrace_vector_finish (struct backtrace_state *state,
				      struct backtrace_vector *vec,
				      backtrace_error_callback error_callback,
				      void *data);

/* Release any extra space allocated for VEC.  This may change
   VEC->base.  Returns 1 on success, 0 on failure.  */

extern int backtrace_vector_release (struct backtrace_state *state,
				     struct backtrace_vector *vec,
				     backtrace_error_callback error_callback,
				     void *data);

/* Free the space managed by VEC.  This will reset VEC.  */

static inline void
backtrace_vector_free (struct backtrace_state *state,
		       struct backtrace_vector *vec,
		       backtrace_error_callback error_callback, void *data)
{
  vec->alc += vec->size;
  vec->size = 0;
  backtrace_vector_release (state, vec, error_callback, data);
}

/* Read initial debug data from a descriptor, and set the
   fileline_data, syminfo_fn, and syminfo_data fields of STATE.
   Return the fileln_fn field in *FILELN_FN--this is done this way so
   that the synchronization code is only implemented once.  This is
   called after the descriptor has first been opened.  It will close
   the descriptor if it is no longer needed.  Returns 1 on success, 0
   on error.  There will be multiple implementations of this function,
   for different file formats.  Each system will compile the
   appropriate one.  */

extern int backtrace_initialize (struct backtrace_state *state,
				 const char *filename,
				 int descriptor,
				 backtrace_error_callback error_callback,
				 void *data,
				 fileline *fileline_fn);

struct dwarf_data;

/* Add file/line information for a DWARF module.  */

extern int backtrace_dwarf_add (struct backtrace_state *state,
				uintptr_t base_address,
				const unsigned char* dwarf_info,
				size_t dwarf_info_size,
				const unsigned char *dwarf_line,
				size_t dwarf_line_size,
				const unsigned char *dwarf_abbrev,
				size_t dwarf_abbrev_size,
				const unsigned char *dwarf_ranges,
				size_t dwarf_range_size,
				const unsigned char *dwarf_str,
				size_t dwarf_str_size,
				int is_bigendian,
				struct dwarf_data *fileline_altlink,
				backtrace_error_callback error_callback,
				void *data, fileline *fileline_fn,
				struct dwarf_data **fileline_entry);

/* A test-only hook for elf_uncompress_zdebug.  */

extern int backtrace_uncompress_zdebug (struct backtrace_state *,
					const unsigned char *compressed,
					size_t compressed_size,
					backtrace_error_callback, void *data,
					unsigned char **uncompressed,
					size_t *uncompressed_size);

#endif
Commit	Line	Data
ecd3459e	1	/* internal.h -- Internal header file for stack backtrace library.
fbd26352	2	Copyright (C) 2012-2019 Free Software Foundation, Inc.
ecd3459e	3	Written by Ian Lance Taylor, Google.
	4
	5	Redistribution and use in source and binary forms, with or without
	6	modification, are permitted provided that the following conditions are
	7	met:
	8
	9	(1) Redistributions of source code must retain the above copyright
75c399ef	10	notice, this list of conditions and the following disclaimer.
ecd3459e	11
	12	(2) Redistributions in binary form must reproduce the above copyright
	13	notice, this list of conditions and the following disclaimer in
	14	the documentation and/or other materials provided with the
75c399ef	15	distribution.
75c399ef	16
ecd3459e	17	(3) The name of the author may not be used to
	18	endorse or promote products derived from this software without
	19	specific prior written permission.
	20
	21	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	22	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	23	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	24	DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
	25	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	26	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	27	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	29	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	30	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	31	POSSIBILITY OF SUCH DAMAGE. */
	32
	33	#ifndef BACKTRACE_INTERNAL_H
	34	#define BACKTRACE_INTERNAL_H
	35
	36	/* We assume that <sys/types.h> and "backtrace.h" have already been
	37	included. */
	38
	39	#ifndef GCC_VERSION
	40	# define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
	41	#endif
	42
	43	#if (GCC_VERSION < 2007)
	44	# define __attribute__(x)
	45	#endif
	46
	47	#ifndef ATTRIBUTE_UNUSED
	48	# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
	49	#endif
	50
	51	#ifndef ATTRIBUTE_MALLOC
	52	# if (GCC_VERSION >= 2096)
	53	# define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
	54	# else
	55	# define ATTRIBUTE_MALLOC
	56	# endif
	57	#endif
	58
	59	#ifndef HAVE_SYNC_FUNCTIONS
	60
	61	/* Define out the sync functions. These should never be called if
	62	they are not available. */
	63
	64	#define __sync_bool_compare_and_swap(A, B, C) (abort(), 1)
	65	#define __sync_lock_test_and_set(A, B) (abort(), 0)
	66	#define __sync_lock_release(A) abort()
	67
bcafb4a8	68	#endif /* !defined (HAVE_SYNC_FUNCTIONS) */
	69
	70	#ifdef HAVE_ATOMIC_FUNCTIONS
	71
	72	/* We have the atomic builtin functions. */
	73
	74	#define backtrace_atomic_load_pointer(p) \
	75	__atomic_load_n ((p), __ATOMIC_ACQUIRE)
	76	#define backtrace_atomic_load_int(p) \
	77	__atomic_load_n ((p), __ATOMIC_ACQUIRE)
	78	#define backtrace_atomic_store_pointer(p, v) \
	79	__atomic_store_n ((p), (v), __ATOMIC_RELEASE)
	80	#define backtrace_atomic_store_size_t(p, v) \
	81	__atomic_store_n ((p), (v), __ATOMIC_RELEASE)
	82	#define backtrace_atomic_store_int(p, v) \
	83	__atomic_store_n ((p), (v), __ATOMIC_RELEASE)
	84
	85	#else /* !defined (HAVE_ATOMIC_FUNCTIONS) */
	86	#ifdef HAVE_SYNC_FUNCTIONS
	87
	88	/* We have the sync functions but not the atomic functions. Define
	89	the atomic ones in terms of the sync ones. */
	90
	91	extern void backtrace_atomic_load_pointer (void );
	92	extern int backtrace_atomic_load_int (int *);
	93	extern void backtrace_atomic_store_pointer (void , void );
	94	extern void backtrace_atomic_store_size_t (size_t *, size_t);
	95	extern void backtrace_atomic_store_int (int *, int);
	96
	97	#else /* !defined (HAVE_SYNC_FUNCTIONS) */
	98
	99	/* We have neither the sync nor the atomic functions. These will
	100	never be called. */
	101
f62ce0c7	102	#define backtrace_atomic_load_pointer(p) (abort(), (void *) NULL)
bcafb4a8	103	#define backtrace_atomic_load_int(p) (abort(), 0)
	104	#define backtrace_atomic_store_pointer(p, v) abort()
	105	#define backtrace_atomic_store_size_t(p, v) abort()
	106	#define backtrace_atomic_store_int(p, v) abort()
	107
	108	#endif /* !defined (HAVE_SYNC_FUNCTIONS) */
	109	#endif /* !defined (HAVE_ATOMIC_FUNCTIONS) */
ecd3459e	110
	111	/* The type of the function that collects file/line information. This
	112	is like backtrace_pcinfo. */
	113
	114	typedef int (fileline) (struct backtrace_state state, uintptr_t pc,
	115	backtrace_full_callback callback,
	116	backtrace_error_callback error_callback, void *data);
	117
	118	/* The type of the function that collects symbol information. This is
	119	like backtrace_syminfo. */
	120
	121	typedef void (syminfo) (struct backtrace_state state, uintptr_t pc,
	122	backtrace_syminfo_callback callback,
	123	backtrace_error_callback error_callback, void *data);
	124
	125	/* What the backtrace state pointer points to. */
	126
	127	struct backtrace_state
	128	{
	129	/* The name of the executable. */
	130	const char *filename;
	131	/* Non-zero if threaded. */
	132	int threaded;
	133	/* The master lock for fileline_fn, fileline_data, syminfo_fn,
	134	syminfo_data, fileline_initialization_failed and everything the
	135	data pointers point to. */
	136	void *lock;
	137	/* The function that returns file/line information. */
	138	fileline fileline_fn;
	139	/* The data to pass to FILELINE_FN. */
	140	void *fileline_data;
	141	/* The function that returns symbol information. */
	142	syminfo syminfo_fn;
	143	/* The data to pass to SYMINFO_FN. */
	144	void *syminfo_data;
	145	/* Whether initializing the file/line information failed. */
	146	int fileline_initialization_failed;
	147	/* The lock for the freelist. */
	148	int lock_alloc;
	149	/* The freelist when using mmap. */
	150	struct backtrace_freelist_struct *freelist;
	151	};
	152
b60ebf03	153	/* Open a file for reading. Returns -1 on error. If DOES_NOT_EXIST
	154	is not NULL, *DOES_NOT_EXIST will be set to 0 normally and set to 1
	155	if the file does not exist. If the file does not exist and
	156	DOES_NOT_EXIST is not NULL, the function will return -1 and will
	157	not call ERROR_CALLBACK. On other errors, or if DOES_NOT_EXIST is
	158	NULL, the function will call ERROR_CALLBACK before returning. */
ecd3459e	159	extern int backtrace_open (const char *filename,
ecd3459e	160	backtrace_error_callback error_callback,
b60ebf03	161	void *data,
b60ebf03	162	int *does_not_exist);
ecd3459e	163
	164	/* A view of the contents of a file. This supports mmap when
	165	available. A view will remain in memory even after backtrace_close
	166	is called on the file descriptor from which the view was
	167	obtained. */
	168
	169	struct backtrace_view
	170	{
	171	/* The data that the caller requested. */
	172	const void *data;
	173	/* The base of the view. */
	174	void *base;
	175	/* The total length of the view. */
	176	size_t len;
	177	};
	178
	179	/* Create a view of SIZE bytes from DESCRIPTOR at OFFSET. Store the
	180	result in VIEW. Returns 1 on success, 0 on error. /
	181	extern int backtrace_get_view (struct backtrace_state *state, int descriptor,
432ce2bc	182	off_t offset, uint64_t size,
ecd3459e	183	backtrace_error_callback error_callback,
	184	void data, struct backtrace_view view);
	185
	186	/* Release a view created by backtrace_get_view. */
	187	extern void backtrace_release_view (struct backtrace_state *state,
	188	struct backtrace_view *view,
	189	backtrace_error_callback error_callback,
	190	void *data);
	191
	192	/* Close a file opened by backtrace_open. Returns 1 on success, 0 on
	193	error. */
	194
	195	extern int backtrace_close (int descriptor,
	196	backtrace_error_callback error_callback,
	197	void *data);
	198
1329f160	199	/* Sort without using memory. */
	200
	201	extern void backtrace_qsort (void *base, size_t count, size_t size,
	202	int (compar) (const void , const void *));
	203
61ee636a	204	/* Allocate memory. This is like malloc. If ERROR_CALLBACK is NULL,
61ee636a	205	this does not report an error, it just returns NULL. */
ecd3459e	206
	207	extern void backtrace_alloc (struct backtrace_state state, size_t size,
	208	backtrace_error_callback error_callback,
	209	void *data) ATTRIBUTE_MALLOC;
	210
61ee636a	211	/* Free memory allocated by backtrace_alloc. If ERROR_CALLBACK is
61ee636a	212	NULL, this does not report an error. */
ecd3459e	213
	214	extern void backtrace_free (struct backtrace_state state, void mem,
	215	size_t size,
	216	backtrace_error_callback error_callback,
	217	void *data);
	218
	219	/* A growable vector of some struct. This is used for more efficient
	220	allocation when we don't know the final size of some group of data
	221	that we want to represent as an array. */
	222
	223	struct backtrace_vector
	224	{
	225	/* The base of the vector. */
	226	void *base;
	227	/* The number of bytes in the vector. */
	228	size_t size;
	229	/* The number of bytes available at the current allocation. */
	230	size_t alc;
	231	};
	232
	233	/* Grow VEC by SIZE bytes. Return a pointer to the newly allocated
	234	bytes. Note that this may move the entire vector to a new memory
	235	location. Returns NULL on failure. */
	236
	237	extern void backtrace_vector_grow (struct backtrace_state state, size_t size,
	238	backtrace_error_callback error_callback,
	239	void *data,
	240	struct backtrace_vector *vec);
	241
	242	/* Finish the current allocation on VEC. Prepare to start a new
583d5f6b	243	allocation. The finished allocation will never be freed. Returns
	244	a pointer to the base of the finished entries, or NULL on
	245	failure. */
ecd3459e	246
583d5f6b	247	extern void* backtrace_vector_finish (struct backtrace_state *state,
	248	struct backtrace_vector *vec,
	249	backtrace_error_callback error_callback,
	250	void *data);
ecd3459e	251
583d5f6b	252	/* Release any extra space allocated for VEC. This may change
583d5f6b	253	VEC->base. Returns 1 on success, 0 on failure. */
ecd3459e	254
	255	extern int backtrace_vector_release (struct backtrace_state *state,
	256	struct backtrace_vector *vec,
	257	backtrace_error_callback error_callback,
	258	void *data);
	259
579f637c	260	/* Free the space managed by VEC. This will reset VEC. */
	261
	262	static inline void
	263	backtrace_vector_free (struct backtrace_state *state,
	264	struct backtrace_vector *vec,
	265	backtrace_error_callback error_callback, void *data)
	266	{
	267	vec->alc += vec->size;
	268	vec->size = 0;
	269	backtrace_vector_release (state, vec, error_callback, data);
	270	}
	271
ecd3459e	272	/* Read initial debug data from a descriptor, and set the
	273	fileline_data, syminfo_fn, and syminfo_data fields of STATE.
	274	Return the fileln_fn field in *FILELN_FN--this is done this way so
	275	that the synchronization code is only implemented once. This is
	276	called after the descriptor has first been opened. It will close
	277	the descriptor if it is no longer needed. Returns 1 on success, 0
	278	on error. There will be multiple implementations of this function,
	279	for different file formats. Each system will compile the
	280	appropriate one. */
	281
	282	extern int backtrace_initialize (struct backtrace_state *state,
b919941e	283	const char *filename,
ecd3459e	284	int descriptor,
	285	backtrace_error_callback error_callback,
	286	void *data,
	287	fileline *fileline_fn);
	288
477b4e4c	289	struct dwarf_data;
477b4e4c	290
1bfb5d87	291	/* Add file/line information for a DWARF module. */
	292
	293	extern int backtrace_dwarf_add (struct backtrace_state *state,
	294	uintptr_t base_address,
	295	const unsigned char* dwarf_info,
	296	size_t dwarf_info_size,
	297	const unsigned char *dwarf_line,
	298	size_t dwarf_line_size,
	299	const unsigned char *dwarf_abbrev,
	300	size_t dwarf_abbrev_size,
	301	const unsigned char *dwarf_ranges,
	302	size_t dwarf_range_size,
	303	const unsigned char *dwarf_str,
	304	size_t dwarf_str_size,
	305	int is_bigendian,
7ad450d1	306	struct dwarf_data *fileline_altlink,
1bfb5d87	307	backtrace_error_callback error_callback,
477b4e4c	308	void data, fileline fileline_fn,
477b4e4c	309	struct dwarf_data **fileline_entry);
ecd3459e	310
1fffcf69	311	/* A test-only hook for elf_uncompress_zdebug. */
	312
	313	extern int backtrace_uncompress_zdebug (struct backtrace_state *,
	314	const unsigned char *compressed,
	315	size_t compressed_size,
	316	backtrace_error_callback, void *data,
	317	unsigned char **uncompressed,
	318	size_t *uncompressed_size);
	319
ecd3459e	320	#endif