Add the ability to extract the unwind rows from DWARF Call Frame Information.

[clayborg]

Summary

This patch adds the ability to evaluate the state machine for CIE and FDE unwind objects and produce a UnwindTable with all UnwindRow objects needed to unwind registers. It will also dump the UnwindTable for each CIE and FDE when dumping DWARF .debug_frame or .eh_frame sections in llvm-dwarfdump or llvm-objdump. This allows users to see what the unwind rows actually look like for a given CIE or FDE instead of just seeing a list of opcodes.

This patch adds new classes: UnwindLocation, RegisterLocations, UnwindRow, and UnwindTable.

UnwindLocation is a class that describes how to unwind a register or Call Frame Address (CFA).

RegisterLocations is a class that tracks registers and their UnwindLocations. It gets populated when parsing the DWARF call frame instruction opcodes for a unwind row. The registers are mapped from their register numbers to the UnwindLocation in a map.

UnwindRow contains the result of evaluating a row of DWARF call frame instructions for the CIE, or a row from a FDE. The CIE can produce a set of initial instructions that each FDE that points to that CIE will use as the seed for the state machine when parsing FDE opcodes. A UnwindRow for a CIE will not have a valid address, whille a UnwindRow for a FDE will have a valid address.

The UnwindTable is a class that contains a sorted (by address) vector of UnwindRow objects and is the result of parsing all opcodes in a CIE, or FDE. Parsing a CIE should produce a UnwindTable with a single row. Parsing a FDE will produce a UnwindTable with one or more UnwindRow objects where all UnwindRow objects have valid addresses. The rows in the UnwindTable will be sorted from lowest Address to highest after parsing the state machine, or an error will be returned if the table isn't sorted. To parse a UnwindTable clients can use the following methods:

static Expected<UnwindTable> UnwindTable::create(const CIE *Cie);
static Expected<UnwindTable> UnwindTable::create(const FDE *Fde);

A valid table will be returned if the DWARF call frame instruction opcodes have no encoding errors. There are a few things that can go wrong during the evaluation of the state machine and these create functions will catch and return them.

[MaskRay]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

29

Delete 'static': const and constexpr in the namespace scope is of internal linkage and thus implicitly 'static'.

57

Might be easier using member initializers for these variables of non-class types.

[MaskRay]

Thanks for working on this! I'll spend time reading it on another day. Just wanted to mention that libunwind/src/DwarfParser.hpp has another parser and it would be good cross validating the implementations.

[clayborg]

Friendly ping

[clayborg]

If anyone knows anyone that has a lot of experience with unwind information, please feel free to add them as reviewers.

[aprantl]

Not an expert either, but at a high level this seems reasonable.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

37

nit:

/// Not specified.
Unspecified
...

Then it will show up in Doxygen.

56

same for these comments

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

370

Just double-checking: Is this really unreachable, or should this be error handling?

408

same here

[clayborg]

Updated the opcode value accessors to use errors instead of asserts. This helped find some issues with the usage of this class and made its use cleaner.

[MaskRay]

Adding @grimar who touched the code last time.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

29

static is redundant. namespace-scope const/constexpr variables automatically have internal linkage.

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

142

DW_CFA_expression and DW_CFA_val_expression have different Dereference

190

auto -> UnwindRow

207

The description of illegal_byte_sequence (EILSEQ) is: Invalid or incomplete multibyte or wide character. It is about an encoding problem. Probably just use errc::invalid_argument

508

This needs to consider the pointer encoding in FDE.

[clayborg]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

508

The CFIProgram::parse() already did:

case DW_CFA_set_loc:
  // Operands: Address
  addInstruction(Opcode, Data.getRelocatedAddress(C));
  break;

Do we still need to do something here then?

[clayborg]

Fixed issues found by MaskRay.

[grimar]

Few minor nits from me (I am not an expert to review this).

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

259

No need to have an assert to check hasValue here and below,
the Optional<> does it internally:

constexpr T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
  assert(hasVal);
  return value;
}

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

962

Has an excessive double space after "opcodes".

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

508

You can remove this check, StringRef does length comparsion internally:

bool equals(StringRef RHS) const {
  return (Length == RHS.Length &&
          compareMemory(Data, RHS.Data, RHS.Length) == 0);
}

[clayborg]

Fixed issues found by grimar.

[clayborg]

Post holiday ping! I'd love to get this in so I can get unwind info into GSYM with a follow up patch.

[clayborg]

One week ping.

[clayborg]

Update to be based off of the "main" branch.

[wallace]

Looks good to me. Let's see if anyone has any objections before landing

[jhenderson]

There's at least one pre-merge bot failure that looks like its failing due to something in this change.

I've not reviewed the testing yet (but am happy to do so if I get a chance in the coming days), but I've done a mostly cosmetic review of the rest. I don't have enough experience in this area to review the detail though.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

41

This comment is a little confusing to me. The register is in itself? Should it be "Value is unchanged..."? Note: I don't know much about this stuff, so accept that might not make sense.

88

Should this be register rather than registers?

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

97

I think you spill onto the stack, not into it, right?

163

(or "maps are")

195

200

228

273

Unnecessary assert?

305

Maybe. I say "an eff-dee-ee" in my head for this.

343

353

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

207

@MaskRay, I thought that too, but I've been unable to find where the description comes from. Could you point me at it, please?

367

There's inconsistency here and above. Earlier you use errc::invalid_argument without the std. We should be consistent!

368

These messages should all use PRIu32 to go with the uint32_t type.

Also, the style for error messages according to the style guide nowadays is no capitalization on first letter (for regular words at least) and no trailing full stop.

428

Same comment as above re. error message style.

432

Some of these cases are identical. Can we combine them? Same goes above in getOperandAsUnsigned.

498

Maybe not use auto here (what is the type of Inst?)

508

This probably shouldn't be auto. What is the size of the return value? Same goes below for Offset, RegNum etc.

612

Not sure whether this is a clang-tidy issue or something not matching coding standards here. If the former, perhaps worth reporting it? If the latter, please fix!

643

Any particular reason to do the str() here rather than just doing .str().c_str() below?

687

This seems to be identical to the below case? Could they be folded together.

722

This and the next case are almost identical, except for a single string. I wonder if we could factor them out int a helper function or similar?

746

These next two are identical again. Fold them together?

936–937

This sounds like it should be reported through an error handler, rather than printed into the main stream?

962

Same comment as above.

[clayborg]

Fixed issue found by jhenderson.

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

448

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

368

Also, the style for error messages according to the style guide nowadays is no capitalization on first letter (for regular words at least) and no trailing full stop.

Looks like you missed the second half of my previous comment?

432

This comment hasn't been addressed? If you add a function that maps an operand type to a string (or use an existing one if there is one), you could fold several of these cases together by using that function.

853

I might be wrong, but I think LLVM_FALLTHROUGH wasn't needed if there were multiple labels with identical behaviour. I think it is for the case where you have:

case 1:
  something();
  // don't break
  LLVM_FALLTHROUGH;
case 2:
  somethingThatCase1AlsoNeedsToDo();
  break;

895

905

[clayborg]

Update to fix more of jhenderson's issues.

[MaskRay]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

207

https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html EILSEQ "Illegal byte sequence.". This is brief but in other pages in POSIX you can find descriptions like "The data obtained from the input stream does not form a valid character." "The wide-character code wc does not correspond to a valid character."

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

492

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

207

Thanks.

448

455

Looks like this could be merged with OT_Address?

478

This and the above case look like they have the operand type in the message. Aside from that, I think they're identical, so can they be merged?

[clayborg]

Fixed more jhenderson comments. Combined many common cases that were possible after making OperandType to string function.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

448

Looks like you missed this comment?

936–937

Ping this?

962

Ping this?

[clayborg]

Fix one last missed comment fix.

[jhenderson]

Looks fine aside from the two outstanding comments re. error messages.

[clayborg]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

368

Yes I did miss the error message string part. I will fix!

432

They have different error messages as they mention the "Type" by the enumeration name.

432

Will do

937

This function dumps the CFIProgram contents to the stream that is supplied. I don't believe that returning an error from a dumping function is a good idea as I like to see all errors in a file, not just the first error and have the tool stop dumping.

962

This function dumps the FDE to the stream that is supplied. Same argument as before. If this was a parsing function, then yes, an error should be returned.

[clayborg]

In D89845#2454273, @jhenderson wrote:

Looks fine aside from the two outstanding comments re. error messages.

I commented that these are in dump functions that were already created before this patch. They are in the process of dumping the contents to the stream, so dumping the error messages to the stream seems most important. We don't want to stop dumping the information that people asked for due to running into a single error in a file as people will probably want see all of the errors in a file.

[jhenderson]

In D89845#2455700, @clayborg wrote:

In D89845#2454273, @jhenderson wrote:

Looks fine aside from the two outstanding comments re. error messages.

I commented that these are in dump functions that were already created before this patch. They are in the process of dumping the contents to the stream, so dumping the error messages to the stream seems most important. We don't want to stop dumping the information that people asked for due to running into a single error in a file as people will probably want see all of the errors in a file.

Continuing rather than stopping makes sense to me for dumpers. This is the approach we already follow in llvm-readelf and in some other parts of llvm-dwarfdump. In the debug line dumper (which happens to effectively run in parallel to the parser), we report format issues via a callback, which by default prints a warning to stderr, but still continue parsing when we can (see the recoverable error handler). This allows library consumers to handle the problem differently, e.g. if they have warnings as errors enabled. If I follow it correctly, your code here prints it into stdout, without textual colouring, and with the "error:" prefix. This would mean that someone redirecting stderr to a file will not see the errors in that file. I don't think that's what a user would expect.

Essentially, I'm suggesting adding an additional parameter to the dump functions e.g. function_ref<void(Error)> ErrorCallback which the caller can pass. Somewhere up the stack, this would for llvm-dwarfdump at least be defaultWarningHandler. This would allow other clients to do something different, should they choose to. See my LLVMDev 2018 lightning talk on "Error Handling in Libraries" for an example of what I mean.

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

768

Looks like this message hasn't been reformatted with lower-case first letter and no full stop.

[clayborg]

Fixed remaining error message and used error handling build into the dump options.

[clayborg]

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

768

You are correct. I will fix.

937

I found that DumpOpts had error handlers built in, so I used them. They are hooked up and caused a few tests that needed to be updated, so the error handling worked.

962

I found that DumpOpts had error handlers built in, so I used them. They are hooked up and caused a few tests that needed to be updated, so the error handling worked.

[jhenderson]

Mostly looks fine, although there's a unit test failure, so not formally LGTMing. As I think I mentioned earlier, I'm not really familiar with the functional aspects of this change, so don't rely on me alone anyway. Tomorrow will be my last day in the office for over two weeks, so feel free to land if you think others have reviewed sufficiently after the remaining test fix.

[clayborg]

Update to main branch from today.

[clayborg]

Found the test suite issue on

https://reviews.llvm.org/harbormaster/unit/view/247190/

DWARFExpression wasn't initializing the "bool Error;" instance variable.

[jhenderson]

Phabricator is still saying there are unit tests failing. Are these up-to-date reports, or is Phabricator stale?

[clayborg]

In D89845#2481493, @jhenderson wrote:

Phabricator is still saying there are unit tests failing. Are these up-to-date reports, or is Phabricator stale?

They are up to date. I am trying to figure out what is going on without much luck. I thought I had found the issue. Really hard when only one buildbot fails and you have no access to figure out what is going wrong.

[clayborg]

The really confusing thing is the error message for x64 debian > LLVM-Unit.DebugInfo/DWARF/_/DebugInfoDWARFTests::DWARFDebugFrame.UnwindTable_DW_CFA_expression:

/mnt/disks/ssd0/agent/llvm-project/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp:1318: Failure
      Expected: Rows[0].getRegisterLocations()
      Which is: reg13=[<decoding error> 00]
To be equal to: VerifyLocs
      Which is: reg13=[DW_OP_reg10]

The FDE tries to parse:

parseCFI(TestFDE, {dwarf::DW_CFA_expression, Reg, 1, dwarf::DW_OP_reg12}),

Where this clearly encodes DW_CFA_expression (first byte) with a register value or "Reg" which is 13 (second byte) and the a DW_FORM_block where the third byte 1 is the length of the expression for reg13 and the only byte in the expression is DW_OP_reg12 (4th byte).

This somehow fails to decode only on debian??

VerifyLocs is created using:

dwarf::RegisterLocations VerifyLocs;
DataExtractor ExprData({dwarf::DW_OP_reg12}, true, AddrSize);
DWARFExpression Expr(ExprData, AddrSize);
VerifyLocs.setRegisterLocation(
    Reg, dwarf::UnwindLocation::createAtDWARFExpression(Expr));

We can easily see the expression data contains _only_ DW_OP_reg12 but in the printout above it says:

To be equal to: VerifyLocs
      Which is: reg13=[DW_OP_reg10]

No idea how this is getting modified???

[clayborg]

So I setup a CentOS 8 linux server today and ran the failing tests and they succeed. I am out of options here. I would like to submit this as I need it to get other work submitted. Is there any way to see how the debian x86 harbormaster build is setup? Maybe it is enabling some extra things?

[MaskRay]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

85

The two lines can be dropped.

171

This can be dropped.

250

Delete Address(None)

[smeenai]

Running the unit test with ASAN gives me the following. The stack trace isn't the most helpful, unfortunately, but it should hopefully be something to go on.

