[Windows] Use information from the PE32 exceptions directory to construct unwind plans

[aleksandr.urakov]

Summary

This patch adds an implementation of unwinding using PE EH info. It allows to get almost ideal call stacks on 64-bit Windows systems (except some epilogue cases, but I believe that they can be fixed with unwind plan disassembly augmentation in the future).

To achieve the goal the CallFrameInfo abstraction was made. It is based on the DWARFCallFrameInfo class interface with a few changes to make it less DWARF-specific.

To implement the new interface for PECOFF object files the class PECallFrameInfo was written. It uses the next helper classes:

• UnwindCodesIterator helps to iterate through UnwindCode structures (and processes chained infos transparently);
• EHProgramBuilder with the use of UnwindCodesIterator constructs EHProgram;
• EHProgram is, by fact, a vector of EHInstructions. It creates an abstraction over the low-level unwind codes and simplifies work with them. It contains only the information that is relevant to unwinding in the unified form. Also the required unwind codes are read from the object file only once with it;
• EHProgramRange allows to take a range of EHProgram and to build an unwind row for it.

So, PECallFrameInfo builds the EHProgram with EHProgramBuilder, takes the ranges corresponding to every offset in prologue and builds the rows of the resulted unwind plan. The resulted plan covers the whole range of the function except the epilogue.

[clayborg]

At the object file level I would love to see much less of this specific unwind info making it into the ObjectFile interface. Why can't we just ask the ObjectFile to provide an UnwindPlan for a given address. There is so much complexity within the UnwindPlan where it is managing all these specific unwind plans. IMHO we should just ask the ObjectFile for an UnwindPlan and let the ObjectFile decide which one is best. Right now UnwindPlan manages a ton of different kinds of unwind alternatives and UnwindPlan has all sorts of knowledge about each specific unwind plan type (ARM compact unwind, Apple compact unwind, EH frame, .debug_frame, arch default, and more). We seem to be adding to this complexity here by making all ObjectFile instances having to know how to create each different type when UnwindPlan already has the all the abstraction we need in UnwindPlan::Row.

[aleksandr.urakov]

It's a good point, thank you! I had the same thoughts when I done it, but I'm not completely sure. The problem is that an object file can't be completely responsible for choosing an unwind plan, because some plans are produced by symbol files (and an object file knows nothing about that, if I understand right). So we can move only a part of the plan-choosing-functionality from FuncUnwinders to ObjectFiles, but will it be better? In that case both FuncUnwinders and ObjectFiles will be responsible for managing plans, won't it add an additional complexity to the solution?

[labath]

In D67347#1664640, @aleksandr.urakov wrote:

It's a good point, thank you! I had the same thoughts when I done it, but I'm not completely sure. The problem is that an object file can't be completely responsible for choosing an unwind plan, because some plans are produced by symbol files (and an object file knows nothing about that, if I understand right). So we can move only a part of the plan-choosing-functionality from FuncUnwinders to ObjectFiles, but will it be better? In that case both FuncUnwinders and ObjectFiles will be responsible for managing plans, won't it add an additional complexity to the solution?

I spent a lot of time thinking about this when introducing the "breakpad" unwind plans. My conclusion was too, that making ObjectFile solely responsible for this is not a good idea, for the reasons that you already mention (and others), but I haven't really found a solution that would be fully satisfactory. Having the plans be managed by the symbol file is not that great either, because a lot of unwind plans (instruction emulation) really don't have anything to do with symbol files.

The solution that sounded most promising to me back then was making the unwind plan providers pluggable. For instance, the Module (or probably the UnwindTable contained within it) would contain a list of callbacks, which it would invoke when it wanted to create an unwind plan for a given function. Then, anybody could register itself as an unwind info provider. This format seems to be naturally tied to the COFF object files, so the related code could live inside ObjectFilePECOFF. The breakpad unwind info could be provided by SymbolFileBreakpad. Things that are truly independent of any object or symbol file format (like instruction emulation again) could be handled within the UnwindTable by just pre-populating the list of callbacks.

This sounds pretty nice in theory, but what makes it harder in practice is that there isn't just a single ultimate unwind plan for one function. There's the synchronous/asynchronous distinction for one. And then, there are various places throughout the code which reach for a specific unwind method to do some special thing. Doing this is hard if the unwind method is abstracted behind an abstract callback, and it's the reason I gave up on this idea, originally

However, maybe it would be good to resurrect it. The case for a callback solution is stronger if we have two methods that would make use of it (this stuff, and the breakpad format) than it was when we had just one. So, we could port these two methods to the callback mechanism, and others could follow at their own pace. I'd be happy to help with the breakpad side of things if needed.

All that said, I do think there is some degree of elegance in how you've done things in this patch (though I am not a fan of the windows ISomething convention). I've been thinking a lot about what will we do once we get to implementing win64 unwinding, and I haven't though of this. Though, like I already said, none of these solutions seems truly *right*, so I'd like to hear what others think about this too.

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.cpp

16

It doesn't look like this will do the right thing in if host endianness differs from the target. You should use GetMaxU64 instead. (or given that PE should be always little-endian (right?), you could also ditch the DataExtractor and read stuff by casting to llvm::support::ulittleXX_t. I believe that's how most of PECOFF parsing in llvm works.)

179

llvm::array_lengthof

lldb/source/Symbol/DWARFCallFrameInfo.cpp

455

Too much clang format. Please make sure you only format the lines you modify.

lldb/unittests/Symbol/CMakeLists.txt

17 ↗

