[Clang][MC][MachO]Only emits compact-unwind format for "canonical" personality symbols. For the rest, use DWARFs.

[oontvoo]

Summary

Details: https://github.com/rust-lang/rust/issues/102754

The MachO format uses 2 bits to encode these personality funtions, with 0 reserved for "no-personality".
This means we can only have up to 3 personality. There are already three popular personalities: gxx_personality_v0, gcc_personality_v0, and __objc_personality_v0.
As a result, any system that needs custom-personality will run into a problem (case in point : Rust).

This patch implemented jyknight's proposal to simply force DWARFs for all non-canonical personality functions , ie., __gxx_personality_v0 and __objc_personality_v0 (intentionally left out __gcc_personality_v0 since it's rarely used anyway - there is no point in reserving a spot for it.)

Additionally, added a flag to let users request emitting compact-unwind for non-canonical personality functions if they know it'd be OK for their builds (We have one "free" slot left).

[oontvoo]

new change:

• updated tests to set the flag that emits compact-unwind for non-canonical to preserve old testings
• added new tests that does NOT emit compact-unwind for non-canonical

[oontvoo]

rebase

[oontvoo]

fix build warnings (struct vs class in forward decl)

[oontvoo]

updated clang test

[oontvoo]

• defined equivalent flag in the clang driver

[jyknight]

I wonder if we actually need to define a clang frontend flag for this; I suspect nobody will ever want to specify it, since the only non-canonical personality clang will ever generate that changes behavior is the pure-C destructor-only personality, __gnu_personality_v0. Otherwise, it could only arise from assembly or IR.

For a test-case, can just use -mllvm -emit-compact-unwind-non-canonical.

llvm/lib/MC/MCAsmBackend.cpp

119

This could use a comment as to why these two are "canonical" and why "__gcc_personality_v0" is excluded despite being similar.

[oontvoo]

updated more clang test

[oontvoo]

In D144999#4319964, @jyknight wrote:

I wonder if we actually need to define a clang frontend flag for this; I suspect nobody will ever want to specify it, since the only non-canonical personality clang will ever generate that changes behavior is the pure-C destructor-only personality, __gnu_personality_v0. Otherwise, it could only arise from assembly or IR.

For a test-case, can just use -mllvm -emit-compact-unwind-non-canonical.

Per offline discussion, passing it via -mllvm doesn't work because llvm-flags that populate MCTargetOptions flags aren't registered in Clang, so it needs to be at least a clang cc1 option.

lld/MachO/UnwindInfoSection.cpp

361

yes - good catch

[oontvoo]

addressed review comments:

• added explanation on why we left out _gcc personality
• updated more clang tests

hopefully should be all green now!

[oontvoo]

rebase

[oontvoo]

Hi all! The CI builds are all clean now. Any further comment/review on this?
Would love to close this out soon. Thanks! :)

[oontvoo]

@int3 @thakis, et al - friendly 🔔 :)

[int3]

lgtm

lld/MachO/UnwindInfoSection.cpp

346–347

looks like the old comment can be retained

[oontvoo]

updated comment

[oontvoo]

rebase

[oontvoo]

Thanks!

[oontvoo]

rebase again (windows failures in flang tests looked unrelated)

[thakis]

This makes lld crash when linking a libc++ with object files built by a clang that also contains the patch. Here's a reduced (to just libc++), stand-alone repro that repros the crash in 6 seconds on my m1 mbp: https://bugs.chromium.org/p/chromium/issues/detail?id=1446967#c10

[thakis]

Reverted in 4980eead4d0b4666d53dad07afb091375b3a13a0 for now.

(The assert only happens when targeting x86_64, not arm64. The repro script above has the right -arch flag to toggle it.)

[oontvoo]

In D144999#4356218, @thakis wrote:

Reverted in 4980eead4d0b4666d53dad07afb091375b3a13a0 for now.

(The assert only happens when targeting x86_64, not arm64. The repro script above has the right -arch flag to toggle it.)