==16512==ERROR: AddressSanitizer: stack-use-after-scope on address 0x7fff6bf46fc3 at pc 0x0000034713cf bp 0x7fff6bf46900 sp 0x7fff6bf460b0
READ of size 1 at 0x7fff6bf46fc3 thread T0
    #0 0x34713ce in MemcmpInterceptorCommon(void*, int (*)(void const*, void const*, unsigned long), void const*, void const*, unsigned long) (/data/users/smeenai/llvm-project/build/ASanUBSan/unittests/DebugInfo/DWARF/DebugInfoDWARFTests+0x34713ce)
    #1 0x3471a08 in bcmp (/data/users/smeenai/llvm-project/build/ASanUBSan/unittests/DebugInfo/DWARF/DebugInfoDWARFTests+0x3471a08)
    #2 0x35c6165 in compareMemory /home/smeenai/llvm-project/llvm/include/llvm/ADT/StringRef.h:76:14
    #3 0x35c6165 in llvm::StringRef::equals(llvm::StringRef) const /home/smeenai/llvm-project/llvm/include/llvm/ADT/StringRef.h:192:15
    #4 0x4eeb444 in operator== /home/smeenai/llvm-project/llvm/include/llvm/ADT/StringRef.h:901:16
    #5 0x4eeb444 in llvm::DWARFExpression::operator==(llvm::DWARFExpression const&) const /home/smeenai/llvm-project/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp:507:25
    #6 0x4e7b95e in llvm::dwarf::UnwindLocation::operator==(llvm::dwarf::UnwindLocation const&) const /home/smeenai/llvm-project/llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp:142:18
    #7 0x35e5d08 in operator==<const unsigned int, llvm::dwarf::UnwindLocation> /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_pair.h:444:51
    #8 0x35e5d08 in bool std::__equal<false>::equal<std::_Rb_tree_const_iterator<std::pair<unsigned int const, llvm::dwarf::UnwindLocation> >, std::_Rb_tree_const_iterator<std::pair<unsigned int const, llvm::dwarf::UnwindLocation> > >(std::_Rb_tree_const_iterator<std::pair<unsigned int const, llvm::dwarf::UnwindLocation> >, std::_Rb_tree_const_iterator<std::pair<unsigned int const, llvm::dwarf::UnwindLocation> >, std::_Rb_tree_const_iterator<std::pair<unsigned int const, llvm::dwarf::UnwindLocation> >) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_algobase.h:800:22
    #9 0x35fac2b in operator==<unsigned int, llvm::dwarf::UnwindLocation, std::less<unsigned int>, std::allocator<std::pair<const unsigned int, llvm::dwarf::UnwindLocation> > > /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_map.h:1437:23
    #10 0x35fac2b in operator== /home/smeenai/llvm-project/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h:220:22
    #11 0x35fac2b in CmpHelperEQ<llvm::dwarf::RegisterLocations, llvm::dwarf::RegisterLocations> /home/smeenai/llvm-project/llvm/utils/unittest/googletest/include/gtest/gtest.h:1392:11
    #12 0x35fac2b in Compare<llvm::dwarf::RegisterLocations, llvm::dwarf::RegisterLocations> /home/smeenai/llvm-project/llvm/utils/unittest/googletest/include/gtest/gtest.h:1421:12
    #13 0x35fac2b in (anonymous namespace)::DWARFDebugFrame_UnwindTable_DW_CFA_expression_Test::TestBody() /home/smeenai/llvm-project/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp:1318:3
    #14 0x5797598 in testing::Test::Run() /home/smeenai/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:2474:5
    #15 0x579a084 in testing::TestInfo::Run() /home/smeenai/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:2656:11
    #16 0x579bce3 in testing::TestCase::Run() /home/smeenai/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:2774:28
    #17 0x57ace73 in testing::internal::UnitTestImpl::RunAllTests() /home/smeenai/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:4649:43
    #18 0x57ac32e in testing::UnitTest::Run() /home/smeenai/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:4257:10
    #19 0x5786874 in RUN_ALL_TESTS /home/smeenai/llvm-project/llvm/utils/unittest/googletest/include/gtest/gtest.h:2233:46
    #20 0x5786874 in main /home/smeenai/llvm-project/llvm/utils/unittest/UnitTestMain/TestMain.cpp:50:10
    #21 0x7f30c6215554 in __libc_start_main (/lib64/libc.so.6+0x22554)
    #22 0x33f5028 in _start (/data/users/smeenai/llvm-project/build/ASanUBSan/unittests/DebugInfo/DWARF/DebugInfoDWARFTests+0x33f5028)

Address 0x7fff6bf46fc3 is located in stack of thread T0 at offset 1155 in frame
    #0 0x35f983f in (anonymous namespace)::DWARFDebugFrame_UnwindTable_DW_CFA_expression_Test::TestBody() /home/smeenai/llvm-project/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp:1271

  This frame has 47 object(s):
    [32, 36) 'RegNum.addr.i'
    [48, 120) 'ref.tmp.i'
    [160, 200) 'Data.i267' (line 134)
    [240, 248) 'Offset.i' (line 136)
    [272, 488) 'TestCIE' (line 1274)
    [560, 688) 'TestFDE' (line 1278)
    [720, 736) 'agg.tmp'
    [752, 768) 'gtest_ar' (line 1290)
    [784, 785) 'ref.tmp' (line 1290)
    [800, 824) 'ref.tmp10' (line 1290)
    [864, 872) 'agg.tmp11'
    [896, 899) 'ref.tmp16' (line 1290)
    [912, 928) 'agg.tmp22'
    [944, 952) 'ref.tmp29' (line 1290)
    [976, 984) 'ref.tmp34' (line 1290)
    [1008, 1024) 'gtest_ar42' (line 1299)
    [1040, 1041) 'ref.tmp43' (line 1299)
    [1056, 1080) 'ref.tmp49' (line 1299)
    [1120, 1128) 'agg.tmp50'
    [1152, 1156) 'ref.tmp55' (line 1299) <== Memory access at offset 1155 is inside this variable
    [1168, 1176) 'ref.tmp74' (line 1299)
    [1200, 1208) 'ref.tmp79' (line 1299)
    [1232, 1280) 'VerifyLocs' (line 1305)
    [1312, 1336) 'ExprData' (line 1307)
    [1376, 1377) 'ref.tmp92' (line 1307)
    [1392, 1424) 'Expr' (line 1308)
    [1456, 1520) 'ref.tmp111' (line 1309)
    [1552, 1600) 'RowsOrErr' (line 1313)
    [1632, 1648) 'gtest_ar115' (line 1314)
    [1664, 1665) 'ref.tmp116' (line 1314)
    [1680, 1704) 'ref.tmp122' (line 1314)
    [1744, 1752) 'agg.tmp123'
    [1776, 1784) 'ref.tmp133' (line 1314)
    [1808, 1816) 'ref.tmp138' (line 1314)
    [1840, 1856) 'gtest_ar152' (line 1316)
    [1872, 1880) 'ref.tmp153' (line 1316)
    [1904, 1908) 'ref.tmp159' (line 1316)
    [1920, 1928) 'ref.tmp167' (line 1316)
    [1952, 1960) 'ref.tmp172' (line 1316)
    [1984, 2000) 'gtest_ar181' (line 1317)
    [2016, 2024) 'ref.tmp182' (line 1317)
    [2048, 2052) 'ref.tmp191' (line 1317)
    [2064, 2072) 'ref.tmp199' (line 1317)
    [2096, 2104) 'ref.tmp204' (line 1317)
    [2128, 2144) 'gtest_ar213' (line 1318)
    [2160, 2168) 'ref.tmp229' (line 1318)
    [2192, 2200) 'ref.tmp234' (line 1318)
HINT: this may be a false positive if your program uses some custom stack unwind mechanism, swapcontext or vfork
      (longjmp and C++ exceptions *are* supported)
SUMMARY: AddressSanitizer: stack-use-after-scope (/data/users/smeenai/llvm-project/build/ASanUBSan/unittests/DebugInfo/DWARF/DebugInfoDWARFTests+0x34713ce) in MemcmpInterceptorCommon(void*, int (*)(void const*, void const*, unsigned long), void const*, void const*, unsigned long)
Shadow bytes around the buggy address:
  0x10006d7e0da0: 00 00 00 00 00 f2 f2 f2 f2 f2 f2 f2 f2 f2 00 00
  0x10006d7e0db0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f2 f2
  0x10006d7e0dc0: f2 f2 00 00 f2 f2 f8 f8 f2 f2 f8 f2 f8 f8 f8 f2
  0x10006d7e0dd0: f2 f2 f2 f2 00 f2 f2 f2 f8 f2 00 00 f2 f2 f8 f2
  0x10006d7e0de0: f2 f2 f8 f2 f2 f2 f8 f8 f2 f2 f8 f2 f8 f8 f8 f2
=>0x10006d7e0df0: f2 f2 f2 f2 00 f2 f2 f2[f8]f2 f8 f2 f2 f2 f8 f2
  0x10006d7e0e00: f2 f2 00 00 00 00 00 00 f2 f2 f2 f2 00 00 00 f2
  0x10006d7e0e10: f2 f2 f2 f2 f8 f2 00 00 00 00 f2 f2 f2 f2 f8 f8
  0x10006d7e0e20: f8 f8 f8 f8 f8 f8 f2 f2 f2 f2 00 00 00 00 00 00
  0x10006d7e0e30: f2 f2 f2 f2 f8 f8 f2 f2 f8 f2 f8 f8 f8 f2 f2 f2
  0x10006d7e0e40: f2 f2 00 f2 f2 f2 f8 f2 f2 f2 f8 f2 f2 f2 f8 f8
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07
  Heap left redzone:       fa
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Container overflow:      fc
  Array cookie:            ac
  Intra object redzone:    bb
  ASan internal:           fe
  Left alloca redzone:     ca
  Right alloca redzone:    cb
  Shadow gap:              cc

[clayborg]

Fixed inline issues found by MaskRay and fixed the issue found by ASAN that was making the debian buildbot fail. Thanks Shoaib for the ASAN suggestion.

[clayborg]

Looks like harbormaster is finally clean. Any more issues or is this good to go?

[jhenderson]

Looks fine to me, with the caveat that I don't really know much about the functionality, so others with more knowledge should approve too.

[clayborg]

Can I get one more approval so I can commit? This is blocking my unwind in GSYM patch that I would like to post next.

[clayborg]

If no one has any additional comments I will check this in in a few days.

[clayborg]

Windows buildbot had build issues. Fixed with:

commit a1a3fdcdba52c9d0a045af5f68365c273467b127 (HEAD -> main, origin/main, origin/HEAD)
Author: Greg Clayton <[e-mail]>
Date:   Thu Jan 28 15:23:22 2021 -0800

    Fix windows buildbot build errors from D89845.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

 //===- DWARFDebugFrame.h - Parsing of .debug_frame --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARF_DWARFDEBUGFRAME_H
 #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGFRAME_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/iterator.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/ADT/iterator.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/Support/Error.h"
+#include <map>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 namespace dwarf {
 