(On Diff #219314)

As the code you're testing lives in ObjectFilePECOFF, it would probably be better to move this stuff to unittests/ObjectFile/PECOFF (new folder).

[amccarth]

I've been trying to figure out how to implement the same functionality you've got here, so I'm very interested in helping you land this in some form.

I think Clayborg and Pavel makes some good points about where the right layer of abstraction is for the unwind plans. I've copied your patch locally and will try out some different ideas and report back.

This patch is pretty large. It might be easier to break it up into a series of small steps to get there. The bullet points in the CL description might be a good roadmap for such a break-up. But let's first figure out the right abstraction points.

[aleksandr.urakov]

Update diff due to Pavel's requests.

[aleksandr.urakov]

Thanks all for taking a look!

In D67347#1666509, @amccarth wrote:

This patch is pretty large. It might be easier to break it up into a series of small steps to get there. The bullet points in the CL description might be a good roadmap for such a break-up. But let's first figure out the right abstraction points.

I'm open to this, just let me know.

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.cpp

16

I believe that this code is ok: it actually doesn't read a pointer to data, it gets the data read from the file and interprets it like a structure of type T (GetData returns just a pointer to the data buffer). I think it's safe because T can be RuntimeFunction, UnwindInfo or UnwindCode, but all these types are already using ulittleXX_t in their definitions.

lldb/unittests/Symbol/CMakeLists.txt

17 ↗

(On Diff #219314)

My bad, fixed, thank you!

[clayborg]

My opinion is we need to be able to ask both the SymbolFile and ObjectFile for unwind plans in the API, but we can always just ask the SymbolFile for the unwind plan and the default SymbolFile virtual function can just defer to the ObjectFile. We also need to say "I need an async unwind plan" or "I need an sync unwind plan". Since we always have a symbol file, we fall back to SymbolFileSymtab if we don't have DWARF or PDB.

If we look at FuncUnwinders we see just how many different ways we currently have:

class FuncUnwinders {
  ...
  lldb::UnwindPlanSP m_unwind_plan_assembly_sp;
  lldb::UnwindPlanSP m_unwind_plan_eh_frame_sp;
  lldb::UnwindPlanSP m_unwind_plan_debug_frame_sp;
  // augmented by assembly inspection so it's valid everywhere
  lldb::UnwindPlanSP m_unwind_plan_eh_frame_augmented_sp;
  lldb::UnwindPlanSP m_unwind_plan_debug_frame_augmented_sp;
  std::vector<lldb::UnwindPlanSP> m_unwind_plan_compact_unwind;
  lldb::UnwindPlanSP m_unwind_plan_arm_unwind_sp;
  lldb::UnwindPlanSP m_unwind_plan_symbol_file_sp;
  lldb::UnwindPlanSP m_unwind_plan_fast_sp;
  lldb::UnwindPlanSP m_unwind_plan_arch_default_sp;
  lldb::UnwindPlanSP m_unwind_plan_arch_default_at_func_entry_sp;
};

So it seems we need to be able to ask:

• SymbolFile for unwind plan which would be able to get us:
  • m_unwind_plan_debug_frame_sp
  • m_unwind_plan_debug_frame_augmented_sp
  • m_unwind_plan_symbol_file_sp
• ObjectFile for unwind plan which would get us:
  • m_unwind_plan_eh_frame_sp
  • m_unwind_plan_eh_frame_augmented_sp
  • m_unwind_plan_arm_unwind_sp
  • would assembly unwind go here?
• Achitecture plug-ins for unwind plan
  • m_unwind_plan_arch_default_sp
  • m_unwind_plan_arch_default_at_func_entry_sp
  • would assembly unwind go here?

It would be great to clean this up with a function that SymbolFile, ObjectFile and Architecture implement like:

virtual UnwindPlanSP GetUnwindPlan(bool async);

The architecture plug-ins could drop the "bool async" part. But in general this would really clean up the code in FuncUnwinders.

[clayborg]

Added Jason Molenda who owns the unwind stuff so he might be able to comment and help us with this patch.

[jasonmolenda]

Hi Aleksandr, nice job getting this working. I read over the patch and had a couple of initial questions.

I don't understand the creation of the ICallFrameInfo base class. All of the unwind info providers (things which parse their own format and output an UnwindPlan) are independent. We could create a base class for these to give them an interface they must implement if that's helpful to something. I don't understand how DWARFCallFrameInfo and the PE EH format are related; why is it closer than the CompactUnwindInfo or ArmUnwindInfo. I don't understand what the "I" at the beginning of the base class name is indicating, but that's a minor point.

Ideally all details of the input sources are hidden behind the UnwindTable and FuncUnwinders objects in the Module. We obviously have places in generic code that look for a specific unwind source for something unusual. One spot is in a section your patch modifies, in ObjectFileMachO when we don't have an authoritative source of information for function start addresses, we see if we have eh_frame information which gives us the start addresses for every function with eh information.

Most of the unwind formats are not wedded to a specific ObjectFile or SymbolFile format, so having them be separate from the OF/SF class is a good separation IMO. For instance, CompactUnwindInfo is only used, today, on Darwin systems. But it's a pretty clever format and I could see it being adopted on an ELF system. Putting compact unwind parsed in ObjectFileMachO would prevent that kind of flexibility.

I agree with the general point that the FuncUnwinders class is messy, but that mess is mostly contained behind a simple API. I'm not opposed to rethinking this -- plugins is an interesting idea -- but it doesn't bother me a lot given how little this code is typically worked on.

I probably read through the patch too quickly to understand it, but why is this different from other unwind info providers? From the UnwindTable we have access to the ObjectFile and SymbolFile directly - I don't understand the motivation of that part of the change. I don't understand the move of the methods into the ObjectFile class - I don't object to it, but I'm missing the motivation for moving things there from the UnwindTable.

I guess it's best to start out with, the most basic: why isn't this a sources/Symbol/PEUnwindInfo.cpp standalone that UnwindTable instantiates and FuncUnwinders asks for UnwindPlans from.

[amccarth]

I have a couple more questions and some renaming requests.

lldb/include/lldb/Symbol/DWARFCallFrameInfo.h

74

I find the name ForEachEntries confusing. I know this is a leftover from the original code that you're modifying, but I wonder if it can get a better name. In particular, I don't know why it's plural, so I'd expect ForEachEntry, but even that is pretty vague. I realize FDE is DWARF-specific, but at least it gives a clue as to what type of entries are involved.

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.cpp

541

Isn't it possible for more than one RuntimeFunction to intersect with an address range? In normal use, it might not happen because it's being called with constrained ranges, so maybe it's nothing to worry about. I suppose if the range were too large and it encompassed several functions, returning any one of them is acceptable.

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.h

46

nit: missing n: FindRuntimeFunctionIntersectsWithRange

50

m_exception_data is vague. In the constructor, it's referred to as the exception directory, so perhaps m_exception_dir would be a bit more descriptive.

lldb/source/Symbol/ObjectFile.cpp

687

It seems a bit weird for DWARF-specific code to be here, when there are ObjectFile plugins for PECOFF, ELF, and Mach-O. Obviously the PECOFFCallFrameInfo is instantiated in the PECOFF plugin. The ELF and Mach-O versions instantiate DWARFCallFrameInfos. Does the generic ObjectFile need to do the same?

[aleksandr.urakov]

Update due to the requests.

[aleksandr.urakov]

Hi Jason, thanks for the review!

Initially, the reason of these changes was to reuse the code that works with eh_frame, because on Windows we have a very similar compiler generated info designed to help with unwinding stacks during exception handling. That's why I have chosen DWARFCallFrameInfo and have extracted its interface (I in ICallFrameInfo stands for Interface, but I've renamed it to CallFrameInfo in the last patch, because this notation doesn't look common in LLVM).

But there is one more reason that makes it very difficult to just create PECallFrameInfo in UnwindTable like we do with DWARFCallFrameInfo: PECallFrameInfo is coupled very tight with ObjectFilePECOFF and can't work over plain ObjectFile. First of all, it uses several functions for work with relative virtual addresses (RVA), and they are implemented with the use of ObjectFilePECOFF's private variable m_image_base (however, may be it is possible to implement these methods over the ObjectFile interface, I'm not sure about that). The second, it requires information about exception directory location, but it is an inner mechanics of ObjectFilePECOFF. So its relations with ObjectFilePECOFF are not the same as between DWARFCallFrameInfo and ELF or Mach-O.

To resolve the situation we can:

• use something like a dynamic_cast to ObjectFilePECOFF in UnwindTable and create PECallFrameInfo with it. But in this case lldbSymbol becomes dependent on lldbPluginObjectFilePECOFF (and we get a circular dependency);
• extend ObjectFile's interface to make it possible for PECallFrameInfo to work with required PE abstractions. In this case we can just create PECallFrameInfo in UnwindTable like we do with DWARFCallFrameInfo, but it adds weird operations to ObjectFile's interface, which are not related to other object file formats;
• allow ObjectFile to create its own unwind infos by himself.

I've found the last idea good, and decided to redo things in this way (because DWARFCallFrameInfo etc. are working over object files too). But you are right, it also has a negative impact on ObjectFile: it becomes knowing of the things it shouldn't. So in the last patch I have left only a most abstract method, which only allows to get some unwind info from an object file, and introduced corresponding entities in UnwindTable and FuncUnwinders. I think it can be a good start for moving in the direction that Greg suggests.

What do you think of this?

lldb/include/lldb/Symbol/DWARFCallFrameInfo.h

74

I just have removed it from the new version.

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.cpp

541

Yes, it is possible. The problem here is that FuncUnwinders requests the plan with an AddressRange, not with an Address, and the information about the original requested address is lost to that moment. The required AddressRange is calculated in UnwindTable::GetAddressRange, that's why the order of querying unwind infos is important in that function. I think that this logic requires some rework, but it seems that it is not a good idea to do it in this patch.

lldb/source/Symbol/ObjectFile.cpp

687

I just have made a default implementation to avoid duplication of the code in ELF and Mach-O plugins, but I agree, it looks weird here. It was removed in the new implementation.

[labath]

Sorry for the delay, I was OOO. I haven't yet read through all of the discussion, but I wanted to plug into this part.

In D67347#1669877, @aleksandr.urakov wrote:

But there is one more reason that makes it very difficult to just create PECallFrameInfo in UnwindTable like we do with DWARFCallFrameInfo: PECallFrameInfo is coupled very tight with ObjectFilePECOFF and can't work over plain ObjectFile. First of all, it uses several functions for work with relative virtual addresses (RVA), and they are implemented with the use of ObjectFilePECOFF's private variable m_image_base (however, may be it is possible to implement these methods over the ObjectFile interface, I'm not sure about that). The second, it requires information about exception directory location, but it is an inner mechanics of ObjectFilePECOFF. So its relations with ObjectFilePECOFF are not the same as between DWARFCallFrameInfo and ELF or Mach-O.

PE m_image_base is already available through generic object file interfaces. You can access it as obj_file->GetBaseAddress().GetFileAddress(). This is the same way as the Breakpad symbol file plugin does it. As for the location of the exception directory, it sounds like it would not be too horrendous to have the PE plugin parse that and expose this bit as a special section (with it's own special section type etc.). Then, we could (hopefully) write the PE unwind parser in a way which does not depend on object file internals, similar to how the eh_frame parser does it.

That said, there are two reasons I am not 100% in favour of that idea:

• the current location of the unwind parsers (source/Symbol) seems pretty weird to me. The code in this folder already does a lot of stuff, and most of it has nothing to do with unwinding. So, shoving more unwinding code there seems suboptimal. If we go down that path, I would propose we create a new folder (source/Unwind ?) and put the unwind parsers there.
• even with a separate "unwind" folder, it seems slightly weird to have formats which are clearly specific to one {symbol|object}file be in a generic place. I am here mostly thinking of more "exotic" formats like breakpad. While it would be possible (and I am happy to do that) to refactor the breakpad parser to work in this way, in does not seem completely optimal to me. That's why I would still be in favour of some "plugin" mechanism, where unwind formats which are definitely tied to some kind of a file format be implemented there. Then the more generic formats could live in the generic place, and things like breakpad (and possibly PECOFF) could live inside their plugins.

(Overall, don't take my comments as a hard objection to anything. It's just an opinion that I am happy to be overridden on.)

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.cpp

16

Ah sorry. I missed that part. This seems fine then.

[aleksandr.urakov]

Gentle ping! What do you think of this?

[labath]

I'm afraid I don't have much to add beyond what I've already said. I think @jasonmolenda should make the call as to how to move forward here. If the chosen direction requires any changes in how the breakpad unwind info handled, I'm happy to give you a hand there.

[amccarth]

I'm just back from vacation. I agree with Pavel that we need to hear more from Jason at this point. I'm still very interested in helping this land in some form.

[jasonmolenda]

Thanks for all of the work on this patch Aleksandr, I really appreciate the work and this will be a nice addition to lldb. Apologies again for not looking over the revised patch earlier -- this looks really good to me, please do commit it when you have a chance.

[aleksandr.urakov]

Thanks a lot for the review!

[mstorsjo]

Quick question here; will unwinding using DWARF debug info still work like before after this, for binaries that don't use SEH for exception unwinding?

[aleksandr.urakov]

In D67347#1705563, @mstorsjo wrote:

Quick question here; will unwinding using DWARF debug info still work like before after this, for binaries that don't use SEH for exception unwinding?

Hi Martin!

Do I understand the question correctly: you mean x64 Windows binaries with an additional DWARF unwind info inside, right? In that case the info from PE32+ directory should be used, it has a higher priority than the debug info. I think it should have a higher priority because it is used by the system during an unwind and is always presented in x64 binaries, so we have stronger guarantees with it.

In all other cases, when the info in PE32+ directory is not presented, all things should work as usual (then, the DWARF info will be used).

[labath]

In D67347#1705563, @mstorsjo wrote:

Quick question here; will unwinding using DWARF debug info still work like before after this, for binaries that don't use SEH for exception unwinding?

Do you mean debug_frame or eh_frame? debug_frame should be completely unaffected by this. the interaction between eh_frame and SEH is more tricky, but I don't know if that's ever used/emitted on windows (since presumably the system libraries don't know how to read it)...

[mstorsjo]

In D67347#1705611, @labath wrote:

In D67347#1705563, @mstorsjo wrote:

Quick question here; will unwinding using DWARF debug info still work like before after this, for binaries that don't use SEH for exception unwinding?

Do you mean debug_frame or eh_frame? debug_frame should be completely unaffected by this. the interaction between eh_frame and SEH is more tricky, but I don't know if that's ever used/emitted on windows (since presumably the system libraries don't know how to read it)...

I meant debug_frame. Ok, good if that's unaffected.

In MinGW setups, you can have a number of different combinations of both unwind and debug info. The debug info normally is DWARF (i.e. debug_frame), but it can also (in pure clang/lld based environments, not with GCC/binutils) optionally use codeview/PDB.

For unwind info, on x64, SEH is normally used, but it can also optionally use SjLj or DWARF (i.e. eh_frame). For i686 (and armv7), DWARF is the default.

And for the cases where it does use SEH for C++ exception unwinding, it doesn't do it exactly like MSVC does, but it uses a special gcc personality function which unwinds one step at a time with RtlVirtualUnwind. So it still does use the system unwinder facility, but slightly differently.

In D67347#1705573, @aleksandr.urakov wrote:

In D67347#1705563, @mstorsjo wrote:

Quick question here; will unwinding using DWARF debug info still work like before after this, for binaries that don't use SEH for exception unwinding?

Do I understand the question correctly: you mean x64 Windows binaries with an additional DWARF unwind info inside, right? In that case the info from PE32+ directory should be used, it has a higher priority than the debug info. I think it should have a higher priority because it is used by the system during an unwind and is always presented in x64 binaries, so we have stronger guarantees with it.

No, I meant DWARF debug info.

In all other cases, when the info in PE32+ directory is not presented, all things should work as usual (then, the DWARF info will be used).

Ok, that's good.

If I build an environment for x86_64 that uses DWARF for exception handling, ExceptionTableRVA/ExceptionTableSize are zero in the data directory, so I would presume this would be skipped then, and use the DWARF info instead.

[stella.stamenova]

It looks like this changed fixed at least one of the XFAILed tests on Windows:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/9751

So now the test results would be red because of the unexpectedly passing test (if there wasn't another failure). Could you have a look at whether any of the other tests that were XFAILed for the same bug are also now passing and remove the expected failure tags as appropriate?

[stella.stamenova]

In D67347#1706405, @stella.stamenova wrote:

It looks like this changed fixed at least one of the XFAILed tests on Windows:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/9751

So now the test results would be red because of the unexpectedly passing test (if there wasn't another failure). Could you have a look at whether any of the other tests that were XFAILed for the same bug are also now passing and remove the expected failure tags as appropriate?

This is still "failing" on the windows bot. Please fix the issue or revert the change.

[aleksandr.urakov]

@stella.stamenova I've fixed it with r374888, thanks again for pointing to that. The fix of unwind can fix some stepping issues, because stepping logic uses call stack information actively.

lldb/include/lldb/Symbol/DWARFCallFrameInfo.h

 //===-- DWARFCallFrameInfo.h ------------------------------------*- 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 liblldb_DWARFCallFrameInfo_h_
 #define liblldb_DWARFCallFrameInfo_h_
 
 #include <map>
 #include <mutex>
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/dwarf.h"
+#include "lldb/Symbol/ICallFrameInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/Utility/VMRange.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 // DWARFCallFrameInfo is a class which can read eh_frame and DWARF Call Frame
 // Information FDEs.  It stores little information internally. Only two APIs
 // are exported - one to find the high/low pc values of a function given a text
 // address via the information in the eh_frame / debug_frame, and one to
 // generate an UnwindPlan based on the FDE in the eh_frame / debug_frame
 // section.
 
-class DWARFCallFrameInfo {
+class DWARFCallFrameInfo : public virtual ICallFrameInfo {
 public:
   enum Type { EH, DWARF };
 
   DWARFCallFrameInfo(ObjectFile &objfile, lldb::SectionSP &section, Type type);
 
   ~DWARFCallFrameInfo() = default;
 
   // Locate an AddressRange that includes the provided Address in this object's
   // eh_frame/debug_info Returns true if a range is found to cover that
   // address.
-  bool GetAddressRange(Address addr, AddressRange &range);
+  bool GetAddressRange(Address addr, AddressRange &range) override;
 
   /// Return an UnwindPlan based on the call frame information encoded in the
   /// FDE of this DWARFCallFrameInfo section. The returned plan will be valid
   /// (at least) for the given address.
-  bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan);
+  bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan) override;
 
   /// Return an UnwindPlan based on the call frame information encoded in the
   /// FDE of this DWARFCallFrameInfo section. The returned plan will be valid
   /// (at least) for some address in the given range.
-  bool GetUnwindPlan(const AddressRange &range, UnwindPlan &unwind_plan);
-
-  typedef RangeVector<lldb::addr_t, uint32_t> FunctionAddressAndSizeVector;
+  bool GetUnwindPlan(const AddressRange &range, UnwindPlan &unwind_plan) override;
 
   // Build a vector of file address and size for all functions in this Module
   // based on the eh_frame FDE entries.
   //
   // The eh_frame information can be a useful source of file address and size
   // of the functions in a Module.  Often a binary's non-exported symbols are
   // stripped before shipping so lldb won't know the start addr / size of many
   // functions in the Module.  But the eh_frame can help to give the addresses
   // of these stripped symbols, at least.
   //
   // \param[out] function_info
   //      A vector provided by the caller is filled out.  May be empty if no
   //      FDEs/no eh_frame
   //      is present in this Module.
 
   void
-  GetFunctionAddressAndSizeVector(FunctionAddressAndSizeVector &function_info);
+  GetFunctionAddressAndSizeVector(FunctionAddressAndSizeVector &function_info) override;
 
-  void ForEachFDEEntries(
-      const std::function<bool(lldb::addr_t, uint32_t, dw_offset_t)> &callback);
+  void ForEachEntries(const std::function<bool(lldb::addr_t, uint32_t)> &callback) override;
 
 private:
   enum { CFI_AUG_MAX_SIZE = 8, CFI_HEADER_SIZE = 8 };
   enum CFIVersion {
     CFI_VERSION1 = 1, // DWARF v.2
     CFI_VERSION3 = 3, // DWARF v.3
     CFI_VERSION4 = 4  // DWARF v.4, v.5
   };

lldb/include/lldb/Symbol/ICallFrameInfo.h

+//===-- ICallFrameInfo.h ----------------------------------------*- 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 liblldb_ICallFrameInfo_h_
+#define liblldb_ICallFrameInfo_h_
+
+#include "lldb/Core/AddressRange.h"
+#include "lldb/Utility/RangeMap.h"
+
+namespace lldb_private {
+
+class ICallFrameInfo {
+public:
+  virtual ~ICallFrameInfo() = default;
+
+  virtual bool GetAddressRange(Address addr, AddressRange &range) = 0;
+
+  virtual bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan) = 0;
+  virtual bool GetUnwindPlan(const AddressRange &range, UnwindPlan &unwind_plan) = 0;
+
+  typedef RangeVector<lldb::addr_t, uint32_t> FunctionAddressAndSizeVector;
+  virtual void GetFunctionAddressAndSizeVector(FunctionAddressAndSizeVector &function_info) = 0;
+
+  virtual void ForEachEntries(const std::function<bool(lldb::addr_t, uint32_t)> &callback) = 0;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_ICallFrameInfo_h_

lldb/include/lldb/Symbol/ObjectFile.h

public:
   /// start a process itself.
   ///
   /// \param[in] target
   ///     Target where to load.
   ///
   /// \return
   virtual std::vector<LoadableData> GetLoadableData(Target &target);
 
+  virtual std::unique_ptr<ICallFrameInfo> CreateEHCallFrameInfo();
+  virtual std::unique_ptr<ICallFrameInfo> CreateDebugCallFrameInfo();
+  virtual std::unique_ptr<CompactUnwindInfo> CreateCompactUnwindInfo();
+  virtual std::unique_ptr<ArmUnwindInfo> CreateArmUnwindInfo();
+
 protected:
   // Member variables.
   FileSpec m_file;
   Type m_type;
   Strata m_strata;
   lldb::addr_t m_file_offset; ///< The offset in bytes into the file, or the
                               ///address in memory
   lldb::addr_t m_length; ///< The length of this object file if it is known (can

lldb/include/lldb/Symbol/UnwindTable.h

 
 class UnwindTable {
 public:
   /// Create an Unwind table using the data in the given module.
   explicit UnwindTable(Module &module);
 
   ~UnwindTable();
 
-  lldb_private::DWARFCallFrameInfo *GetEHFrameInfo();
-  lldb_private::DWARFCallFrameInfo *GetDebugFrameInfo();
+  lldb_private::ICallFrameInfo *GetEHFrameInfo();
+  lldb_private::ICallFrameInfo *GetDebugFrameInfo();
 
   lldb_private::CompactUnwindInfo *GetCompactUnwindInfo();
 
   ArmUnwindInfo *GetArmUnwindInfo();
   SymbolFile *GetSymbolFile();
 
   lldb::FuncUnwindersSP GetFuncUnwindersContainingAddress(const Address &addr,
                                                           SymbolContext &sc);
private:
   typedef collection::const_iterator const_iterator;
 
   Module &m_module;
   collection m_unwinds;
 
   bool m_initialized; // delay some initialization until ObjectFile is set up
   std::mutex m_mutex;
 
-  std::unique_ptr<DWARFCallFrameInfo> m_eh_frame_up;
-  std::unique_ptr<DWARFCallFrameInfo> m_debug_frame_up;
+  std::unique_ptr<ICallFrameInfo> m_eh_frame_up;
+  std::unique_ptr<ICallFrameInfo> m_debug_frame_up;
   std::unique_ptr<CompactUnwindInfo> m_compact_unwind_up;
   std::unique_ptr<ArmUnwindInfo> m_arm_unwind_up;
 
   DISALLOW_COPY_AND_ASSIGN(UnwindTable);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_UnwindTable_h

lldb/include/lldb/lldb-forward.h

 class CompilerDecl;
 class CompilerDeclContext;
 class CompilerType;
 class CompileUnit;
 class Connection;
 class ConnectionFileDescriptor;
 class ConstString;
 class CXXSyntheticChildren;
-class DWARFCallFrameInfo;
+class ICallFrameInfo;
 class DWARFDataExtractor;
 class DWARFExpression;
 class DataBuffer;
 class DataEncoder;
 class DataExtractor;
 class Debugger;
 class Declaration;
 class DiagnosticManager;

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

private:
   /// given symbol table for each PLT slot.  Returns the number of symbols
   /// added.
   unsigned ParseTrampolineSymbols(lldb_private::Symtab *symbol_table,
                                   lldb::user_id_t start_id,
                                   const ELFSectionHeaderInfo *rela_hdr,
                                   lldb::user_id_t section_id);
 
   void ParseUnwindSymbols(lldb_private::Symtab *symbol_table,
-                          lldb_private::DWARFCallFrameInfo *eh_frame);
+                          lldb_private::ICallFrameInfo *eh_frame);
 
   /// Relocates debug sections
   unsigned RelocateDebugSections(const elf::ELFSectionHeader *rel_hdr,
                                  lldb::user_id_t rel_id,
                                  lldb_private::Symtab *thetab);
 
   unsigned ApplyRelocations(lldb_private::Symtab *symtab,
                             const elf::ELFHeader *hdr,

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 #include <unordered_map>
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
-#include "lldb/Symbol/DWARFCallFrameInfo.h"
+#include "lldb/Symbol/ICallFrameInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/Utility/Status.h"
if (symbol) {
         if (m_symtab_up == nullptr)
           m_symtab_up.reset(new Symtab(reloc_section->GetObjectFile()));
 
         ParseTrampolineSymbols(m_symtab_up.get(), symbol_id, reloc_header,
                                reloc_id);
       }
     }
 
-    if (DWARFCallFrameInfo *eh_frame =
+    if (ICallFrameInfo *eh_frame =
             GetModule()->GetUnwindTable().GetEHFrameInfo()) {
       if (m_symtab_up == nullptr)
         m_symtab_up.reset(new Symtab(this));
       ParseUnwindSymbols(m_symtab_up.get(), eh_frame);
     }
 
     // If we still don't have any symtab then create an empty instance to avoid
     // do the section lookup next time.
if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) {
         RelocateDebugSections(&reloc_header, reloc_id, GetSymtab());
         break;
       }
     }
   }
 }
 
 void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table,
-                                       DWARFCallFrameInfo *eh_frame) {
+                                       ICallFrameInfo *eh_frame) {
   SectionList *section_list = GetSectionList();
   if (!section_list)
     return;
 
   // First we save the new symbols into a separate list and add them to the
   // symbol table after we colleced all symbols we want to add. This is
   // neccessary because adding a new symbol invalidates the internal index of
   // the symtab what causing the next lookup to be slow because it have to
   // recalculate the index first.
   std::vector<Symbol> new_symbols;
 
-  eh_frame->ForEachFDEEntries([this, symbol_table, section_list, &new_symbols](
-      lldb::addr_t file_addr, uint32_t size, dw_offset_t) {
+  eh_frame->ForEachEntries([this, symbol_table, section_list, &new_symbols](
+      lldb::addr_t file_addr, uint32_t size) {
     Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr);
     if (symbol) {
       if (!symbol->GetByteSizeIsValid()) {
         symbol->SetByteSize(size);
         symbol->SetSizeIsSynthesized(true);
       }
     } else {
       SectionSP section_sp =

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (text_section_sp && function_starts_data.GetByteSize()) {
       // load command claiming an eh_frame but it doesn't actually have the
       // eh_frame content.  And if we have a dSYM, we don't need to do any of
       // this fill-in-the-missing-symbols works anyway - the debug info should
       // give us all the functions in the module.
       if (text_section_sp.get() && eh_frame_section_sp.get() &&
           m_type != eTypeDebugInfo) {
         DWARFCallFrameInfo eh_frame(*this, eh_frame_section_sp,
                                     DWARFCallFrameInfo::EH);
-        DWARFCallFrameInfo::FunctionAddressAndSizeVector functions;
+        ICallFrameInfo::FunctionAddressAndSizeVector functions;
         eh_frame.GetFunctionAddressAndSizeVector(functions);
         addr_t text_base_addr = text_section_sp->GetFileAddress();
         size_t count = functions.GetSize();
         for (size_t i = 0; i < count; ++i) {
-          const DWARFCallFrameInfo::FunctionAddressAndSizeVector::Entry *func =
+          const ICallFrameInfo::FunctionAddressAndSizeVector::Entry *func =
               functions.GetEntryAtIndex(i);
           if (func) {
             FunctionStarts::Entry function_start_entry;
             function_start_entry.addr = func->base - text_base_addr;
             function_starts.Append(function_start_entry);
           }
         }
       }

lldb/source/Plugins/ObjectFile/PECOFF/CMakeLists.txt

 add_lldb_library(lldbPluginObjectFilePECOFF PLUGIN
   ObjectFilePECOFF.cpp
+  PECallFrameInfo.cpp
   WindowsMiniDump.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbTarget
   LINK_COMPONENTS
     BinaryFormat
     Support
   )

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

public:
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   bool IsWindowsSubsystem();
 
+  uint32_t GetRVA(const lldb_private::Address &addr) const;
+  lldb_private::Address GetAddress(uint32_t rva);
+  lldb::addr_t GetFileAddress(uint32_t rva) const;
+
   lldb_private::DataExtractor ReadImageData(uint32_t offset, size_t size);
+  lldb_private::DataExtractor ReadImageDataByRVA(uint32_t rva, size_t size);
+
+  std::unique_ptr<lldb_private::ICallFrameInfo>
+  CreateEHCallFrameInfo() override;
 
 protected:
   bool NeedsEndianSwap() const;
 
   typedef struct dos_header { // DOS .EXE header
     uint16_t e_magic;         // Magic number
     uint16_t e_cblp;          // Bytes on last page of file
     uint16_t e_cp;            // Pages in file
typedef struct coff_opt_header {
     //    uint32_t  num_data_dir_entries;
     std::vector<data_directory>
         data_dirs; // will contain num_data_dir_entries entries
   } coff_opt_header_t;
 
   enum coff_data_dir_type {
     coff_data_dir_export_table = 0,
     coff_data_dir_import_table = 1,
+    coff_data_dir_exception_table = 3
   };
 
   typedef struct section_header {
     char name[8];
     uint32_t vmsize;  // Virtual Size
     uint32_t vmaddr;  // Virtual Addr
     uint32_t size;    // File size
     uint32_t offset;  // File offset

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 //===-- ObjectFilePECOFF.cpp ------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ObjectFilePECOFF.h"
+#include "PECallFrameInfo.h"
 #include "WindowsMiniDump.h"
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
if (*offset_ptr < end_offset) {
       }
     }
   }
   // Make sure we are on track for section data which follows
   *offset_ptr = end_offset;
   return success;
 }
 
+uint32_t ObjectFilePECOFF::GetRVA(const Address &addr) const {
+  return addr.GetFileAddress() - m_image_base;
+}
+
+Address ObjectFilePECOFF::GetAddress(uint32_t rva) {
+  SectionList *sect_list = GetSectionList();
+  if (!sect_list)
+    return Address(GetFileAddress(rva));
+
+  return Address(GetFileAddress(rva), sect_list);
+}
+
+lldb::addr_t ObjectFilePECOFF::GetFileAddress(uint32_t rva) const {
+  return m_image_base + rva;
+}
+
 DataExtractor ObjectFilePECOFF::ReadImageData(uint32_t offset, size_t size) {
+  if (!size)
+    return {};
+
   if (m_file) {
     // A bit of a hack, but we intend to write to this buffer, so we can't
     // mmap it.
     auto buffer_sp = MapFileData(m_file, size, offset);
     return DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize());
   }
   ProcessSP process_sp(m_process_wp.lock());
   DataExtractor data;
   if (process_sp) {
     auto data_up = std::make_unique<DataBufferHeap>(size, 0);
     Status readmem_error;
     size_t bytes_read =
         process_sp->ReadMemory(m_image_base + offset, data_up->GetBytes(),
                                data_up->GetByteSize(), readmem_error);
     if (bytes_read == size) {
       DataBufferSP buffer_sp(data_up.release());
       data.SetData(buffer_sp, 0, buffer_sp->GetByteSize());
     }
   }
   return data;
 }
 
+DataExtractor ObjectFilePECOFF::ReadImageDataByRVA(uint32_t rva, size_t size) {
+  if (m_file) {
+    Address addr = GetAddress(rva);
+    rva = addr.GetSection()->GetFileOffset() + addr.GetOffset();
+  }
+
+  return ReadImageData(rva, size);
+}
+
 // ParseSectionHeaders
 bool ObjectFilePECOFF::ParseSectionHeaders(
     uint32_t section_header_data_offset) {
   const uint32_t nsects = m_coff_header.nsects;
   m_sect_headers.clear();
 
   if (nsects > 0) {
     const size_t section_header_byte_size = nsects * sizeof(section_header_t);
if (m_symtab_up == nullptr) {
       // Read export header
       if (coff_data_dir_export_table < m_coff_header_opt.data_dirs.size() &&
           m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmsize > 0 &&
           m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmaddr > 0) {
         export_directory_entry export_table;
         uint32_t data_start =
             m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmaddr;
 
-        uint32_t address_rva = data_start;
-        if (m_file) {
-          Address address(m_coff_header_opt.image_base + data_start, sect_list);
-          address_rva =
-              address.GetSection()->GetFileOffset() + address.GetOffset();
-        }
-        DataExtractor symtab_data =
-            ReadImageData(address_rva, m_coff_header_opt.data_dirs[0].vmsize);
+        DataExtractor symtab_data = ReadImageDataByRVA(
+            data_start, m_coff_header_opt.data_dirs[0].vmsize);
         lldb::offset_t offset = 0;
 
         // Read export_table header
         export_table.characteristics = symtab_data.GetU32(&offset);
         export_table.time_date_stamp = symtab_data.GetU32(&offset);
         export_table.major_version = symtab_data.GetU16(&offset);
         export_table.minor_version = symtab_data.GetU16(&offset);
         export_table.name = symtab_data.GetU32(&offset);
if (m_symtab_up == nullptr) {
         }
       }
       m_symtab_up->CalculateSymbolSizes();
     }
   }
   return m_symtab_up.get();
 }
 
+std::unique_ptr<ICallFrameInfo> ObjectFilePECOFF::CreateEHCallFrameInfo() {
+  if (coff_data_dir_exception_table >= m_coff_header_opt.data_dirs.size())
+    return {};
+
+  data_directory data_dir_exception =
+      m_coff_header_opt.data_dirs[coff_data_dir_exception_table];
+  if (!data_dir_exception.vmaddr)
+    return {};
+
+  return std::make_unique<PECallFrameInfo>(*this, data_dir_exception.vmaddr,
+                                           data_dir_exception.vmsize);
+}
+
 bool ObjectFilePECOFF::IsStripped() {
   // TODO: determine this for COFF
   return false;
 }
 
 void ObjectFilePECOFF::CreateSections(SectionList &unified_section_list) {
   if (m_sections_up)
     return;

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.h

+//===-- PECallFrameInfo.h ---------------------------------------*- 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 liblldb_PECallFrameInfo_h_
+#define liblldb_PECallFrameInfo_h_
+
+#include "lldb/Symbol/ICallFrameInfo.h"
+#include "lldb/Utility/DataExtractor.h"
+
+class ObjectFilePECOFF;
+
+namespace llvm {
+namespace Win64EH {
+
+struct RuntimeFunction;
+
+}
+} // namespace llvm
+
+class PECallFrameInfo : public virtual lldb_private::ICallFrameInfo {
+public:
+  explicit PECallFrameInfo(ObjectFilePECOFF &object_file,
+                           uint32_t exception_dir_rva,
+                           uint32_t exception_dir_size);
+
+  bool GetAddressRange(lldb_private::Address addr,
+                       lldb_private::AddressRange &range) override;
+
+  bool GetUnwindPlan(const lldb_private::Address &addr,
+                     lldb_private::UnwindPlan &unwind_plan) override;
+  bool GetUnwindPlan(const lldb_private::AddressRange &range,
+                     lldb_private::UnwindPlan &unwind_plan) override;
+
+  void GetFunctionAddressAndSizeVector(
+      FunctionAddressAndSizeVector &function_info) override;
+
+  void ForEachEntries(
+      const std::function<bool(lldb::addr_t, uint32_t)> &callback) override;
+
+private:
+  const llvm::Win64EH::RuntimeFunction *FindRuntimeFunctionItersectsWithRange(
+      const lldb_private::AddressRange &range) const;
+
+  ObjectFilePECOFF &m_object_file;
+  lldb_private::DataExtractor m_exception_data;
+};
+
+#endif // liblldb_PECallFrameInfo_h_

lldb/source/Plugins/ObjectFile/PECOFF/PECallFrameInfo.cpp

+#include "PECallFrameInfo.h"
+
+#include "ObjectFilePECOFF.h"
+
+#include "Plugins/Process/Utility/lldb-x86-register-enums.h"
+#include "lldb/Symbol/UnwindPlan.h"
+#include "llvm/Support/Win64EH.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm::Win64EH;
+
+template <typename T>
+static const T *TypedRead(const DataExtractor &data_extractor, offset_t &offset,
+                          offset_t size = sizeof(T)) {
+  return static_cast<const T *>(data_extractor.GetData(&offset, size));
+}
+
+struct EHInstruction {
+  enum class Type {
+    PUSH_REGISTER,
+    ALLOCATE,
+    SET_FRAME_POINTER_REGISTER,
+    SAVE_REGISTER
+  };
+
+  uint8_t offset;
+  Type type;
+  uint32_t reg;
+  uint32_t frame_offset;
+};
+
+using EHProgram = std::vector<EHInstruction>;
+
+class UnwindCodesIterator {
+public:
+  UnwindCodesIterator(ObjectFilePECOFF &object_file, uint32_t unwind_info_rva);
+
+  bool GetNext();
+  bool IsError() const { return m_error; }
+
+  const UnwindInfo *GetUnwindInfo() const { return m_unwind_info; }
+  const UnwindCode *GetUnwindCode() const { return m_unwind_code; }
+  bool IsChained() const { return m_chained; }
+
+private:
+  ObjectFilePECOFF &m_object_file;
+
+  bool m_error;
+
+  uint32_t m_unwind_info_rva;
+  DataExtractor m_unwind_info_data;
+  const UnwindInfo *m_unwind_info;
+
+  DataExtractor m_unwind_code_data;
+  offset_t m_unwind_code_offset;
+  const UnwindCode *m_unwind_code;
+
+  bool m_chained;
+};
+
+UnwindCodesIterator::UnwindCodesIterator(ObjectFilePECOFF &object_file,
+                                         uint32_t unwind_info_rva)
+    : m_object_file(object_file), m_error(false),
+      m_unwind_info_rva(unwind_info_rva),
+      m_unwind_info(nullptr), m_unwind_code_offset{}, m_unwind_code(nullptr),
+      m_chained(false) {}
+
+bool UnwindCodesIterator::GetNext() {
+  static constexpr int UNWIND_INFO_SIZE = 4;
+
+  m_error = false;
+  m_unwind_code = nullptr;
+  while (!m_unwind_code) {
+    if (!m_unwind_info) {
+      m_unwind_info_data =
+          m_object_file.ReadImageDataByRVA(m_unwind_info_rva, UNWIND_INFO_SIZE);
+
+      offset_t offset = 0;
+      m_unwind_info =
+          TypedRead<UnwindInfo>(m_unwind_info_data, offset, UNWIND_INFO_SIZE);
+      if (!m_unwind_info) {
+        m_error = true;
+        break;
+      }
+
+      m_unwind_code_data = m_object_file.ReadImageDataByRVA(
+          m_unwind_info_rva + UNWIND_INFO_SIZE,
+          m_unwind_info->NumCodes * sizeof(UnwindCode));
+      m_unwind_code_offset = 0;
+    }
+
+    if (m_unwind_code_offset < m_unwind_code_data.GetByteSize()) {
+      m_unwind_code =
+          TypedRead<UnwindCode>(m_unwind_code_data, m_unwind_code_offset);
+      m_error = !m_unwind_code;
+      break;
+    }
+
+    if (!(m_unwind_info->getFlags() & UNW_ChainInfo))
+      break;
+
+    uint32_t runtime_function_rva =
+        m_unwind_info_rva + UNWIND_INFO_SIZE +
+        ((m_unwind_info->NumCodes + 1) & ~1) * sizeof(UnwindCode);
+    DataExtractor runtime_function_data = m_object_file.ReadImageDataByRVA(
+        runtime_function_rva, sizeof(RuntimeFunction));
+
+    offset_t offset = 0;
+    const auto *runtime_function =
+        TypedRead<RuntimeFunction>(runtime_function_data, offset);
+    if (!runtime_function) {
+      m_error = true;
+      break;
+    }
+
+    m_unwind_info_rva = runtime_function->UnwindInfoOffset;
+    m_unwind_info = nullptr;
+    m_chained = true;
+  }
+
+  return !!m_unwind_code;
+}
+
+class EHProgramBuilder {
+public:
+  EHProgramBuilder(ObjectFilePECOFF &object_file, uint32_t unwind_info_rva);
+
+  bool Build();
+
+  const EHProgram &GetProgram() const { return m_program; }
+
+private:
+  static uint32_t ConvertMachineToLLDBRegister(uint8_t machine_reg);
+  static uint32_t ConvertXMMToLLDBRegister(uint8_t xmm_reg);
+
+  bool ProcessUnwindCode(UnwindCode code);
+  void Finalize();
+
+  bool ParseBigOrScaledFrameOffset(uint32_t &result, bool big, uint32_t scale);
+  bool ParseBigFrameOffset(uint32_t &result);
+  bool ParseFrameOffset(uint32_t &result);
+
+  UnwindCodesIterator m_iterator;
+  EHProgram m_program;
+};
+
+EHProgramBuilder::EHProgramBuilder(ObjectFilePECOFF &object_file,
+                                   uint32_t unwind_info_rva)
+    : m_iterator(object_file, unwind_info_rva) {}
+
+bool EHProgramBuilder::Build() {
+  while (m_iterator.GetNext())
+    if (!ProcessUnwindCode(*m_iterator.GetUnwindCode()))
+      return false;
+
+  if (m_iterator.IsError())
+    return false;
+
+  Finalize();
+
+  return true;
+}
+
+uint32_t EHProgramBuilder::ConvertMachineToLLDBRegister(uint8_t machine_reg) {
+  static uint32_t machine_to_lldb_register[] = {
+      lldb_rax_x86_64, lldb_rcx_x86_64, lldb_rdx_x86_64, lldb_rbx_x86_64,
+      lldb_rsp_x86_64, lldb_rbp_x86_64, lldb_rsi_x86_64, lldb_rdi_x86_64,
+      lldb_r8_x86_64,  lldb_r9_x86_64,  lldb_r10_x86_64, lldb_r11_x86_64,
+      lldb_r12_x86_64, lldb_r13_x86_64, lldb_r14_x86_64, lldb_r15_x86_64};
+
+  if (machine_reg >= llvm::array_lengthof(machine_to_lldb_register))
+    return LLDB_INVALID_REGNUM;
+
+  return machine_to_lldb_register[machine_reg];
+}
+
+uint32_t EHProgramBuilder::ConvertXMMToLLDBRegister(uint8_t xmm_reg) {
+  static uint32_t xmm_to_lldb_register[] = {
+      lldb_xmm0_x86_64,  lldb_xmm1_x86_64,  lldb_xmm2_x86_64,
+      lldb_xmm3_x86_64,  lldb_xmm4_x86_64,  lldb_xmm5_x86_64,
+      lldb_xmm6_x86_64,  lldb_xmm7_x86_64,  lldb_xmm8_x86_64,
+      lldb_xmm9_x86_64,  lldb_xmm10_x86_64, lldb_xmm11_x86_64,
+      lldb_xmm12_x86_64, lldb_xmm13_x86_64, lldb_xmm14_x86_64,
+      lldb_xmm15_x86_64};
+
+  if (xmm_reg >= llvm::array_lengthof(xmm_to_lldb_register))
+    return LLDB_INVALID_REGNUM;
+
+  return xmm_to_lldb_register[xmm_reg];
+}
+
+bool EHProgramBuilder::ProcessUnwindCode(UnwindCode code) {
+  uint8_t o = m_iterator.IsChained() ? 0 : code.u.CodeOffset;
+  uint8_t unwind_operation = code.getUnwindOp();
+  uint8_t operation_info = code.getOpInfo();
+
+  switch (unwind_operation) {
+  case UOP_PushNonVol: {
+    uint32_t r = ConvertMachineToLLDBRegister(operation_info);
+    if (r == LLDB_INVALID_REGNUM)
+      return false;
+
+    m_program.emplace_back(
+        EHInstruction{o, EHInstruction::Type::PUSH_REGISTER, r, 8});
+
+    return true;
+  }
+  case UOP_AllocLarge: {
+    uint32_t fo;
+    if (!ParseBigOrScaledFrameOffset(fo, operation_info, 8))
+      return false;
+
+    m_program.emplace_back(EHInstruction{o, EHInstruction::Type::ALLOCATE,
+                                         LLDB_INVALID_REGNUM, fo});
+
+    return true;
+  }
+  case UOP_AllocSmall: {
+    m_program.emplace_back(
+        EHInstruction{o, EHInstruction::Type::ALLOCATE, LLDB_INVALID_REGNUM,
+                      static_cast<uint32_t>(operation_info) * 8 + 8});
+    return true;
+  }
+  case UOP_SetFPReg: {
+    uint32_t fpr = LLDB_INVALID_REGNUM;
+    if (m_iterator.GetUnwindInfo()->getFrameRegister())
+      fpr = ConvertMachineToLLDBRegister(
+          m_iterator.GetUnwindInfo()->getFrameRegister());
+    if (fpr == LLDB_INVALID_REGNUM)
+      return false;
+
+    uint32_t fpro =
+        static_cast<uint32_t>(m_iterator.GetUnwindInfo()->getFrameOffset()) *
+        16;
+
+    m_program.emplace_back(EHInstruction{
+        o, EHInstruction::Type::SET_FRAME_POINTER_REGISTER, fpr, fpro});
+
+    return true;
+  }
+  case UOP_SaveNonVol:
+  case UOP_SaveNonVolBig: {
+    uint32_t r = ConvertMachineToLLDBRegister(operation_info);
+    if (r == LLDB_INVALID_REGNUM)
+      return false;
+
+    uint32_t fo;
+    if (!ParseBigOrScaledFrameOffset(fo, unwind_operation == UOP_SaveNonVolBig,
+                                     8))
+      return false;
+
+    m_program.emplace_back(
+        EHInstruction{o, EHInstruction::Type::SAVE_REGISTER, r, fo});
+
+    return true;
+  }
+  case UOP_Epilog: {
+    return m_iterator.GetNext();
+  }
+  case UOP_SpareCode: {
+    // ReSharper disable once CppIdenticalOperandsInBinaryExpression
+    return m_iterator.GetNext() && m_iterator.GetNext();
+  }
+  case UOP_SaveXMM128:
+  case UOP_SaveXMM128Big: {
+    uint32_t r = ConvertXMMToLLDBRegister(operation_info);
+    if (r == LLDB_INVALID_REGNUM)
+      return false;
+
+    uint32_t fo;
+    if (!ParseBigOrScaledFrameOffset(fo, unwind_operation == UOP_SaveXMM128Big,
+                                     16))
+      return false;
+
+    m_program.emplace_back(
+        EHInstruction{o, EHInstruction::Type::SAVE_REGISTER, r, fo});
+
+    return true;
+  }
+  case UOP_PushMachFrame: {
+    if (operation_info)
+      m_program.emplace_back(EHInstruction{o, EHInstruction::Type::ALLOCATE,
+                                           LLDB_INVALID_REGNUM, 8});
+    m_program.emplace_back(EHInstruction{o, EHInstruction::Type::PUSH_REGISTER,
+                                         lldb_rip_x86_64, 8});
+    m_program.emplace_back(EHInstruction{o, EHInstruction::Type::PUSH_REGISTER,
+                                         lldb_cs_x86_64, 8});
+    m_program.emplace_back(EHInstruction{o, EHInstruction::Type::PUSH_REGISTER,
+                                         lldb_rflags_x86_64, 8});
+    m_program.emplace_back(EHInstruction{o, EHInstruction::Type::PUSH_REGISTER,
+                                         lldb_rsp_x86_64, 8});
+    m_program.emplace_back(EHInstruction{o, EHInstruction::Type::PUSH_REGISTER,
+                                         lldb_ss_x86_64, 8});
+
+    return true;
+  }
+  default:
+    return false;
+  }
+}
+
+void EHProgramBuilder::Finalize() {
+  for (const EHInstruction &i : m_program)
+    if (i.reg == lldb_rip_x86_64)
+      return;
+
+  m_program.emplace_back(
+      EHInstruction{0, EHInstruction::Type::PUSH_REGISTER, lldb_rip_x86_64, 8});
+}
+
+bool EHProgramBuilder::ParseBigOrScaledFrameOffset(uint32_t &result, bool big,
+                                                   uint32_t scale) {
+  if (big) {
+    if (!ParseBigFrameOffset(result))
+      return false;
+  } else {
+    if (!ParseFrameOffset(result))
+      return false;
+
+    result *= scale;
+  }
+
+  return true;
+}
+
+bool EHProgramBuilder::ParseBigFrameOffset(uint32_t &result) {
+  if (!m_iterator.GetNext())
+    return false;
+
+  result = m_iterator.GetUnwindCode()->FrameOffset;
+
+  if (!m_iterator.GetNext())
+    return false;
+
+  result += static_cast<uint32_t>(m_iterator.GetUnwindCode()->FrameOffset)
+            << 16;
+
+  return true;
+}
+
+bool EHProgramBuilder::ParseFrameOffset(uint32_t &result) {
+  if (!m_iterator.GetNext())
+    return false;
+
+  result = m_iterator.GetUnwindCode()->FrameOffset;
+
+  return true;
+}
+
+class EHProgramRange {
+public:
+  EHProgramRange(EHProgram::const_iterator begin,
+                 EHProgram::const_iterator end);
+
+  std::unique_ptr<UnwindPlan::Row> BuildUnwindPlanRow() const;
+
+private:
+  int32_t GetCFAFrameOffset() const;
+
+  EHProgram::const_iterator m_begin;
+  EHProgram::const_iterator m_end;
+};
+
+EHProgramRange::EHProgramRange(EHProgram::const_iterator begin,
+                               EHProgram::const_iterator end)
+    : m_begin(begin), m_end(end) {}
+
+std::unique_ptr<UnwindPlan::Row> EHProgramRange::BuildUnwindPlanRow() const {
+  std::unique_ptr<UnwindPlan::Row> row = std::make_unique<UnwindPlan::Row>();
+
+  if (m_begin != m_end)
+    row->SetOffset(m_begin->offset);
+
+  int32_t cfa_frame_offset = GetCFAFrameOffset();
+
+  bool frame_pointer_found = false;
+  for (EHProgram::const_iterator it = m_begin; it != m_end; ++it) {
+    switch (it->type) {
+    case EHInstruction::Type::SET_FRAME_POINTER_REGISTER:
+      row->GetCFAValue().SetIsRegisterPlusOffset(it->reg, cfa_frame_offset -
+                                                              it->frame_offset);
+      frame_pointer_found = true;
+      break;
+    default:
+      break;
+    }
+    if (frame_pointer_found)
+      break;
+  }
+  if (!frame_pointer_found)
+    row->GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64,
+                                               cfa_frame_offset);
+
+  int32_t rsp_frame_offset = 0;
+  for (EHProgram::const_iterator it = m_begin; it != m_end; ++it) {
+    switch (it->type) {
+    case EHInstruction::Type::PUSH_REGISTER:
+      row->SetRegisterLocationToAtCFAPlusOffset(
+          it->reg, rsp_frame_offset - cfa_frame_offset, false);
+      rsp_frame_offset += it->frame_offset;
+      break;
+    case EHInstruction::Type::ALLOCATE:
+      rsp_frame_offset += it->frame_offset;
+      break;
+    case EHInstruction::Type::SAVE_REGISTER:
+      row->SetRegisterLocationToAtCFAPlusOffset(
+          it->reg, it->frame_offset - cfa_frame_offset, false);
+      break;
+    default:
+      break;
+    }
+  }
+
+  row->SetRegisterLocationToIsCFAPlusOffset(lldb_rsp_x86_64, 0, false);
+
+  return row;
+}
+
+int32_t EHProgramRange::GetCFAFrameOffset() const {
+  int32_t result = 0;
+
+  for (EHProgram::const_iterator it = m_begin; it != m_end; ++it) {
+    switch (it->type) {
+    case EHInstruction::Type::PUSH_REGISTER:
+    case EHInstruction::Type::ALLOCATE:
+      result += it->frame_offset;
+    default:
+      break;
+    }
+  }
+
+  return result;
+}
+
+PECallFrameInfo::PECallFrameInfo(ObjectFilePECOFF &object_file,
+                                 uint32_t exception_dir_rva,
+                                 uint32_t exception_dir_size)
+    : m_object_file(object_file),
+      m_exception_data(object_file.ReadImageDataByRVA(exception_dir_rva,
+                                                      exception_dir_size)) {}
+
+bool PECallFrameInfo::GetAddressRange(Address addr, AddressRange &range) {
+  range.Clear();
+
+  const RuntimeFunction *runtime_function =
+      FindRuntimeFunctionItersectsWithRange(AddressRange(addr, 1));
+  if (!runtime_function)
+    return false;
+
+  range.GetBaseAddress() =
+      m_object_file.GetAddress(runtime_function->StartAddress);
+  range.SetByteSize(runtime_function->EndAddress -
+                    runtime_function->StartAddress);
+
+  return true;
+}
+
+bool PECallFrameInfo::GetUnwindPlan(const Address &addr,
+                                    UnwindPlan &unwind_plan) {
+  return GetUnwindPlan(AddressRange(addr, 1), unwind_plan);
+}
+
+bool PECallFrameInfo::GetUnwindPlan(const AddressRange &range,
+                                    UnwindPlan &unwind_plan) {
+  unwind_plan.Clear();
+
+  unwind_plan.SetSourceName("PE EH info");
+  unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
+  unwind_plan.SetRegisterKind(eRegisterKindLLDB);
+
+  const RuntimeFunction *runtime_function =
+      FindRuntimeFunctionItersectsWithRange(range);
+  if (!runtime_function)
+    return false;
+
+  EHProgramBuilder builder(m_object_file, runtime_function->UnwindInfoOffset);
+  if (!builder.Build())
+    return false;
+
+  std::vector<UnwindPlan::RowSP> rows;
+
+  uint32_t last_offset = UINT32_MAX;
+  for (auto it = builder.GetProgram().begin(); it != builder.GetProgram().end();
+       ++it) {
+    if (it->offset == last_offset)
+      continue;
+
+    EHProgramRange program_range =
+        EHProgramRange(it, builder.GetProgram().end());
+    rows.push_back(program_range.BuildUnwindPlanRow());
+
+    last_offset = it->offset;
+  }
+
+  for (auto it = rows.rbegin(); it != rows.rend(); ++it)
+    unwind_plan.AppendRow(*it);
+
+  unwind_plan.SetPlanValidAddressRange(AddressRange(
+      m_object_file.GetAddress(runtime_function->StartAddress),
+      runtime_function->EndAddress - runtime_function->StartAddress));
+  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+
+  return true;
+}
+
+void PECallFrameInfo::GetFunctionAddressAndSizeVector(
+    FunctionAddressAndSizeVector &function_info) {
+  function_info.Clear();
+
+  offset_t offset = 0;
+  while (offset < m_exception_data.GetByteSize()) {
+    const auto *runtime_function =
+        TypedRead<RuntimeFunction>(m_exception_data, offset);
+    if (!runtime_function)
+      break;
+
+    function_info.Append(
+        {m_object_file.GetFileAddress(runtime_function->StartAddress),
+         runtime_function->EndAddress - runtime_function->StartAddress});
+  }
+}
+
+void PECallFrameInfo::ForEachEntries(
+    const std::function<bool(addr_t, uint32_t)> &callback) {
+  offset_t offset = 0;
+  while (offset < m_exception_data.GetByteSize()) {
+    const auto *runtime_function =
+        TypedRead<RuntimeFunction>(m_exception_data, offset);
+    if (!runtime_function)
+      break;
+
+    if (!callback(m_object_file.GetFileAddress(runtime_function->StartAddress),
+                  runtime_function->EndAddress -
+                      runtime_function->StartAddress))
+      break;
+  }
+}
+
+const RuntimeFunction *PECallFrameInfo::FindRuntimeFunctionItersectsWithRange(
+    const AddressRange &range) const {
+  uint32_t rva = m_object_file.GetRVA(range.GetBaseAddress());
+  addr_t size = range.GetByteSize();
+
+  uint32_t begin = 0;
+  uint32_t end = m_exception_data.GetByteSize() / sizeof(RuntimeFunction);
+  while (begin < end) {
+    uint32_t curr = (begin + end) / 2;
+
+    offset_t offset = curr * sizeof(RuntimeFunction);
+    const auto *runtime_function =
+        TypedRead<RuntimeFunction>(m_exception_data, offset);
+    if (!runtime_function)
+      break;
+
+    if (runtime_function->StartAddress < rva + size &&
+        runtime_function->EndAddress > rva)
+      return runtime_function;
+
+    if (runtime_function->StartAddress >= rva + size)
+      end = curr;
+
+    if (runtime_function->EndAddress <= rva)
+      begin = curr + 1;
+  }
+
+  return nullptr;
+}

lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

if (!func_unwinders_sp) {
     m_frame_type = eNormalFrame;
 
     if (!pc_module_sp || !pc_module_sp->GetObjectFile() ||
         !m_current_pc.IsValid())
       return arch_default_unwind_plan_sp;
 
     // Even with -fomit-frame-pointer, we can try eh_frame to get back on
     // track.
-    DWARFCallFrameInfo *eh_frame =
+    ICallFrameInfo *eh_frame =
         pc_module_sp->GetUnwindTable().GetEHFrameInfo();
     if (eh_frame) {
       unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (eh_frame->GetUnwindPlan(m_current_pc, *unwind_plan_sp))
         return unwind_plan_sp;
       else
         unwind_plan_sp.reset();
     }

lldb/source/Symbol/DWARFCallFrameInfo.cpp

while (m_cfi_data.ValidOffsetForDataOfSize(offset, 8)) {
     } else {
       cie_id = m_cfi_data.GetU32(&offset);
       next_entry = current_entry + len + 4;
       cie_offset = current_entry + 4 - cie_id;
     }
 
     if (next_entry > m_cfi_data.GetByteSize() + 1) {
       Host::SystemLog(Host::eSystemLogError, "error: Invalid fde/cie next "
-                                             "entry offset of 0x%x found in "
-                                             "cie/fde at 0x%x\n",
                       next_entry, current_entry);
       // Don't trust anything in this eh_frame section if we find blatantly
       // invalid data.
       m_fde_index.Clear();
       m_fde_index_initialized = true;
       return;
     }
 
if (cie) {
 
       lldb::addr_t length = GetGNUEHPointer(
           m_cfi_data, &offset, cie->ptr_encoding & DW_EH_PE_MASK_ENCODING,
           pc_rel_addr, text_addr, data_addr);
       FDEEntryMap::Entry fde(addr, length, current_entry);
       m_fde_index.Append(fde);
     } else {
       Host::SystemLog(Host::eSystemLogError, "error: unable to find CIE at "
-                                             "0x%8.8x for cie_id = 0x%8.8x for "
-                                             "entry at 0x%8.8x.\n",
                       cie_offset, cie_id, current_entry);
     }
     offset = next_entry;
   }
   m_fde_index.Sort();
   m_fde_index_initialized = true;
 }
 
if (aug_data_len != 0 && cie->lsda_addr_encoding != DW_EH_PE_omit) {
         // don't read anything.
         lsda_data_file_address = LLDB_INVALID_ADDRESS;
       }
       offset = saved_offset;
     }
     offset += aug_data_len;
   }
   unwind_plan.SetUnwindPlanForSignalTrap(
       strchr(cie->augmentation, 'S') ? eLazyBoolYes : eLazyBoolNo);
 
   Address lsda_data;
   Address personality_function_ptr;
 
   if (lsda_data_file_address != LLDB_INVALID_ADDRESS &&
       cie->personality_loc != LLDB_INVALID_ADDRESS) {
     m_objfile.GetModule()->ResolveFileAddress(lsda_data_file_address,
                                               lsda_data);
case DW_CFA_val_expression: // 0x16
       row.SetRegisterInfo(reg_num, reg_location);
       return true;
     }
     }
   }
   return false;
 }
 
-void DWARFCallFrameInfo::ForEachFDEEntries(
-    const std::function<bool(lldb::addr_t, uint32_t, dw_offset_t)> &callback) {
+void DWARFCallFrameInfo::ForEachEntries(
+    const std::function<bool(lldb::addr_t, uint32_t)> &callback) {
   GetFDEIndex();
 
   for (size_t i = 0, c = m_fde_index.GetSize(); i < c; ++i) {
     const FDEEntryMap::Entry &entry = m_fde_index.GetEntryRef(i);
-    if (!callback(entry.base, entry.size, entry.data))
+    if (!callback(entry.base, entry.size))
       break;
   }
 }

lldb/source/Symbol/FuncUnwinders.cpp

 
 UnwindPlanSP FuncUnwinders::GetEHFrameUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_eh_frame_sp.get() || m_tried_unwind_plan_eh_frame)
     return m_unwind_plan_eh_frame_sp;
 
   m_tried_unwind_plan_eh_frame = true;
   if (m_range.GetBaseAddress().IsValid()) {
-    DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
+    ICallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
     if (eh_frame) {
       m_unwind_plan_eh_frame_sp =
           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (!eh_frame->GetUnwindPlan(m_range, *m_unwind_plan_eh_frame_sp))
         m_unwind_plan_eh_frame_sp.reset();
     }
   }
   return m_unwind_plan_eh_frame_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetDebugFrameUnwindPlan(Target &target) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_debug_frame_sp || m_tried_unwind_plan_debug_frame)
     return m_unwind_plan_debug_frame_sp;
 
   m_tried_unwind_plan_debug_frame = true;
   if (m_range.GetBaseAddress().IsValid()) {
-    DWARFCallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo();
+    ICallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo();
     if (debug_frame) {
       m_unwind_plan_debug_frame_sp =
           std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (!debug_frame->GetUnwindPlan(m_range, *m_unwind_plan_debug_frame_sp))
         m_unwind_plan_debug_frame_sp.reset();
     }
   }
   return m_unwind_plan_debug_frame_sp;

lldb/source/Symbol/ObjectFile.cpp

 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/lldb-private.h"
+#include "lldb/Symbol/DWARFCallFrameInfo.h"
+#include "lldb/Symbol/CompactUnwindInfo.h"
+#include "lldb/Symbol/ArmUnwindInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 char ObjectFile::ID;
 
 ObjectFileSP
 ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,
for (size_t i = 0; i < section_count; ++i) {
     section_sp->GetSectionData(section_data);
     loadable.Contents = llvm::ArrayRef<uint8_t>(section_data.GetDataStart(),
                                                 section_data.GetByteSize());
     loadables.push_back(loadable);
   }
   return loadables;
 }
 
+std::unique_ptr<ICallFrameInfo> ObjectFile::CreateEHCallFrameInfo() {
+  SectionList *sl = GetSectionList();
+  if (!sl)
+    return {};
+
+  SectionSP sect = sl->FindSectionByType(eSectionTypeEHFrame, true);
+  if (!sect)
+    return {};
+
+  return std::make_unique<DWARFCallFrameInfo>(*this, sect,
+                                              DWARFCallFrameInfo::EH);
+}
+
+std::unique_ptr<ICallFrameInfo> ObjectFile::CreateDebugCallFrameInfo() {
+  SectionList *sl = GetSectionList();
+  if (!sl)
+    return {};
+
+  SectionSP sect = sl->FindSectionByType(eSectionTypeDWARFDebugFrame, true);
+  if (!sect)
+    return {};
+
+  return std::make_unique<DWARFCallFrameInfo>(*this, sect,
+                                              DWARFCallFrameInfo::DWARF);
+}
+
+std::unique_ptr<CompactUnwindInfo> ObjectFile::CreateCompactUnwindInfo() {
+  SectionList *sl = GetSectionList();
+  if (!sl)
+    return {};
+
+  SectionSP sect = sl->FindSectionByType(eSectionTypeCompactUnwind, true);
+  if (!sect)
+    return {};
+
+  return std::make_unique<CompactUnwindInfo>(*this, sect);
+}
+
+std::unique_ptr<ArmUnwindInfo> ObjectFile::CreateArmUnwindInfo() {
+  SectionList *sl = GetSectionList();
+  if (!sl)
+    return {};
+
+  SectionSP sect = sl->FindSectionByType(eSectionTypeARMexidx, true);
+  if (!sect)
+    return {};
+
+  SectionSP sect_extab = sl->FindSectionByType(eSectionTypeARMextab, true);
+  if (!sect_extab)
+    return {};
+
+  return std::make_unique<ArmUnwindInfo>(*this, sect, sect_extab);
+}
+
 void ObjectFile::RelocateSection(lldb_private::Section *section)
 {
 }
 
 DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
                                      uint64_t Offset) {
   return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
 }

lldb/source/Symbol/Type.cpp

bool Type::WriteToMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
                          AddressType address_type, DataExtractor &data) {
   return false;
 }
 
 const Declaration &Type::GetDeclaration() const { return m_decl; }
 
 bool Type::ResolveClangType(ResolveState compiler_type_resolve_state) {
   // TODO: This needs to consider the correct type system to use.
+  compiler_type_resolve_state = eResolveStateForward;
   Type *encoding_type = nullptr;
   if (!m_compiler_type.IsValid()) {
     encoding_type = GetEncodingType();
     if (encoding_type) {
       switch (m_encoding_uid_type) {
       case eEncodingIsUID: {
         CompilerType encoding_compiler_type =
             encoding_type->GetForwardCompilerType();

lldb/source/Symbol/UnwindTable.cpp

void UnwindTable::Initialize() {
 
   if (m_initialized) // check again once we've acquired the lock
     return;
   m_initialized = true;
   ObjectFile *object_file = m_module.GetObjectFile();
   if (!object_file)
     return;
 
-  SectionList *sl = m_module.GetSectionList();
-  if (!sl)
-    return;
-
-  SectionSP sect = sl->FindSectionByType(eSectionTypeEHFrame, true);
-  if (sect.get()) {
-    m_eh_frame_up.reset(
-        new DWARFCallFrameInfo(*object_file, sect, DWARFCallFrameInfo::EH));
-  }
-
-  sect = sl->FindSectionByType(eSectionTypeDWARFDebugFrame, true);
-  if (sect) {
-    m_debug_frame_up.reset(
-        new DWARFCallFrameInfo(*object_file, sect, DWARFCallFrameInfo::DWARF));
-  }
-
-  sect = sl->FindSectionByType(eSectionTypeCompactUnwind, true);
-  if (sect) {
-    m_compact_unwind_up.reset(new CompactUnwindInfo(*object_file, sect));
-  }
-
-  sect = sl->FindSectionByType(eSectionTypeARMexidx, true);
-  if (sect) {
-    SectionSP sect_extab = sl->FindSectionByType(eSectionTypeARMextab, true);
-    if (sect_extab.get()) {
-      m_arm_unwind_up.reset(new ArmUnwindInfo(*object_file, sect, sect_extab));
-    }
-  }
+  m_eh_frame_up = object_file->CreateEHCallFrameInfo();
+  m_debug_frame_up = object_file->CreateDebugCallFrameInfo();
+  m_compact_unwind_up = object_file->CreateCompactUnwindInfo();
+  m_arm_unwind_up = object_file->CreateArmUnwindInfo();
 }
 
 UnwindTable::~UnwindTable() {}
 
 llvm::Optional<AddressRange> UnwindTable::GetAddressRange(const Address &addr,
                                                           SymbolContext &sc) {
   AddressRange range;
 
-  // First check the symbol context
-  if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
-                         false, range) &&
-      range.GetBaseAddress().IsValid())
-    return range;
-
   // Does the eh_frame unwind info has a function bounds for this addr?
   if (m_eh_frame_up && m_eh_frame_up->GetAddressRange(addr, range))
     return range;
 
   // Try debug_frame as well
   if (m_debug_frame_up && m_debug_frame_up->GetAddressRange(addr, range))
     return range;
 
+  // Last check the symbol context
+  if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
+                         false, range) &&
+      range.GetBaseAddress().IsValid())
+    return range;
+
   return llvm::None;
 }
 
 FuncUnwindersSP
 UnwindTable::GetFuncUnwindersContainingAddress(const Address &addr,
                                                SymbolContext &sc) {
   Initialize();
 
void UnwindTable::Dump(Stream &s) {
   const_iterator end = m_unwinds.end();
   for (const_iterator pos = begin; pos != end; ++pos) {
     s.Printf("[%u] 0x%16.16" PRIx64 "\n", (unsigned)std::distance(begin, pos),
              pos->first);
   }
   s.EOL();
 }
 
-DWARFCallFrameInfo *UnwindTable::GetEHFrameInfo() {
+ICallFrameInfo *UnwindTable::GetEHFrameInfo() {
   Initialize();
   return m_eh_frame_up.get();
 }
 
-DWARFCallFrameInfo *UnwindTable::GetDebugFrameInfo() {
+ICallFrameInfo *UnwindTable::GetDebugFrameInfo() {
   Initialize();
   return m_debug_frame_up.get();
 }
 
 CompactUnwindInfo *UnwindTable::GetCompactUnwindInfo() {
   Initialize();
   return m_compact_unwind_up.get();
 }

lldb/unittests/ObjectFile/CMakeLists.txt

 add_subdirectory(Breakpad)
 add_subdirectory(ELF)
+add_subdirectory(PECOFF)

lldb/unittests/ObjectFile/PECOFF/CMakeLists.txt

+add_lldb_unittest(ObjectFilePECOFFTests
+  TestPECallFrameInfo.cpp
+
+  LINK_LIBS
+    lldbUtilityHelpers
+    lldbPluginObjectFilePECOFF
+    LLVMTestingSupport
+  )

lldb/unittests/ObjectFile/PECOFF/TestPECallFrameInfo.cpp

+//===-- TestPECallFrameInfo.cpp ------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
+#include "Plugins/Process/Utility/lldb-x86-register-enums.h"
+#include "TestingSupport/TestUtilities.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Symbol/ICallFrameInfo.h"
+#include "lldb/Symbol/UnwindPlan.h"
+#include "llvm/Testing/Support/Error.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+class PECallFrameInfoTest : public testing::Test {
+public:
+  void SetUp() override {
+    FileSystem::Initialize();
+    ObjectFilePECOFF::Initialize();
+  }
+
+  void TearDown() override {
+    ObjectFilePECOFF::Terminate();
+    FileSystem::Terminate();
+  }
+
+protected:
+  void GetUnwindPlan(addr_t file_addr, UnwindPlan &plan) const;
+};
+
+void PECallFrameInfoTest::GetUnwindPlan(addr_t file_addr, UnwindPlan &plan) const {
+  llvm::Expected<TestFile> ExpectedFile = TestFile::fromYaml(
+      R"(
+--- !COFF
+OptionalHeader:  
+  AddressOfEntryPoint: 0
+  ImageBase:       16777216
+  SectionAlignment: 4096
+  FileAlignment:   512
+  MajorOperatingSystemVersion: 6
+  MinorOperatingSystemVersion: 0
+  MajorImageVersion: 0
+  MinorImageVersion: 0
+  MajorSubsystemVersion: 6
+  MinorSubsystemVersion: 0
+  Subsystem:       IMAGE_SUBSYSTEM_WINDOWS_CUI
+  DLLCharacteristics: [ IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT ]
+  SizeOfStackReserve: 1048576
+  SizeOfStackCommit: 4096
+  SizeOfHeapReserve: 1048576
+  SizeOfHeapCommit: 4096
+  ExportTable:     
+    RelativeVirtualAddress: 0
+    Size:            0
+  ImportTable:     
+    RelativeVirtualAddress: 0
+    Size:            0
+  ResourceTable:   
+    RelativeVirtualAddress: 0
+    Size:            0
+  ExceptionTable:  
+    RelativeVirtualAddress: 12288
+    Size:            60
+  CertificateTable: 
+    RelativeVirtualAddress: 0
+    Size:            0
+  BaseRelocationTable: 
+    RelativeVirtualAddress: 0
+    Size:            0
+  Debug:           
+    RelativeVirtualAddress: 0
+    Size:            0
+  Architecture:    
+    RelativeVirtualAddress: 0
+    Size:            0
+  GlobalPtr:       
+    RelativeVirtualAddress: 0
+    Size:            0
+  TlsTable:        
+    RelativeVirtualAddress: 0
+    Size:            0
+  LoadConfigTable: 
+    RelativeVirtualAddress: 0
+    Size:            0
+  BoundImport:     
+    RelativeVirtualAddress: 0
+    Size:            0
+  IAT:             
+    RelativeVirtualAddress: 0
+    Size:            0
+  DelayImportDescriptor: 
+    RelativeVirtualAddress: 0
+    Size:            0
+  ClrRuntimeHeader: 
+    RelativeVirtualAddress: 0
+    Size:            0
+header:          
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [ IMAGE_FILE_EXECUTABLE_IMAGE, IMAGE_FILE_LARGE_ADDRESS_AWARE ]
+sections:        
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  4096
+    VirtualSize:     4096
+  - Name:            .rdata
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  8192
+    VirtualSize:     68
+    SectionData:     010C06000C3208F006E00470036002302105020005540D0000100000001100000020000019400E352F74670028646600213465001A3315015E000EF00CE00AD008C00650
+
+
+# Unwind info at 0x2000:
+# 01 0C 06 00    No chained info, prolog size = 0xC, unwind codes size is 6 words, no frame register
+# 0C 32          UOP_AllocSmall(2) 3 * 8 + 8 bytes, offset in prolog is 0xC
+# 08 F0          UOP_PushNonVol(0) R15(0xF), offset in prolog is 8
+# 06 E0          UOP_PushNonVol(0) R14(0xE), offset in prolog is 6
+# 04 70          UOP_PushNonVol(0) RDI(7), offset in prolog is 4
+# 03 60          UOP_PushNonVol(0) RSI(6), offset in prolog is 3
+# 02 30          UOP_PushNonVol(0) RBX(3), offset in prolog is 2
+# Corresponding prolog:
+# 00    push    rbx
+# 02    push    rsi
+# 03    push    rdi
+# 04    push    r14
+# 06    push    r15
+# 08    sub     rsp, 20h
+
+# Unwind info at 0x2010:
+# 21 05 02 00    Has chained info, prolog size = 5, unwind codes size is 2 words, no frame register
+# 05 54 0D 00    UOP_SaveNonVol(4) RBP(5) to RSP + 0xD * 8, offset in prolog is 5
+# Chained runtime function:
+# 00 10 00 00    Start address is 0x1000
+# 00 11 00 00    End address is 0x1100
+# 00 20 00 00    Unwind info RVA is 0x2000
+# Corresponding prolog:
+# 00    mov     [rsp+68h], rbp
+
+# Unwind info at 0x2024:
+# 19 40 0E 35    No chained info, prolog size = 0x40, unwind codes size is 0xE words, frame register is RBP, frame register offset is RSP + 3 * 16
+# 2F 74 67 00    UOP_SaveNonVol(4) RDI(7) to RSP + 0x67 * 8, offset in prolog is 0x2F
+# 28 64 66 00    UOP_SaveNonVol(4) RSI(6) to RSP + 0x66 * 8, offset in prolog is 0x28
+# 21 34 65 00    UOP_SaveNonVol(4) RBX(3) to RSP + 0x65 * 8, offset in prolog is 0x21
+# 1A 33          UOP_SetFPReg(3), offset in prolog is 0x1A
+# 15 01 5E 00    UOP_AllocLarge(1) 0x5E * 8 bytes, offset in prolog is 0x15
+# 0E F0          UOP_PushNonVol(0) R15(0xF), offset in prolog is 0xE
+# 0C E0          UOP_PushNonVol(0) R14(0xE), offset in prolog is 0xC
+# 0A D0          UOP_PushNonVol(0) R13(0xD), offset in prolog is 0xA
+# 08 C0          UOP_PushNonVol(0) R12(0xC), offset in prolog is 8
+# 06 50          UOP_PushNonVol(0) RBP(5), offset in prolog is 6
+# Corresponding prolog:
+# 00    mov     [rsp+8], rcx
+# 05    push    rbp
+# 06    push    r12
+# 08    push    r13
+# 0A    push    r14
+# 0C    push    r15
+# 0E    sub     rsp, 2F0h
+# 15    lea     rbp, [rsp+30h]
+# 1A    mov     [rbp+2F8h], rbx
+# 21    mov     [rbp+300h], rsi
+# 28    mov     [rbp+308h], rdi
+
+  - Name:            .pdata
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  12288
+    VirtualSize:     60
+    SectionData:     000000000000000000000000000000000000000000000000001000000011000000200000001100000012000010200000001200000013000024200000
+
+# 00 00 00 00
+# 00 00 00 00    Test correct processing of empty runtime functions at begin
+# 00 00 00 00
+
+# 00 00 00 00
+# 00 00 00 00    Test correct processing of empty runtime functions at begin
+# 00 00 00 00
+
+# 00 10 00 00    Start address is 0x1000
+# 00 11 00 00    End address is 0x1100
+# 00 20 00 00    Unwind info RVA is 0x2000
+
+# 00 11 00 00    Start address is 0x1100
+# 00 12 00 00    End address is 0x1200
+# 10 20 00 00    Unwind info RVA is 0x2010
+
+# 00 12 00 00    Start address is 0x1200
+# 00 13 00 00    End address is 0x1300
+# 24 20 00 00    Unwind info RVA is 0x2024
+
+symbols:         []
+...
+)");
+  ASSERT_THAT_EXPECTED(ExpectedFile, llvm::Succeeded());
+
+  ModuleSP module_sp = std::make_shared<Module>(ModuleSpec(FileSpec(ExpectedFile->name())));
+  ObjectFile *object_file = module_sp->GetObjectFile();
+  ASSERT_NE(object_file, nullptr);
+
+  std::unique_ptr<ICallFrameInfo> cfi = object_file->CreateEHCallFrameInfo();
+  ASSERT_NE(cfi.get(), nullptr);
+
+  SectionList *sect_list = object_file->GetSectionList();
+  ASSERT_NE(sect_list, nullptr);
+
+  EXPECT_TRUE(cfi->GetUnwindPlan(Address(file_addr, sect_list), plan));
+}
+
+TEST_F(PECallFrameInfoTest, Basic_eh) {
+  UnwindPlan plan(eRegisterKindLLDB);
+  GetUnwindPlan(0x1001080, plan);
+  EXPECT_EQ(plan.GetRowCount(), 7);
+
+  UnwindPlan::Row row;
+  row.SetOffset(0);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 8);
+  row.SetRegisterLocationToIsCFAPlusOffset(lldb_rsp_x86_64, 0, true);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rip_x86_64, -8, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(0), row);
+
+  row.SetOffset(2);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x10);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rbx_x86_64, -0x10, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(1), row);
+
+  row.SetOffset(3);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x18);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rsi_x86_64, -0x18, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(2), row);
+
+  row.SetOffset(4);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x20);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rdi_x86_64, -0x20, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(3), row);
+
+  row.SetOffset(6);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x28);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_r14_x86_64, -0x28, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(4), row);
+
+  row.SetOffset(8);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x30);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_r15_x86_64, -0x30, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(5), row);
+
+  row.SetOffset(0xC);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x50);
+  EXPECT_EQ(*plan.GetRowAtIndex(6), row);
+}
+
+TEST_F(PECallFrameInfoTest, Chained_eh) {
+  UnwindPlan plan(eRegisterKindLLDB);
+  GetUnwindPlan(0x1001180, plan);
+  EXPECT_EQ(plan.GetRowCount(), 2);
+
+  UnwindPlan::Row row;
+  row.SetOffset(0);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x50);
+  row.SetRegisterLocationToIsCFAPlusOffset(lldb_rsp_x86_64, 0, true);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rip_x86_64, -8, true);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rbx_x86_64, -0x10, true);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rsi_x86_64, -0x18, true);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rdi_x86_64, -0x20, true);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_r14_x86_64, -0x28, true);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_r15_x86_64, -0x30, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(0), row);
+
+  row.SetOffset(5);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rbp_x86_64, 0x18, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(1), row);
+}
+
+TEST_F(PECallFrameInfoTest, Frame_reg_eh) {
+  UnwindPlan plan(eRegisterKindLLDB);
+  GetUnwindPlan(0x1001280, plan);
+  EXPECT_EQ(plan.GetRowCount(), 11);
+
+  UnwindPlan::Row row;
+  row.SetOffset(0);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 8);
+  row.SetRegisterLocationToIsCFAPlusOffset(lldb_rsp_x86_64, 0, true);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rip_x86_64, -8, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(0), row);
+
+  row.SetOffset(6);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x10);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rbp_x86_64, -0x10, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(1), row);
+
+  row.SetOffset(8);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x18);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_r12_x86_64, -0x18, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(2), row);
+
+  row.SetOffset(0xA);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x20);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_r13_x86_64, -0x20, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(3), row);
+
+  row.SetOffset(0xC);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x28);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_r14_x86_64, -0x28, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(4), row);
+
+  row.SetOffset(0xE);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x30);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_r15_x86_64, -0x30, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(5), row);
+
+  row.SetOffset(0x15);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rsp_x86_64, 0x320);
+  EXPECT_EQ(*plan.GetRowAtIndex(6), row);
+
+  row.SetOffset(0x1A);
+  row.GetCFAValue().SetIsRegisterPlusOffset(lldb_rbp_x86_64, 0x2F0);
+  EXPECT_EQ(*plan.GetRowAtIndex(7), row);
+
+  row.SetOffset(0x21);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rbx_x86_64, 8, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(8), row);
+
+  row.SetOffset(0x28);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rsi_x86_64, 0x10, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(9), row);
+
+  row.SetOffset(0x2F);
+  row.SetRegisterLocationToAtCFAPlusOffset(lldb_rdi_x86_64, 0x18, true);
+  EXPECT_EQ(*plan.GetRowAtIndex(10), row);
+}

llvm/include/llvm/Support/Win64EH.h

 /// the prolog of a function.
 enum UnwindOpcodes {
   UOP_PushNonVol = 0,
   UOP_AllocLarge,
   UOP_AllocSmall,
   UOP_SetFPReg,
   UOP_SaveNonVol,
   UOP_SaveNonVolBig,
-  UOP_SaveXMM128 = 8,
+  UOP_Epilog,
+  UOP_SpareCode,
+  UOP_SaveXMM128,
   UOP_SaveXMM128Big,
   UOP_PushMachFrame,
   // The following set of unwind opcodes is for ARM64.  They are documented at
   // https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
   UOP_AllocMedium,
   UOP_SaveFPLRX,
   UOP_SaveFPLR,
   UOP_SaveReg,