1 /* Internal definitions for libdwarf.
2    Copyright (C) 2002-2011, 2013-2015 Red Hat, Inc.
3    This file is part of elfutils.
4    Written by Ulrich Drepper <drepper@redhat.com>, 2002.
5 
6    This file is free software; you can redistribute it and/or modify
7    it under the terms of either
8 
9      * the GNU Lesser General Public License as published by the Free
10        Software Foundation; either version 3 of the License, or (at
11        your option) any later version
12 
13    or
14 
15      * the GNU General Public License as published by the Free
16        Software Foundation; either version 2 of the License, or (at
17        your option) any later version
18 
19    or both in parallel, as here.
20 
21    elfutils is distributed in the hope that it will be useful, but
22    WITHOUT ANY WARRANTY; without even the implied warranty of
23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24    General Public License for more details.
25 
26    You should have received copies of the GNU General Public License and
27    the GNU Lesser General Public License along with this program.  If
28    not, see <http://www.gnu.org/licenses/>.  */
29 
30 #ifndef _LIBDWP_H
31 #define _LIBDWP_H 1
32 
33 #include <libintl.h>
34 #include <stdbool.h>
35 
36 #include <libdw.h>
37 #include <dwarf.h>
38 
39 
40 /* gettext helper macros.  */
41 #define _(Str) dgettext ("elfutils", Str)
42 
43 
44 /* Known location expressions already decoded.  */
45 struct loc_s
46 {
47   void *addr;
48   Dwarf_Op *loc;
49   size_t nloc;
50 };
51 
52 /* Known DW_OP_implicit_value blocks already decoded.
53    This overlaps struct loc_s exactly, but only the
54    first member really has to match.  */
55 struct loc_block_s
56 {
57   void *addr;
58   unsigned char *data;
59   size_t length;
60 };
61 
62 /* Already decoded .debug_line units.  */
63 struct files_lines_s
64 {
65   Dwarf_Off debug_line_offset;
66   Dwarf_Files *files;
67   Dwarf_Lines *lines;
68 };
69 
70 /* Valid indeces for the section data.  */
71 enum
72   {
73     IDX_debug_info = 0,
74     IDX_debug_types,
75     IDX_debug_abbrev,
76     IDX_debug_aranges,
77     IDX_debug_line,
78     IDX_debug_frame,
79     IDX_debug_loc,
80     IDX_debug_pubnames,
81     IDX_debug_str,
82     IDX_debug_macinfo,
83     IDX_debug_macro,
84     IDX_debug_ranges,
85     IDX_gnu_debugaltlink,
86     IDX_last
87   };
88 
89 
90 /* Error values.  */
91 enum
92 {
93   DWARF_E_NOERROR = 0,
94   DWARF_E_UNKNOWN_ERROR,
95   DWARF_E_INVALID_ACCESS,
96   DWARF_E_NO_REGFILE,
97   DWARF_E_IO_ERROR,
98   DWARF_E_INVALID_ELF,
99   DWARF_E_NO_DWARF,
100   DWARF_E_COMPRESSED_ERROR,
101   DWARF_E_NOELF,
102   DWARF_E_GETEHDR_ERROR,
103   DWARF_E_NOMEM,
104   DWARF_E_UNIMPL,
105   DWARF_E_INVALID_CMD,
106   DWARF_E_INVALID_VERSION,
107   DWARF_E_INVALID_FILE,
108   DWARF_E_NO_ENTRY,
109   DWARF_E_INVALID_DWARF,
110   DWARF_E_NO_STRING,
111   DWARF_E_NO_ADDR,
112   DWARF_E_NO_CONSTANT,
113   DWARF_E_NO_REFERENCE,
114   DWARF_E_INVALID_REFERENCE,
115   DWARF_E_NO_DEBUG_LINE,
116   DWARF_E_INVALID_DEBUG_LINE,
117   DWARF_E_TOO_BIG,
118   DWARF_E_VERSION,
119   DWARF_E_INVALID_DIR_IDX,
120   DWARF_E_ADDR_OUTOFRANGE,
121   DWARF_E_NO_LOCLIST,
122   DWARF_E_NO_BLOCK,
123   DWARF_E_INVALID_LINE_IDX,
124   DWARF_E_INVALID_ARANGE_IDX,
125   DWARF_E_NO_MATCH,
126   DWARF_E_NO_FLAG,
127   DWARF_E_INVALID_OFFSET,
128   DWARF_E_NO_DEBUG_RANGES,
129   DWARF_E_INVALID_CFI,
130   DWARF_E_NO_ALT_DEBUGLINK,
131   DWARF_E_INVALID_OPCODE,
132   DWARF_E_NOT_CUDIE,
133 };
134 
135 
136 #include "dwarf_sig8_hash.h"
137 
138 /* This is the structure representing the debugging state.  */
139 struct Dwarf
140 {
141   /* The underlying ELF file.  */
142   Elf *elf;
143 
144   /* dwz alternate DWARF file.  */
145   Dwarf *alt_dwarf;
146 
147   /* The section data.  */
148   Elf_Data *sectiondata[IDX_last];
149 
150   /* True if the file has a byte order different from the host.  */
151   bool other_byte_order;
152 
153   /* If true, we allocated the ELF descriptor ourselves.  */
154   bool free_elf;
155 
156   /* Information for traversing the .debug_pubnames section.  This is
157      an array and separately allocated with malloc.  */
158   struct pubnames_s
159   {
160     Dwarf_Off cu_offset;
161     Dwarf_Off set_start;
162     unsigned int cu_header_size;
163     int address_len;
164   } *pubnames_sets;
165   size_t pubnames_nsets;
166 
167   /* Search tree for the CUs.  */
168   void *cu_tree;
169   Dwarf_Off next_cu_offset;
170 
171   /* Search tree and sig8 hash table for .debug_types type units.  */
172   void *tu_tree;
173   Dwarf_Off next_tu_offset;
174   Dwarf_Sig8_Hash sig8_hash;
175 
176   /* Search tree for .debug_macro operator tables.  */
177   void *macro_ops;
178 
179   /* Search tree for decoded .debug_line units.  */
180   void *files_lines;
181 
182   /* Address ranges.  */
183   Dwarf_Aranges *aranges;
184 
185   /* Cached info from the CFI section.  */
186   struct Dwarf_CFI_s *cfi;
187 
188   /* Fake loc CU.  Used when synthesizing attributes for Dwarf_Ops that
189      came from a location list entry in dwarf_getlocation_attr.  */
190   struct Dwarf_CU *fake_loc_cu;
191 
192   /* Internal memory handling.  This is basically a simplified
193      reimplementation of obstacks.  Unfortunately the standard obstack
194      implementation is not usable in libraries.  */
195   struct libdw_memblock
196   {
197     size_t size;
198     size_t remaining;
199     struct libdw_memblock *prev;
200     char mem[0];
201   } *mem_tail;
202 
203   /* Default size of allocated memory blocks.  */
204   size_t mem_default_size;
205 
206   /* Registered OOM handler.  */
207   Dwarf_OOM oom_handler;
208 };
209 
210 
211 /* Abbreviation representation.  */
212 struct Dwarf_Abbrev
213 {
214   Dwarf_Off offset;
215   unsigned char *attrp;
216   unsigned int attrcnt;
217   unsigned int code;
218   unsigned int tag;
219   bool has_children;
220 };
221 
222 #include "dwarf_abbrev_hash.h"
223 
224 
225 /* Files in line information records.  */
226 struct Dwarf_Files_s
227   {
228     unsigned int ndirs;
229     unsigned int nfiles;
230     struct Dwarf_Fileinfo_s
231     {
232       char *name;
233       Dwarf_Word mtime;
234       Dwarf_Word length;
235     } info[0];
236     /* nfiles of those, followed by char *[ndirs].  */
237   };
238 typedef struct Dwarf_Fileinfo_s Dwarf_Fileinfo;
239 
240 
241 /* Representation of a row in the line table.  */
242 
243 struct Dwarf_Line_s
244 {
245   Dwarf_Files *files;
246 
247   Dwarf_Addr addr;
248   unsigned int file;
249   int line;
250   unsigned short int column;
251   unsigned int is_stmt:1;
252   unsigned int basic_block:1;
253   unsigned int end_sequence:1;
254   unsigned int prologue_end:1;
255   unsigned int epilogue_begin:1;
256   /* The remaining bit fields are not flags, but hold values presumed to be
257      small.  All the flags and other bit fields should add up to 48 bits
258      to give the whole struct a nice round size.  */
259   unsigned int op_index:8;
260   unsigned int isa:8;
261   unsigned int discriminator:24;
262 };
263 
264 struct Dwarf_Lines_s
265 {
266   size_t nlines;
267   struct Dwarf_Line_s info[0];
268 };
269 
270 /* Representation of address ranges.  */
271 struct Dwarf_Aranges_s
272 {
273   Dwarf *dbg;
274   size_t naranges;
275 
276   struct Dwarf_Arange_s
277   {
278     Dwarf_Addr addr;
279     Dwarf_Word length;
280     Dwarf_Off offset;
281   } info[0];
282 };
283 
284 
285 /* CU representation.  */
286 struct Dwarf_CU
287 {
288   Dwarf *dbg;
289   Dwarf_Off start;
290   Dwarf_Off end;
291   uint8_t address_size;
292   uint8_t offset_size;
293   uint16_t version;
294 
295   /* Zero if this is a normal CU.  Nonzero if it is a type unit.  */
296   size_t type_offset;
297   uint64_t type_sig8;
298 
299   /* Hash table for the abbreviations.  */
300   Dwarf_Abbrev_Hash abbrev_hash;
301   /* Offset of the first abbreviation.  */
302   size_t orig_abbrev_offset;
303   /* Offset past last read abbreviation.  */
304   size_t last_abbrev_offset;
305 
306   /* The srcline information.  */
307   Dwarf_Lines *lines;
308 
309   /* The source file information.  */
310   Dwarf_Files *files;
311 
312   /* Known location lists.  */
313   void *locs;
314 
315   /* Memory boundaries of this CU.  */
316   void *startp;
317   void *endp;
318 };
319 
320 /* Compute the offset of a CU's first DIE from its offset.  This
321    is either:
322         LEN       VER     OFFSET    ADDR
323       4-bytes + 2-bytes + 4-bytes + 1-byte  for 32-bit dwarf
324      12-bytes + 2-bytes + 8-bytes + 1-byte  for 64-bit dwarf
325    or in .debug_types, 			     SIGNATURE TYPE-OFFSET
326       4-bytes + 2-bytes + 4-bytes + 1-byte + 8-bytes + 4-bytes  for 32-bit
327      12-bytes + 2-bytes + 8-bytes + 1-byte + 8-bytes + 8-bytes  for 64-bit
328 
329    Note the trick in the computation.  If the offset_size is 4
330    the '- 4' term changes the '3 *' into a '2 *'.  If the
331    offset_size is 8 it accounts for the 4-byte escape value
332    used at the start of the length.  */
333 #define DIE_OFFSET_FROM_CU_OFFSET(cu_offset, offset_size, type_unit)	\
334   ((type_unit) ? ((cu_offset) + 4 * (offset_size) - 4 + 3 + 8)		\
335    : ((cu_offset) + 3 * (offset_size) - 4 + 3))
336 
337 #define CUDIE(fromcu)							      \
338   ((Dwarf_Die)								      \
339    {									      \
340      .cu = (fromcu),							      \
341      .addr = ((char *) fromcu->dbg->sectiondata[cu_sec_idx (fromcu)]->d_buf   \
342 	      + DIE_OFFSET_FROM_CU_OFFSET ((fromcu)->start,		      \
343 					   (fromcu)->offset_size,	      \
344 					   (fromcu)->type_offset != 0))	      \
345    })									      \
346 
347 
348 /* Prototype of a single .debug_macro operator.  */
349 typedef struct
350 {
351   Dwarf_Word nforms;
352   unsigned char const *forms;
353 } Dwarf_Macro_Op_Proto;
354 
355 /* Prototype table.  */
356 typedef struct
357 {
358   /* Offset of .debug_macro section.  */
359   Dwarf_Off offset;
360 
361   /* Offset of associated .debug_line section.  */
362   Dwarf_Off line_offset;
363 
364   /* The source file information.  */
365   Dwarf_Files *files;
366 
367   /* If this macro unit was opened through dwarf_getmacros or
368      dwarf_getmacros_die, this caches value of DW_AT_comp_dir, if
369      present.  */
370   const char *comp_dir;
371 
372   /* Header length.  */
373   Dwarf_Half header_len;
374 
375   uint16_t version;
376   bool is_64bit;
377   uint8_t sec_index;	/* IDX_debug_macro or IDX_debug_macinfo.  */
378 
379   /* Shows where in TABLE each opcode is defined.  Since opcode 0 is
380      never used, it stores index of opcode X in X-1'th element.  The
381      value of 0xff means not stored at all.  */
382   unsigned char opcodes[255];
383 
384   /* Individual opcode prototypes.  */
385   Dwarf_Macro_Op_Proto table[];
386 } Dwarf_Macro_Op_Table;
387 
388 struct Dwarf_Macro_s
389 {
390   Dwarf_Macro_Op_Table *table;
391   Dwarf_Attribute *attributes;
392   uint8_t opcode;
393 };
394 
395 static inline Dwarf_Word
libdw_macro_nforms(Dwarf_Macro * macro)396 libdw_macro_nforms (Dwarf_Macro *macro)
397 {
398   return macro->table->table[macro->table->opcodes[macro->opcode - 1]].nforms;
399 }
400 
401 /* We have to include the file at this point because the inline
402    functions access internals of the Dwarf structure.  */
403 #include "memory-access.h"
404 
405 
406 /* Set error value.  */
407 extern void __libdw_seterrno (int value) internal_function;
408 
409 
410 /* Memory handling, the easy parts.  This macro does not do any locking.  */
411 #define libdw_alloc(dbg, type, tsize, cnt) \
412   ({ struct libdw_memblock *_tail = (dbg)->mem_tail;			      \
413      size_t _required = (tsize) * (cnt);				      \
414      type *_result = (type *) (_tail->mem + (_tail->size - _tail->remaining));\
415      size_t _padding = ((__alignof (type)				      \
416 			 - ((uintptr_t) _result & (__alignof (type) - 1)))    \
417 			& (__alignof (type) - 1));			      \
418      if (unlikely (_tail->remaining < _required + _padding))		      \
419        _result = (type *) __libdw_allocate (dbg, _required, __alignof (type));\
420      else								      \
421        {								      \
422 	 _required += _padding;						      \
423 	 _result = (type *) ((char *) _result + _padding);		      \
424 	 _tail->remaining -= _required;					      \
425        }								      \
426      _result; })
427 
428 #define libdw_typed_alloc(dbg, type) \
429   libdw_alloc (dbg, type, sizeof (type), 1)
430 
431 /* Callback to allocate more.  */
432 extern void *__libdw_allocate (Dwarf *dbg, size_t minsize, size_t align)
433      __attribute__ ((__malloc__)) __nonnull_attribute__ (1);
434 
435 /* Default OOM handler.  */
436 extern void __libdw_oom (void) __attribute ((noreturn, visibility ("hidden")));
437 
438 /* Allocate the internal data for a unit not seen before.  */
439 extern struct Dwarf_CU *__libdw_intern_next_unit (Dwarf *dbg, bool debug_types)
440      __nonnull_attribute__ (1) internal_function;
441 
442 /* Find CU for given offset.  */
443 extern struct Dwarf_CU *__libdw_findcu (Dwarf *dbg, Dwarf_Off offset, bool tu)
444      __nonnull_attribute__ (1) internal_function;
445 
446 /* Get abbreviation with given code.  */
447 extern Dwarf_Abbrev *__libdw_findabbrev (struct Dwarf_CU *cu,
448 					 unsigned int code)
449      __nonnull_attribute__ (1) internal_function;
450 
451 /* Get abbreviation at given offset.  */
452 extern Dwarf_Abbrev *__libdw_getabbrev (Dwarf *dbg, struct Dwarf_CU *cu,
453 					Dwarf_Off offset, size_t *lengthp,
454 					Dwarf_Abbrev *result)
455      __nonnull_attribute__ (1) internal_function;
456 
457 /* Get abbreviation of given DIE, and optionally set *READP to the DIE memory
458    just past the abbreviation code.  */
459 static inline Dwarf_Abbrev *
460 __nonnull_attribute__ (1)
__libdw_dieabbrev(Dwarf_Die * die,const unsigned char ** readp)461 __libdw_dieabbrev (Dwarf_Die *die, const unsigned char **readp)
462 {
463   /* Do we need to get the abbreviation, or need to read after the code?  */
464   if (die->abbrev == NULL || readp != NULL)
465     {
466       /* Get the abbreviation code.  */
467       unsigned int code;
468       const unsigned char *addr = die->addr;
469       get_uleb128 (code, addr, die->cu->endp);
470       if (readp != NULL)
471 	*readp = addr;
472 
473       /* Find the abbreviation.  */
474       if (die->abbrev == NULL)
475 	die->abbrev = __libdw_findabbrev (die->cu, code);
476     }
477   return die->abbrev;
478 }
479 
480 /* Helper functions for form handling.  */
481 extern size_t __libdw_form_val_compute_len (struct Dwarf_CU *cu,
482 					    unsigned int form,
483 					    const unsigned char *valp)
484      __nonnull_attribute__ (1, 3) internal_function;
485 
486 /* Find the length of a form attribute.  */
487 static inline size_t
488 __nonnull_attribute__ (1, 3)
__libdw_form_val_len(struct Dwarf_CU * cu,unsigned int form,const unsigned char * valp)489 __libdw_form_val_len (struct Dwarf_CU *cu, unsigned int form,
490 		      const unsigned char *valp)
491 {
492   /* Small lookup table of forms with fixed lengths.  Absent indexes are
493      initialized 0, so any truly desired 0 is set to 0x80 and masked.  */
494   static const uint8_t form_lengths[] =
495     {
496       [DW_FORM_flag_present] = 0x80,
497       [DW_FORM_data1] = 1, [DW_FORM_ref1] = 1, [DW_FORM_flag] = 1,
498       [DW_FORM_data2] = 2, [DW_FORM_ref2] = 2,
499       [DW_FORM_data4] = 4, [DW_FORM_ref4] = 4,
500       [DW_FORM_data8] = 8, [DW_FORM_ref8] = 8, [DW_FORM_ref_sig8] = 8,
501     };
502 
503   /* Return immediately for forms with fixed lengths.  */
504   if (form < sizeof form_lengths / sizeof form_lengths[0])
505     {
506       uint8_t len = form_lengths[form];
507       if (len != 0)
508 	{
509 	  const unsigned char *endp = cu->endp;
510 	  len &= 0x7f; /* Mask to allow 0x80 -> 0.  */
511 	  if (unlikely (len > (size_t) (endp - valp)))
512 	    {
513 	      __libdw_seterrno (DWARF_E_INVALID_DWARF);
514 	      return -1;
515 	    }
516 	  return len;
517 	}
518     }
519 
520   /* Other forms require some computation.  */
521   return __libdw_form_val_compute_len (cu, form, valp);
522 }
523 
524 /* Helper function for DW_FORM_ref* handling.  */
525 extern int __libdw_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
526      __nonnull_attribute__ (1, 2) internal_function;
527 
528 
529 /* Helper function to locate attribute.  */
530 extern unsigned char *__libdw_find_attr (Dwarf_Die *die,
531 					 unsigned int search_name,
532 					 unsigned int *codep,
533 					 unsigned int *formp)
534      __nonnull_attribute__ (1) internal_function;
535 
536 /* Helper function to access integer attribute.  */
537 extern int __libdw_attr_intval (Dwarf_Die *die, int *valp, int attval)
538      __nonnull_attribute__ (1, 2) internal_function;
539 
540 /* Helper function to walk scopes.  */
541 struct Dwarf_Die_Chain
542 {
543   Dwarf_Die die;
544   struct Dwarf_Die_Chain *parent;
545   bool prune;			/* The PREVISIT function can set this.  */
546 };
547 extern int __libdw_visit_scopes (unsigned int depth,
548 				 struct Dwarf_Die_Chain *root,
549 				 struct Dwarf_Die_Chain *imports,
550 				 int (*previsit) (unsigned int depth,
551 						  struct Dwarf_Die_Chain *,
552 						  void *arg),
553 				 int (*postvisit) (unsigned int depth,
554 						   struct Dwarf_Die_Chain *,
555 						   void *arg),
556 				 void *arg)
557   __nonnull_attribute__ (2, 4) internal_function;
558 
559 /* Parse a DWARF Dwarf_Block into an array of Dwarf_Op's,
560    and cache the result (via tsearch).  */
561 extern int __libdw_intern_expression (Dwarf *dbg,
562 				      bool other_byte_order,
563 				      unsigned int address_size,
564 				      unsigned int ref_size,
565 				      void **cache, const Dwarf_Block *block,
566 				      bool cfap, bool valuep,
567 				      Dwarf_Op **llbuf, size_t *listlen,
568 				      int sec_index)
569   __nonnull_attribute__ (5, 6, 9, 10) internal_function;
570 
571 extern Dwarf_Die *__libdw_offdie (Dwarf *dbg, Dwarf_Off offset,
572 				  Dwarf_Die *result, bool debug_types)
573   internal_function;
574 
575 
576 /* Return error code of last failing function call.  This value is kept
577    separately for each thread.  */
578 extern int __dwarf_errno_internal (void);
579 
580 
581 /* Reader hooks.  */
582 
583 /* Relocation hooks return -1 on error (in that case the error code
584    must already have been set), 0 if there is no relocation and 1 if a
585    relocation was present.*/
586 
587 static inline int
__libdw_relocate_address(Dwarf * dbg,int sec_index,const void * addr,int width,Dwarf_Addr * val)588 __libdw_relocate_address (Dwarf *dbg __attribute__ ((unused)),
589 			  int sec_index __attribute__ ((unused)),
590 			  const void *addr __attribute__ ((unused)),
591 			  int width __attribute__ ((unused)),
592 			  Dwarf_Addr *val __attribute__ ((unused)))
593 {
594   return 0;
595 }
596 
597 static inline int
__libdw_relocate_offset(Dwarf * dbg,int sec_index,const void * addr,int width,Dwarf_Off * val)598 __libdw_relocate_offset (Dwarf *dbg __attribute__ ((unused)),
599 			 int sec_index __attribute__ ((unused)),
600 			 const void *addr __attribute__ ((unused)),
601 			 int width __attribute__ ((unused)),
602 			 Dwarf_Off *val __attribute__ ((unused)))
603 {
604   return 0;
605 }
606 
607 static inline Elf_Data *
__libdw_checked_get_data(Dwarf * dbg,int sec_index)608 __libdw_checked_get_data (Dwarf *dbg, int sec_index)
609 {
610   Elf_Data *data = dbg->sectiondata[sec_index];
611   if (unlikely (data == NULL)
612       || unlikely (data->d_buf == NULL))
613     {
614       __libdw_seterrno (DWARF_E_INVALID_DWARF);
615       return NULL;
616     }
617   return data;
618 }
619 
620 static inline int
__libdw_offset_in_section(Dwarf * dbg,int sec_index,Dwarf_Off offset,size_t size)621 __libdw_offset_in_section (Dwarf *dbg, int sec_index,
622 			   Dwarf_Off offset, size_t size)
623 {
624   Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
625   if (data == NULL)
626     return -1;
627   if (unlikely (offset > data->d_size)
628       || unlikely (data->d_size - offset < size))
629     {
630       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
631       return -1;
632     }
633 
634   return 0;
635 }
636 
637 static inline bool
__libdw_in_section(Dwarf * dbg,int sec_index,const void * addr,size_t size)638 __libdw_in_section (Dwarf *dbg, int sec_index,
639 		    const void *addr, size_t size)
640 {
641   Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
642   if (data == NULL)
643     return false;
644   if (unlikely (addr < data->d_buf)
645       || unlikely (data->d_size - (addr - data->d_buf) < size))
646     {
647       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
648       return false;
649     }
650 
651   return true;
652 }
653 
654 #define READ_AND_RELOCATE(RELOC_HOOK, VAL)				\
655   ({									\
656     if (!__libdw_in_section (dbg, sec_index, addr, width))		\
657       return -1;							\
658 									\
659     const unsigned char *orig_addr = addr;				\
660     if (width == 4)							\
661       VAL = read_4ubyte_unaligned_inc (dbg, addr);			\
662     else								\
663       VAL = read_8ubyte_unaligned_inc (dbg, addr);			\
664 									\
665     int status = RELOC_HOOK (dbg, sec_index, orig_addr, width, &VAL);	\
666     if (status < 0)							\
667       return status;							\
668     status > 0;								\
669    })
670 
671 static inline int
__libdw_read_address_inc(Dwarf * dbg,int sec_index,const unsigned char ** addrp,int width,Dwarf_Addr * ret)672 __libdw_read_address_inc (Dwarf *dbg,
673 			  int sec_index, const unsigned char **addrp,
674 			  int width, Dwarf_Addr *ret)
675 {
676   const unsigned char *addr = *addrp;
677   READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
678   *addrp = addr;
679   return 0;
680 }
681 
682 static inline int
__libdw_read_address(Dwarf * dbg,int sec_index,const unsigned char * addr,int width,Dwarf_Addr * ret)683 __libdw_read_address (Dwarf *dbg,
684 		      int sec_index, const unsigned char *addr,
685 		      int width, Dwarf_Addr *ret)
686 {
687   READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
688   return 0;
689 }
690 
691 static inline int
__libdw_read_offset_inc(Dwarf * dbg,int sec_index,const unsigned char ** addrp,int width,Dwarf_Off * ret,int sec_ret,size_t size)692 __libdw_read_offset_inc (Dwarf *dbg,
693 			 int sec_index, const unsigned char **addrp,
694 			 int width, Dwarf_Off *ret, int sec_ret,
695 			 size_t size)
696 {
697   const unsigned char *addr = *addrp;
698   READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
699   *addrp = addr;
700   return __libdw_offset_in_section (dbg, sec_ret, *ret, size);
701 }
702 
703 static inline int
__libdw_read_offset(Dwarf * dbg,Dwarf * dbg_ret,int sec_index,const unsigned char * addr,int width,Dwarf_Off * ret,int sec_ret,size_t size)704 __libdw_read_offset (Dwarf *dbg, Dwarf *dbg_ret,
705 		     int sec_index, const unsigned char *addr,
706 		     int width, Dwarf_Off *ret, int sec_ret,
707 		     size_t size)
708 {
709   READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
710   return __libdw_offset_in_section (dbg_ret, sec_ret, *ret, size);
711 }
712 
713 static inline size_t
cu_sec_idx(struct Dwarf_CU * cu)714 cu_sec_idx (struct Dwarf_CU *cu)
715 {
716   return cu->type_offset == 0 ? IDX_debug_info : IDX_debug_types;
717 }
718 
719 static inline bool
is_cudie(Dwarf_Die * cudie)720 is_cudie (Dwarf_Die *cudie)
721 {
722   return CUDIE (cudie->cu).addr == cudie->addr;
723 }
724 
725 /* Read up begin/end pair and increment read pointer.
726     - If it's normal range record, set up *BEGINP and *ENDP and return 0.
727     - If it's base address selection record, set up *BASEP and return 1.
728     - If it's end of rangelist, don't set anything and return 2
729     - If an error occurs, don't set anything and return <0.  */
730 int __libdw_read_begin_end_pair_inc (Dwarf *dbg, int sec_index,
731 				     unsigned char **addr, int width,
732 				     Dwarf_Addr *beginp, Dwarf_Addr *endp,
733 				     Dwarf_Addr *basep)
734   internal_function;
735 
736 unsigned char * __libdw_formptr (Dwarf_Attribute *attr, int sec_index,
737 				 int err_nodata, unsigned char **endpp,
738 				 Dwarf_Off *offsetp)
739   internal_function;
740 
741 /* Fills in the given attribute to point at an empty location expression.  */
742 void __libdw_empty_loc_attr (Dwarf_Attribute *attr)
743   internal_function;
744 
745 /* Load .debug_line unit at DEBUG_LINE_OFFSET.  COMP_DIR is a value of
746    DW_AT_comp_dir or NULL if that attribute is not available.  Caches
747    the loaded unit and optionally set *LINESP and/or *FILESP (if not
748    NULL) with loaded information.  Returns 0 for success or a negative
749    value for failure.  */
750 int __libdw_getsrclines (Dwarf *dbg, Dwarf_Off debug_line_offset,
751 			 const char *comp_dir, unsigned address_size,
752 			 Dwarf_Lines **linesp, Dwarf_Files **filesp)
753   internal_function
754   __nonnull_attribute__ (1);
755 
756 /* Load and return value of DW_AT_comp_dir from CUDIE.  */
757 const char *__libdw_getcompdir (Dwarf_Die *cudie);
758 
759 
760 /* Aliases to avoid PLTs.  */
761 INTDECL (dwarf_aggregate_size)
762 INTDECL (dwarf_attr)
763 INTDECL (dwarf_attr_integrate)
764 INTDECL (dwarf_begin)
765 INTDECL (dwarf_begin_elf)
766 INTDECL (dwarf_child)
767 INTDECL (dwarf_dieoffset)
768 INTDECL (dwarf_diename)
769 INTDECL (dwarf_end)
770 INTDECL (dwarf_entrypc)
771 INTDECL (dwarf_errmsg)
772 INTDECL (dwarf_formaddr)
773 INTDECL (dwarf_formblock)
774 INTDECL (dwarf_formref_die)
775 INTDECL (dwarf_formsdata)
776 INTDECL (dwarf_formstring)
777 INTDECL (dwarf_formudata)
778 INTDECL (dwarf_getalt)
779 INTDECL (dwarf_getarange_addr)
780 INTDECL (dwarf_getarangeinfo)
781 INTDECL (dwarf_getaranges)
782 INTDECL (dwarf_getlocation_die)
783 INTDECL (dwarf_getsrcfiles)
784 INTDECL (dwarf_getsrclines)
785 INTDECL (dwarf_hasattr)
786 INTDECL (dwarf_haschildren)
787 INTDECL (dwarf_haspc)
788 INTDECL (dwarf_highpc)
789 INTDECL (dwarf_lowpc)
790 INTDECL (dwarf_nextcu)
791 INTDECL (dwarf_next_unit)
792 INTDECL (dwarf_offdie)
793 INTDECL (dwarf_peel_type)
794 INTDECL (dwarf_ranges)
795 INTDECL (dwarf_setalt)
796 INTDECL (dwarf_siblingof)
797 INTDECL (dwarf_srclang)
798 INTDECL (dwarf_tag)
799 
800 #endif	/* libdwP.h */
801