+constexpr uint32_t InvalidRegisterNumber = UINT32_MAX;
+
+/// A class that represents a location for the Call Frame Address (CFA) or a
+/// register. This is decoded from the DWARF Call Frame Information
+/// instructions and put into an UnwindRow.
+class UnwindLocation {
+public:
+  enum Location {
+    /// Not specified.
+    Unspecified,
+    /// Register is not available and can't be recovered.
+    Undefined,
+    /// Register value is in the register, nothing needs to be done to unwind
+    /// it:
+    ///   reg = reg
+    Same,
+    /// Register is in or at the CFA plus an offset:
+    ///   reg = CFA + offset
+    ///   reg = defef(CFA + offset)
+    CFAPlusOffset,
+    /// Register it in or at a register plus offset:
+    ///   reg = reg + offset
+    ///   reg = deref(reg + offset)
+    RegPlusOffset,
+    /// Register value is in or at a value found by evaluating a DWARF
+    /// expression:
+    ///   reg = eval(dwarf_expr)
+    ///   reg = deref(eval(dwarf_expr))
+    DWARFExpr,
+    /// Value is a constant value contained in "Offset":
+    ///   reg = Offset
+    Constant,
+  };
+
+private:
+  Location Kind;   /// The type of the location that describes how to unwind it.
+  uint32_t RegNum; /// The register number for Kind == RegPlusOffset.
+  int32_t Offset;  /// The offset for Kind == CFAPlusOffset or RegPlusOffset.
+  Optional<DWARFExpression> Expr; /// The DWARF expression for Kind ==
+                                  /// DWARFExpression.
+  bool Dereference; /// If true, the resulting location must be dereferenced
+                    /// after the location value is computed.
+
+  // Constructors are private to force people to use the create static
+  // functions.
+  UnwindLocation(Location K)
+      : Kind(K), RegNum(InvalidRegisterNumber), Offset(0), Dereference(false) {}
+
+  UnwindLocation(Location K, uint32_t Reg, int32_t Off, bool Deref)
+      : Kind(K), RegNum(Reg), Offset(Off), Dereference(Deref) {}
+
+  UnwindLocation(DWARFExpression E, bool Deref)
+      : Kind(DWARFExpr), RegNum(InvalidRegisterNumber), Offset(0), Expr(E),
+        Dereference(Deref) {}
+
+public:
+  UnwindLocation(const UnwindLocation &RHS) = default;
+  UnwindLocation &operator=(const UnwindLocation &RHS) = default;
+
+  /// Create a location whose rule is set to Unspecified. This means the
+  /// register value might be in the same register but it wasn't specified in
+  /// the unwind opcodes.
+  static UnwindLocation createUnspecified();
+  /// Create a location where the value is undefined and not available. This can
+  /// happen when a register is volatile and can't be recovered.
+  static UnwindLocation createUndefined();
+  /// Create a location where the value is known to be in the register itself.
+  static UnwindLocation createSame();
+  /// Create a location that is in (Deref == false) or at (Deref == true) the
+  /// CFA plus an offset. Most registers that are spilled onto the stack use
+  /// this rule. The rule for the register will use this rule and specify a
+  /// unique offset from the CFA with \a Deref set to true. This value will be
+  /// relative to a CFA value which is typically defined using the register
+  /// plus offset location. \see createRegisterPlusOffset(...) for more
+  /// information.
+  static UnwindLocation createIsCFAPlusOffset(int32_t Off);
+  static UnwindLocation createAtCFAPlusOffset(int32_t Off);
+  /// Create a location where the saved value is in (Deref == false) or at
+  /// (Deref == true) a regiser plus an offset.
+  ///
+  /// The CFA is usually defined using this rule by using the stack pointer or
+  /// frame pointer as the register, with an offset that accounts for all
+  /// spilled registers and all local variables in a function, and Deref ==
+  /// false.
+  static UnwindLocation createIsRegisterPlusOffset(uint32_t Reg, int32_t Off);
+  static UnwindLocation createAtRegisterPlusOffset(uint32_t Reg, int32_t Off);
+  /// Create a location whose value is the result of evaluating a DWARF
+  /// expression. This allows complex expressions to be evaluated in order to
+  /// unwind a register or CFA value.
+  static UnwindLocation createIsDWARFExpression(DWARFExpression Expr);
+  static UnwindLocation createAtDWARFExpression(DWARFExpression Expr);
+  static UnwindLocation createIsConstant(int32_t Value);
+
+  Location getLocation() const { return Kind; }
+  uint32_t getRegister() const { return RegNum; }
+  int32_t getOffset() const { return Offset; }
+  int32_t getConstant() const { return Offset; }
+  /// Some opcodes will modify the CFA location's register only, so we need
+  /// to be able to modify the CFA register when evaluating DWARF Call Frame
+  /// Information opcodes.
+  void setRegister(uint32_t NewRegNum) { RegNum = NewRegNum; }
+  /// Some opcodes will modify the CFA location's offset only, so we need
+  /// to be able to modify the CFA register when evaluating DWARF Call Frame
+  /// Information opcodes.
+  void setOffset(int32_t NewOffset) { Offset = NewOffset; }
+  /// Some opcodes modify a constant value and we need to be able to update
+  /// the constant value (DW_CFA_GNU_window_save which is also known as
+  // DW_CFA_AARCH64_negate_ra_state).
+  void setConstant(int32_t Value) { Offset = Value; }
+
+  Optional<DWARFExpression> getDWARFExpressionBytes() const { return Expr; }
+  /// Dump a location expression as text and use the register information if
+  /// some is provided.
+  ///
+  /// \param OS the stream to use for output.
+  ///
+  /// \param MRI register information that helps emit register names insteead
+  /// of raw register numbers.
+  ///
+  /// \param IsEH true if the DWARF Call Frame Information is from .eh_frame
+  /// instead of from .debug_frame. This is needed for register number
+  /// conversion because some register numbers differ between the two sections
+  /// for certain architectures like x86.
+  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const;
+
+  bool operator==(const UnwindLocation &RHS) const;
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const UnwindLocation &R);
+
+/// A class that can track all registers with locations in a UnwindRow object.
+///
+/// Register locations use a map where the key is the register number and the
+/// the value is a UnwindLocation.
+///
+/// The register maps are put into a class so that all register locations can
+/// be copied when parsing the unwind opcodes DW_CFA_remember_state and
+/// DW_CFA_restore_state.
+class RegisterLocations {
+  std::map<uint32_t, UnwindLocation> Locations;
+
+public:
+  RegisterLocations() = default;
+
+  /// Return the location for the register in \a RegNum if there is a location.
+  ///
+  /// \param RegNum the register number to find a location for.
+  ///
+  /// \returns A location if one is available for \a RegNum, or llvm::None
+  /// otherwise.
+  Optional<UnwindLocation> getRegisterLocation(uint32_t RegNum) const {
+    auto Pos = Locations.find(RegNum);
+    if (Pos == Locations.end())
+      return llvm::None;
+    return Pos->second;
+  }
+
+  /// Set the location for the register in \a RegNum to \a Location.
+  ///
+  /// \param RegNum the register number to set the location for.
+  ///
+  /// \param Location the UnwindLocation that describes how to unwind the value.
+  void setRegisterLocation(uint32_t RegNum, const UnwindLocation &Location) {
+    Locations.erase(RegNum);
+    Locations.insert(std::make_pair(RegNum, Location));
+  }
+
+  /// Removes any rule for the register in \a RegNum.
+  ///
+  /// \param RegNum the register number to remove the location for.
+  void removeRegisterLocation(uint32_t RegNum) { Locations.erase(RegNum); }
+
+  /// Dump all registers + locations that are currently defined in this object.
+  ///
+  /// \param OS the stream to use for output.
+  ///
+  /// \param MRI register information that helps emit register names insteead
+  /// of raw register numbers.
+  ///
+  /// \param IsEH true if the DWARF Call Frame Information is from .eh_frame
+  /// instead of from .debug_frame. This is needed for register number
+  /// conversion because some register numbers differ between the two sections
+  /// for certain architectures like x86.
+  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const;
+
+  /// Returns true if we have any register locations in this object.
+  bool hasLocations() const { return !Locations.empty(); }
+
+  size_t size() const { return Locations.size(); }
+
+  bool operator==(const RegisterLocations &RHS) const {
+    return Locations == RHS.Locations;
+  }
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const RegisterLocations &RL);
+
+/// A class that represents a single row in the unwind table that is decoded by
+/// parsing the DWARF Call Frame Information opcodes.
+///
+/// The row consists of an optional address, the rule to unwind the CFA and all
+/// rules to unwind any registers. If the address doesn't have a value, this
+/// row represents the initial instructions for a CIE. If the address has a
+/// value the UnwindRow represents a row in the UnwindTable for a FDE. The
+/// address is the first address for which the CFA location and register rules
+/// are valid within a function.
+///
+/// UnwindRow objects are created by parsing opcodes in the DWARF Call Frame
+/// Information and UnwindRow objects are lazily populated and pushed onto a
+/// stack in the UnwindTable when evaluating this state machine. Accessors are
+/// needed for the address, CFA value, and register locations as the opcodes
+/// encode a state machine that produces a sorted array of UnwindRow objects
+/// \see UnwindTable.
+class UnwindRow {
+  /// The address will be valid when parsing the instructions in a FDE. If
+  /// invalid, this object represents the initial instructions of a CIE.
+  Optional<uint64_t> Address; ///< Address for row in FDE, invalid for CIE.
+  UnwindLocation CFAValue;    ///< How to unwind the Call Frame Address (CFA).
+  RegisterLocations RegLocs;  ///< How to unwind all registers in this list.
+
+public:
+  UnwindRow() : Address(None), CFAValue(UnwindLocation::createUnspecified()) {}
+
+  /// Returns true if the address is valid in this object.
+  bool hasAddress() const { return Address.hasValue(); }
+
+  /// Get the address for this row.
+  ///
+  /// Clients should only call this function after verifying it has a valid
+  /// address with a call to \see hasAddress().
+  uint64_t getAddress() const { return *Address; }
+
+  /// Set the address for this UnwindRow.
+  ///
+  /// The address represents the first address for which the CFAValue and
+  /// RegLocs are valid within a function.
+  void setAddress(uint64_t Addr) { Address = Addr; }
+
+  /// Offset the address for this UnwindRow.
+  ///
+  /// The address represents the first address for which the CFAValue and
+  /// RegLocs are valid within a function. Clients must ensure that this object
+  /// already has an address (\see hasAddress()) prior to calling this
+  /// function.
+  void slideAddress(uint64_t Offset) { *Address += Offset; }
+  UnwindLocation &getCFAValue() { return CFAValue; }
+  const UnwindLocation &getCFAValue() const { return CFAValue; }
+  RegisterLocations &getRegisterLocations() { return RegLocs; }
+  const RegisterLocations &getRegisterLocations() const { return RegLocs; }
+
+  /// Dump the UnwindRow to the stream.
+  ///
+  /// \param OS the stream to use for output.
+  ///
+  /// \param MRI register information that helps emit register names insteead
+  /// of raw register numbers.
+  ///
+  /// \param IsEH true if the DWARF Call Frame Information is from .eh_frame
+  /// instead of from .debug_frame. This is needed for register number
+  /// conversion because some register numbers differ between the two sections
+  /// for certain architectures like x86.
+  ///
+  /// \param IndentLevel specify the indent level as an integer. The UnwindRow
+  /// will be output to the stream preceded by 2 * IndentLevel number of spaces.
+  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+            unsigned IndentLevel = 0) const;
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const UnwindRow &Row);
+
+class CFIProgram;
+class CIE;
+class FDE;
+
+/// A class that contains all UnwindRow objects for an FDE or a single unwind
+/// row for a CIE. To unwind an address the rows, which are sorted by start
+/// address, can be searched to find the UnwindRow with the lowest starting
+/// address that is greater than or equal to the address that is being looked
+/// up.
+class UnwindTable {
+public:
+  using RowContainer = std::vector<UnwindRow>;
+  using iterator = RowContainer::iterator;
+  using const_iterator = RowContainer::const_iterator;
+
+  size_t size() const { return Rows.size(); }
+  iterator begin() { return Rows.begin(); }
+  const_iterator begin() const { return Rows.begin(); }
+  iterator end() { return Rows.end(); }
+  const_iterator end() const { return Rows.end(); }
+  const UnwindRow &operator[](size_t Index) const {
+    assert(Index < size());
+    return Rows[Index];
+  }
+
+  /// Dump the UnwindTable to the stream.
+  ///
+  /// \param OS the stream to use for output.
+  ///
+  /// \param MRI register information that helps emit register names insteead
+  /// of raw register numbers.
+  ///
+  /// \param IsEH true if the DWARF Call Frame Information is from .eh_frame
+  /// instead of from .debug_frame. This is needed for register number
+  /// conversion because some register numbers differ between the two sections
+  /// for certain architectures like x86.
+  ///
+  /// \param IndentLevel specify the indent level as an integer. The UnwindRow
+  /// will be output to the stream preceded by 2 * IndentLevel number of spaces.
+  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+            unsigned IndentLevel = 0) const;
+
+  /// Create an UnwindTable from a Common Information Entry (CIE).
+  ///
+  /// \param Cie The Common Information Entry to extract the table from. The
+  /// CFIProgram is retrieved from the \a Cie object and used to create the
+  /// UnwindTable.
+  ///
+  /// \returns An error if the DWARF Call Frame Information opcodes have state
+  /// machine errors, or a valid UnwindTable otherwise.
+  static Expected<UnwindTable> create(const CIE *Cie);
+
+  /// Create an UnwindTable from a Frame Descriptor Entry (FDE).
+  ///
+  /// \param Fde The Frame Descriptor Entry to extract the table from. The
+  /// CFIProgram is retrieved from the \a Fde object and used to create the
+  /// UnwindTable.
+  ///
+  /// \returns An error if the DWARF Call Frame Information opcodes have state
+  /// machine errors, or a valid UnwindTable otherwise.
+  static Expected<UnwindTable> create(const FDE *Fde);
+
+private:
+  RowContainer Rows;
+  /// The end address when data is extracted from a FDE. This value will be
+  /// invalid when a UnwindTable is extracted from a CIE.
+  Optional<uint64_t> EndAddress;
+
+  /// Parse the information in the CFIProgram and update the CurrRow object
+  /// that the state machine describes.
+  ///
+  /// This is an internal implementation that emulates the state machine
+  /// described in the DWARF Call Frame Information opcodes and will push
+  /// CurrRow onto the Rows container when needed. \param CFID the CFI program
+  /// that contains the opcodes from a CIE or FDE.
+  ///
+  /// \param CurrRow the current row to modify while parsing the state machine.
+  ///
+  /// \param InitialLocs If non-NULL, we are parsing a FDE and this contains
+  /// the initial register locations from the CIE. If NULL, then a CIE's
+  /// opcodes are being parsed and this is not needed. This is used for the
+  /// DW_CFA_restore and DW_CFA_restore_extended opcodes.
+  Error parseRows(const CFIProgram &CFIP, UnwindRow &CurrRow,
+                  const RegisterLocations *InitialLocs);
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const UnwindTable &Rows);
+
 /// Represent a sequence of Call Frame Information instructions that, when read
 /// in order, construct a table mapping PC to frame state. This can also be
 /// referred to as "CFI rules" in DWARF literature to avoid confusion with
 /// computer programs in the broader sense, and in this context each instruction
 /// would be a rule to establish the mapping. Refer to pg. 172 in the DWARF5
 /// manual, "6.4.1 Structure of Call Frame Information".
 class CFIProgram {
 public:
   typedef SmallVector<uint64_t, 2> Operands;
 
   /// An instruction consists of a DWARF CFI opcode and an optional sequence of
   /// operands. If it refers to an expression, then this expression has its own
   /// sequence of operations and operands handled separately by DWARFExpression.
   struct Instruction {
     Instruction(uint8_t Opcode) : Opcode(Opcode) {}
 
     uint8_t Opcode;
     Operands Ops;
     // Associated DWARF expression in case this instruction refers to one
     Optional<DWARFExpression> Expression;
+
+    Expected<uint64_t> getOperandAsUnsigned(const CFIProgram &CFIP,
+                                            uint32_t OperandIdx) const;
+
+    Expected<int64_t> getOperandAsSigned(const CFIProgram &CFIP,
+                                         uint32_t OperandIdx) const;
   };
 
   using InstrList = std::vector<Instruction>;
   using iterator = InstrList::iterator;
   using const_iterator = InstrList::const_iterator;
 
   iterator begin() { return Instructions.begin(); }
   const_iterator begin() const { return Instructions.begin(); }
   iterator end() { return Instructions.end(); }
   const_iterator end() const { return Instructions.end(); }
 
   unsigned size() const { return (unsigned)Instructions.size(); }
   bool empty() const { return Instructions.empty(); }
+  uint64_t codeAlign() const { return CodeAlignmentFactor; }
+  int64_t dataAlign() const { return DataAlignmentFactor; }
+  Triple::ArchType triple() const { return Arch; }
 
   CFIProgram(uint64_t CodeAlignmentFactor, int64_t DataAlignmentFactor,
              Triple::ArchType Arch)
       : CodeAlignmentFactor(CodeAlignmentFactor),
         DataAlignmentFactor(DataAlignmentFactor),
         Arch(Arch) {}
 
   /// Parse and store a sequence of CFI instructions from Data,
   /// starting at *Offset and ending at EndOffset. *Offset is updated
   /// to EndOffset upon successful parsing, or indicates the offset
   /// where a problem occurred in case an error is returned.
   Error parse(DWARFDataExtractor Data, uint64_t *Offset, uint64_t EndOffset);
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
             bool IsEH, unsigned IndentLevel = 1) const;
 
