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 {
PrologInfoStackEntrylibunwind::CFI_Parser::PrologInfoStackEntry97 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>
decodeFDE(A & addressSpace,pint_t fdeStart,FDE_Info * fdeInfo,CIE_Info * cieInfo)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>
findFDE(A & addressSpace,pint_t pc,pint_t ehSectionStart,uint32_t sectionLength,pint_t fdeHint,FDE_Info * fdeInfo,CIE_Info * cieInfo)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>
parseCIE(A & addressSpace,pint_t cie,CIE_Info * cieInfo)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>
parseFDEInstructions(A & addressSpace,const FDE_Info & fdeInfo,const CIE_Info & cieInfo,pint_t upToPC,int arch,PrologInfo * results)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>
parseInstructions(A & addressSpace,pint_t instructions,pint_t instructionsEnd,const CIE_Info & cieInfo,pint_t pcoffset,PrologInfoStackEntry * & rememberStack,int arch,PrologInfo * results)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