sysdeps/generic/unwind-pe.h

   1 /* Exception handling and frame unwind runtime interface routines.
   2    Copyright (C) 2001-2023 Free Software Foundation, Inc.
   3
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <https://www.gnu.org/licenses/>.  */
  19
  20 /* @@@ Really this should be out of line, but this also causes link
  21    compatibility problems with the base ABI.  This is slightly better
  22    than duplicating code, however.  */
  23
  24 /* If using C++, references to abort have to be qualified with std::.  */
  25 #ifdef __cplusplus
  26 #define __gxx_abort std::abort
  27 #else
  28 #define __gxx_abort abort
  29 #endif
  30
  31 /* Pointer encodings, from dwarf2.h.  */
  32 #define DW_EH_PE_absptr         0x00
  33 #define DW_EH_PE_omit           0xff
  34
  35 #define DW_EH_PE_uleb128        0x01
  36 #define DW_EH_PE_udata2         0x02
  37 #define DW_EH_PE_udata4         0x03
  38 #define DW_EH_PE_udata8         0x04
  39 #define DW_EH_PE_sleb128        0x09
  40 #define DW_EH_PE_sdata2         0x0A
  41 #define DW_EH_PE_sdata4         0x0B
  42 #define DW_EH_PE_sdata8         0x0C
  43 #define DW_EH_PE_signed         0x08
  44
  45 #define DW_EH_PE_pcrel          0x10
  46 #define DW_EH_PE_textrel        0x20
  47 #define DW_EH_PE_datarel        0x30
  48 #define DW_EH_PE_funcrel        0x40
  49 #define DW_EH_PE_aligned        0x50
  50
  51 #define DW_EH_PE_indirect       0x80
  52 \f
  53
  54 #if defined(_LIBC)
  55
  56 /* Prototypes.  */
  57 extern unsigned int size_of_encoded_value (unsigned char encoding)
  58   attribute_hidden;
  59
  60 extern const unsigned char *read_encoded_value_with_base
  61   (unsigned char encoding, _Unwind_Ptr base,
  62    const unsigned char *p, _Unwind_Ptr *val)
  63   attribute_hidden;
  64
  65 extern const unsigned char * read_encoded_value
  66   (struct _Unwind_Context *context, unsigned char encoding,
  67    const unsigned char *p, _Unwind_Ptr *val)
  68   attribute_hidden;
  69
  70 extern const unsigned char * read_uleb128 (const unsigned char *p,
  71                                            _Unwind_Word *val)
  72   attribute_hidden;
  73 extern const unsigned char * read_sleb128 (const unsigned char *p,
  74                                            _Unwind_Sword *val)
  75   attribute_hidden;
  76
  77 #endif
  78 #if defined(_LIBC) && defined(_LIBC_DEFINITIONS)
  79
  80 #ifdef _LIBC
  81 #define STATIC
  82 #else
  83 #define STATIC static
  84 #endif
  85
  86 /* Given an encoding, return the number of bytes the format occupies.
  87    This is only defined for fixed-size encodings, and so does not
  88    include leb128.  */
  89
  90 STATIC unsigned int
  91 size_of_encoded_value (unsigned char encoding)
  92 {
  93   if (encoding == DW_EH_PE_omit)
  94     return 0;
  95
  96   switch (encoding & 0x07)
  97     {
  98     case DW_EH_PE_absptr:
  99       return sizeof (void *);
 100     case DW_EH_PE_udata2:
 101       return 2;
 102     case DW_EH_PE_udata4:
 103       return 4;
 104     case DW_EH_PE_udata8:
 105       return 8;
 106     }
 107   __gxx_abort ();
 108 }
 109
 110 #ifndef NO_BASE_OF_ENCODED_VALUE
 111
 112 /* Given an encoding and an _Unwind_Context, return the base to which
 113    the encoding is relative.  This base may then be passed to
 114    read_encoded_value_with_base for use when the _Unwind_Context is
 115    not available.  */
 116
 117 STATIC _Unwind_Ptr
 118 base_of_encoded_value (unsigned char encoding, struct _Unwind_Context *context)
 119 {
 120   if (encoding == DW_EH_PE_omit)
 121     return 0;
 122
 123   switch (encoding & 0x70)
 124     {
 125     case DW_EH_PE_absptr:
 126     case DW_EH_PE_pcrel:
 127     case DW_EH_PE_aligned:
 128       return 0;
 129
 130     case DW_EH_PE_textrel:
 131       return _Unwind_GetTextRelBase (context);
 132     case DW_EH_PE_datarel:
 133       return _Unwind_GetDataRelBase (context);
 134     case DW_EH_PE_funcrel:
 135       return _Unwind_GetRegionStart (context);
 136     }
 137   __gxx_abort ();
 138 }
 139
 140 #endif
 141
 142 /* Read an unsigned leb128 value from P, store the value in VAL, return
 143    P incremented past the value.  We assume that a word is large enough to
 144    hold any value so encoded; if it is smaller than a pointer on some target,
 145    pointers should not be leb128 encoded on that target.  */
 146
 147 STATIC const unsigned char *
 148 read_uleb128 (const unsigned char *p, _Unwind_Word *val)
 149 {
 150   unsigned int shift = 0;
 151   unsigned char byte;
 152   _Unwind_Word result;
 153
 154   result = 0;
 155   do
 156     {
 157       byte = *p++;
 158       result |= (byte & 0x7f) << shift;
 159       shift += 7;
 160     }
 161   while (byte & 0x80);
 162
 163   *val = result;
 164   return p;
 165 }
 166
 167 /* Similar, but read a signed leb128 value.  */
 168
 169 STATIC const unsigned char *
 170 read_sleb128 (const unsigned char *p, _Unwind_Sword *val)
 171 {
 172   unsigned int shift = 0;
 173   unsigned char byte;
 174   _Unwind_Word result;
 175
 176   result = 0;
 177   do
 178     {
 179       byte = *p++;
 180       result |= (byte & 0x7f) << shift;
 181       shift += 7;
 182     }
 183   while (byte & 0x80);
 184
 185   /* Sign-extend a negative value.  */
 186   if (shift < 8 * sizeof (result) && (byte & 0x40) != 0)
 187     result |= -(1L << shift);
 188
 189   *val = (_Unwind_Sword) result;
 190   return p;
 191 }
 192
 193 /* Load an encoded value from memory at P.  The value is returned in VAL;
 194    The function returns P incremented past the value.  BASE is as given
 195    by base_of_encoded_value for this encoding in the appropriate context.  */
 196
 197 STATIC const unsigned char *
 198 read_encoded_value_with_base (unsigned char encoding, _Unwind_Ptr base,
 199                               const unsigned char *p, _Unwind_Ptr *val)
 200 {
 201   union unaligned
 202     {
 203       void *ptr;
 204       unsigned u2 __attribute__ ((mode (HI)));
 205       unsigned u4 __attribute__ ((mode (SI)));
 206       unsigned u8 __attribute__ ((mode (DI)));
 207       signed s2 __attribute__ ((mode (HI)));
 208       signed s4 __attribute__ ((mode (SI)));
 209       signed s8 __attribute__ ((mode (DI)));
 210     } __attribute__((__packed__));
 211
 212   union unaligned *u = (union unaligned *) p;
 213   _Unwind_Internal_Ptr result;
 214
 215   if (encoding == DW_EH_PE_aligned)
 216     {
 217       _Unwind_Internal_Ptr a = (_Unwind_Internal_Ptr) p;
 218       a = (a + sizeof (void *) - 1) & - sizeof (void *);
 219       result = *(_Unwind_Internal_Ptr *) a;
 220       p = (const unsigned char *) (a + sizeof (void *));
 221     }
 222   else
 223     {
 224       switch (encoding & 0x0f)
 225         {
 226         case DW_EH_PE_absptr:
 227           result = (_Unwind_Internal_Ptr) u->ptr;
 228           p += sizeof (void *);
 229           break;
 230
 231         case DW_EH_PE_uleb128:
 232           {
 233             _Unwind_Word tmp;
 234             p = read_uleb128 (p, &tmp);
 235             result = (_Unwind_Internal_Ptr) tmp;
 236           }
 237           break;
 238
 239         case DW_EH_PE_sleb128:
 240           {
 241             _Unwind_Sword tmp;
 242             p = read_sleb128 (p, &tmp);
 243             result = (_Unwind_Internal_Ptr) tmp;
 244           }
 245           break;
 246
 247         case DW_EH_PE_udata2:
 248           result = u->u2;
 249           p += 2;
 250           break;
 251         case DW_EH_PE_udata4:
 252           result = u->u4;
 253           p += 4;
 254           break;
 255         case DW_EH_PE_udata8:
 256           result = u->u8;
 257           p += 8;
 258           break;
 259
 260         case DW_EH_PE_sdata2:
 261           result = u->s2;
 262           p += 2;
 263           break;
 264         case DW_EH_PE_sdata4:
 265           result = u->s4;
 266           p += 4;
 267           break;
 268         case DW_EH_PE_sdata8:
 269           result = u->s8;
 270           p += 8;
 271           break;
 272
 273         default:
 274           __gxx_abort ();
 275         }
 276
 277       if (result != 0)
 278         {
 279           result += ((encoding & 0x70) == DW_EH_PE_pcrel
 280                      ? (_Unwind_Internal_Ptr) u : base);
 281           if (encoding & DW_EH_PE_indirect)
 282             result = *(_Unwind_Internal_Ptr *) result;
 283         }
 284     }
 285
 286   *val = result;
 287   return p;
 288 }
 289
 290 #ifndef NO_BASE_OF_ENCODED_VALUE
 291
 292 /* Like read_encoded_value_with_base, but get the base from the context
 293    rather than providing it directly.  */
 294
 295 STATIC const unsigned char *
 296 read_encoded_value (struct _Unwind_Context *context, unsigned char encoding,
 297                     const unsigned char *p, _Unwind_Ptr *val)
 298 {
 299   return read_encoded_value_with_base (encoding,
 300                 base_of_encoded_value (encoding, context),
 301                 p, val);
 302 }
 303
 304 #endif
 305 #endif /* _LIBC */