+  void addInstruction(const Instruction &I) { Instructions.push_back(I); }
+
+  /// Get a DWARF CFI call frame string for the given DW_CFA opcode.
+  StringRef callFrameString(unsigned Opcode) const;
+
 private:
   std::vector<Instruction> Instructions;
   const uint64_t CodeAlignmentFactor;
   const int64_t DataAlignmentFactor;
   Triple::ArchType Arch;
 
   /// Convenience method to add a new instruction with the given opcode.
   void addInstruction(uint8_t Opcode) {
enum OperandType {
     OT_Offset,
     OT_FactoredCodeOffset,
     OT_SignedFactDataOffset,
     OT_UnsignedFactDataOffset,
     OT_Register,
     OT_Expression
   };
 
+  /// Get the OperandType as a "const char *
+  static const char *operandTypeString(OperandType OT);
+
   /// Retrieve the array describing the types of operands according to the enum
   /// above. This is indexed by opcode.
   static ArrayRef<OperandType[2]> getOperandTypes();
 
   /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand.
   void printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
                     const MCRegisterInfo *MRI, bool IsEH,
                     const Instruction &Instr, unsigned OperandIdx,

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

public:
   /// Print the expression in a format intended to be compact and useful to a
   /// user, but not perfectly unambiguous, or capable of representing every
   /// valid DWARF expression. Returns true if the expression was sucessfully
   /// printed.
   bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo);
 
   bool verify(DWARFUnit *U);
 
+  bool operator==(const DWARFExpression &RHS) const;
+
 private:
   DataExtractor Data;
   uint8_t AddressSize;
   Optional<dwarf::DwarfFormat> Format;
 };
 
 inline bool operator==(const DWARFExpression::iterator &LHS,
                        const DWARFExpression::iterator &RHS) {

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

if (Optional<unsigned> LLVMRegNum = MRI->getLLVMRegNum(RegNum, IsEH)) {
         OS << RegName;
         return;
       }
     }
   }
   OS << "reg" << RegNum;
 }
 
+UnwindLocation UnwindLocation::createUnspecified() { return {Unspecified}; }
+
+UnwindLocation UnwindLocation::createUndefined() { return {Undefined}; }
+
+UnwindLocation UnwindLocation::createSame() { return {Same}; }
+
+UnwindLocation UnwindLocation::createIsConstant(int32_t Value) {
+  return {Constant, InvalidRegisterNumber, Value, false};
+}
+
+UnwindLocation UnwindLocation::createIsCFAPlusOffset(int32_t Offset) {
+  return {CFAPlusOffset, InvalidRegisterNumber, Offset, false};
+}
+
+UnwindLocation UnwindLocation::createAtCFAPlusOffset(int32_t Offset) {
+  return {CFAPlusOffset, InvalidRegisterNumber, Offset, true};
+}
+
+UnwindLocation UnwindLocation::createIsRegisterPlusOffset(uint32_t RegNum,
+                                                          int32_t Offset) {
+  return {RegPlusOffset, RegNum, Offset, false};
+}
+UnwindLocation UnwindLocation::createAtRegisterPlusOffset(uint32_t RegNum,
+                                                          int32_t Offset) {
+  return {RegPlusOffset, RegNum, Offset, true};
+}
+
+UnwindLocation UnwindLocation::createIsDWARFExpression(DWARFExpression Expr) {
+  return {Expr, false};
+}
+
+UnwindLocation UnwindLocation::createAtDWARFExpression(DWARFExpression Expr) {
+  return {Expr, true};
+}
+
+void UnwindLocation::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+                          bool IsEH) const {
+  if (Dereference)
+    OS << '[';
+  switch (Kind) {
+  case Unspecified:
+    OS << "unspecified";
+    break;
+  case Undefined:
+    OS << "undefined";
+    break;
+  case Same:
+    OS << "same";
+    break;
+  case CFAPlusOffset:
+    OS << "CFA";
+    if (Offset == 0)
+      break;
+    if (Offset > 0)
+      OS << "+";
+    OS << Offset;
+    break;
+  case RegPlusOffset:
+    printRegister(OS, MRI, IsEH, RegNum);
+    if (Offset == 0)
+      break;
+    if (Offset > 0)
+      OS << "+";
+    OS << Offset;
+    break;
+  case DWARFExpr:
+    Expr->print(OS, DIDumpOptions(), MRI, nullptr, IsEH);
+    break;
+  case Constant:
+    OS << Offset;
+    break;
+  }
+  if (Dereference)
+    OS << ']';
+}
+
+raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS,
+                                     const UnwindLocation &UL) {
+  UL.dump(OS, nullptr, false);
+  return OS;
+}
+
+bool UnwindLocation::operator==(const UnwindLocation &RHS) const {
+  if (Kind != RHS.Kind)
+    return false;
+  switch (Kind) {
+  case Unspecified:
+  case Undefined:
+  case Same:
+    return true;
+  case CFAPlusOffset:
+    return Offset == RHS.Offset && Dereference == RHS.Dereference;
+  case RegPlusOffset:
+    return RegNum == RHS.RegNum && Offset == RHS.Offset &&
+           Dereference == RHS.Dereference;
+  case DWARFExpr:
+    return *Expr == *RHS.Expr && Dereference == RHS.Dereference;
+  case Constant:
+    return Offset == RHS.Offset;
+  }
+  return false;
+}
+
+void RegisterLocations::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
+                             bool IsEH) const {
+  bool First = true;
+  for (const auto &RegLocPair : Locations) {
+    if (First)
+      First = false;
+    else
+      OS << ", ";
+    printRegister(OS, MRI, IsEH, RegLocPair.first);
+    OS << '=';
+    RegLocPair.second.dump(OS, MRI, IsEH);
+  }
+}
+
+raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS,
+                                     const RegisterLocations &RL) {
+  RL.dump(OS, nullptr, false);
+  return OS;
+}
+
+void UnwindRow::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+                     unsigned IndentLevel) const {
+  OS.indent(2 * IndentLevel);
+  if (hasAddress())
+    OS << format("0x%" PRIx64 ": ", *Address);
+  OS << "CFA=";
+  CFAValue.dump(OS, MRI, IsEH);
+  if (RegLocs.hasLocations()) {
+    OS << ": ";
+    RegLocs.dump(OS, MRI, IsEH);
+  }
+  OS << "\n";
+}
+
+raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindRow &Row) {
+  Row.dump(OS, nullptr, false, 0);
+  return OS;
+}
+
+void UnwindTable::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+                       unsigned IndentLevel) const {
+  for (const UnwindRow &Row : Rows)
+    Row.dump(OS, MRI, IsEH, IndentLevel);
+}
+
+raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindTable &Rows) {
+  Rows.dump(OS, nullptr, false, 0);
+  return OS;
+}
+
+Expected<UnwindTable> UnwindTable::create(const FDE *Fde) {
+  UnwindTable UT;
+  UnwindRow Row;
+  Row.setAddress(Fde->getInitialLocation());
+  UT.EndAddress = Fde->getInitialLocation() + Fde->getAddressRange();
+
+  const CIE *Cie = Fde->getLinkedCIE();
+  if (Cie == nullptr)
+    return createStringError(errc::invalid_argument,
+                             "unable to get CIE for FDE at offset 0x%" PRIx64,
+                             Fde->getOffset());
+
+  if (Error CieError = UT.parseRows(Cie->cfis(), Row, nullptr))
+    return std::move(CieError);
+  // We need to save the initial locations of registers from the CIE parsing
+  // in case we run into DW_CFA_restore or DW_CFA_restore_extended opcodes.
+  const RegisterLocations InitialLocs = Row.getRegisterLocations();
+  if (Error FdeError = UT.parseRows(Fde->cfis(), Row, &InitialLocs))
+    return std::move(FdeError);
+  UT.Rows.push_back(Row);
+  return UT;
+}
+
+Expected<UnwindTable> UnwindTable::create(const CIE *Cie) {
+  UnwindTable UT;
+  UnwindRow Row;
+  if (Error CieError = UT.parseRows(Cie->cfis(), Row, nullptr))
+    return std::move(CieError);
+  UT.Rows.push_back(Row);
+  return UT;
+}
+
 // See DWARF standard v3, section 7.23
 const uint8_t DWARF_CFI_PRIMARY_OPCODE_MASK = 0xc0;
 const uint8_t DWARF_CFI_PRIMARY_OPERAND_MASK = 0x3f;
 
 Error CFIProgram::parse(DWARFDataExtractor Data, uint64_t *Offset,
                         uint64_t EndOffset) {
   DataExtractor::Cursor C(*Offset);
   while (C && C.tell() < EndOffset) {
while (C && C.tell() < EndOffset) {
     }
     }
   }
 
   *Offset = C.tell();
   return C.takeError();
 }
 