Thanks for the revert! This was caused by another bug (should be fixed in https://reviews.llvm.org/D151824)
Will reland this once that is landed.

llvm/lib/MC/MCAsmBackend.cpp

125

need an additional _

[oontvoo]

rebase for rolling forward. (Will wait ~1 day before pushing to avoid possible stacking reverts because this depends on D151824)

[oontvoo]

rebase

[fdeazeve]

I believe this is breaking the LLDB tests:
https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/56106/changes
https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/buildTimeTrend

Build 56105 was passing, and the only relevant change seems to come from this review.

Note that the failure is due to a test that is now passing:

Unexpectedly Passed Tests (1):
  lldb-shell :: Unwind/prefer-debug-over-eh-frame.test

Maybe we forgot to re-enable that test?

[oontvoo]

In D144999#4405793, @fdeazeve wrote:

I believe this is breaking the LLDB tests:
https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/56106/changes
https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/buildTimeTrend

Build 56105 was passing, and the only relevant change seems to come from this review.

Note that the failure is due to a test that is now passing:

Unexpectedly Passed Tests (1):
  lldb-shell :: Unwind/prefer-debug-over-eh-frame.test

Maybe we forgot to re-enable that test?

The behaviour has changed - I can update the test.
Question: Do you prefer to have it set a flag that goes back to the old behaviour? OR change to to expect-passing?

(My vote would be on have it expect the test to pass because, from reading the test, this is preferring debug-frame over eh-frame, which probably isn't ideal in the new code beacuse all non-canonical personality symbols will now be eh-frame)

[oontvoo]

P.S: https://reviews.llvm.org/D152449

[t.p.northover]

I don't think this handles the no-personality case properly. For example this code leads to a DWARF entry now:

void bar(int *) noexcept;
void foo() {
  int arr;
  bar(&arr);
}

[Michael137]

Looks like the latest reland of this patch (e60b30d5e3878e7d91f8872ec4c4dca00d4a2dfc) broke some debug-info cross-project-tests on the Arm64 macOS buildbots: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-as/263/execution/node/54/log/

Failed Tests (2):
  cross-project-tests :: debuginfo-tests/dexter-tests/optnone-fastmath.cpp
  cross-project-tests :: debuginfo-tests/dexter-tests/optnone-struct-and-methods.cpp

You can run those tests by adding cross-project-tests to LLVM_ENABLE_PROJECTS and running ninja check-debuginfo.

AFAICT, it also broke following LLDB test (https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-as/263/execution/node/65/log/):

Failed Tests (1):
  lldb-api :: functionalities/step-avoids-no-debug/TestStepNoDebug.py

Let me know if you need help reproducing this

[oontvoo]

In D144999#4407934, @t.p.northover wrote:

I don't think this handles the no-personality case properly. For example this code leads to a DWARF entry now:

void bar(int *) noexcept;
void foo() {
  int arr;
  bar(&arr);
}

Thanks! Sent the fix in D152540

[Michael137]

In D144999#4408248, @Michael137 wrote:

Looks like the latest reland of this patch (e60b30d5e3878e7d91f8872ec4c4dca00d4a2dfc) broke some debug-info cross-project-tests on the Arm64 macOS buildbots: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-as/263/execution/node/54/log/

Failed Tests (2):
  cross-project-tests :: debuginfo-tests/dexter-tests/optnone-fastmath.cpp
  cross-project-tests :: debuginfo-tests/dexter-tests/optnone-struct-and-methods.cpp

You can run those tests by adding cross-project-tests to LLVM_ENABLE_PROJECTS and running ninja check-debuginfo.

AFAICT, it also broke following LLDB test (https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-as/263/execution/node/65/log/):

Failed Tests (1):
  lldb-api :: functionalities/step-avoids-no-debug/TestStepNoDebug.py

Let me know if you need help reproducing this

Mind taking a look or reverting the patch until the tests pass?

[oontvoo]

In D144999#4409149, @Michael137 wrote:

In D144999#4408248, @Michael137 wrote:

Looks like the latest reland of this patch (e60b30d5e3878e7d91f8872ec4c4dca00d4a2dfc) broke some debug-info cross-project-tests on the Arm64 macOS buildbots: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-as/263/execution/node/54/log/

Failed Tests (2):
  cross-project-tests :: debuginfo-tests/dexter-tests/optnone-fastmath.cpp
  cross-project-tests :: debuginfo-tests/dexter-tests/optnone-struct-and-methods.cpp

You can run those tests by adding cross-project-tests to LLVM_ENABLE_PROJECTS and running ninja check-debuginfo.

AFAICT, it also broke following LLDB test (https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-as/263/execution/node/65/log/):

Failed Tests (1):
  lldb-api :: functionalities/step-avoids-no-debug/TestStepNoDebug.py

Let me know if you need help reproducing this

Mind taking a look or reverting the patch until the tests pass?

Yes - having a look now - wasn't able to repro the test failure before because the build broke at HEAD:

/mnt/ssd/repo/llvm-project/llvm/include/llvm/CodeGen/RDFRegisters.h: In member function ‘constexpr size_t llvm::rdf::RegisterRef::hash() const’:
/mnt/ssd/repo/llvm-project/llvm/include/llvm/CodeGen/RDFRegisters.h:92:35: error: call to non-‘constexpr’ function ‘std::size_t std::hash<unsigned int>::operator()(unsigned int) const’
   92 |     return std::hash<RegisterId>{}(Reg) ^
      |            ~~~~~~~~~~~~~~~~~~~~~~~^~~~~

[oontvoo]

P.S This might have the same root-cause with the previous comment and could be fixed by D152540 as well.
(not able to repro the failures yet - don't have arm64 readily available, will test it later this evening. but on linux x86-64 and macos x86-64, ninja check-debuginfo passed for me)

[Michael137]

In D144999#4409671, @oontvoo wrote:

P.S This might have the same root-cause with the previous comment and could be fixed by D152540 as well.
(not able to repro the failures yet - don't have arm64 readily available, will test it later this evening. but on linux x86-64 and macos x86-64, ninja check-debuginfo passed for me)

FYI, still failing with D152540. I'm able to repro this on my arm64 machine.

The repro without running dexter is as follows:

./bin/clang++ cross-project-tests/debuginfo-tests/dexter-tests/optnone-struct-and-methods.cpp -g -O0 -o test.out
./bin/lldb test.out -o "br se -l 90" -o run -o s -o s -o s -o s -o "expr _data.b.other_b"
(lldb) expr _data.b.other_b 
(A::B) $0 = 0x10d50

We would however expect the value to be B_VALUE

The backtrace also looks wonky:

(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = step in
  * frame #0: 0x0000000100003d18 test.out`(anonymous namespace)::A::getData(this=0x0000000100011910) at optnone-struct-and-methods.cpp:87:5
    frame #1: 0x0000000187185058 dyld`start + 2224

[jasonmolenda]

Michael and I looked into this. This simple c++ file is resulting in eh_frame unwind info on aarch64 darwin instead of compact unwind info. The eh_frame instructions don't describe the epilogue, so lldb is stopping on the final RET instruction after it has adjusted $sp back to its original value and the unwind now fails to work in the debugger. That's always the problem with eh_frame/debug_frame from the debugger's point of view - it's only guaranteed to describe the unwind state at throwable locations. gdb lives exclusively off of eh_frame/debug_frame so in practice gcc/clang (at least on intel) describe both the prologue and the epilogue for the debugger's benefit. But that's not what this eh_frame includes on aarch64 darwin, and it breaks the debugger because it's trusting the eh_frame to be accurate at every instruction point.

The emission of eh_frame on aarch64 darwin instead of compact unwind, for this simple codegen, is a bug and cannot remain in the tree unfixed. It will increase binary size and reduce throw performance. It also happens to cause lldb regressions like this because we've never lived off of eh_frame as our primary unwind format on this platform, but that's a separate issue and I'm not going to dig in to finding a way to detect this & ignore the eh_frame on this target.

Looking at the failing test case that Michael has been debugging, none of these methods have a personality, and yet we're getting eh_frame instead of compact unwind. That's the bug.

[oontvoo]

In D144999#4415137, @jasonmolenda wrote:

Michael and I looked into this. This simple c++ file is resulting in eh_frame unwind info on aarch64 darwin instead of compact unwind info. The eh_frame instructions don't describe the epilogue, so lldb is stopping on the final RET instruction after it has adjusted $sp back to its original value and the unwind now fails to work in the debugger. That's always the problem with eh_frame/debug_frame from the debugger's point of view - it's only guaranteed to describe the unwind state at throwable locations. gdb lives exclusively off of eh_frame/debug_frame so in practice gcc/clang (at least on intel) describe both the prologue and the epilogue for the debugger's benefit. But that's not what this eh_frame includes on aarch64 darwin, and it breaks the debugger because it's trusting the eh_frame to be accurate at every instruction point.

The emission of eh_frame on aarch64 darwin instead of compact unwind, for this simple codegen, is a bug and cannot remain in the tree unfixed. It will increase binary size and reduce throw performance. It also happens to cause lldb regressions like this because we've never lived off of eh_frame as our primary unwind format on this platform, but that's a separate issue and I'm not going to dig in to finding a way to detect this & ignore the eh_frame on this target.

Thanks for the details! From your descriptions, I agree that this is a bug - the change in this patch is *NOT* intended to change the unwind format when there's no personality symbol - (it should only affect custom personality symbols, which is not the case in this example)
Still debugging - not sure why it only occurs for aarch64

Looking at the failing test case that Michael has been debugging, none of these methods have a personality, and yet we're getting eh_frame instead of compact unwind. That's the bug.

[oontvoo]

In D144999#4415419, @oontvoo wrote:

In D144999#4415137, @jasonmolenda wrote:

Michael and I looked into this. This simple c++ file is resulting in eh_frame unwind info on aarch64 darwin instead of compact unwind info.

P.S: still no luck reproducing this with TOT clang. Would you mind verifying my test case below (this was on M1 mac):

### clang is built with commit up to 5b1c62c0f2e9a739707429f650cb897c067f86c2
vyng-macbookpro3 /Users/vyng/repo/llvm-project/build_all$ ./bin/clang++  ../cross-project-tests/debuginfo-tests/dexter-tests/optnone-struct-and-methods.cpp -g -O0 -c -o test_tot.o

vyng-macbookpro3 /Users/vyng/repo/llvm-project/build_all$ objdump --macho --unwind-info --dwarf=frames  test_tot.o
Contents of __compact_unwind section:
  Entry at offset 0x0:
    start:                0x0 ltmp0
    length:               0x70
    compact encoding:     0x44000000
    personality function: 0x0 ___gxx_personality_v0
    LSDA:                 0x238 ltmp1
  Entry at offset 0x20:
    start:                0x70 __ZN12_GLOBAL__N_11AC1Ev
    length:               0x2c
    compact encoding:     0x04000000
  Entry at offset 0x40:
    start:                0x9c __ZN12_GLOBAL__N_11A7getDataEv
    length:               0x78
    compact encoding:     0x04000000
  Entry at offset 0x60:
    start:                0x114 __ZN12_GLOBAL__N_11AD1Ev
    length:               0x2c
    compact encoding:     0x04000000
  Entry at offset 0x80:
    start:                0x140 __ZN12_GLOBAL__N_11AC2Ev
    length:               0x2c
    compact encoding:     0x02001000
  Entry at offset 0xa0:
    start:                0x16c __ZN12_GLOBAL__N_11A12setOtherDataEv
    length:               0x74
    compact encoding:     0x04000000
  Entry at offset 0xc0:
    start:                0x1e0 __ZN12_GLOBAL__N_11A12getOtherDataEv
    length:               0x18
    compact encoding:     0x02001000
  Entry at offset 0xe0:
    start:                0x1f8 __ZN12_GLOBAL__N_11AD2Ev
    length:               0x40
    compact encoding:     0x04000000

.debug_frame contents:


.eh_frame contents:
<<<< nothing in eh_frame section, which is expected and matches what produced by base clang

[Michael137]

In D144999#4417731, @oontvoo wrote:

In D144999#4415419, @oontvoo wrote:

In D144999#4415137, @jasonmolenda wrote:

Michael and I looked into this. This simple c++ file is resulting in eh_frame unwind info on aarch64 darwin instead of compact unwind info.

P.S: still no luck reproducing this with TOT clang. Would you mind verifying my test case below (this was on M1 mac):

### clang is built with commit up to 5b1c62c0f2e9a739707429f650cb897c067f86c2
vyng-macbookpro3 /Users/vyng/repo/llvm-project/build_all$ ./bin/clang++  ../cross-project-tests/debuginfo-tests/dexter-tests/optnone-struct-and-methods.cpp -g -O0 -c -o test_tot.o

vyng-macbookpro3 /Users/vyng/repo/llvm-project/build_all$ objdump --macho --unwind-info --dwarf=frames  test_tot.o
Contents of __compact_unwind section:
  Entry at offset 0x0:
    start:                0x0 ltmp0
    length:               0x70
    compact encoding:     0x44000000
    personality function: 0x0 ___gxx_personality_v0
    LSDA:                 0x238 ltmp1
  Entry at offset 0x20:
    start:                0x70 __ZN12_GLOBAL__N_11AC1Ev
    length:               0x2c
    compact encoding:     0x04000000
  Entry at offset 0x40:
    start:                0x9c __ZN12_GLOBAL__N_11A7getDataEv
    length:               0x78
    compact encoding:     0x04000000
  Entry at offset 0x60:
    start:                0x114 __ZN12_GLOBAL__N_11AD1Ev
    length:               0x2c
    compact encoding:     0x04000000
  Entry at offset 0x80:
    start:                0x140 __ZN12_GLOBAL__N_11AC2Ev
    length:               0x2c
    compact encoding:     0x02001000
  Entry at offset 0xa0:
    start:                0x16c __ZN12_GLOBAL__N_11A12setOtherDataEv
    length:               0x74
    compact encoding:     0x04000000
  Entry at offset 0xc0:
    start:                0x1e0 __ZN12_GLOBAL__N_11A12getOtherDataEv
    length:               0x18
    compact encoding:     0x02001000
  Entry at offset 0xe0:
    start:                0x1f8 __ZN12_GLOBAL__N_11AD2Ev
    length:               0x40
    compact encoding:     0x04000000

.debug_frame contents:


.eh_frame contents:
<<<< nothing in eh_frame section, which is expected and matches what produced by base clang

Sorry for the back-and-forth
Looks like D152540 did indeed resolve this. The bots apparently didn't pick that change up until today. And locally I must've been producing the binary without that commit

It's all good now, thanks!

clang/include/clang/Basic/CodeGenOptions.def

CODEGENOPT(IndirectBranchCSPrefix, 1, 0) ///< if -mindirect-branch-cs-prefix
                                          ///< is set.
 
 CODEGENOPT(XRayInstrumentFunctions , 1, 0) ///< Set when -fxray-instrument is
                                            ///< enabled.
 CODEGENOPT(StackSizeSection  , 1, 0) ///< Set when -fstack-size-section is enabled.
 CODEGENOPT(ForceDwarfFrameSection , 1, 0) ///< Set when -fforce-dwarf-frame is
                                           ///< enabled.
 
+///< Set when -femit-compact-unwind-non-canonical is enabled.
+CODEGENOPT(EmitCompactUnwindNonCanonical, 1, 0)
+
 ///< Set when -femit-dwarf-unwind is passed.
 ENUM_CODEGENOPT(EmitDwarfUnwind, llvm::EmitDwarfUnwindType, 2,
                 llvm::EmitDwarfUnwindType::Default)
 
 ///< Set when -fxray-always-emit-customevents is enabled.
 CODEGENOPT(XRayAlwaysEmitCustomEvents , 1, 0)
 
 ///< Set when -fxray-always-emit-typedevents is enabled.

clang/include/clang/Driver/Options.td

defm force_dwarf_frame : BoolFOption<"force-dwarf-frame",
   PosFlag<SetTrue, [CC1Option], "Always emit a debug frame section">, NegFlag<SetFalse>>;
 def femit_dwarf_unwind_EQ : Joined<["-"], "femit-dwarf-unwind=">,
   Group<f_Group>, Flags<[CC1Option, CC1AsOption]>,
   HelpText<"When to emit DWARF unwind (EH frame) info">,
   Values<"always,no-compact-unwind,default">,
   NormalizedValues<["Always", "NoCompactUnwind", "Default"]>,
   NormalizedValuesScope<"llvm::EmitDwarfUnwindType">,
   MarshallingInfoEnum<CodeGenOpts<"EmitDwarfUnwind">, "Default">;
+defm emit_compact_unwind_non_canonical : BoolFOption<"emit-compact-unwind-non-canonical",
+  CodeGenOpts<"EmitCompactUnwindNonCanonical">, DefaultFalse,
+  PosFlag<SetTrue, [CC1Option, CC1AsOption], "Try emitting Compact-Unwind for non-canonical entries. Maybe overriden by other constraints">, NegFlag<SetFalse>>;
 def g_Flag : Flag<["-"], "g">, Group<g_Group>,
     Flags<[CoreOption,FlangOption]>, HelpText<"Generate source-level debug information">;
 def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>,
   Flags<[CoreOption,FlangOption]>, HelpText<"Emit debug line number tables only">;
 def gline_directives_only : Flag<["-"], "gline-directives-only">, Group<gN_Group>,
   Flags<[CoreOption]>, HelpText<"Emit debug line info directives only">;
 def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;
 def g0 : Flag<["-"], "g0">, Group<gN_Group>;

clang/lib/CodeGen/BackendUtil.cpp

static bool initTargetOptions(DiagnosticsEngine &Diags,
 
   case CodeGenOptions::SwiftAsyncFramePointerKind::Never:
     Options.SwiftAsyncFramePointer = SwiftAsyncFramePointerMode::Never;
     break;
   }
 
   Options.MCOptions.SplitDwarfFile = CodeGenOpts.SplitDwarfFile;
   Options.MCOptions.EmitDwarfUnwind = CodeGenOpts.getEmitDwarfUnwind();
+  Options.MCOptions.EmitCompactUnwindNonCanonical =
+      CodeGenOpts.EmitCompactUnwindNonCanonical;
   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
   Options.MCOptions.MCUseDwarfDirectory =
       CodeGenOpts.NoDwarfDirectoryAsm
           ? llvm::MCTargetOptions::DisableDwarfDirectory
           : llvm::MCTargetOptions::EnableDwarfDirectory;
   Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
   Options.MCOptions.MCIncrementalLinkerCompatible =

clang/lib/Driver/ToolChains/Clang.cpp

bool DefaultIncrementalLinkerCompatible =
       C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
   if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
                    options::OPT_mno_incremental_linker_compatible,
                    DefaultIncrementalLinkerCompatible))
     CmdArgs.push_back("-mincremental-linker-compatible");
 
   Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ);
 
+  Args.addOptInFlag(CmdArgs, options::OPT_femit_compact_unwind_non_canonical,
+                    options::OPT_fno_emit_compact_unwind_non_canonical);
+
   // If you add more args here, also add them to the block below that
   // starts with "// If CollectArgsForIntegratedAssembler() isn't called below".
 
   // When passing -I arguments to the assembler we sometimes need to
   // unconditionally take the next argument.  For example, when parsing
   // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
   // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
   // arg after parsing the '-I' arg.

clang/test/Driver/femit-dwarf-unwind.c

 // REQUIRES: x86-registered-target
 
 // RUN: rm -rf %t; mkdir %t
-// RUN: %clang -target x86_64-apple-macos11.0 -c %s -o %t/x86_64.o
-// RUN: %clang -target x86_64-apple-macos11.0 -femit-dwarf-unwind=no-compact-unwind -c %s -o %t/x86_64-no-dwarf.o
+// RUN: %clang -target x86_64-apple-macos11.0 -c %s -o %t/x86_64.o -femit-compact-unwind-non-canonical
+// RUN: %clang -target x86_64-apple-macos11.0 -femit-dwarf-unwind=no-compact-unwind -femit-compact-unwind-non-canonical -c %s -o %t/x86_64-no-dwarf.o
 // RUN: llvm-objdump --macho --dwarf=frames %t/x86_64.o | FileCheck %s --check-prefix=WITH-FDE
 // RUN: llvm-objdump --macho --dwarf=frames %t/x86_64-no-dwarf.o | FileCheck %s --check-prefix=NO-FDE
 
 // WITH-FDE: FDE
 // NO-FDE-NOT: FDE
 
 int foo() {
   return 1;
 }

clang/test/Driver/femit-dwarf-unwind.s

 // REQUIRES: x86-registered-target
 
 // RUN: rm -rf %t; mkdir %t
-// RUN: %clang -target x86_64-apple-macos11.0 -c %s -o %t/x86_64.o
-// RUN: %clang -target x86_64-apple-macos11.0 -femit-dwarf-unwind=no-compact-unwind -c %s -o %t/x86_64-no-dwarf.o
+// RUN: %clang -target x86_64-apple-macos11.0 -c %s -o %t/x86_64.o -femit-compact-unwind-non-canonical
+// RUN: %clang -target x86_64-apple-macos11.0 -femit-dwarf-unwind=no-compact-unwind -c %s -o %t/x86_64-no-dwarf.o -femit-compact-unwind-non-canonical
 // RUN: llvm-objdump --macho --dwarf=frames %t/x86_64.o | FileCheck %s --check-prefix=WITH-FDE
 // RUN: llvm-objdump --macho --dwarf=frames %t/x86_64-no-dwarf.o | FileCheck %s --check-prefix=NO-FDE
 
 // WITH-FDE: FDE
 // NO-FDE-NOT: FDE
 
 .text
 _foo:
   .cfi_startproc
   .cfi_def_cfa_offset 8
   ret
   .cfi_endproc

clang/tools/driver/cc1as_main.cpp

struct AssemblerInvocation {
   unsigned NoWarn : 1;
   unsigned NoTypeCheck : 1;
   unsigned IncrementalLinkerCompatible : 1;
   unsigned EmbedBitcode : 1;
 
   /// Whether to emit DWARF unwind info.
   EmitDwarfUnwindType EmitDwarfUnwind;
 
+  // Whether to emit compact-unwind for non-canonical entries.
+  // Note: maybe overriden by other constraints.
+  unsigned EmitCompactUnwindNonCanonical : 1;
+
   /// The name of the relocation model to use.
   std::string RelocationModel;
 
   /// The ABI targeted by the backend. Specified using -target-abi. Empty
   /// otherwise.
   std::string TargetABI;
 
   /// Darwin target variant triple, the variant of the deployment target
AssemblerInvocation() {
     FatalWarnings = 0;
     NoWarn = 0;
     NoTypeCheck = 0;
     IncrementalLinkerCompatible = 0;
     Dwarf64 = 0;
     DwarfVersion = 0;
     EmbedBitcode = 0;
     EmitDwarfUnwind = EmitDwarfUnwindType::Default;
+    EmitCompactUnwindNonCanonical = false;
   }
 
   static bool CreateFromArgs(AssemblerInvocation &Res,
                              ArrayRef<const char *> Argv,
                              DiagnosticsEngine &Diags);
 };
 
 }
bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   if (auto *A = Args.getLastArg(OPT_femit_dwarf_unwind_EQ)) {
     Opts.EmitDwarfUnwind =
         llvm::StringSwitch<EmitDwarfUnwindType>(A->getValue())
             .Case("always", EmitDwarfUnwindType::Always)
             .Case("no-compact-unwind", EmitDwarfUnwindType::NoCompactUnwind)
             .Case("default", EmitDwarfUnwindType::Default);
   }
 
+  Opts.EmitCompactUnwindNonCanonical =
+      Args.hasArg(OPT_femit_compact_unwind_non_canonical);
+
   Opts.AsSecureLogFile = Args.getLastArgValue(OPT_as_secure_log_file);
 
   return Success;
 }
 
 static std::unique_ptr<raw_fd_ostream>
 getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
   // Make sure that the Out file gets unlinked from the disk if we get a
