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