-namespace {
+StringRef CFIProgram::callFrameString(unsigned Opcode) const {
+  return dwarf::CallFrameString(Opcode, Arch);
+}
+
+const char *CFIProgram::operandTypeString(CFIProgram::OperandType OT) {
+#define ENUM_TO_CSTR(e)                                                        \
+  case e:                                                                      \
+    return #e;
+  switch (OT) {
+    ENUM_TO_CSTR(OT_Unset);
+    ENUM_TO_CSTR(OT_None);
+    ENUM_TO_CSTR(OT_Address);
+    ENUM_TO_CSTR(OT_Offset);
+    ENUM_TO_CSTR(OT_FactoredCodeOffset);
+    ENUM_TO_CSTR(OT_SignedFactDataOffset);
+    ENUM_TO_CSTR(OT_UnsignedFactDataOffset);
+    ENUM_TO_CSTR(OT_Register);
+    ENUM_TO_CSTR(OT_Expression);
+  }
+  return "<unknown CFIProgram::OperandType>";
+}
+
+llvm::Expected<uint64_t>
+CFIProgram::Instruction::getOperandAsUnsigned(const CFIProgram &CFIP,
+                                              uint32_t OperandIdx) const {
+  if (OperandIdx >= 2)
+    return createStringError(errc::invalid_argument,
+                             "operand index %" PRIu32 " is not valid",
+                             OperandIdx);
+  OperandType Type = CFIP.getOperandTypes()[Opcode][OperandIdx];
+  uint64_t Operand = Ops[OperandIdx];
+  switch (Type) {
+  case OT_Unset:
+  case OT_None:
+  case OT_Expression:
+    return createStringError(errc::invalid_argument,
+                             "op[%" PRIu32 "] has type %s which has no value",
+                             OperandIdx, CFIProgram::operandTypeString(Type));
+
+  case OT_Offset:
+  case OT_SignedFactDataOffset:
+  case OT_UnsignedFactDataOffset:
+    return createStringError(
+        errc::invalid_argument,
+        "op[%" PRIu32 "] has OperandType OT_Offset which produces a signed "
+        "result, call getOperandAsSigned instead",
+        OperandIdx);
+
+  case OT_Address:
+  case OT_Register:
+    return Operand;
+
+  case OT_FactoredCodeOffset: {
+    const uint64_t CodeAlignmentFactor = CFIP.codeAlign();
+    if (CodeAlignmentFactor == 0)
+      return createStringError(
+          errc::invalid_argument,
+          "op[%" PRIu32 "] has type OT_FactoredCodeOffset but code alignment "
+          "is zero",
+          OperandIdx);
+    return Operand * CodeAlignmentFactor;
+  }
+  }
+}
+
+llvm::Expected<int64_t>
+CFIProgram::Instruction::getOperandAsSigned(const CFIProgram &CFIP,
+                                            uint32_t OperandIdx) const {
+  if (OperandIdx >= 2)
+    return createStringError(errc::invalid_argument,
+                             "Operand index %" PRIu32 " is not valid.",
+                             OperandIdx);
+  OperandType Type = CFIP.getOperandTypes()[Opcode][OperandIdx];
+  uint64_t Operand = Ops[OperandIdx];
+  switch (Type) {
+  case OT_Unset:
+  case OT_None:
+  case OT_Expression:
+    return createStringError(errc::invalid_argument,
+                             "op[%" PRIu32 "] has type %s which has no value",
+                             OperandIdx, CFIProgram::operandTypeString(Type));
+
+  case OT_Address:
+    return createStringError(
+        errc::invalid_argument,
+        "op[%" PRIu32 "] has OperandType OT_Address which produces a unsigned "
+        "result, call getOperandAsUnsigned instead",
+        OperandIdx);
+
+  case OT_Offset:
+    return (int64_t)Operand;
+
+  case OT_Register:
+    return createStringError(
+        errc::invalid_argument,
+        "op[%" PRIu32 "] has OperandType OT_Register which produces a unsigned "
+        "result, call getOperandAsUnsigned instead",
+        OperandIdx);
+
+  case OT_FactoredCodeOffset: {
+    const int64_t DataAlignmentFactor = CFIP.dataAlign();
+    if (DataAlignmentFactor == 0)
+      return createStringError(errc::invalid_argument,
+                               "op[%" PRIu32
+                               "] has type OT_UnsignedFactDataOffset but data "
+                               "alignment is zero",
+                               OperandIdx);
+    return int64_t(Operand) * DataAlignmentFactor;
+  }
+
+  case OT_SignedFactDataOffset: {
+    const int64_t DataAlignmentFactor = CFIP.dataAlign();
+    if (DataAlignmentFactor == 0)
+      return createStringError(errc::invalid_argument,
+                               "op[%" PRIu32
+                               "] has type OT_UnsignedFactDataOffset but data "
+                               "alignment is zero",
+                               OperandIdx);
+    return int64_t(Operand) * DataAlignmentFactor;
+  }
+
+  case OT_UnsignedFactDataOffset: {
+    const int64_t DataAlignmentFactor = CFIP.dataAlign();
+    if (DataAlignmentFactor == 0)
+      return createStringError(errc::invalid_argument,
+                               "op[%" PRIu32
+                               "] has type OT_UnsignedFactDataOffset but data "
+                               "alignment is zero",
+                               OperandIdx);
+    return Operand * DataAlignmentFactor;
+  }
+  }
+}
+
+Error UnwindTable::parseRows(const CFIProgram &CFIP, UnwindRow &Row,
+                             const RegisterLocations *InitialLocs) {
+  std::vector<RegisterLocations> RegisterStates;
+  for (const CFIProgram::Instruction &Inst : CFIP) {
+    switch (Inst.Opcode) {
+    case dwarf::DW_CFA_set_loc: {
+      // The DW_CFA_set_loc instruction takes a single operand that
+      // represents a target address. The required action is to create a new
+      // table row using the specified address as the location. All other
+      // values in the new row are initially identical to the current row.
+      // The new location value is always greater than the current one. If
+      // the segment_size field of this FDE's CIE is non- zero, the initial
+      // location is preceded by a segment selector of the given length
+      llvm::Expected<uint64_t> NewAddress = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!NewAddress)
+        return NewAddress.takeError();
+      if (*NewAddress <= Row.getAddress())
+        return createStringError(
+            errc::invalid_argument,
+            "%s with adrress 0x%" PRIx64 " which must be greater than the "
+            "current row address 0x%" PRIx64,
+            CFIP.callFrameString(Inst.Opcode).str().c_str(), *NewAddress,
+            Row.getAddress());
+      Rows.push_back(Row);
+      Row.setAddress(*NewAddress);
+      break;
+    }
+
+    case dwarf::DW_CFA_advance_loc:
+    case dwarf::DW_CFA_advance_loc1:
+    case dwarf::DW_CFA_advance_loc2:
+    case dwarf::DW_CFA_advance_loc4: {
+      // The DW_CFA_advance instruction takes a single operand that
+      // represents a constant delta. The required action is to create a new
+      // table row with a location value that is computed by taking the
+      // current entry’s location value and adding the value of delta *
+      // code_alignment_factor. All other values in the new row are initially
+      // identical to the current row.
+      Rows.push_back(Row);
+      llvm::Expected<uint64_t> Offset = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!Offset)
+        return Offset.takeError();
+      Row.slideAddress(*Offset);
+      break;
+    }
+
+    case dwarf::DW_CFA_restore:
+    case dwarf::DW_CFA_restore_extended: {
+      // The DW_CFA_restore instruction takes a single operand (encoded with
+      // the opcode) that represents a register number. The required action
+      // is to change the rule for the indicated register to the rule
+      // assigned it by the initial_instructions in the CIE.
+      if (InitialLocs == nullptr)
+        return createStringError(
+            errc::invalid_argument, "%s encountered while parsing a CIE",
+            CFIP.callFrameString(Inst.Opcode).str().c_str());
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      if (Optional<UnwindLocation> O =
+              InitialLocs->getRegisterLocation(*RegNum))
+        Row.getRegisterLocations().setRegisterLocation(*RegNum, *O);
+      else
+        Row.getRegisterLocations().removeRegisterLocation(*RegNum);
+      break;
+    }
+
+    case dwarf::DW_CFA_offset:
+    case dwarf::DW_CFA_offset_extended:
+    case dwarf::DW_CFA_offset_extended_sf: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 1);
+      if (!Offset)
+        return Offset.takeError();
+      Row.getRegisterLocations().setRegisterLocation(
+          *RegNum, UnwindLocation::createAtCFAPlusOffset(*Offset));
+      break;
+    }
+
+    case dwarf::DW_CFA_nop:
+      break;
+
+    case dwarf::DW_CFA_remember_state:
+      RegisterStates.push_back(Row.getRegisterLocations());
+      break;
+
+    case dwarf::DW_CFA_restore_state:
+      if (RegisterStates.empty())
+        return createStringError(errc::invalid_argument,
+                                 "DW_CFA_restore_state without a matching "
+                                 "previous DW_CFA_remember_state");
+      Row.getRegisterLocations() = RegisterStates.back();
+      RegisterStates.pop_back();
+      break;
+
+    case dwarf::DW_CFA_GNU_window_save:
+      switch (CFIP.triple()) {
+      case Triple::aarch64:
+      case Triple::aarch64_be:
+      case Triple::aarch64_32: {
+        // DW_CFA_GNU_window_save is used for different things on different
+        // architectures. For aarch64 it is known as
+        // DW_CFA_AARCH64_negate_ra_state. The action is to toggle the
+        // value of the return address state between 1 and 0. If there is
+        // no rule for the AARCH64_DWARF_PAUTH_RA_STATE register, then it
+        // should be initially set to 1.
+        constexpr uint32_t AArch64DWARFPAuthRaState = 34;
+        auto LRLoc = Row.getRegisterLocations().getRegisterLocation(
+            AArch64DWARFPAuthRaState);
+        if (LRLoc) {
+          if (LRLoc->getLocation() == UnwindLocation::Constant) {
+            // Toggle the constant value from 0 to 1 or 1 to 0.
+            LRLoc->setConstant(LRLoc->getConstant() ^ 1);
+          } else {
+            return createStringError(
+                errc::invalid_argument,
+                "%s encountered when existing rule for this register is not "
+                "a constant",
+                CFIP.callFrameString(Inst.Opcode).str().c_str());
+          }
+        } else {
+          Row.getRegisterLocations().setRegisterLocation(
+              AArch64DWARFPAuthRaState, UnwindLocation::createIsConstant(1));
+        }
+        break;
+      }
+
+      case Triple::sparc:
+      case Triple::sparcv9:
+      case Triple::sparcel:
+        for (uint32_t RegNum = 16; RegNum < 32; ++RegNum) {
+          Row.getRegisterLocations().setRegisterLocation(
+              RegNum, UnwindLocation::createAtCFAPlusOffset((RegNum - 16) * 8));
+        }
+        break;
+
+      default: {
+        return createStringError(
+            errc::not_supported,
+            "DW_CFA opcode %#x is not supported for architecture %s",
+            Inst.Opcode, Triple::getArchTypeName(CFIP.triple()).str().c_str());
+
+        break;
+      }
+      }
+      break;
+
+    case dwarf::DW_CFA_undefined: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      Row.getRegisterLocations().setRegisterLocation(
+          *RegNum, UnwindLocation::createUndefined());
+      break;
+    }
+
+    case dwarf::DW_CFA_same_value: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      Row.getRegisterLocations().setRegisterLocation(
+          *RegNum, UnwindLocation::createSame());
+      break;
+    }
+
+    case dwarf::DW_CFA_GNU_args_size:
+      break;
+
+    case dwarf::DW_CFA_register: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      llvm::Expected<uint64_t> NewRegNum = Inst.getOperandAsUnsigned(CFIP, 1);
+      if (!NewRegNum)
+        return NewRegNum.takeError();
+      Row.getRegisterLocations().setRegisterLocation(
+          *RegNum, UnwindLocation::createIsRegisterPlusOffset(*NewRegNum, 0));
+      break;
+    }
+
+    case dwarf::DW_CFA_val_offset:
+    case dwarf::DW_CFA_val_offset_sf: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 1);
+      if (!Offset)
+        return Offset.takeError();
+      Row.getRegisterLocations().setRegisterLocation(
+          *RegNum, UnwindLocation::createIsCFAPlusOffset(*Offset));
+      break;
+    }
 
+    case dwarf::DW_CFA_expression: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      Row.getRegisterLocations().setRegisterLocation(
+          *RegNum, UnwindLocation::createAtDWARFExpression(*Inst.Expression));
+      break;
+    }
 