static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   // it later.
   SrcMgr.setIncludeDirs(Opts.IncludePaths);
 
   std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(Opts.Triple));
   assert(MRI && "Unable to create target register info!");
 
   MCTargetOptions MCOptions;
   MCOptions.EmitDwarfUnwind = Opts.EmitDwarfUnwind;
+  MCOptions.EmitCompactUnwindNonCanonical = Opts.EmitCompactUnwindNonCanonical;
   MCOptions.AsSecureLogFile = Opts.AsSecureLogFile;
 
   std::unique_ptr<MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, Opts.Triple, MCOptions));
   assert(MAI && "Unable to create target asm info!");
 
   // Ensure MCAsmInfo initialization occurs before any use, otherwise sections
   // may be created with a combination of default and explicit settings.

lld/MachO/UnwindInfoSection.cpp

void UnwindInfoSectionImpl::relocateCompactUnwind(
     std::vector<CompactUnwindEntry> &cuEntries) {
   parallelFor(0, symbolsVec.size(), [&](size_t i) {
     CompactUnwindEntry &cu = cuEntries[i];
     const Defined *d = symbolsVec[i].second;
     cu.functionAddress = d->getVA();
     if (!d->unwindEntry)
       return;
 
-    // If we have DWARF unwind info, create a CU entry that points to it.
+    // If we have DWARF unwind info, create a slimmed-down CU entry that points
+    // to it.
     if (d->unwindEntry->getName() == section_names::ehFrame) {
       // The unwinder will look for the DWARF entry starting at the hint,
       // assuming the hint points to a valid CFI record start. If it
       // fails to find the record, it proceeds in a linear search through the
       // contiguous CFI records from the hint until the end of the section.
       // Ideally, in the case where the offset is too large to be encoded, we
       // would instead encode the largest possible offset to a valid CFI record,
       // but since we don't keep track of that, just encode zero -- the start of
       // the section is always the start of a CFI record.
       uint64_t dwarfOffsetHint =
           d->unwindEntry->outSecOff <= DWARF_SECTION_OFFSET
               ? d->unwindEntry->outSecOff
               : 0;
       cu.encoding = target->modeDwarfEncoding | dwarfOffsetHint;
       const FDE &fde = cast<ObjFile>(d->getFile())->fdes[d->unwindEntry];
       cu.functionLength = fde.funcLength;
-      cu.personality = fde.personality;
+      // Omit the DWARF personality from compact-unwind entry so that we
+      // don't need to encode it.
+      cu.personality = nullptr;
       cu.lsda = fde.lsda;
       return;
     }
 
     assert(d->unwindEntry->getName() == section_names::compactUnwind);
 
     auto buf = reinterpret_cast<const uint8_t *>(d->unwindEntry->data.data()) -
                target->wordSize;
     cu.functionLength =

lld/test/MachO/compact-unwind-both-local-and-dylib-personality.s

 ## Tests that lld-macho can handle the case where personality symbols with the same name
 ## are both from a dylib and locally defined in an object file.
 
 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/user_2.s -o %t/user_2.o
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/user_3.s -o %t/user_3.o
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=true -filetype=obj  -triple=x86_64-apple-darwin19.0.0 %t/user_2.s -o %t/user_2.o
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=true -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/user_3.s -o %t/user_3.o
+
+## Test case for linking 3+ personaltiies (all globals) without crashing because all the non-canonical are DWARFs
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=false -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/user_4.s -o %t/user_4.o
+  
 # RUN: yaml2obj %t/combined.yaml > %t/combined.o
 
 ## Pre-condition: check that ___gxx_personality_v0 really is locally defined in combined.o before we proceed.
 # RUN: llvm-nm %t/combined.o | grep '___gxx_personality_v0'  | FileCheck %s --check-prefix=PRECHECK
 # PRECHECK: {{.*}} t ___gxx_personality_v0
 # PRECHECK-NOT: {{.*}} U ___gxx_personality_v0
 # PRECHECK-NOT: {{.*}} T ___gxx_personality_v0
 
 ## check that we can link with 4 personalities without crashing:
 ## ___gxx_personality_v0 (libc++.tbd), ___gxx_personality_v0(local), _personality_1, and _personality_2
 # RUN: %lld -lSystem -lc++ %t/user_2.o %t/combined.o -o %t/a.out
 ## ___gxx_personality_v0 (global), ___gxx_personality_v0(libc++.tbd), _personality_1, and _personality_2
 # RUN: %lld -lSystem -lc++ %t/user_3.o %t/user_2.o -o %t/b.out
 ## ___gxx_personality_v0 (global), ___gxx_personality_v0(local), _personality_1, and _personality_2
 # RUN: %lld -lSystem -dylib %t/user_3.o %t/combined.o %t/user_2.o -o %t/c.out
 
+## check that we can link with 3+ personalities without crashing because
+## non-canonical personalities are dwarf.
+## This has ___gxx_personality_v0(global), ___gxx_personality_v0(local), and _personality_{1,2,3,4}
+## Only the ___gxx_personality_v0(global) should have compact-unwind. The rest should have DWARFs.
+# RUN: %lld -lSystem -lc++ %t/user_4.o %t/combined.o -o %t/d.out
+
 ## Postlink checks.
 # RUN: llvm-nm %t/a.out | FileCheck %s --check-prefix=POSTCHECK
 # POSTCHECK: {{.*}} U ___gxx_personality_v0
 # POSTCHECK: {{.*}} t ___gxx_personality_v0
 
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --bind %t/a.out | FileCheck %s --check-prefixes=A,CHECK -D#%x,OFF=0x100000000
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --bind %t/b.out | FileCheck %s --check-prefixes=BC,CHECK -D#%x,OFF=0x100000000
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --bind %t/c.out | FileCheck %s --check-prefixes=BC,C,CHECK -D#%x,OFF=0
 
+# RUN: llvm-objdump --macho --indirect-symbols --unwind-info --bind %t/d.out | FileCheck %s --check-prefixes=D -D#%x,OFF=0x100000000
+
 # A:      Indirect symbols for (__DATA_CONST,__got)
 # A-NEXT: address                    index name
 # A:      0x[[#%x,GXX_PERSONALITY_LO:]] [[#]] ___gxx_personality_v0
 # A:      0x[[#%x,GXX_PERSONALITY_HI:]] [[#]] ___gxx_personality_v0
 # A:      0x[[#%x,PERSONALITY_1:]]  LOCAL
 # A:      0x[[#%x,PERSONALITY_2:]]  LOCAL
 
 # BC:      Indirect symbols for (__DATA_CONST,__got)
 # BC-NEXT: address                    index name
 # C:       0x[[#%x,GXX_PERSONALITY_HI:]] LOCAL
 # BC:      0x[[#%x,GXX_PERSONALITY_LO:]] LOCAL
 # BC:      0x[[#%x,PERSONALITY_1:]]      LOCAL
 # BC:      0x[[#%x,PERSONALITY_2:]]      LOCAL
 
 # CHECK:        Personality functions: (count = 3)
 # CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#GXX_PERSONALITY_LO-OFF]]
 # CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#PERSONALITY_1-OFF]]
 # CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#PERSONALITY_2-OFF]]
 
 # A: Bind table
 # A-NEXT: segment  section          address      type       addend dylib            symbol
 # A-NEXT: __DATA_CONST __got        0x[[#GXX_PERSONALITY_LO-0]] pointer         0 libc++abi        ___gxx_personality_v0
 
+
+# D:      Indirect symbols for (__DATA_CONST,__got)
+# D-NEXT: address                    index name
+# D:      0x[[#%x,GXX_PERSONALITY_HI:]] [[#]] ___gxx_personality_v0
+# D:      0x[[#%x,PERSONALITY_1:]] [[#]] _personality_1
+# D:      0x[[#%x,PERSONALITY_2:]] [[#]] _personality_2
+# D:      0x[[#%x,PERSONALITY_3:]] [[#]] _personality_3
+# D:      0x[[#%x,PERSONALITY_4:]] [[#]] _personality_4
+# D:      0x[[#%x,GXX_PERSONALITY_LO:]] [[#]] ___gxx_personality_v0
+
+# D: Contents of __unwind_info section:
+# D:  Personality functions: (count = 1)
+     personality[1]: 0x{{0*}}[[#GXX_PERSONALITY_HI-OFF]]
+ 
+# D: Bind table:
+# D: segment  section          address    type       addend dylib            symbol
+# D: __DATA_CONST __got        0x[[#GXX_PERSONALITY_HI-0]] pointer         0 libc++abi        ___gxx_personality_v0
+
+
 ## Error cases.
 ## Check that dylib symbols are picked (which means without libc++, we'd get an undefined symbol error.
 # RUN:  not %lld -lSystem %t/user_2.o %t/combined.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERRORCHECK
 # ERRORCHECK: {{.*}} undefined symbol: ___gxx_personality_v0
 
+#--- user_4.s
+.globl _main, _personality_1, _personality_2, _personality_3, _personality_4
+
+.text
+
+_baz1:
+  .cfi_startproc
+  .cfi_personality 155, _personality_1
+  .cfi_def_cfa_offset 16
+  retq
+  .cfi_endproc
+
+_baz2:
+  .cfi_startproc
+  .cfi_personality 155, _personality_2
+  .cfi_def_cfa_offset 16
+  retq
+  .cfi_endproc
+
+_baz3:
+  .cfi_startproc
+  .cfi_personality 155, _personality_3
+  .cfi_def_cfa_offset 16
+  retq
+  .cfi_endproc
+
+
+_baz4:
+  .cfi_startproc
+  .cfi_personality 155, _personality_4
+  .cfi_def_cfa_offset 16
+  retq
+  .cfi_endproc
+  
+_main:
+  .cfi_startproc
+  .cfi_personality 155, ___gxx_personality_v0
+  .cfi_def_cfa_offset 16
+  retq
+  .cfi_endproc
+
+_personality_1:
+  retq
+_personality_2:
+  retq
+_personality_3:
+  retq
+_personality_4:
+  retq
+  
 #--- user_3.s
 .globl _baz3
 .private_extern ___gxx_personality_v0
 
 .text
 _baz3:
   .cfi_startproc
   .cfi_personality 155, ___gxx_personality_v0

lld/test/MachO/compact-unwind-generated.test

 #
 # 2) Summary encodings from the input object will match
 #    those from the linked output
 #
 # 3) Encodings & symbols from the input object will match
 #    those from the linked output
 
 # RUN: %python %S/tools/generate-cfi-funcs.py --seed=johnnyapple >%t.s
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 -o %t.o %t.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 -emit-compact-unwind-non-canonical=true -o %t.o %t.s
 # RUN: %lld -Z -L%S/Inputs/MacOSX.sdk/usr/lib -lSystem -o %t %t.o
 # RUN: llvm-objdump --unwind-info --syms %t %t.o >%t.dump
 # RUN: %python %S/tools/validate-unwind-info.py %t.dump

lld/test/MachO/compact-unwind-lsda-folding.s

 ## Verify that the compact unwind entries for two functions with identical
 ## unwind information and LSDA aren't folded together; see the comment in
 ## UnwindInfoSectionImpl::finalize for why.
 
 # REQUIRES: x86
 # RUN: rm -rf %t; mkdir %t
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos11.0 -o %t/lsda.o %s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos11.0 -emit-compact-unwind-non-canonical=true -o %t/lsda.o %s
 # RUN: %lld -dylib --icf=all -lSystem -lc++ -o %t/liblsda.dylib %t/lsda.o
 # RUN: llvm-objdump --macho --syms --unwind-info %t/liblsda.dylib | FileCheck %s
 
 ## Check that f and g have the same unwind encoding and LSDA offset (we need to
 ## link with ICF above in order to get the LSDA deduplicated), and that their
 ## compact unwind entries aren't folded.
 
 # CHECK-LABEL: SYMBOL TABLE:

lld/test/MachO/compact-unwind-stack-ind.s

 # REQUIRES: x86
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 -emit-compact-unwind-non-canonical=true %s -o %t.o
 # RUN: %lld -arch x86_64 -dylib %t.o -o %t.dylib
 # RUN: llvm-objdump --macho --syms --unwind-info %t.dylib | FileCheck %s
 
 ## Both _f and _g have the same compact unwind encoding,
 ## but different stack sizes. So their compact unwindings
 ## can't be merged.
 # CHECK:  SYMBOL TABLE:
 # CHECK:  [[#%x,F:]] g  F __TEXT,__text _f

lld/test/MachO/compact-unwind.s

 # REQUIRES: x86, aarch64
 # RUN: rm -rf %t; split-file %s %t
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/my-personality.s -o %t/x86_64-my-personality.o
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/main.s -o %t/x86_64-main.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 -emit-compact-unwind-non-canonical=true %t/my-personality.s -o %t/x86_64-my-personality.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 -emit-compact-unwind-non-canonical=true %t/main.s -o %t/x86_64-main.o
 # RUN: %lld -arch x86_64 -lSystem -lc++ %t/x86_64-my-personality.o %t/x86_64-main.o -o %t/x86_64-personality-first
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/x86_64-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK -D#%x,BASE=0x100000000 -DSEG=__TEXT
 # RUN: %lld -dead_strip -arch x86_64 -lSystem -lc++ %t/x86_64-main.o %t/x86_64-my-personality.o -o %t/x86_64-personality-second
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/x86_64-personality-second | FileCheck %s --check-prefixes=SECOND,CHECK -D#%x,BASE=0x100000000 -DSEG=__TEXT
 
-# RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin19.0.0 %t/my-personality.s -o %t/arm64-my-personality.o
-# RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin19.0.0 %t/main.s -o %t/arm64-main.o
+# RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin19.0.0 -emit-compact-unwind-non-canonical=true %t/my-personality.s -o %t/arm64-my-personality.o
+# RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin19.0.0 -emit-compact-unwind-non-canonical=true %t/main.s -o %t/arm64-main.o
 # RUN: %lld -arch arm64 -lSystem -lc++ %t/arm64-my-personality.o %t/arm64-main.o -o %t/arm64-personality-first
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK -D#%x,BASE=0x100000000 -DSEG=__TEXT
 # RUN: %lld -dead_strip -arch arm64 -lSystem -lc++ %t/arm64-main.o %t/arm64-my-personality.o -o %t/arm64-personality-second
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-personality-second | FileCheck %s --check-prefixes=SECOND,CHECK -D#%x,BASE=0x100000000 -DSEG=__TEXT
 
-# RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %t/my-personality.s -o %t/arm64-32-my-personality.o
-# RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %t/main.s -o %t/arm64-32-main.o
+# RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos -emit-compact-unwind-non-canonical=true %t/my-personality.s -o %t/arm64-32-my-personality.o
+# RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos -emit-compact-unwind-non-canonical=true %t/main.s -o %t/arm64-32-main.o
 # RUN: %lld-watchos -lSystem -lc++ %t/arm64-32-my-personality.o %t/arm64-32-main.o -o %t/arm64-32-personality-first
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-32-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK -D#%x,BASE=0x4000 -DSEG=__TEXT
 # RUN: %lld-watchos -dead_strip -lSystem -lc++ %t/arm64-32-main.o %t/arm64-32-my-personality.o -o %t/arm64-32-personality-second
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-32-personality-second | FileCheck %s --check-prefixes=SECOND,CHECK -D#%x,BASE=0x4000 -DSEG=__TEXT
 
 # RUN: %lld -arch x86_64 -rename_section __TEXT __gcc_except_tab __RODATA __gcc_except_tab -lSystem -lc++ %t/x86_64-my-personality.o %t/x86_64-main.o -o %t/x86_64-personality-first
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/x86_64-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK -D#%x,BASE=0x100000000 -DSEG=__RODATA
 # RUN: %lld -dead_strip -arch x86_64 -rename_section __TEXT __gcc_except_tab __RODATA __gcc_except_tab -lSystem -lc++ %t/x86_64-main.o %t/x86_64-my-personality.o -o %t/x86_64-personality-second

lld/test/MachO/eh-frame-personality-dedup.s

 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/eh-frame.s -o %t/eh-frame.o
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/cu.s -o %t/cu.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 -emit-compact-unwind-non-canonical=true %t/eh-frame.s -o %t/eh-frame.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 -emit-compact-unwind-non-canonical=true %t/cu.s -o %t/cu.o
 # RUN: %lld -dylib %t/cu.o %t/eh-frame.o -o %t/out
 
 ## Sanity check: we want our input to contain a section (and not symbol)
 ## relocation for the personality reference.
 # RUN: llvm-readobj --relocations %t/cu.o | FileCheck %s --check-prefix=SECT-RELOC
 # SECT-RELOC:      Section __compact_unwind {
 # SECT-RELOC-NEXT:   __text
 # SECT-RELOC-NEXT:   __text

lld/test/MachO/eh-frame.s

 # REQUIRES: x86, aarch64
 # RUN: rm -rf %t; mkdir %t
 
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos10.15 %s -o %t/eh-frame-x86_64.o
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=true -filetype=obj -triple=x86_64-apple-macos10.15 %s -o %t/eh-frame-x86_64.o
 # RUN: %lld -lSystem -lc++ %t/eh-frame-x86_64.o -o %t/eh-frame-x86_64
 # RUN: llvm-objdump --macho --syms --indirect-symbols --unwind-info \
 # RUN:   --dwarf=frames %t/eh-frame-x86_64 | FileCheck %s -D#BASE=0x100000000 -D#DWARF_ENC=4
 # RUN: llvm-nm -m %t/eh-frame-x86_64 | FileCheck %s --check-prefix NO-EH-SYMS
 # RUN: llvm-readobj --section-headers %t/eh-frame-x86_64 | FileCheck %s --check-prefix=ALIGN -D#ALIGN=3
 
 ## Test that we correctly handle the output of `ld -r`, which emits EH frames
 ## using subtractor relocations instead of implicitly encoding the offsets.
 ## In order to keep this test cross-platform, we check in ld64's output rather
 ## than invoking ld64 directly. NOTE: whenever this test is updated, the
 ## checked-in copy of `ld -r`'s output should be updated too!
 # COM: ld -r %t/eh-frame-x86_64.o -o %S/Inputs/eh-frame-x86_64-r.o
 # RUN: %lld -lSystem -lc++ %S/Inputs/eh-frame-x86_64-r.o -o %t/eh-frame-x86_64-r
 # RUN: llvm-objdump --macho --syms --indirect-symbols --unwind-info \
 # RUN:   --dwarf=frames %t/eh-frame-x86_64-r | FileCheck %s -D#BASE=0x100000000 -D#DWARF_ENC=4
 # RUN: llvm-nm -m %t/eh-frame-x86_64-r | FileCheck %s --check-prefix NO-EH-SYMS
 # RUN: llvm-readobj --section-headers %t/eh-frame-x86_64-r | FileCheck %s --check-prefix=ALIGN -D#ALIGN=3
 
-# RUN: llvm-mc -filetype=obj -triple=arm64-apple-macos11.0 %s -o %t/eh-frame-arm64.o
+# RUN: llvm-mc -filetype=obj -emit-compact-unwind-non-canonical=true -triple=arm64-apple-macos11.0 %s -o %t/eh-frame-arm64.o
 # RUN: %lld -arch arm64 -lSystem -lc++ %t/eh-frame-arm64.o -o %t/eh-frame-arm64
 # RUN: llvm-objdump --macho --syms --indirect-symbols --unwind-info \
 # RUN:   --dwarf=frames %t/eh-frame-arm64 | FileCheck %s -D#BASE=0x100000000 -D#DWARF_ENC=3
 # RUN: llvm-nm -m %t/eh-frame-arm64 | FileCheck %s --check-prefix NO-EH-SYMS
 
 # COM: ld -r %t/eh-frame-arm64.o -o %S/Inputs/eh-frame-arm64-r.o
 # RUN: %lld -arch arm64 -lSystem -lc++ %S/Inputs/eh-frame-arm64-r.o -o %t/eh-frame-arm64-r
 # RUN: llvm-objdump --macho --syms --indirect-symbols --unwind-info \

 # CHECK-DAG: [[#%x,G:]]              l   F __TEXT,__text _g
 # CHECK-DAG: [[#%x,H:]]              l   F __TEXT,__text _h
 # CHECK-DAG: [[#%x,EXCEPT0:]]        l   O __TEXT,__gcc_except_tab GCC_except_table0
 # CHECK-DAG: [[#%x,EXCEPT1:]]        l   O __TEXT,__gcc_except_tab GCC_except_table1
 # CHECK-DAG: [[#%x,EXCEPT2:]]        l   O __TEXT,custom_except custom_except_table2
 # CHECK-DAG: [[#%x,MY_PERSONALITY:]] g   F __TEXT,__text _my_personality
 # CHECK: Contents of __unwind_info section:
 # CHECK:   Version:                                   0x1
-# CHECK:   Number of personality functions in array:  0x2
+# CHECK:   Number of personality functions in array:  0x1
 # CHECK:   Number of indices in array:                0x2
-# CHECK:   Personality functions: (count = 2)
+# CHECK:   Personality functions: (count = 1)
 # CHECK:     personality[1]: 0x[[#%.8x,GXX_PERSONALITY_GOT - BASE]]
-# CHECK:     personality[2]: 0x[[#%.8x,MY_PERSONALITY_GOT - BASE]]
 # CHECK:   LSDA descriptors:
 # CHECK:     [0]: function offset=0x[[#%.8x,F - BASE]], LSDA offset=0x[[#%.8x,EXCEPT0 - BASE]]
 # CHECK:     [1]: function offset=0x[[#%.8x,G - BASE]], LSDA offset=0x[[#%.8x,EXCEPT1 - BASE]]
 # CHECK:     [2]: function offset=0x[[#%.8x,H - BASE]], LSDA offset=0x[[#%.8x,EXCEPT2 - BASE]]
 # CHECK:   Second level indices:
 # CHECK:     Second level index[0]:
-# CHECK:       [0]: function offset=0x[[#%.8x,F - BASE]],              encoding[{{.*}}]=0x52{{.*}}
-# CHECK:       [1]: function offset=0x[[#%.8x,NO_UNWIND - BASE]],      encoding[{{.*}}]=0x00000000
-# CHECK:       [2]: function offset=0x[[#%.8x,G - BASE]],              encoding[{{.*}}]=0x1[[#%x,DWARF_ENC]][[#%.6x, G_DWARF_OFF:]]
-# CHECK:       [3]: function offset=0x[[#%.8x,H - BASE]],              encoding[{{.*}}]=0x2[[#%x,DWARF_ENC]][[#%.6x, H_DWARF_OFF:]]
-# CHECK:       [4]: function offset=0x[[#%.8x,MY_PERSONALITY - BASE]], encoding[{{.*}}]=0x00000000
+# CHECK       [0]: function offset=0x[[#%.8x,F - BASE]],              encoding[{{.*}}]=0x52{{.*}}
+# CHECK       [1]: function offset=0x[[#%.8x,NO_UNWIND - BASE]],      encoding[{{.*}}]=0x00000000
+# CHECK:      [2]: function offset=0x[[#%.8x,G - BASE]],              encoding[{{.*}}]=0x0[[#%x,DWARF_ENC]][[#%.6x, G_DWARF_OFF:]]
+# CHECK:      [3]: function offset=0x[[#%.8x,H - BASE]],              encoding[{{.*}}]=0x0[[#%x,DWARF_ENC]][[#%.6x, H_DWARF_OFF:]]
+# CHECK:      [4]: function offset=0x[[#%.8x,MY_PERSONALITY - BASE]], encoding[{{.*}}]=0x00000000
 
 # CHECK: .debug_frame contents:
 # CHECK: .eh_frame contents:
 
 # CHECK: [[#%.8x,CIE1_OFF:]] {{.*}} CIE
 # CHECK:   Format:                DWARF32
 # CHECK:   Version:               1
 # CHECK:   Augmentation:          "zPLR"

lld/test/MachO/icf-only-lsda-folded.s

 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
 
 ## This is a regression test. Previously, we would emit a bogus LSDA pointer if
 ## the following conditions held:
 ##   * ICF and dead-strip were both done
 ##   * There exist two functions different compact unwind encodings, but the
 ##     same LSDA
 ##
 ## Essentially, we'd neglected to canonicalize the LSDA pointer after ICF, but
 ## the broken output would only appear if the compact unwind entry that pointed
 ## to it was not itself folded.
 
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/test.s -o %t/test.o
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=true -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/test.s -o %t/test.o
 # RUN: %lld -dylib -dead_strip --icf=all %t/test.o -o %t/test
 # RUN: llvm-objdump --macho --syms --unwind-info %t/test | FileCheck %s
 
 # CHECK:      SYMBOL TABLE:
 ## Sanity check: Verify that the LSDAs are dedup'ed
 # CHECK-NEXT: [[#%.16x, EXC:]]       l     O __TEXT,__gcc_except_tab _exception0
 # CHECK-NEXT: [[#EXC]]               l     O __TEXT,__gcc_except_tab _exception1
 ## But that the functions themselves aren't

lld/test/MachO/icf.s

 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
 
 ## Check that we fold identical function bodies correctly. Note: This test
 ## has many different functions; each group of similarly-named functions aim
 ## to test one aspect of ICF's logic. To prevent accidental folding across
 ## groups, we use `mov` instructions with a variety of immediates, with
 ## different immediate values for each group.
 
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/main.s -o %t/main.o
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/abs.s -o %t/abs.o
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=true -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/main.s -o %t/main.o
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=true -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/abs.s -o %t/abs.o
 # RUN: %lld -lSystem --icf=all -o %t/main %t/main.o %t/abs.o
 # RUN: llvm-objdump -d --syms --dwarf=frames %t/main | FileCheck %s
 
 # CHECK-LABEL: SYMBOL TABLE:
 # CHECK: [[#%x,ABS1B_REF:]]                 l     F __TEXT,__text _abs1a_ref
 # CHECK: [[#%x,ABS1B_REF]]                  l     F __TEXT,__text _abs1b_ref
 # CHECK: [[#%x,ABS1B_REF_WITH_ADDEND:]]     l     F __TEXT,__text _abs1a_ref_with_addend
 # CHECK: [[#%x,ABS1B_REF_WITH_ADDEND]]      l     F __TEXT,__text _abs1b_ref_with_addend

lld/test/MachO/invalid/compact-unwind-bad-reloc.s

 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/bad-function.s -o %t/bad-function.o
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=true -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/bad-function.s -o %t/bad-function.o
 # RUN: not %lld -lSystem -dylib -lc++ %t/bad-function.o -o /dev/null 2>&1 | FileCheck %s
 # CHECK: error: {{.*}}bad-function.o:(__compact_unwind+0x0) references section __data which is not in segment __TEXT
 # CHECK: error: {{.*}}bad-function.o:(__compact_unwind+0x20) references section __data which is not in segment __TEXT
 
 #--- bad-function.s
 .data
 _not_a_function:
   .cfi_startproc

lld/test/MachO/invalid/compact-unwind-personalities.s

 # REQUIRES: x86
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %s -o %t.o
+  
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=true -filetype=obj -triple=x86_64-apple-darwin19.0.0 %s -o %t.o
 # RUN: not %lld -lSystem -lc++ %t.o -o %t 2>&1 | FileCheck %s --check-prefix=TOO-MANY
 # RUN: not %lld -lSystem %t.o -o %t 2>&1 | FileCheck %s --check-prefix=UNDEF
 # TOO-MANY: error: too many personalities (4) for compact unwind to encode
 # UNDEF: error: undefined symbol: ___gxx_personality_v0
 
+## Tests that we can handle more than 3 personalities with DWARFs
+# RUN: llvm-mc -emit-compact-unwind-non-canonical=false -filetype=obj -triple=x86_64-apple-darwin19.0.0 %s -o %t-dwarf.o
+# RUN: %lld -lSystem -lc++ %t-dwarf.o -o %t-dwarf
+# RUN: llvm-objdump --macho --indirect-symbols --dwarf=frames %t-dwarf | FileCheck %s --check-prefix=DWARF -D#BASE=0x100000000 
+
+# DWARF: Indirect symbols
+# DWARF: address            index name
+# DWARF: 0x[[#%x,GXX_PERSONALITY:]]     {{.*}} ___gxx_personality_v0
+# DWARF: 0x[[#%x,PERSONALITY_1:]]     {{.*}} _personality_1
+# DWARF: 0x[[#%x,PERSONALITY_2:]]     {{.*}} _personality_2
+# DWARF: 0x[[#%x,PERSONALITY_3:]]     {{.*}} _personality_3
+# DWARF: .eh_frame contents:
+# DWARF: Personality Address: [[#%.16x,GXX_PERSONALITY]]
+# DWARF: Personality Address: [[#%.16x,PERSONALITY_1]]
+# DWARF: Personality Address: [[#%.16x,PERSONALITY_2]]
+# DWARF: Personality Address: [[#%.16x,PERSONALITY_3]]
+
+
 .globl _main, _personality_1, _personality_2, _personality_3
 
 .text
 
 _foo:
   .cfi_startproc
   .cfi_personality 155, _personality_1
   .cfi_def_cfa_offset 16

llvm/include/llvm/MC/MCAsmBackend.h

 class MCAlignFragment;
 class MCDwarfCallFrameFragment;
 class MCDwarfLineAddrFragment;
 class MCFragment;
 class MCRelaxableFragment;
 class MCSymbol;
 class MCAsmLayout;
 class MCAssembler;
-class MCCFIInstruction;
+class MCContext;
+struct MCDwarfFrameInfo;
 struct MCFixupKindInfo;
 class MCInst;
 class MCObjectStreamer;
 class MCObjectTargetWriter;
 class MCObjectWriter;
 class MCSubtargetInfo;
 class MCValue;
 class raw_pwrite_stream;
public:
   /// Give backend an opportunity to finish layout after relaxation
   virtual void finishLayout(MCAssembler const &Asm,
                             MCAsmLayout &Layout) const {}
 
   /// Handle any target-specific assembler flags. By default, do nothing.
   virtual void handleAssemblerFlag(MCAssemblerFlag Flag) {}
 
   /// Generate the compact unwind encoding for the CFI instructions.
-  virtual uint32_t
-      generateCompactUnwindEncoding(ArrayRef<MCCFIInstruction>) const {
+  virtual uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
+                                                 const MCContext *Ctxt) const {
     return 0;
   }
 
   /// Check whether a given symbol has been flagged with MICROMIPS flag.
   virtual bool isMicroMips(const MCSymbol *Sym) const {
     return false;
   }
+
+  bool isDarwinCanonicalPersonality(const MCSymbol *Sym) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCASMBACKEND_H

llvm/include/llvm/MC/MCContext.h

public:
 
   bool getDwarfLocSeen() { return DwarfLocSeen; }
   const MCDwarfLoc &getCurrentDwarfLoc() { return CurrentDwarfLoc; }
 
   bool getGenDwarfForAssembly() { return GenDwarfForAssembly; }
   void setGenDwarfForAssembly(bool Value) { GenDwarfForAssembly = Value; }
   unsigned getGenDwarfFileNumber() { return GenDwarfFileNumber; }
   EmitDwarfUnwindType emitDwarfUnwindInfo() const;
+  bool emitCompactUnwindNonCanonical() const;
 
   void setGenDwarfFileNumber(unsigned FileNumber) {
     GenDwarfFileNumber = FileNumber;
   }
 
   /// Specifies information about the "root file" for assembler clients
   /// (e.g., llvm-mc). Assumes compilation dir etc. have been set up.
   void setGenDwarfRootFile(StringRef FileName, StringRef Buffer);

llvm/include/llvm/MC/MCTargetOptions.h

public:
 
   const char *Argv0 = nullptr;
   ArrayRef<std::string> CommandLineArgs;
 
   /// Additional paths to search for `.include` directives when using the
   /// integrated assembler.
   std::vector<std::string> IASSearchPaths;
 
+  // Whether to emit compact-unwind for non-canonical personality
+  // functions on Darwins.
+  bool EmitCompactUnwindNonCanonical : 1;
+
   MCTargetOptions();
 
   /// getABIName - If this returns a non-empty string this represents the
   /// textual name of the ABI that we want the backend to use, e.g. o32, or
   /// aapcs-linux.
   StringRef getABIName() const;
 
   /// getAssemblyLanguage - If this returns a non-empty string this represents
   /// the textual name of the assembly language that we will use for this
   /// target, e.g. masm.
   StringRef getAssemblyLanguage() const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCTARGETOPTIONS_H

llvm/include/llvm/MC/MCTargetOptionsCommandFlags.h

 bool getIncrementalLinkerCompatible();
 
 int getDwarfVersion();
 
 bool getDwarf64();
 
 EmitDwarfUnwindType getEmitDwarfUnwind();
 
+bool getEmitCompactUnwindNonCanonical();
+
 bool getShowMCInst();
 
 bool getFatalWarnings();
 
 bool getNoWarn();
 
 bool getNoDeprecatedWarn();
 

llvm/lib/MC/MCAsmBackend.cpp

 bool MCAsmBackend::fixupNeedsRelaxationAdvanced(
     const MCFixup &Fixup, bool Resolved, uint64_t Value,
     const MCRelaxableFragment *DF, const MCAsmLayout &Layout,
     const bool WasForced) const {
   if (!Resolved)
     return true;
   return fixupNeedsRelaxation(Fixup, Value, DF, Layout);
 }
+
+bool MCAsmBackend::isDarwinCanonicalPersonality(const MCSymbol *Sym) const {
+  if (Sym && Sym->isMachO()) {
+    StringRef name = Sym->getName();
+    // XXX: We intentionally leave out "___gcc_personality_v0" because, despite
+    // being system-defined like these two, it is not very commonly-used.
+    // Reserving an empty slot for it seems silly.
+    return name == "___gxx_personality_v0" || name == "___objc_personality_v0";
+  }
+  return false;
+}

llvm/lib/MC/MCContext.cpp

 //===----------------------------------------------------------------------===//
 
 EmitDwarfUnwindType MCContext::emitDwarfUnwindInfo() const {
   if (!TargetOptions)
     return EmitDwarfUnwindType::Default;
   return TargetOptions->EmitDwarfUnwind;
 }
 
+bool MCContext::emitCompactUnwindNonCanonical() const {
+  if (TargetOptions)
+    return TargetOptions->EmitCompactUnwindNonCanonical;
+  return false;
+}
+
 void MCContext::setGenDwarfRootFile(StringRef InputFileName, StringRef Buffer) {
   // MCDwarf needs the root file as well as the compilation directory.
   // If we find a '.file 0' directive that will supersede these values.
   std::optional<MD5::MD5Result> Cksum;
   if (getDwarfVersion() >= 5) {
     MD5 Hash;
     MD5::MD5Result Sum;
     Hash.update(Buffer);

llvm/lib/MC/MCStreamer.cpp

 void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
 
 void MCStreamer::addExplicitComment(const Twine &T) {}
 void MCStreamer::emitExplicitComments() {}
 
 void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) {
   for (auto &FI : DwarfFrameInfos)
     FI.CompactUnwindEncoding =
-        (MAB ? MAB->generateCompactUnwindEncoding(FI.Instructions) : 0);
+        (MAB ? MAB->generateCompactUnwindEncoding(&FI, &Context) : 0);
 }
 
 /// EmitIntValue - Special case of EmitValue that avoids the client having to
 /// pass in a MCExpr for constant integers.
 void MCStreamer::emitIntValue(uint64_t Value, unsigned Size) {
   assert(1 <= Size && Size <= 8 && "Invalid size");
   assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
          "Invalid size");

llvm/lib/MC/MCTargetOptionsCommandFlags.cpp

std::optional<TY> llvm::mc::getExplicit##NAME() {                            \
     return std::nullopt;                                                       \
   }
 
 MCOPT_EXP(bool, RelaxAll)
 MCOPT(bool, IncrementalLinkerCompatible)
 MCOPT(int, DwarfVersion)
 MCOPT(bool, Dwarf64)
 MCOPT(EmitDwarfUnwindType, EmitDwarfUnwind)
+MCOPT(bool, EmitCompactUnwindNonCanonical)
 MCOPT(bool, ShowMCInst)
 MCOPT(bool, FatalWarnings)
 MCOPT(bool, NoWarn)
 MCOPT(bool, NoDeprecatedWarn)
 MCOPT(bool, NoTypeCheck)
 MCOPT(std::string, ABIName)
 MCOPT(std::string, AsSecureLogFile)
 
static cl::opt<EmitDwarfUnwindType> EmitDwarfUnwind(
                  clEnumValN(EmitDwarfUnwindType::NoCompactUnwind,
                             "no-compact-unwind",
                             "Only emit EH frame entries when compact unwind is "
                             "not available"),
                  clEnumValN(EmitDwarfUnwindType::Default, "default",
                             "Use target platform default")));
   MCBINDOPT(EmitDwarfUnwind);
 
+  static cl::opt<bool> EmitCompactUnwindNonCanonical(
+      "emit-compact-unwind-non-canonical",
+      cl::desc(
+          "Whether to try to emit Compact Unwind for non canonical entries."),
+      cl::init(
+          false)); // By default, use DWARF for non-canonical personalities.
+  MCBINDOPT(EmitCompactUnwindNonCanonical);
+
   static cl::opt<bool> ShowMCInst(
       "asm-show-inst",
       cl::desc("Emit internal instruction representation to assembly file"));
   MCBINDOPT(ShowMCInst);
 
   static cl::opt<bool> FatalWarnings("fatal-warnings",
                                      cl::desc("Treat warnings as errors"));
   MCBINDOPT(FatalWarnings);
MCTargetOptions llvm::mc::InitMCTargetOptionsFromFlags() {
   Options.DwarfVersion = getDwarfVersion();
   Options.ShowMCInst = getShowMCInst();
   Options.ABIName = getABIName();
   Options.MCFatalWarnings = getFatalWarnings();
   Options.MCNoWarn = getNoWarn();
   Options.MCNoDeprecatedWarn = getNoDeprecatedWarn();
   Options.MCNoTypeCheck = getNoTypeCheck();
   Options.EmitDwarfUnwind = getEmitDwarfUnwind();
+  Options.EmitCompactUnwindNonCanonical = getEmitCompactUnwindNonCanonical();
   Options.AsSecureLogFile = getAsSecureLogFile();
 
   return Options;
 }

llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

public:
   createObjectTargetWriter() const override {
     uint32_t CPUType = cantFail(MachO::getCPUType(TheTriple));
     uint32_t CPUSubType = cantFail(MachO::getCPUSubType(TheTriple));
     return createAArch64MachObjectWriter(CPUType, CPUSubType,
                                          TheTriple.isArch32Bit());
   }
 
   /// Generate the compact unwind encoding from the CFI directives.
-  uint32_t generateCompactUnwindEncoding(
-                             ArrayRef<MCCFIInstruction> Instrs) const override {
+  uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
+                                         const MCContext *Ctxt) const override {
+    ArrayRef<MCCFIInstruction> Instrs = FI->Instructions;
     if (Instrs.empty())
       return CU::UNWIND_ARM64_MODE_FRAMELESS;
+    if (!isDarwinCanonicalPersonality(FI->Personality) &&
+        !Ctxt->emitCompactUnwindNonCanonical())
+      return CU::UNWIND_ARM64_MODE_DWARF;
 
     bool HasFP = false;
     unsigned StackSize = 0;
 
     uint32_t CompactUnwindEncoding = 0;
     int CurOffset = 0;
     for (size_t i = 0, e = Instrs.size(); i != e; ++i) {
       const MCCFIInstruction &Inst = Instrs[i];

llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp

 
 } // end CU namespace
 
 /// Generate compact unwind encoding for the function based on the CFI
 /// instructions. If the CFI instructions describe a frame that cannot be
 /// encoded in compact unwind, the method returns UNWIND_ARM_MODE_DWARF which
 /// tells the runtime to fallback and unwind using dwarf.
 uint32_t ARMAsmBackendDarwin::generateCompactUnwindEncoding(
-    ArrayRef<MCCFIInstruction> Instrs) const {
+    const MCDwarfFrameInfo *FI, const MCContext *Ctxt) const {
   DEBUG_WITH_TYPE("compact-unwind", llvm::dbgs() << "generateCU()\n");
   // Only armv7k uses CFI based unwinding.
   if (Subtype != MachO::CPU_SUBTYPE_ARM_V7K)
     return 0;
   // No .cfi directives means no frame.
+  ArrayRef<MCCFIInstruction> Instrs = FI->Instructions;
   if (Instrs.empty())
     return 0;
+  if (!isDarwinCanonicalPersonality(FI->Personality) &&
+      !Ctxt->emitCompactUnwindNonCanonical())
+    return CU::UNWIND_ARM_MODE_DWARF;
+
   // Start off assuming CFA is at SP+0.
   unsigned CFARegister = ARM::SP;
   int CFARegisterOffset = 0;
   // Mark savable registers as initially unsaved
   DenseMap<unsigned, int> RegOffsets;
   int FloatRegCount = 0;
   // Process each .cfi directive and build up compact unwind info.
   for (const MCCFIInstruction &Inst : Instrs) {

llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackendDarwin.h

 //===-- ARMAsmBackendDarwin.h   ARM Asm Backend Darwin ----------*- 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_LIB_TARGET_ARM_ARMASMBACKENDDARWIN_H
 #define LLVM_LIB_TARGET_ARM_ARMASMBACKENDDARWIN_H
 
 #include "ARMAsmBackend.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectWriter.h"
 
 namespace llvm {
 class ARMAsmBackendDarwin : public ARMAsmBackend {
   const MCRegisterInfo &MRI;
   Triple TT;
 public:
   const MachO::CPUSubTypeARM Subtype;
   ARMAsmBackendDarwin(const Target &T, const MCSubtargetInfo &STI,
                       const MCRegisterInfo &MRI)
       : ARMAsmBackend(T, STI.getTargetTriple().isThumb(), support::little),
         MRI(MRI), TT(STI.getTargetTriple()),
         Subtype((MachO::CPUSubTypeARM)cantFail(
             MachO::getCPUSubType(STI.getTargetTriple()))) {}
 
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override {
     return createARMMachObjectWriter(
         /*Is64Bit=*/false, cantFail(MachO::getCPUType(TT)), Subtype);
   }
 
-  uint32_t generateCompactUnwindEncoding(
-      ArrayRef<MCCFIInstruction> Instrs) const override;
+  uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
+                                         const MCContext *Ctxt) const override;
 };
 } // end namespace llvm
 
 #endif

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

public:
   createObjectTargetWriter() const override {
     uint32_t CPUType = cantFail(MachO::getCPUType(TT));
     uint32_t CPUSubType = cantFail(MachO::getCPUSubType(TT));
     return createX86MachObjectWriter(Is64Bit, CPUType, CPUSubType);
   }
 
   /// Implementation of algorithm to generate the compact unwind encoding
   /// for the CFI instructions.
-  uint32_t
-  generateCompactUnwindEncoding(ArrayRef<MCCFIInstruction> Instrs) const override {
+  uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
+                                         const MCContext *Ctxt) const override {
+    ArrayRef<MCCFIInstruction> Instrs = FI->Instructions;
     if (Instrs.empty()) return 0;
+    if (!isDarwinCanonicalPersonality(FI->Personality) &&
+        !Ctxt->emitCompactUnwindNonCanonical())
+      return CU::UNWIND_MODE_DWARF;
 
     // Reset the saved registers.
     unsigned SavedRegIdx = 0;
     memset(SavedRegs, 0, sizeof(SavedRegs));
 
     bool HasFP = false;
 
     // Encode that we are using EBP/RBP as the frame pointer.

llvm/test/CodeGen/X86/2014-08-29-CompactUnwind.ll

-; RUN: llc < %s -mtriple x86_64-apple-darwin11 -mcpu corei7 -filetype=obj -o - | llvm-objdump -d --unwind-info -s - | FileCheck %s
+; RUN: llc < %s -mtriple x86_64-apple-darwin11 -mcpu corei7 -emit-compact-unwind-non-canonical=true -filetype=obj -o - | llvm-objdump -d --unwind-info -s - | FileCheck %s
 ; Regression test for http://llvm.org/bugs/show_bug.cgi?id=20800.
 
 ; ModuleID = 'asan_report.ii'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 @.str = private unnamed_addr constant [3 x i8] c"=>\00", align 1
 @.str1 = private unnamed_addr constant [3 x i8] c"  \00", align 1

llvm/test/CodeGen/X86/compact-unwind.ll

-; RUN: llc < %s -frame-pointer=all -mtriple x86_64-apple-darwin11 -mcpu corei7 | FileCheck -check-prefix=ASM %s
-; RUN: llc < %s -frame-pointer=all -mtriple x86_64-apple-darwin11 -mcpu corei7 -filetype=obj -o - \
+; RUN: llc < %s -frame-pointer=all -mtriple x86_64-apple-darwin11 -mcpu corei7 -emit-compact-unwind-non-canonical=true | FileCheck -check-prefix=ASM %s
+; RUN: llc < %s -frame-pointer=all -mtriple x86_64-apple-darwin11 -mcpu corei7 -filetype=obj -emit-compact-unwind-non-canonical=true -o - \
 ; RUN:  | llvm-objdump --triple=x86_64-apple-darwin11 --unwind-info - \
 ; RUN:  | FileCheck -check-prefix=CU %s
-; RUN: llc < %s -frame-pointer=all -mtriple x86_64-apple-darwin11 -mcpu corei7 \
-; RUN:  | llvm-mc -triple x86_64-apple-darwin11 -filetype=obj -o - \
+; RUN: llc < %s -frame-pointer=all -mtriple x86_64-apple-darwin11 -mcpu corei7 -emit-compact-unwind-non-canonical=true \
+; RUN:  | llvm-mc -triple x86_64-apple-darwin11 -filetype=obj -emit-compact-unwind-non-canonical=true -o - \
 ; RUN:  | llvm-objdump --triple=x86_64-apple-darwin11 --unwind-info - \
 ; RUN:  | FileCheck -check-prefix=FROM-ASM %s
 
-; RUN: llc < %s -mtriple x86_64-apple-macosx10.8.0 -mcpu corei7 -filetype=obj -o - \
+; RUN: llc < %s -mtriple x86_64-apple-macosx10.8.0 -mcpu corei7 -filetype=obj -emit-compact-unwind-non-canonical=true -o - \
 ; RUN:  | llvm-objdump --triple=x86_64-apple-macosx10.8.0 --unwind-info - \
 ; RUN:  | FileCheck -check-prefix=NOFP-CU %s
 ; RUN: llc < %s -mtriple x86_64-apple-darwin11 -mcpu corei7 \
-; RUN:  | llvm-mc -triple x86_64-apple-darwin11 -filetype=obj -o - \
+; RUN:  | llvm-mc -triple x86_64-apple-darwin11 -filetype=obj -emit-compact-unwind-non-canonical=true -o - \
 ; RUN:  | llvm-objdump --triple=x86_64-apple-darwin11 --unwind-info - \
 ; RUN:  | FileCheck -check-prefix=NOFP-FROM-ASM %s
 
 %ty = type { ptr }
 
 @gv = external global i32
 
 ; This is aligning the stack with a push of a random register.

llvm/test/MC/AArch64/arm64-leaf-compact-unwind.s

-// RUN: llvm-mc -triple=arm64-apple-ios -filetype=obj < %s | \
+// RUN: llvm-mc -triple=arm64-apple-ios -filetype=obj -emit-compact-unwind-non-canonical=true < %s | \
 // RUN: llvm-objdump --macho --unwind-info - | \
 // RUN: FileCheck %s
 //
 // rdar://13070556
 
 // CHECK:      Contents of __compact_unwind section:
 // CHECK-NEXT:   Entry at offset 0x0:
 // CHECK-NEXT:     start:                0x0 ltmp0

llvm/test/MC/MachO/AArch64/emit-dwarf-unwind.s

 // RUN: rm -rf %t; mkdir %t
-// RUN: llvm-mc -triple x86_64-apple-macos11.0 %s -filetype=obj -o %t/x86_64.o
+// RUN: llvm-mc -triple x86_64-apple-macos11.0 %s -filetype=obj -o %t/x86_64.o -emit-compact-unwind-non-canonical=true
 // RUN: llvm-objdump --macho --dwarf=frames %t/x86_64.o | FileCheck %s --check-prefix TWO-FDES
-// RUN: llvm-mc -triple arm64-apple-macos11.0 %s -filetype=obj -o %t/arm64.o
+// RUN: llvm-mc -triple arm64-apple-macos11.0 %s -filetype=obj -o %t/arm64.o -emit-compact-unwind-non-canonical=true
 // RUN: llvm-objdump --macho --dwarf=frames %t/arm64.o | FileCheck %s --check-prefix ONE-FDE
-// RUN: llvm-mc -triple x86_64-apple-macos11.0 %s -filetype=obj --emit-dwarf-unwind no-compact-unwind -o %t/x86_64-no-dwarf.o
+// RUN: llvm-mc -triple x86_64-apple-macos11.0 %s -filetype=obj --emit-dwarf-unwind no-compact-unwind -o %t/x86_64-no-dwarf.o -emit-compact-unwind-non-canonical=true
 // RUN: llvm-objdump --macho --dwarf=frames %t/x86_64-no-dwarf.o | FileCheck %s --check-prefix ONE-FDE
-// RUN: llvm-mc -triple arm64-apple-macos11.0 %s -filetype=obj --emit-dwarf-unwind always -o %t/arm64-dwarf.o
+// RUN: llvm-mc -triple arm64-apple-macos11.0 %s -filetype=obj --emit-dwarf-unwind always -o %t/arm64-dwarf.o -emit-compact-unwind-non-canonical=true
 // RUN: llvm-objdump --macho --dwarf=frames %t/arm64-dwarf.o | FileCheck %s --check-prefix TWO-FDES
 
 // TWO-FDES: FDE
 // TWO-FDES: FDE
 
 // ONE-FDE-NOT: FDE
 // ONE-FDE:     FDE
 // ONE-FDE-NOT: FDE

llvm/test/MC/MachO/ARM/compact-unwind-armv7k.s

-@ RUN: llvm-mc -triple=thumbv7k-apple-watchos2.0.0 -filetype=obj -o %t < %s && llvm-objdump --unwind-info %t | FileCheck %s
+@ RUN: llvm-mc -triple=thumbv7k-apple-watchos2.0.0 -emit-compact-unwind-non-canonical=true -filetype=obj -o %t < %s && llvm-objdump --unwind-info %t | FileCheck %s
 
 @ CHECK: Contents of __compact_unwind section:
 
         .syntax unified
         .align        2
         .code        16
 
 @ CHECK-LABEL: start: {{.*}} _test_r4_r5_r6

llvm/test/MC/X86/compact-unwind.s

-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin10.0 %s | llvm-objdump --unwind-info - | FileCheck %s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin10.0 %s -emit-compact-unwind-non-canonical=true | llvm-objdump --unwind-info - | FileCheck %s
 
   .section  __TEXT,__text,regular,pure_instructions
   .macosx_version_min 10, 10
 
 # Check that we emit compact-unwind info with UNWIND_X86_MODE_STACK_IND encoding
 
 # CHECK: Contents of __compact_unwind section:
 # CHECK-NEXT:   Entry at offset 0x0: