1 //===--------------------------- DwarfParser.hpp --------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //
9 //  Parses DWARF CFIs (FDEs and CIEs).
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef __DWARF_PARSER_HPP__
14 #define __DWARF_PARSER_HPP__
15 
16 #include <inttypes.h>
17 #include <stdint.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 
21 #include "libunwind.h"
22 #include "dwarf2.h"
23 #include "Registers.hpp"
24 
25 #include "config.h"
26 
27 namespace libunwind {
28 
29 /// CFI_Parser does basic parsing of a CFI (Call Frame Information) records.
30 /// See DWARF Spec for details:
31 ///    http://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
32 ///
33 template <typename A>
34 class CFI_Parser {
35 public:
36   typedef typename A::pint_t pint_t;
37 
38   /// Information encoded in a CIE (Common Information Entry)
39   struct CIE_Info {
40     pint_t    cieStart;
41     pint_t    cieLength;
42     pint_t    cieInstructions;
43     uint8_t   pointerEncoding;
44     uint8_t   lsdaEncoding;
45     uint8_t   personalityEncoding;
46     uint8_t   personalityOffsetInCIE;
47     pint_t    personality;
48     uint32_t  codeAlignFactor;
49     int       dataAlignFactor;
50     bool      isSignalFrame;
51     bool      fdesHaveAugmentationData;
52     uint8_t   returnAddressRegister;
53 #if defined(_LIBUNWIND_TARGET_AARCH64)
54     bool      addressesSignedWithBKey;
55 #endif
56   };
57 
58   /// Information about an FDE (Frame Description Entry)
59   struct FDE_Info {
60     pint_t  fdeStart;
61     pint_t  fdeLength;
62     pint_t  fdeInstructions;
63     pint_t  pcStart;
64     pint_t  pcEnd;
65     pint_t  lsda;
66   };
67 
68   enum {
69     kMaxRegisterNumber = _LIBUNWIND_HIGHEST_DWARF_REGISTER
70   };
71   enum RegisterSavedWhere {
72     kRegisterUnused,
73     kRegisterInCFA,
74     kRegisterOffsetFromCFA,
75     kRegisterInRegister,
76     kRegisterAtExpression,
77     kRegisterIsExpression
78   };
79   struct RegisterLocation {
80     RegisterSavedWhere location;
81     int64_t value;
82   };
83   /// Information about a frame layout and registers saved determined
84   /// by "running" the DWARF FDE "instructions"
85   struct PrologInfo {
86     uint32_t          cfaRegister;
87     int32_t           cfaRegisterOffset;  // CFA = (cfaRegister)+cfaRegisterOffset
88     int64_t           cfaExpression;      // CFA = expression
89     uint32_t          spExtraArgSize;
90     uint32_t          codeOffsetAtStackDecrement;
91     bool              registersInOtherRegisters;
92     bool              sameValueUsed;
93     RegisterLocation  savedRegisters[kMaxRegisterNumber + 1];
94   };
95 
96   struct PrologInfoStackEntry {
97     PrologInfoStackEntry(PrologInfoStackEntry *n, const PrologInfo &i)
98         : next(n), info(i) {}
99     PrologInfoStackEntry *next;
100     PrologInfo info;
101   };
102 
103   static bool findFDE(A &addressSpace, pint_t pc, pint_t ehSectionStart,
104                       uint32_t sectionLength, pint_t fdeHint, FDE_Info *fdeInfo,
105                       CIE_Info *cieInfo);
106   static const char *decodeFDE(A &addressSpace, pint_t fdeStart,
107                                FDE_Info *fdeInfo, CIE_Info *cieInfo);
108   static bool parseFDEInstructions(A &addressSpace, const FDE_Info &fdeInfo,
109                                    const CIE_Info &cieInfo, pint_t upToPC,
110                                    int arch, PrologInfo *results);
111 
112   static const char *parseCIE(A &addressSpace, pint_t cie, CIE_Info *cieInfo);
113 
114 private:
115   static bool parseInstructions(A &addressSpace, pint_t instructions,
116                                 pint_t instructionsEnd, const CIE_Info &cieInfo,
117                                 pint_t pcoffset,
118                                 PrologInfoStackEntry *&rememberStack, int arch,
119                                 PrologInfo *results);
120 };
121 
122 /// Parse a FDE into a CIE_Info and an FDE_Info
123 template <typename A>
124 const char *CFI_Parser<A>::decodeFDE(A &addressSpace, pint_t fdeStart,
125                                      FDE_Info *fdeInfo, CIE_Info *cieInfo) {
126   pint_t p = fdeStart;
127   pint_t cfiLength = (pint_t)addressSpace.get32(p);
128   p += 4;
129   if (cfiLength == 0xffffffff) {
130     // 0xffffffff means length is really next 8 bytes
131     cfiLength = (pint_t)addressSpace.get64(p);
132     p += 8;
133   }
134   if (cfiLength == 0)
135     return "FDE has zero length"; // end marker
136   uint32_t ciePointer = addressSpace.get32(p);
137   if (ciePointer == 0)
138     return "FDE is really a CIE"; // this is a CIE not an FDE
139   pint_t nextCFI = p + cfiLength;
140   pint_t cieStart = p - ciePointer;
141   const char *err = parseCIE(addressSpace, cieStart, cieInfo);
142   if (err != NULL)
143     return err;
144   p += 4;
145   // Parse pc begin and range.
146   pint_t pcStart =
147       addressSpace.getEncodedP(p, nextCFI, cieInfo->pointerEncoding);
148   pint_t pcRange =
149       addressSpace.getEncodedP(p, nextCFI, cieInfo->pointerEncoding & 0x0F);
150   // Parse rest of info.
151   fdeInfo->lsda = 0;
152   // Check for augmentation length.
153   if (cieInfo->fdesHaveAugmentationData) {
154     pint_t augLen = (pint_t)addressSpace.getULEB128(p, nextCFI);
155     pint_t endOfAug = p + augLen;
156     if (cieInfo->lsdaEncoding != DW_EH_PE_omit) {
157       // Peek at value (without indirection).  Zero means no LSDA.
158       pint_t lsdaStart = p;
159       if (addressSpace.getEncodedP(p, nextCFI, cieInfo->lsdaEncoding & 0x0F) !=
160           0) {
161         // Reset pointer and re-parse LSDA address.
162         p = lsdaStart;
163         fdeInfo->lsda =
164             addressSpace.getEncodedP(p, nextCFI, cieInfo->lsdaEncoding);
165       }
166     }
167     p = endOfAug;
168   }
169   fdeInfo->fdeStart = fdeStart;
170   fdeInfo->fdeLength = nextCFI - fdeStart;
171   fdeInfo->fdeInstructions = p;
172   fdeInfo->pcStart = pcStart;
173   fdeInfo->pcEnd = pcStart + pcRange;
174   return NULL; // success
175 }
176 
177 /// Scan an eh_frame section to find an FDE for a pc
178 template <typename A>
179 bool CFI_Parser<A>::findFDE(A &addressSpace, pint_t pc, pint_t ehSectionStart,
180                             uint32_t sectionLength, pint_t fdeHint,
181                             FDE_Info *fdeInfo, CIE_Info *cieInfo) {
182   //fprintf(stderr, "findFDE(0x%llX)\n", (long long)pc);
183   pint_t p = (fdeHint != 0) ? fdeHint : ehSectionStart;
184   const pint_t ehSectionEnd = p + sectionLength;
185   while (p < ehSectionEnd) {
186     pint_t currentCFI = p;
187     //fprintf(stderr, "findFDE() CFI at 0x%llX\n", (long long)p);
188     pint_t cfiLength = addressSpace.get32(p);
189     p += 4;
190     if (cfiLength == 0xffffffff) {
191       // 0xffffffff means length is really next 8 bytes
192       cfiLength = (pint_t)addressSpace.get64(p);
193       p += 8;
194     }
195     if (cfiLength == 0)
196       return false; // end marker
197     uint32_t id = addressSpace.get32(p);
198     if (id == 0) {
199       // Skip over CIEs.
200       p += cfiLength;
201     } else {
202       // Process FDE to see if it covers pc.
203       pint_t nextCFI = p + cfiLength;
204       uint32_t ciePointer = addressSpace.get32(p);
205       pint_t cieStart = p - ciePointer;
206       // Validate pointer to CIE is within section.
207       if ((ehSectionStart <= cieStart) && (cieStart < ehSectionEnd)) {
208         if (parseCIE(addressSpace, cieStart, cieInfo) == NULL) {
209           p += 4;
210           // Parse pc begin and range.
211           pint_t pcStart =
212               addressSpace.getEncodedP(p, nextCFI, cieInfo->pointerEncoding);
213           pint_t pcRange = addressSpace.getEncodedP(
214               p, nextCFI, cieInfo->pointerEncoding & 0x0F);
215           // Test if pc is within the function this FDE covers.
216           if ((pcStart < pc) && (pc <= pcStart + pcRange)) {
217             // parse rest of info
218             fdeInfo->lsda = 0;
219             // check for augmentation length
220             if (cieInfo->fdesHaveAugmentationData) {
221               pint_t augLen = (pint_t)addressSpace.getULEB128(p, nextCFI);
222               pint_t endOfAug = p + augLen;
223               if (cieInfo->lsdaEncoding != DW_EH_PE_omit) {
224                 // Peek at value (without indirection).  Zero means no LSDA.
225                 pint_t lsdaStart = p;
226                 if (addressSpace.getEncodedP(
227                         p, nextCFI, cieInfo->lsdaEncoding & 0x0F) != 0) {
228                   // Reset pointer and re-parse LSDA address.
229                   p = lsdaStart;
230                   fdeInfo->lsda = addressSpace
231                       .getEncodedP(p, nextCFI, cieInfo->lsdaEncoding);
232                 }
233               }
234               p = endOfAug;
235             }
236             fdeInfo->fdeStart = currentCFI;
237             fdeInfo->fdeLength = nextCFI - currentCFI;
238             fdeInfo->fdeInstructions = p;
239             fdeInfo->pcStart = pcStart;
240             fdeInfo->pcEnd = pcStart + pcRange;
241             return true;
242           } else {
243             // pc is not in begin/range, skip this FDE
244           }
245         } else {
246           // Malformed CIE, now augmentation describing pc range encoding.
247         }
248       } else {
249         // malformed FDE.  CIE is bad
250       }
251       p = nextCFI;
252     }
253   }
254   return false;
255 }
256 
257 /// Extract info from a CIE
258 template <typename A>
259 const char *CFI_Parser<A>::parseCIE(A &addressSpace, pint_t cie,
260                                     CIE_Info *cieInfo) {
261   cieInfo->pointerEncoding = 0;
262   cieInfo->lsdaEncoding = DW_EH_PE_omit;
263   cieInfo->personalityEncoding = 0;
264   cieInfo->personalityOffsetInCIE = 0;
265   cieInfo->personality = 0;
266   cieInfo->codeAlignFactor = 0;
267   cieInfo->dataAlignFactor = 0;
268   cieInfo->isSignalFrame = false;
269   cieInfo->fdesHaveAugmentationData = false;
270 #if defined(_LIBUNWIND_TARGET_AARCH64)
271   cieInfo->addressesSignedWithBKey = false;
272 #endif
273   cieInfo->cieStart = cie;
274   pint_t p = cie;
275   pint_t cieLength = (pint_t)addressSpace.get32(p);
276   p += 4;
277   pint_t cieContentEnd = p + cieLength;
278   if (cieLength == 0xffffffff) {
279     // 0xffffffff means length is really next 8 bytes
280     cieLength = (pint_t)addressSpace.get64(p);
281     p += 8;
282     cieContentEnd = p + cieLength;
283   }
284   if (cieLength == 0)
285     return NULL;
286   // CIE ID is always 0
287   if (addressSpace.get32(p) != 0)
288     return "CIE ID is not zero";
289   p += 4;
290   // Version is always 1 or 3
291   uint8_t version = addressSpace.get8(p);
292   if ((version != 1) && (version != 3))
293     return "CIE version is not 1 or 3";
294   ++p;
295   // save start of augmentation string and find end
296   pint_t strStart = p;
297   while (addressSpace.get8(p) != 0)
298     ++p;
299   ++p;
300   // parse code aligment factor
301   cieInfo->codeAlignFactor = (uint32_t)addressSpace.getULEB128(p, cieContentEnd);
302   // parse data alignment factor
303   cieInfo->dataAlignFactor = (int)addressSpace.getSLEB128(p, cieContentEnd);
304   // parse return address register
305   uint64_t raReg = addressSpace.getULEB128(p, cieContentEnd);
306   assert(raReg < 255 && "return address register too large");
307   cieInfo->returnAddressRegister = (uint8_t)raReg;
308   // parse augmentation data based on augmentation string
309   const char *result = NULL;
310   if (addressSpace.get8(strStart) == 'z') {
311     // parse augmentation data length
312     addressSpace.getULEB128(p, cieContentEnd);
313     for (pint_t s = strStart; addressSpace.get8(s) != '\0'; ++s) {
314       switch (addressSpace.get8(s)) {
315       case 'z':
316         cieInfo->fdesHaveAugmentationData = true;
317         break;
318       case 'P':
319         cieInfo->personalityEncoding = addressSpace.get8(p);
320         ++p;
321         cieInfo->personalityOffsetInCIE = (uint8_t)(p - cie);
322         cieInfo->personality = addressSpace
323             .getEncodedP(p, cieContentEnd, cieInfo->personalityEncoding);
324         break;
325       case 'L':
326         cieInfo->lsdaEncoding = addressSpace.get8(p);
327         ++p;
328         break;
329       case 'R':
330         cieInfo->pointerEncoding = addressSpace.get8(p);
331         ++p;
332         break;
333       case 'S':
334         cieInfo->isSignalFrame = true;
335         break;
336 #if defined(_LIBUNWIND_TARGET_AARCH64)
337       case 'B':
338         cieInfo->addressesSignedWithBKey = true;
339         break;
340 #endif
341       default:
342         // ignore unknown letters
343         break;
344       }
345     }
346   }
347   cieInfo->cieLength = cieContentEnd - cieInfo->cieStart;
348   cieInfo->cieInstructions = p;
349   return result;
350 }
351 
352 
353 /// "run" the DWARF instructions and create the abstact PrologInfo for an FDE
354 template <typename A>
355 bool CFI_Parser<A>::parseFDEInstructions(A &addressSpace,
356                                          const FDE_Info &fdeInfo,
357                                          const CIE_Info &cieInfo, pint_t upToPC,
358                                          int arch, PrologInfo *results) {
359   // clear results
360   memset(results, '\0', sizeof(PrologInfo));
361   PrologInfoStackEntry *rememberStack = NULL;
362 
363   // parse CIE then FDE instructions
364   return parseInstructions(addressSpace, cieInfo.cieInstructions,
365                            cieInfo.cieStart + cieInfo.cieLength, cieInfo,
366                            (pint_t)(-1), rememberStack, arch, results) &&
367          parseInstructions(addressSpace, fdeInfo.fdeInstructions,
368                            fdeInfo.fdeStart + fdeInfo.fdeLength, cieInfo,
369                            upToPC - fdeInfo.pcStart, rememberStack, arch,
370                            results);
371 }
372 
373 /// "run" the DWARF instructions
374 template <typename A>
375 bool CFI_Parser<A>::parseInstructions(A &addressSpace, pint_t instructions,
376                                       pint_t instructionsEnd,
377                                       const CIE_Info &cieInfo, pint_t pcoffset,
378                                       PrologInfoStackEntry *&rememberStack,
379                                       int arch, PrologInfo *results) {
380   pint_t p = instructions;
381   pint_t codeOffset = 0;
382   PrologInfo initialState = *results;
383 
384   _LIBUNWIND_TRACE_DWARF("parseInstructions(instructions=0x%0" PRIx64 ")\n",
385                          static_cast<uint64_t>(instructionsEnd));
386 
387   // see DWARF Spec, section 6.4.2 for details on unwind opcodes
388   while ((p < instructionsEnd) && (codeOffset < pcoffset)) {
389     uint64_t reg;
390     uint64_t reg2;
391     int64_t offset;
392     uint64_t length;
393     uint8_t opcode = addressSpace.get8(p);
394     uint8_t operand;
395 #if !defined(_LIBUNWIND_NO_HEAP)
396     PrologInfoStackEntry *entry;
397 #endif
398     ++p;
399     switch (opcode) {
400     case DW_CFA_nop:
401       _LIBUNWIND_TRACE_DWARF("DW_CFA_nop\n");
402       break;
403     case DW_CFA_set_loc:
404       codeOffset =
405           addressSpace.getEncodedP(p, instructionsEnd, cieInfo.pointerEncoding);
406       _LIBUNWIND_TRACE_DWARF("DW_CFA_set_loc\n");
407       break;
408     case DW_CFA_advance_loc1:
409       codeOffset += (addressSpace.get8(p) * cieInfo.codeAlignFactor);
410       p += 1;
411       _LIBUNWIND_TRACE_DWARF("DW_CFA_advance_loc1: new offset=%" PRIu64 "\n",
412                              static_cast<uint64_t>(codeOffset));
413       break;
414     case DW_CFA_advance_loc2:
415       codeOffset += (addressSpace.get16(p) * cieInfo.codeAlignFactor);
416       p += 2;
417       _LIBUNWIND_TRACE_DWARF("DW_CFA_advance_loc2: new offset=%" PRIu64 "\n",
418                              static_cast<uint64_t>(codeOffset));
419       break;
420     case DW_CFA_advance_loc4:
421       codeOffset += (addressSpace.get32(p) * cieInfo.codeAlignFactor);
422       p += 4;
423       _LIBUNWIND_TRACE_DWARF("DW_CFA_advance_loc4: new offset=%" PRIu64 "\n",
424                              static_cast<uint64_t>(codeOffset));
425       break;
426     case DW_CFA_offset_extended:
427       reg = addressSpace.getULEB128(p, instructionsEnd);
428       offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd)
429                                                   * cieInfo.dataAlignFactor;
430       if (reg > kMaxRegisterNumber) {
431         _LIBUNWIND_LOG0(
432                 "malformed DW_CFA_offset_extended DWARF unwind, reg too big");
433         return false;
434       }
435       results->savedRegisters[reg].location = kRegisterInCFA;
436       results->savedRegisters[reg].value = offset;
437       _LIBUNWIND_TRACE_DWARF("DW_CFA_offset_extended(reg=%" PRIu64 ", "
438                              "offset=%" PRId64 ")\n",
439                              reg, offset);
440       break;
441     case DW_CFA_restore_extended:
442       reg = addressSpace.getULEB128(p, instructionsEnd);
443       if (reg > kMaxRegisterNumber) {
444         _LIBUNWIND_LOG0(
445             "malformed DW_CFA_restore_extended DWARF unwind, reg too big");
446         return false;
447       }
448       results->savedRegisters[reg] = initialState.savedRegisters[reg];
449       _LIBUNWIND_TRACE_DWARF("DW_CFA_restore_extended(reg=%" PRIu64 ")\n", reg);
450       break;
451     case DW_CFA_undefined:
452       reg = addressSpace.getULEB128(p, instructionsEnd);
453       if (reg > kMaxRegisterNumber) {
454         _LIBUNWIND_LOG0(
455                 "malformed DW_CFA_undefined DWARF unwind, reg too big");
456         return false;
457       }
458       results->savedRegisters[reg].location = kRegisterUnused;
459       _LIBUNWIND_TRACE_DWARF("DW_CFA_undefined(reg=%" PRIu64 ")\n", reg);
460       break;
461     case DW_CFA_same_value:
462       reg = addressSpace.getULEB128(p, instructionsEnd);
463       if (reg > kMaxRegisterNumber) {
464         _LIBUNWIND_LOG0(
465                 "malformed DW_CFA_same_value DWARF unwind, reg too big");
466         return false;
467       }
468       // <rdar://problem/8456377> DW_CFA_same_value unsupported
469       // "same value" means register was stored in frame, but its current
470       // value has not changed, so no need to restore from frame.
471       // We model this as if the register was never saved.
472       results->savedRegisters[reg].location = kRegisterUnused;
473       // set flag to disable conversion to compact unwind
474       results->sameValueUsed = true;
475       _LIBUNWIND_TRACE_DWARF("DW_CFA_same_value(reg=%" PRIu64 ")\n", reg);
476       break;
477     case DW_CFA_register:
478       reg = addressSpace.getULEB128(p, instructionsEnd);
479       reg2 = addressSpace.getULEB128(p, instructionsEnd);
480       if (reg > kMaxRegisterNumber) {
481         _LIBUNWIND_LOG0(
482                 "malformed DW_CFA_register DWARF unwind, reg too big");
483         return false;
484       }
485       if (reg2 > kMaxRegisterNumber) {
486         _LIBUNWIND_LOG0(
487                 "malformed DW_CFA_register DWARF unwind, reg2 too big");
488         return false;
489       }
490       results->savedRegisters[reg].location = kRegisterInRegister;
491       results->savedRegisters[reg].value = (int64_t)reg2;
492       // set flag to disable conversion to compact unwind
493       results->registersInOtherRegisters = true;
494       _LIBUNWIND_TRACE_DWARF(
495           "DW_CFA_register(reg=%" PRIu64 ", reg2=%" PRIu64 ")\n", reg, reg2);
496       break;
497 #if !defined(_LIBUNWIND_NO_HEAP)
498     case DW_CFA_remember_state:
499       // avoid operator new, because that would be an upward dependency
500       entry = (PrologInfoStackEntry *)malloc(sizeof(PrologInfoStackEntry));
501       if (entry != NULL) {
502         entry->next = rememberStack;
503         entry->info = *results;
504         rememberStack = entry;
505       } else {
506         return false;
507       }
508       _LIBUNWIND_TRACE_DWARF("DW_CFA_remember_state\n");
509       break;
510     case DW_CFA_restore_state:
511       if (rememberStack != NULL) {
512         PrologInfoStackEntry *top = rememberStack;
513         *results = top->info;
514         rememberStack = top->next;
515         free((char *)top);
516       } else {
517         return false;
518       }
519       _LIBUNWIND_TRACE_DWARF("DW_CFA_restore_state\n");
520       break;
521 #endif
522     case DW_CFA_def_cfa:
523       reg = addressSpace.getULEB128(p, instructionsEnd);
524       offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd);
525       if (reg > kMaxRegisterNumber) {
526         _LIBUNWIND_LOG0("malformed DW_CFA_def_cfa DWARF unwind, reg too big");
527         return false;
528       }
529       results->cfaRegister = (uint32_t)reg;
530       results->cfaRegisterOffset = (int32_t)offset;
531       _LIBUNWIND_TRACE_DWARF(
532           "DW_CFA_def_cfa(reg=%" PRIu64 ", offset=%" PRIu64 ")\n", reg, offset);
533       break;
534     case DW_CFA_def_cfa_register:
535       reg = addressSpace.getULEB128(p, instructionsEnd);
536       if (reg > kMaxRegisterNumber) {
537         _LIBUNWIND_LOG0(
538             "malformed DW_CFA_def_cfa_register DWARF unwind, reg too big");
539         return false;
540       }
541       results->cfaRegister = (uint32_t)reg;
542       _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_register(%" PRIu64 ")\n", reg);
543       break;
544     case DW_CFA_def_cfa_offset:
545       results->cfaRegisterOffset = (int32_t)
546                                   addressSpace.getULEB128(p, instructionsEnd);
547       results->codeOffsetAtStackDecrement = (uint32_t)codeOffset;
548       _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_offset(%d)\n",
549                              results->cfaRegisterOffset);
550       break;
551     case DW_CFA_def_cfa_expression:
552       results->cfaRegister = 0;
553       results->cfaExpression = (int64_t)p;
554       length = addressSpace.getULEB128(p, instructionsEnd);
555       assert(length < static_cast<pint_t>(~0) && "pointer overflow");
556       p += static_cast<pint_t>(length);
557       _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_expression(expression=0x%" PRIx64
558                              ", length=%" PRIu64 ")\n",
559                              results->cfaExpression, length);
560       break;
561     case DW_CFA_expression:
562       reg = addressSpace.getULEB128(p, instructionsEnd);
563       if (reg > kMaxRegisterNumber) {
564         _LIBUNWIND_LOG0(
565                 "malformed DW_CFA_expression DWARF unwind, reg too big");
566         return false;
567       }
568       results->savedRegisters[reg].location = kRegisterAtExpression;
569       results->savedRegisters[reg].value = (int64_t)p;
570       length = addressSpace.getULEB128(p, instructionsEnd);
571       assert(length < static_cast<pint_t>(~0) && "pointer overflow");
572       p += static_cast<pint_t>(length);
573       _LIBUNWIND_TRACE_DWARF("DW_CFA_expression(reg=%" PRIu64 ", "
574                              "expression=0x%" PRIx64 ", "
575                              "length=%" PRIu64 ")\n",
576                              reg, results->savedRegisters[reg].value, length);
577       break;
578     case DW_CFA_offset_extended_sf:
579       reg = addressSpace.getULEB128(p, instructionsEnd);
580       if (reg > kMaxRegisterNumber) {
581         _LIBUNWIND_LOG0(
582             "malformed DW_CFA_offset_extended_sf DWARF unwind, reg too big");
583         return false;
584       }
585       offset =
586           addressSpace.getSLEB128(p, instructionsEnd) * cieInfo.dataAlignFactor;
587       results->savedRegisters[reg].location = kRegisterInCFA;
588       results->savedRegisters[reg].value = offset;
589       _LIBUNWIND_TRACE_DWARF("DW_CFA_offset_extended_sf(reg=%" PRIu64 ", "
590                              "offset=%" PRId64 ")\n",
591                              reg, offset);
592       break;
593     case DW_CFA_def_cfa_sf:
594       reg = addressSpace.getULEB128(p, instructionsEnd);
595       offset =
596           addressSpace.getSLEB128(p, instructionsEnd) * cieInfo.dataAlignFactor;
597       if (reg > kMaxRegisterNumber) {
598         _LIBUNWIND_LOG0(
599                 "malformed DW_CFA_def_cfa_sf DWARF unwind, reg too big");
600         return false;
601       }
602       results->cfaRegister = (uint32_t)reg;
603       results->cfaRegisterOffset = (int32_t)offset;
604       _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_sf(reg=%" PRIu64 ", "
605                              "offset=%" PRId64 ")\n",
606                              reg, offset);
607       break;
608     case DW_CFA_def_cfa_offset_sf:
609       results->cfaRegisterOffset = (int32_t)
610         (addressSpace.getSLEB128(p, instructionsEnd) * cieInfo.dataAlignFactor);
611       results->codeOffsetAtStackDecrement = (uint32_t)codeOffset;
612       _LIBUNWIND_TRACE_DWARF("DW_CFA_def_cfa_offset_sf(%d)\n",
613                              results->cfaRegisterOffset);
614       break;
615     case DW_CFA_val_offset:
616       reg = addressSpace.getULEB128(p, instructionsEnd);
617       if (reg > kMaxRegisterNumber) {
618         _LIBUNWIND_LOG(
619                 "malformed DW_CFA_val_offset DWARF unwind, reg (%" PRIu64
620                 ") out of range\n",
621                 reg);
622         return false;
623       }
624       offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd)
625                                                     * cieInfo.dataAlignFactor;
626       results->savedRegisters[reg].location = kRegisterOffsetFromCFA;
627       results->savedRegisters[reg].value = offset;
628       _LIBUNWIND_TRACE_DWARF("DW_CFA_val_offset(reg=%" PRIu64 ", "
629                              "offset=%" PRId64 "\n",
630                              reg, offset);
631       break;
632     case DW_CFA_val_offset_sf:
633       reg = addressSpace.getULEB128(p, instructionsEnd);
634       if (reg > kMaxRegisterNumber) {
635         _LIBUNWIND_LOG0(
636                 "malformed DW_CFA_val_offset_sf DWARF unwind, reg too big");
637         return false;
638       }
639       offset =
640           addressSpace.getSLEB128(p, instructionsEnd) * cieInfo.dataAlignFactor;
641       results->savedRegisters[reg].location = kRegisterOffsetFromCFA;
642       results->savedRegisters[reg].value = offset;
643       _LIBUNWIND_TRACE_DWARF("DW_CFA_val_offset_sf(reg=%" PRIu64 ", "
644                              "offset=%" PRId64 "\n",
645                              reg, offset);
646       break;
647     case DW_CFA_val_expression:
648       reg = addressSpace.getULEB128(p, instructionsEnd);
649       if (reg > kMaxRegisterNumber) {
650         _LIBUNWIND_LOG0(
651                 "malformed DW_CFA_val_expression DWARF unwind, reg too big");
652         return false;
653       }
654       results->savedRegisters[reg].location = kRegisterIsExpression;
655       results->savedRegisters[reg].value = (int64_t)p;
656       length = addressSpace.getULEB128(p, instructionsEnd);
657       assert(length < static_cast<pint_t>(~0) && "pointer overflow");
658       p += static_cast<pint_t>(length);
659       _LIBUNWIND_TRACE_DWARF("DW_CFA_val_expression(reg=%" PRIu64 ", "
660                              "expression=0x%" PRIx64 ", length=%" PRIu64 ")\n",
661                              reg, results->savedRegisters[reg].value, length);
662       break;
663     case DW_CFA_GNU_args_size:
664       length = addressSpace.getULEB128(p, instructionsEnd);
665       results->spExtraArgSize = (uint32_t)length;
666       _LIBUNWIND_TRACE_DWARF("DW_CFA_GNU_args_size(%" PRIu64 ")\n", length);
667       break;
668     case DW_CFA_GNU_negative_offset_extended:
669       reg = addressSpace.getULEB128(p, instructionsEnd);
670       if (reg > kMaxRegisterNumber) {
671         _LIBUNWIND_LOG0("malformed DW_CFA_GNU_negative_offset_extended DWARF "
672                         "unwind, reg too big");
673         return false;
674       }
675       offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd)
676                                                     * cieInfo.dataAlignFactor;
677       results->savedRegisters[reg].location = kRegisterInCFA;
678       results->savedRegisters[reg].value = -offset;
679       _LIBUNWIND_TRACE_DWARF(
680           "DW_CFA_GNU_negative_offset_extended(%" PRId64 ")\n", offset);
681       break;
682 
683 #if defined(_LIBUNWIND_TARGET_AARCH64) || defined(_LIBUNWIND_TARGET_SPARC)
684     // The same constant is used to represent different instructions on
685     // AArch64 (negate_ra_state) and SPARC (window_save).
686     static_assert(DW_CFA_AARCH64_negate_ra_state == DW_CFA_GNU_window_save,
687                   "uses the same constant");
688     case DW_CFA_AARCH64_negate_ra_state:
689       switch (arch) {
690 #if defined(_LIBUNWIND_TARGET_AARCH64)
691       case REGISTERS_ARM64:
692         results->savedRegisters[UNW_ARM64_RA_SIGN_STATE].value ^= 0x1;
693         _LIBUNWIND_TRACE_DWARF("DW_CFA_AARCH64_negate_ra_state\n");
694         break;
695 #endif
696 #if defined(_LIBUNWIND_TARGET_SPARC)
697       // case DW_CFA_GNU_window_save:
698       case REGISTERS_SPARC:
699         _LIBUNWIND_TRACE_DWARF("DW_CFA_GNU_window_save()\n");
700         for (reg = UNW_SPARC_O0; reg <= UNW_SPARC_O7; reg++) {
701           results->savedRegisters[reg].location = kRegisterInRegister;
702           results->savedRegisters[reg].value =
703               ((int64_t)reg - UNW_SPARC_O0) + UNW_SPARC_I0;
704         }
705 
706         for (reg = UNW_SPARC_L0; reg <= UNW_SPARC_I7; reg++) {
707           results->savedRegisters[reg].location = kRegisterInCFA;
708           results->savedRegisters[reg].value =
709               ((int64_t)reg - UNW_SPARC_L0) * 4;
710         }
711         break;
712 #endif
713       }
714       break;
715 #else
716       (void)arch;
717 #endif
718 
719     default:
720       operand = opcode & 0x3F;
721       switch (opcode & 0xC0) {
722       case DW_CFA_offset:
723         reg = operand;
724         if (reg > kMaxRegisterNumber) {
725           _LIBUNWIND_LOG("malformed DW_CFA_offset DWARF unwind, reg (%" PRIu64
726                          ") out of range",
727                   reg);
728           return false;
729         }
730         offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd)
731                                                     * cieInfo.dataAlignFactor;
732         results->savedRegisters[reg].location = kRegisterInCFA;
733         results->savedRegisters[reg].value = offset;
734         _LIBUNWIND_TRACE_DWARF("DW_CFA_offset(reg=%d, offset=%" PRId64 ")\n",
735                                operand, offset);
736         break;
737       case DW_CFA_advance_loc:
738         codeOffset += operand * cieInfo.codeAlignFactor;
739         _LIBUNWIND_TRACE_DWARF("DW_CFA_advance_loc: new offset=%" PRIu64 "\n",
740                                static_cast<uint64_t>(codeOffset));
741         break;
742       case DW_CFA_restore:
743         reg = operand;
744         if (reg > kMaxRegisterNumber) {
745           _LIBUNWIND_LOG("malformed DW_CFA_restore DWARF unwind, reg (%" PRIu64
746                          ") out of range",
747                   reg);
748           return false;
749         }
750         results->savedRegisters[reg] = initialState.savedRegisters[reg];
751         _LIBUNWIND_TRACE_DWARF("DW_CFA_restore(reg=%" PRIu64 ")\n",
752                                static_cast<uint64_t>(operand));
753         break;
754       default:
755         _LIBUNWIND_TRACE_DWARF("unknown CFA opcode 0x%02X\n", opcode);
756         return false;
757       }
758     }
759   }
760 
761   return true;
762 }
763 
764 } // namespace libunwind
765 
766 #endif // __DWARF_PARSER_HPP__
767