-} // end anonymous namespace
+    case dwarf::DW_CFA_val_expression: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      Row.getRegisterLocations().setRegisterLocation(
+          *RegNum, UnwindLocation::createIsDWARFExpression(*Inst.Expression));
+      break;
+    }
+
+    case dwarf::DW_CFA_def_cfa_register: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      if (Row.getCFAValue().getLocation() != UnwindLocation::RegPlusOffset)
+        Row.getCFAValue() =
+            UnwindLocation::createIsRegisterPlusOffset(*RegNum, 0);
+      else
+        Row.getCFAValue().setRegister(*RegNum);
+      break;
+    }
+
+    case dwarf::DW_CFA_def_cfa_offset:
+    case dwarf::DW_CFA_def_cfa_offset_sf: {
+      llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 0);
+      if (!Offset)
+        return Offset.takeError();
+      if (Row.getCFAValue().getLocation() != UnwindLocation::RegPlusOffset) {
+        return createStringError(
+            errc::invalid_argument,
+            "%s found when CFA rule was not RegPlusOffset",
+            CFIP.callFrameString(Inst.Opcode).str().c_str());
+      }
+      Row.getCFAValue().setOffset(*Offset);
+      break;
+    }
+
+    case dwarf::DW_CFA_def_cfa:
+    case dwarf::DW_CFA_def_cfa_sf: {
+      llvm::Expected<uint64_t> RegNum = Inst.getOperandAsUnsigned(CFIP, 0);
+      if (!RegNum)
+        return RegNum.takeError();
+      llvm::Expected<int64_t> Offset = Inst.getOperandAsSigned(CFIP, 1);
+      if (!Offset)
+        return Offset.takeError();
+      Row.getCFAValue() =
+          UnwindLocation::createIsRegisterPlusOffset(*RegNum, *Offset);
+      break;
+    }
+
+    case dwarf::DW_CFA_def_cfa_expression:
+      Row.getCFAValue() =
+          UnwindLocation::createIsDWARFExpression(*Inst.Expression);
+      break;
+    }
+  }
+  return Error::success();
+}
 
 ArrayRef<CFIProgram::OperandType[2]> CFIProgram::getOperandTypes() {
   static OperandType OpTypes[DW_CFA_restore+1][2];
   static bool Initialized = false;
   if (Initialized) {
     return ArrayRef<OperandType[2]>(&OpTypes[0], DW_CFA_restore+1);
   }
   Initialized = true;
 
 #define DECLARE_OP2(OP, OPTYPE0, OPTYPE1)       \
   do {                                          \
     OpTypes[OP][0] = OPTYPE0;                   \
     OpTypes[OP][1] = OPTYPE1;                   \
   } while (false)
 #define DECLARE_OP1(OP, OPTYPE0) DECLARE_OP2(OP, OPTYPE0, OT_None)
 #define DECLARE_OP0(OP) DECLARE_OP1(OP, OT_None)
 
   DECLARE_OP1(DW_CFA_set_loc, OT_Address);
   DECLARE_OP1(DW_CFA_advance_loc, OT_FactoredCodeOffset);
void CFIProgram::printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
                               uint64_t Operand) const {
   assert(OperandIdx < 2);
   uint8_t Opcode = Instr.Opcode;
   OperandType Type = getOperandTypes()[Opcode][OperandIdx];
 
   switch (Type) {
   case OT_Unset: {
     OS << " Unsupported " << (OperandIdx ? "second" : "first") << " operand to";
-    auto OpcodeName = CallFrameString(Opcode, Arch);
+    auto OpcodeName = callFrameString(Opcode);
     if (!OpcodeName.empty())
       OS << " " << OpcodeName;
     else
       OS << format(" Opcode %x",  Opcode);
     break;
   }
   case OT_None:
     break;
case OT_FactoredCodeOffset: // Always Unsigned
     else
       OS << format(" %" PRId64 "*code_alignment_factor" , Operand);
     break;
   case OT_SignedFactDataOffset:
     if (DataAlignmentFactor)
       OS << format(" %" PRId64, int64_t(Operand) * DataAlignmentFactor);
     else
       OS << format(" %" PRId64 "*data_alignment_factor" , int64_t(Operand));
     break;
   case OT_UnsignedFactDataOffset:
     if (DataAlignmentFactor)
       OS << format(" %" PRId64, Operand * DataAlignmentFactor);
     else
       OS << format(" %" PRId64 "*data_alignment_factor" , Operand);
     break;
   case OT_Register:
     OS << ' ';
     printRegister(OS, MRI, IsEH, Operand);
     break;
   case OT_Expression:
     assert(Instr.Expression && "missing DWARFExpression object");
     OS << " ";
     Instr.Expression->print(OS, DumpOpts, MRI, nullptr, IsEH);
     break;
   }
 }
 
 void CFIProgram::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
                       const MCRegisterInfo *MRI, bool IsEH,
                       unsigned IndentLevel) const {
   for (const auto &Instr : Instructions) {
     uint8_t Opcode = Instr.Opcode;
-    if (Opcode & DWARF_CFI_PRIMARY_OPCODE_MASK)
-      Opcode &= DWARF_CFI_PRIMARY_OPCODE_MASK;
     OS.indent(2 * IndentLevel);
-    OS << CallFrameString(Opcode, Arch) << ":";
+    OS << callFrameString(Opcode) << ":";
     for (unsigned i = 0; i < Instr.Ops.size(); ++i)
       printOperand(OS, DumpOpts, MRI, IsEH, Instr, i, Instr.Ops[i]);
     OS << '\n';
   }
 }
 
 // Returns the CIE identifier to be used by the requested format.
 // CIE ids for .debug_frame sections are defined in Section 7.24 of DWARFv5.
 // For CIE ID in .eh_frame sections see
 // https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
 constexpr uint64_t getCIEId(bool IsDWARF64, bool IsEH) {
   if (IsEH)
     return 0;
   if (IsDWARF64)
     return DW64_CIE_ID;
   return DW_CIE_ID;
 }
 
 void CIE::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
                const MCRegisterInfo *MRI, bool IsEH) const {
   // A CIE with a zero length is a terminator entry in the .eh_frame section.
   if (IsEH && Length == 0) {
     OS << format("%08" PRIx64, Offset) << " ZERO terminator\n";
     return;
   }
 
   OS << format("%08" PRIx64, Offset)
      << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
      << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8,
                getCIEId(IsDWARF64, IsEH))
      << " CIE\n"
      << "  Format:                " << FormatString(IsDWARF64) << "\n"
      << format("  Version:               %d\n", Version)
      << "  Augmentation:          \"" << Augmentation << "\"\n";
   if (Version >= 4) {
if (!AugmentationData.empty()) {
     OS << "  Augmentation data:    ";
     for (uint8_t Byte : AugmentationData)
       OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
     OS << "\n";
   }
   OS << "\n";
   CFIs.dump(OS, DumpOpts, MRI, IsEH);
   OS << "\n";
+
+  if (Expected<UnwindTable> RowsOrErr = UnwindTable::create(this))
+    RowsOrErr->dump(OS, MRI, IsEH, 1);
+  else
+    OS << "  error: decoding the CIE opcodes into rows failed: "
+       << toString(RowsOrErr.takeError()) << "\n";
+  OS << "\n";
 }
 
 void FDE::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
                const MCRegisterInfo *MRI, bool IsEH) const {
   OS << format("%08" PRIx64, Offset)
      << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
      << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8, CIEPointer)
      << " FDE cie=";
   if (LinkedCIE)
     OS << format("%08" PRIx64, LinkedCIE->getOffset());
   else
     OS << "<invalid offset>";
   OS << format(" pc=%08" PRIx64 "...%08" PRIx64 "\n", InitialLocation,
                InitialLocation + AddressRange);
   OS << "  Format:       " << FormatString(IsDWARF64) << "\n";
   if (LSDAAddress)
     OS << format("  LSDA Address: %016" PRIx64 "\n", *LSDAAddress);
   CFIs.dump(OS, DumpOpts, MRI, IsEH);
   OS << "\n";
+
+  if (Expected<UnwindTable> RowsOrErr = UnwindTable::create(this))
+    RowsOrErr->dump(OS, MRI, IsEH, 1);
+  else
+    OS << "  error: decoding the CIE opcodes into rows failed: "
+       << toString(RowsOrErr.takeError()) << "\n";
+  OS << "\n";
 }
 
 DWARFDebugFrame::DWARFDebugFrame(Triple::ArchType Arch,
     bool IsEH, uint64_t EHFrameAddress)
     : Arch(Arch), IsEH(IsEH), EHFrameAddress(EHFrameAddress) {}
 
 DWARFDebugFrame::~DWARFDebugFrame() = default;
 

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

static bool printCompactDWARFExpr(raw_ostream &OS, DWARFExpression::iterator I,
 
   return true;
 }
 
 bool DWARFExpression::printCompact(raw_ostream &OS, const MCRegisterInfo &MRI) {
   return printCompactDWARFExpr(OS, begin(), end(), MRI);
 }
 
+bool DWARFExpression::operator==(const DWARFExpression &RHS) const {
+  if (AddressSize != RHS.AddressSize || Format != RHS.Format)
+    return false;
+  return Data.getData() == RHS.Data.getData();
+}
+
 } // namespace llvm

llvm/test/tools/llvm-objdump/eh_frame-mipsel.test

 # RUN: llvm-objdump --dwarf=frames %p/Inputs/eh_frame.elf-mipsel | FileCheck %s
 
 # CHECK:       .eh_frame contents:
 # CHECK-EMPTY:
 # CHECK-NEXT:  00000000 00000018 00000000 CIE
 # CHECK-NEXT:    Format:                DWARF32
 # CHECK-NEXT:    Version:               1
 # CHECK-NEXT:    Augmentation:          "zPLR"
 # CHECK-NEXT:    Code alignment factor: 1
 # CHECK-NEXT:    Data alignment factor: -4
 # CHECK-NEXT:    Return address column: 31
 # CHECK-NEXT:    Personality Address: 0000000000410b90
 # CHECK-NEXT:    Augmentation data:     80 90 0B 41 00 00 0B
 # CHECK-EMPTY:
 # CHECK-NEXT:  DW_CFA_def_cfa: reg29 +0
 # CHECK-EMPTY:
+# CHECK-NEXT:  CFA=reg29
+# CHECK-EMPTY:
 # CHECK-NEXT:  0000001c 00000018 00000020 FDE cie=00000000 pc=00400890...004008dc
 # CHECK-NEXT:    Format:       DWARF32
 # CHECK-NEXT:    LSDA Address: 0000000000400a90
 # CHECK-NEXT:    DW_CFA_advance_loc: 4
 # CHECK-NEXT:    DW_CFA_def_cfa_offset: +24
 # CHECK-NEXT:    DW_CFA_advance_loc: 4
 # CHECK-NEXT:    DW_CFA_offset: reg31 -4
 # CHECK-NEXT:    DW_CFA_nop:
 # CHECK-EMPTY:
+# CHECK-NEXT:    0x400890: CFA=reg29
+# CHECK-NEXT:    0x400894: CFA=reg29+24
+# CHECK-NEXT:    0x400898: CFA=reg29+24: reg31=[CFA-4]
+# CHECK-EMPTY:
 # CHECK-NEXT:  00000038 ZERO terminator
 # CHECK-NOT: {{.}}

llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp

static Error parseCFI(dwarf::CIE &C, ArrayRef<uint8_t> Instructions,
                       Optional<uint64_t> Size = None) {
   DWARFDataExtractor Data(Instructions, /*IsLittleEndian=*/true,
                           /*AddressSize=*/8);
   uint64_t Offset = 0;
   const uint64_t EndOffset = Size ? *Size : (uint64_t)Instructions.size();
   return C.cfis().parse(Data, &Offset, EndOffset);
 }
 
+static Error parseCFI(dwarf::FDE &FDE, ArrayRef<uint8_t> Instructions) {
+  DWARFDataExtractor Data(Instructions, /*IsLittleEndian=*/true,
+                          /*AddressSize=*/8);
+  uint64_t Offset = 0;
+  return FDE.cfis().parse(Data, &Offset, Instructions.size());
+}
+
 TEST(DWARFDebugFrame, InvalidCFIOpcodesTest) {
   llvm::DenseSet<uint8_t> ValidExtendedOpcodes = {
       dwarf::DW_CFA_nop,
       dwarf::DW_CFA_advance_loc,
       dwarf::DW_CFA_offset,
       dwarf::DW_CFA_restore,
       dwarf::DW_CFA_set_loc,
       dwarf::DW_CFA_advance_loc1,
EXPECT_THAT_ERROR(
         FailedWithMessage(
             "unexpected end of data at offset 0x3 while reading [0x3, 0x4)"));
   };
 
   for (uint8_t Inst : {dwarf::DW_CFA_expression, dwarf::DW_CFA_val_expression})
     CheckOp_ULEB128_Expr(Inst);
 }
 
+void expectDumpResult(const dwarf::UnwindLocation &Loc,
+                      StringRef ExpectedFirstLine) {
+  std::string Output;
+  raw_string_ostream OS(Output);
+  OS << Loc;
+  OS.flush();
+  StringRef FirstLine = StringRef(Output).split('\n').first;
+  EXPECT_EQ(FirstLine, ExpectedFirstLine);
+}
+
+TEST(DWARFDebugFrame, DumpUnwindLocations) {
+  // Test constructing unwind locations and dumping each kind.
+  constexpr int32_t PlusOff = 8;
+  constexpr int32_t MinusOff = -8;
+  constexpr uint32_t RegNum = 12;
+  expectDumpResult(dwarf::UnwindLocation::createUnspecified(), "unspecified");
+  expectDumpResult(dwarf::UnwindLocation::createUndefined(), "undefined");
+  expectDumpResult(dwarf::UnwindLocation::createSame(), "same");
+  expectDumpResult(dwarf::UnwindLocation::createIsCFAPlusOffset(PlusOff),
+                   "CFA+8");
+  expectDumpResult(dwarf::UnwindLocation::createIsCFAPlusOffset(MinusOff),
+                   "CFA-8");
+  expectDumpResult(dwarf::UnwindLocation::createAtCFAPlusOffset(PlusOff),
+                   "[CFA+8]");
+  expectDumpResult(dwarf::UnwindLocation::createAtCFAPlusOffset(MinusOff),
+                   "[CFA-8]");
+
+  expectDumpResult(
+      dwarf::UnwindLocation::createIsRegisterPlusOffset(RegNum, PlusOff),
+      "reg12+8");
+  expectDumpResult(
+      dwarf::UnwindLocation::createIsRegisterPlusOffset(RegNum, MinusOff),
+      "reg12-8");
+  expectDumpResult(
+      dwarf::UnwindLocation::createAtRegisterPlusOffset(RegNum, PlusOff),
+      "[reg12+8]");
+  expectDumpResult(
+      dwarf::UnwindLocation::createAtRegisterPlusOffset(RegNum, MinusOff),
+      "[reg12-8]");
+  expectDumpResult(dwarf::UnwindLocation::createIsConstant(12), "12");
+  expectDumpResult(dwarf::UnwindLocation::createIsConstant(-32), "-32");
+}
+
+void expectDumpResult(const dwarf::RegisterLocations &Locs,
+                      StringRef ExpectedFirstLine) {
+  std::string Output;
+  raw_string_ostream OS(Output);
+  OS << Locs;
+  OS.flush();
+  StringRef FirstLine = StringRef(Output).split('\n').first;
+  EXPECT_EQ(FirstLine, ExpectedFirstLine);
+}
+
+TEST(DWARFDebugFrame, RegisterLocations) {
+  // Test the functionality of the RegisterLocations class.
+  dwarf::RegisterLocations Locs;
+  expectDumpResult(Locs, "");
+  EXPECT_FALSE(Locs.hasLocations());
+  // Set a register location for reg12 to unspecified and verify it dumps
+  // correctly.
+  Locs.setRegisterLocation(12, dwarf::UnwindLocation::createUnspecified());
+  EXPECT_TRUE(Locs.hasLocations());
+  expectDumpResult(Locs, "reg12=unspecified");
+
+  // Replace the register location for reg12 to "same" and verify it dumps
+  // correctly after it is modified
+  Locs.setRegisterLocation(12, dwarf::UnwindLocation::createSame());
+  EXPECT_TRUE(Locs.hasLocations());
+  expectDumpResult(Locs, "reg12=same");
+
+  // Remove the register location for reg12 verify it dumps correctly after it
+  // is removed.
+  Locs.removeRegisterLocation(12);
+  EXPECT_FALSE(Locs.hasLocations());
+  expectDumpResult(Locs, "");
+
+  // Verify multiple registers added to the list dump correctly.
+  auto Reg12Loc = dwarf::UnwindLocation::createAtCFAPlusOffset(4);
+  auto Reg13Loc = dwarf::UnwindLocation::createAtCFAPlusOffset(8);
+  auto Reg14Loc = dwarf::UnwindLocation::createSame();
+  Locs.setRegisterLocation(12, Reg12Loc);
+  Locs.setRegisterLocation(13, Reg13Loc);
+  Locs.setRegisterLocation(14, Reg14Loc);
+  EXPECT_TRUE(Locs.hasLocations());
+  expectDumpResult(Locs, "reg12=[CFA+4], reg13=[CFA+8], reg14=same");
+
+  // Verify RegisterLocations::getRegisterLocation() works as expected.
+  Optional<dwarf::UnwindLocation> OptionalLoc;
+  OptionalLoc = Locs.getRegisterLocation(0);
+  EXPECT_FALSE(OptionalLoc.hasValue());
+
+  OptionalLoc = Locs.getRegisterLocation(12);
+  EXPECT_TRUE(OptionalLoc.hasValue());
+  EXPECT_EQ(*OptionalLoc, Reg12Loc);
+
+  OptionalLoc = Locs.getRegisterLocation(13);
+  EXPECT_TRUE(OptionalLoc.hasValue());
+  EXPECT_EQ(*OptionalLoc, Reg13Loc);
+
+  OptionalLoc = Locs.getRegisterLocation(14);
+  EXPECT_TRUE(OptionalLoc.hasValue());
+  EXPECT_EQ(*OptionalLoc, Reg14Loc);
+
+  // Verify registers are correctly removed when multiple exist in the list.
+  Locs.removeRegisterLocation(13);
+  EXPECT_FALSE(Locs.getRegisterLocation(13).hasValue());
+  EXPECT_TRUE(Locs.hasLocations());
+  expectDumpResult(Locs, "reg12=[CFA+4], reg14=same");
+  Locs.removeRegisterLocation(14);
+  EXPECT_FALSE(Locs.getRegisterLocation(14).hasValue());
+  EXPECT_TRUE(Locs.hasLocations());
+  expectDumpResult(Locs, "reg12=[CFA+4]");
+  Locs.removeRegisterLocation(12);
+  EXPECT_FALSE(Locs.getRegisterLocation(12).hasValue());
+  EXPECT_FALSE(Locs.hasLocations());
+  expectDumpResult(Locs, "");
+}
+
+TEST(DWARFDebugFrame, UnwindTableErrorNonAscendingFDERows) {
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition.
+  constexpr uint8_t Reg = 12;
+  constexpr uint8_t Offset = 32;
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, Reg, Offset}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that have valid
+  // syntax, but will cause an error when we parse them into a UnwindTable.
+  // Here we encode two DW_CFA_set_loc opcodes:
+  //   DW_CFA_set_loc(0x1100)
+  //   DW_CFA_set_loc(0x1000)
+  // These opcodes cause a new row to be appended to the rows in a UnwindTable
+  // and the resulting rows are not in ascending address order and should cause
+  // a state machine error.
+  EXPECT_THAT_ERROR(
+      parseCFI(TestFDE, {dwarf::DW_CFA_set_loc, 0x00, 0x11, 0, 0, 0, 0, 0, 0,
+                         dwarf::DW_CFA_set_loc, 0x00, 0x10, 0, 0, 0, 0, 0, 0}),
+      Succeeded());
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(),
+                    FailedWithMessage("DW_CFA_set_loc with adrress 0x1000 which"
+                                      " must be greater than the current row "
+                                      "address 0x1100"));
+}
+
+TEST(DWARFDebugFrame, UnwindTableError_DW_CFA_restore_state) {
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition.
+  constexpr uint8_t Reg = 12;
+  constexpr uint8_t Offset = 32;
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, Reg, Offset}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that have valid
+  // syntax, but will cause an error when we parse them into a UnwindTable.
+  // Here we encode a DW_CFA_restore_state opcode that was not preceded by a
+  // DW_CFA_remember_state, and an error should be returned.
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_restore_state}),
+                    Succeeded());
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(),
+                    FailedWithMessage("DW_CFA_restore_state without a matching "
+                                      "previous DW_CFA_remember_state"));
+}
+
+TEST(DWARFDebugFrame, UnwindTableError_DW_CFA_GNU_window_save) {
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition.
+  constexpr uint8_t Reg = 12;
+  constexpr uint8_t Offset = 32;
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, Reg, Offset}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that have valid
+  // syntax, but will cause an error when we parse them into a UnwindTable.
+  // Here we encode a DW_CFA_GNU_window_save that is not supported. I have not
+  // found any documentation that describes what this does after some brief
+  // searching.
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_GNU_window_save}),
+                    Succeeded());
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(),
+                    FailedWithMessage("DW_CFA opcode 0x2d is not supported for "
+                                      "architecture x86_64"));
+}
+
+TEST(DWARFDebugFrame, UnwindTableError_DW_CFA_def_cfa_offset) {
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has an invalid CFA definition. We do this so we can try
+  // and use a DW_CFA_def_cfa_register opcode in the FDE and get an appropriate
+  // error back.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {}), Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that have valid
+  // syntax, but will cause an error when we parse them into a UnwindTable.
+  // Here we encode a DW_CFA_def_cfa_offset with a offset of 16, but our CIE
+  // didn't define the CFA in terms of a register plus offset, so this should
+  // cause an error.
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_def_cfa_offset, 16}),
+                    Succeeded());
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(),
+                    FailedWithMessage("DW_CFA_def_cfa_offset found when CFA "
+                                      "rule was not RegPlusOffset"));
+}
+
+TEST(DWARFDebugFrame, UnwindTableDefCFAOffsetSFCFAError) {
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has an invalid CFA definition. We do this so we can try
+  // and use a DW_CFA_def_cfa_offset_sf opcode in the FDE and get an
+  // appropriate error back.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {}), Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that have valid
+  // syntax, but will cause an error when we parse them into a UnwindTable.
+  // Here we encode a DW_CFA_def_cfa_offset_sf with a offset of 4, but our CIE
+  // didn't define the CFA in terms of a register plus offset, so this should
+  // cause an error.
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_def_cfa_offset_sf, 4}),
+                    Succeeded());
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(),
+                    FailedWithMessage("DW_CFA_def_cfa_offset_sf found when CFA "
+                                      "rule was not RegPlusOffset"));
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_def_cfa_register) {
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has only defines the CFA register with no offset. Some
+  // architectures do this and we must ensure that we set the CFA value to be
+  // equal to that register with no offset.
+  constexpr uint8_t CFAReg = 12;
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa_register, CFAReg}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that have valid
+  // syntax, but will cause an error when we parse them into a UnwindTable.
+  // Here we encode a DW_CFA_def_cfa_register with a register number of 12, but
+  // our CIE didn't define the CFA in terms of a register plus offset, so this
+  // should cause an error.
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {}), Succeeded());
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getCFAValue(),
+            dwarf::UnwindLocation::createIsRegisterPlusOffset(CFAReg, 0));
+}
+
+TEST(DWARFDebugFrame, UnwindTableRowPushingOpcodes) {
+  // Test all opcodes that should end up pushing a UnwindRow into a UnwindTable.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  constexpr uint8_t CFAReg = 12;
+  constexpr uint8_t CFAOffset = 32;
+  constexpr uint8_t Reg = 13;
+  constexpr uint8_t InReg = 14;
+
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, CFAReg, CFAOffset,
+                                       dwarf::DW_CFA_register, Reg, InReg}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that use all of the
+  // row pushing opcodes. This will verify that all opcodes that should create
+  // a row are correctly working. Each opcode will push a row prior to
+  // advancing the address, and then a row will be automatically pushed at the
+  // end of the parsing, so we should end up with 6 rows starting at address
+  // 0x1000 (from the FDE) and incrementing each one by 4 * CodeAlignmentFactor
+  // from the CIE.
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_advance_loc | 4,
+                                       dwarf::DW_CFA_advance_loc1,
+                                       4,
+                                       dwarf::DW_CFA_advance_loc2,
+                                       4,
+                                       0,
+                                       dwarf::DW_CFA_advance_loc4,
+                                       4,
+                                       0,
+                                       0,
+                                       0,
+                                       dwarf::DW_CFA_set_loc,
+                                       0x14,
+                                       0x10,
+                                       0,
+                                       0,
+                                       0,
+                                       0,
+                                       0,
+                                       0}),
+                    Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+  VerifyLocs.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createIsRegisterPlusOffset(InReg, 0));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  ASSERT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 6u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+  EXPECT_EQ(Rows[1].getAddress(), 0x1004u);
+  EXPECT_EQ(Rows[1].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[1].getRegisterLocations(), VerifyLocs);
+  EXPECT_EQ(Rows[2].getAddress(), 0x1008u);
+  EXPECT_EQ(Rows[2].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[2].getRegisterLocations(), VerifyLocs);
+  EXPECT_EQ(Rows[3].getAddress(), 0x100cu);
+  EXPECT_EQ(Rows[3].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[3].getRegisterLocations(), VerifyLocs);
+  EXPECT_EQ(Rows[4].getAddress(), 0x1010u);
+  EXPECT_EQ(Rows[4].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[4].getRegisterLocations(), VerifyLocs);
+  EXPECT_EQ(Rows[5].getAddress(), 0x1014u);
+  EXPECT_EQ(Rows[5].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[5].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_restore) {
+  // Test that DW_CFA_restore works as expected when parsed in the state
+  // machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  constexpr uint8_t CFAReg = 12;
+  constexpr uint8_t CFAOffset = 32;
+  constexpr uint8_t Reg = 13;
+  constexpr uint8_t InReg = 14;
+  constexpr int32_t RegCFAOffset = -8;
+
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, CFAReg, CFAOffset,
+                                       dwarf::DW_CFA_register, Reg, InReg}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that changes the rule
+  // for register "Reg" to be [CFA-8], then push a row, and then restore the
+  // register unwind rule for "Reg" using DW_CFA_restore. We should end up with
+  // two rows:
+  //   - one with Reg = [CFA-8]
+  //   - one with Reg = InReg
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_offset | Reg, 1,
+                                       dwarf::DW_CFA_advance_loc | 4,
+                                       dwarf::DW_CFA_restore | Reg}),
+                    Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs1;
+  VerifyLocs1.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createAtCFAPlusOffset(RegCFAOffset));
+
+  dwarf::RegisterLocations VerifyLocs2;
+  VerifyLocs2.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createIsRegisterPlusOffset(InReg, 0));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 2u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs1);
+  EXPECT_EQ(Rows[1].getAddress(), 0x1004u);
+  EXPECT_EQ(Rows[1].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[1].getRegisterLocations(), VerifyLocs2);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_restore_extended) {
+  // Test that DW_CFA_restore works as expected when parsed in the state
+  // machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  constexpr uint8_t CFAReg = 12;
+  constexpr uint8_t CFAOffset = 32;
+  constexpr uint8_t Reg = 13;
+  constexpr uint8_t InReg = 14;
+  constexpr int32_t RegCFAOffset = -8;
+
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, CFAReg, CFAOffset,
+                                       dwarf::DW_CFA_register, Reg, InReg}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that changes the rule
+  // for register "Reg" to be [CFA-8], then push a row, and then restore the
+  // register unwind rule for "Reg" using DW_CFA_restore_extended. We should
+  // end up with two rows:
+  //   - one with Reg = [CFA-8]
+  //   - one with Reg = InReg
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_offset | Reg, 1,
+                                       dwarf::DW_CFA_advance_loc | 4,
+                                       dwarf::DW_CFA_restore_extended, Reg}),
+                    Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs1;
+  VerifyLocs1.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createAtCFAPlusOffset(RegCFAOffset));
+
+  dwarf::RegisterLocations VerifyLocs2;
+  VerifyLocs2.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createIsRegisterPlusOffset(InReg, 0));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 2u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs1);
+  EXPECT_EQ(Rows[1].getAddress(), 0x1004u);
+  EXPECT_EQ(Rows[1].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[1].getRegisterLocations(), VerifyLocs2);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_offset) {
+  // Test that DW_CFA_offset, DW_CFA_offset_extended and
+  // DW_CFA_offset_extended_sf work as expected when parsed in the state
+  // machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that changes the
+  // unwind rules for the follwing registers:
+  //   Reg1 = [CFA-8]
+  //   Reg2 = [CFA-16]
+  //   Reg3 = [CFA+8]
+  constexpr uint32_t Reg1 = 14;
+  constexpr uint32_t Reg2 = 15;
+  constexpr uint32_t Reg3 = 16;
+  constexpr uint8_t Neg1SLEB = 0x7f;
+  EXPECT_THAT_ERROR(
+      parseCFI(TestFDE,
+               {dwarf::DW_CFA_offset | Reg1, 1, dwarf::DW_CFA_offset_extended,
+                Reg2, 2, dwarf::DW_CFA_offset_extended_sf, Reg3, Neg1SLEB}),
+      Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+  VerifyLocs.setRegisterLocation(
+      Reg1, dwarf::UnwindLocation::createAtCFAPlusOffset(-8));
+  VerifyLocs.setRegisterLocation(
+      Reg2, dwarf::UnwindLocation::createAtCFAPlusOffset(-16));
+  VerifyLocs.setRegisterLocation(
+      Reg3, dwarf::UnwindLocation::createAtCFAPlusOffset(8));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_val_offset) {
+  // Test that DW_CFA_val_offset and DW_CFA_val_offset_sf work as expected when
+  // parsed in the state machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that changes the
+  // unwind rules for the follwing registers:
+  //   Reg1 = [CFA-8]
+  //   Reg2 = [CFA-16]
+  //   Reg3 = [CFA+8]
+  constexpr uint32_t Reg1 = 14;
+  constexpr uint32_t Reg2 = 15;
+  constexpr uint8_t Neg1SLEB = 0x7f;
+  EXPECT_THAT_ERROR(
+      parseCFI(TestFDE, {dwarf::DW_CFA_val_offset, Reg1, 1,
+                         dwarf::DW_CFA_val_offset_sf, Reg2, Neg1SLEB}),
+      Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+  VerifyLocs.setRegisterLocation(
+      Reg1, dwarf::UnwindLocation::createIsCFAPlusOffset(-8));
+  VerifyLocs.setRegisterLocation(
+      Reg2, dwarf::UnwindLocation::createIsCFAPlusOffset(8));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_nop) {
+  // Test that DW_CFA_nop works as expected when parsed in the state machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that changes the
+  // unwind rules for the follwing registers:
+  //   Reg1 = [CFA-8]
+  // The opcodes for setting Reg1 are preceded by a DW_CFA_nop.
+  constexpr uint32_t Reg1 = 14;
+  EXPECT_THAT_ERROR(
+      parseCFI(TestFDE, {dwarf::DW_CFA_nop, dwarf::DW_CFA_offset | Reg1, 1}),
+      Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+  VerifyLocs.setRegisterLocation(
+      Reg1, dwarf::UnwindLocation::createAtCFAPlusOffset(-8));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_remember_state) {
+  // Test that DW_CFA_remember_state and DW_CFA_restore_state work as expected
+  // when parsed in the state machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that encodes the
+  // follwing rows:
+  // 0x1000: CFA=reg12+32: Reg1=[CFA-8]
+  // 0x1004: CFA=reg12+32: Reg1=[CFA-8] Reg2=[CFA-16]
+  // 0x1008: CFA=reg12+32: Reg1=[CFA-8] Reg2=[CFA-16] Reg3=[CFA-24]
+  // 0x100C: CFA=reg12+32: Reg1=[CFA-8] Reg2=[CFA-16]
+  // 0x1010: CFA=reg12+32: Reg1=[CFA-8]
+  // This state machine will:
+  //  - set Reg1 location
+  //  - push a row (from DW_CFA_advance_loc)
+  //  - remember the state
+  //  - set Reg2 location
+  //  - push a row (from DW_CFA_advance_loc)
+  //  - remember the state
+  //  - set Reg3 location
+  //  - push a row (from DW_CFA_advance_loc)
+  //  - remember the state where Reg1 and Reg2 were set
+  //  - push a row (from DW_CFA_advance_loc)
+  //  - remember the state where only Reg1 was set
+  //  - push a row (automatically at the end of instruction parsing)
+  // Then we verify that all registers are correct in all generated rows.
+  constexpr uint32_t Reg1 = 14;
+  constexpr uint32_t Reg2 = 15;
+  constexpr uint32_t Reg3 = 16;
+  EXPECT_THAT_ERROR(
+      parseCFI(TestFDE,
+               {dwarf::DW_CFA_offset | Reg1, 1, dwarf::DW_CFA_advance_loc | 4,
+                dwarf::DW_CFA_remember_state, dwarf::DW_CFA_offset | Reg2, 2,
+                dwarf::DW_CFA_advance_loc | 4, dwarf::DW_CFA_remember_state,
+                dwarf::DW_CFA_offset | Reg3, 3, dwarf::DW_CFA_advance_loc | 4,
+                dwarf::DW_CFA_restore_state, dwarf::DW_CFA_advance_loc | 4,
+                dwarf::DW_CFA_restore_state}),
+      Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs1;
+  VerifyLocs1.setRegisterLocation(
+      Reg1, dwarf::UnwindLocation::createAtCFAPlusOffset(-8));
+
+  dwarf::RegisterLocations VerifyLocs2;
+  VerifyLocs2.setRegisterLocation(
+      Reg1, dwarf::UnwindLocation::createAtCFAPlusOffset(-8));
+  VerifyLocs2.setRegisterLocation(
+      Reg2, dwarf::UnwindLocation::createAtCFAPlusOffset(-16));
+
+  dwarf::RegisterLocations VerifyLocs3;
+  VerifyLocs3.setRegisterLocation(
+      Reg1, dwarf::UnwindLocation::createAtCFAPlusOffset(-8));
+  VerifyLocs3.setRegisterLocation(
+      Reg2, dwarf::UnwindLocation::createAtCFAPlusOffset(-16));
+  VerifyLocs3.setRegisterLocation(
+      Reg3, dwarf::UnwindLocation::createAtCFAPlusOffset(-24));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 5u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs1);
+
+  EXPECT_EQ(Rows[1].getAddress(), 0x1004u);
+  EXPECT_EQ(Rows[1].getRegisterLocations(), VerifyLocs2);
+
+  EXPECT_EQ(Rows[2].getAddress(), 0x1008u);
+  EXPECT_EQ(Rows[2].getRegisterLocations(), VerifyLocs3);
+
+  EXPECT_EQ(Rows[3].getAddress(), 0x100Cu);
+  EXPECT_EQ(Rows[3].getRegisterLocations(), VerifyLocs2);
+
+  EXPECT_EQ(Rows[4].getAddress(), 0x1010u);
+  EXPECT_EQ(Rows[4].getRegisterLocations(), VerifyLocs1);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_undefined) {
+  // Test that DW_CFA_undefined works as expected when parsed in the state
+  // machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that encodes the
+  // follwing rows:
+  // 0x1000: CFA=reg12+32: Reg1=undefined
+  // Then we verify that all registers are correct in all generated rows.
+  constexpr uint32_t Reg1 = 14;
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_undefined, Reg1}),
+                    Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+  VerifyLocs.setRegisterLocation(Reg1,
+                                 dwarf::UnwindLocation::createUndefined());
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_same_value) {
+  // Test that DW_CFA_same_value works as expected when parsed in the state
+  // machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that encodes the
+  // follwing rows:
+  // 0x1000: CFA=reg12+32: Reg1=same
+  // Then we verify that all registers are correct in all generated rows.
+  constexpr uint32_t Reg1 = 14;
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_same_value, Reg1}),
+                    Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+  VerifyLocs.setRegisterLocation(Reg1, dwarf::UnwindLocation::createSame());
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_register) {
+  // Test that DW_CFA_register works as expected when parsed in the state
+  // machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that encodes the
+  // follwing rows:
+  // 0x1000: CFA=reg12+32: Reg1=same
+  // Then we verify that all registers are correct in all generated rows.
+  constexpr uint8_t Reg = 13;
+  constexpr uint8_t InReg = 14;
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_register, Reg, InReg}),
+                    Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+  VerifyLocs.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createIsRegisterPlusOffset(InReg, 0));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_expression) {
+  // Test that DW_CFA_expression works as expected when parsed in the state
+  // machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that encodes the
+  // follwing rows:
+  // 0x1000: CFA=reg12+32: Reg1=DWARFExpr(DW_OP_reg12)
+  // Then we verify that all registers are correct in all generated rows.
+  constexpr uint8_t Reg = 13;
+  constexpr uint8_t AddrSize = 8;
+  EXPECT_THAT_ERROR(
+      parseCFI(TestFDE, {dwarf::DW_CFA_expression, Reg, 1, dwarf::DW_OP_reg12}),
+      Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+
+  DataExtractor ExprData({dwarf::DW_OP_reg12}, true, AddrSize);
+  DWARFExpression Expr(ExprData, AddrSize);
+  VerifyLocs.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createAtDWARFExpression(Expr));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_val_expression) {
+  // Test that DW_CFA_val_expression works as expected when parsed in the state
+  // machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, 12, 32}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that encodes the
+  // follwing rows:
+  // 0x1000: CFA=reg12+32: Reg1=DWARFExpr(DW_OP_reg12)
+  // Then we verify that all registers are correct in all generated rows.
+  constexpr uint8_t Reg = 13;
+  constexpr uint8_t AddrSize = 8;
+  EXPECT_THAT_ERROR(parseCFI(TestFDE, {dwarf::DW_CFA_val_expression, Reg, 1,
+                                       dwarf::DW_OP_reg12}),
+                    Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+
+  DataExtractor ExprData({dwarf::DW_OP_reg12}, true, AddrSize);
+  DWARFExpression Expr(ExprData, AddrSize);
+  VerifyLocs.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createIsDWARFExpression(Expr));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 1u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+}
+
+TEST(DWARFDebugFrame, UnwindTable_DW_CFA_def_cfa) {
+  // Test that DW_CFA_def_cfa, DW_CFA_def_cfa_sf, DW_CFA_def_cfa_register,
+  // DW_CFA_def_cfa_offset, and DW_CFA_def_cfa_offset_sf works as expected when
+  // parsed in the state machine.
+  dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
+                                 /*Offset=*/0x0,
+                                 /*Length=*/0xff);
+
+  dwarf::FDE TestFDE(/*IsDWARF64=*/true,
+                     /*Offset=*/0x3333abcdabcd,
+                     /*Length=*/0x4444abcdabcd,
+                     /*CIEPointer=*/0x1111abcdabcd,
+                     /*InitialLocation=*/0x1000,
+                     /*AddressRange=*/0x1000,
+                     /*Cie=*/&TestCIE,
+                     /*LSDAAddress=*/None,
+                     /*Arch=*/Triple::x86_64);
+
+  // Make a CIE that has a valid CFA definition and a single register unwind
+  // rule for register that we will verify is in all of the pushed rows.
+  constexpr uint8_t CFAReg1 = 12;
+  constexpr uint8_t CFAOff1 = 32;
+  constexpr uint8_t CFAReg2 = 13;
+  constexpr uint8_t CFAOff2 = 48;
+  constexpr uint8_t Reg = 13;
+  constexpr uint8_t InReg = 14;
+
+  EXPECT_THAT_ERROR(parseCFI(TestCIE, {dwarf::DW_CFA_def_cfa, CFAReg1, CFAOff1,
+                                       dwarf::DW_CFA_register, Reg, InReg}),
+                    Succeeded());
+
+  // Make a FDE with DWARF call frame instruction opcodes that use all of the
+  // DW_CFA_def_cfa* opcodes. This will verify that all opcodes that should
+  // create a row are correctly working.
+  EXPECT_THAT_ERROR(
+      parseCFI(
+          TestFDE,
+          {
+              dwarf::DW_CFA_advance_loc | 4, dwarf::DW_CFA_def_cfa_register,
+              CFAReg2, dwarf::DW_CFA_advance_loc | 4,
+              dwarf::DW_CFA_def_cfa_offset, CFAOff2,
+              dwarf::DW_CFA_advance_loc | 4, dwarf::DW_CFA_def_cfa_offset_sf,
+              0x7c, // -4 SLEB to make offset = 32 (CFAOff1)
+              dwarf::DW_CFA_advance_loc | 4, dwarf::DW_CFA_def_cfa_sf, CFAReg1,
+              0x7a, // -6 SLEB to make CFA offset 48 (CFAOff2)
+          }),
+      Succeeded());
+
+  // Create locations that we expect the UnwindRow objects to contain after
+  // parsing the DWARF call frame instructions.
+  dwarf::RegisterLocations VerifyLocs;
+  VerifyLocs.setRegisterLocation(
+      Reg, dwarf::UnwindLocation::createIsRegisterPlusOffset(InReg, 0));
+
+  // Verify we catch state machine error.
+  Expected<dwarf::UnwindTable> RowsOrErr = dwarf::UnwindTable::create(&TestFDE);
+  EXPECT_THAT_ERROR(RowsOrErr.takeError(), Succeeded());
+  const dwarf::UnwindTable &Rows = RowsOrErr.get();
+  EXPECT_EQ(Rows.size(), 5u);
+  EXPECT_EQ(Rows[0].getAddress(), 0x1000u);
+  EXPECT_EQ(
+      Rows[0].getCFAValue(),
+      dwarf::UnwindLocation::createIsRegisterPlusOffset(CFAReg1, CFAOff1));
+  EXPECT_EQ(Rows[0].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[0].getRegisterLocations(), VerifyLocs);
+
+  EXPECT_EQ(Rows[1].getAddress(), 0x1004u);
+  EXPECT_EQ(
+      Rows[1].getCFAValue(),
+      dwarf::UnwindLocation::createIsRegisterPlusOffset(CFAReg2, CFAOff1));
+  EXPECT_EQ(Rows[1].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[1].getRegisterLocations(), VerifyLocs);
+
+  EXPECT_EQ(Rows[2].getAddress(), 0x1008u);
+  EXPECT_EQ(
+      Rows[2].getCFAValue(),
+      dwarf::UnwindLocation::createIsRegisterPlusOffset(CFAReg2, CFAOff2));
+  EXPECT_EQ(Rows[2].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[2].getRegisterLocations(), VerifyLocs);
+
+  EXPECT_EQ(Rows[3].getAddress(), 0x100cu);
+  EXPECT_EQ(
+      Rows[3].getCFAValue(),
+      dwarf::UnwindLocation::createIsRegisterPlusOffset(CFAReg2, CFAOff1));
+  EXPECT_EQ(Rows[3].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[3].getRegisterLocations(), VerifyLocs);
+
+  EXPECT_EQ(Rows[4].getAddress(), 0x1010u);
+  EXPECT_EQ(
+      Rows[4].getCFAValue(),
+      dwarf::UnwindLocation::createIsRegisterPlusOffset(CFAReg1, CFAOff2));
+  EXPECT_EQ(Rows[4].getRegisterLocations().size(), 1u);
+  EXPECT_EQ(Rows[4].getRegisterLocations(), VerifyLocs);
+}
+
 } // end anonymous namespace