[BOLT] Update split landing pad check for stripped binaries

[nhuhuan]

Summary

Landing pad represents catch block, so it needs to be in same function
with callsite. If both reside in two different fragments, we check if
these fragments are siblings.

In nonstripped binaries, we rely on symbol name to verify sibling
relationship. In stripped binaries, we don't have symbol name.

Unlike jump table where it is challenging to detect the size, LSDA uses
an encoding format that reveals its size, even in stripped mode. It
makes sense to trust the correctness of input binaries, and skip the
sibling check only for stripped binaries.

Test Plan:

ninja check-bolt

bolt/lib/Core/Exceptions.cpp

uint64_t LandingPad = *Data.getEncodedPointer(
         &CallSitePtr, CallSiteEncoding, CallSitePtr + LSDASectionAddress);
     uint64_t ActionEntry = Data.getULEB128(&CallSitePtr);
 
     uint64_t LPOffset = LPStart + LandingPad;
     uint64_t LPAddress = Address + LPOffset;
     BinaryFunction *Fragment = BC.getBinaryFunctionContainingAddress(LPAddress);
 
     // Verify if landing pad code is located outside current function
-    // Support landing pad to builtin_unreachable
+    // Skip case where landing pad targets builtin_unreachable
     if (LPAddress < Address || LPAddress > Address + getSize()) {
+      // Assume landing pad not target another fragment's builtin_unreachable
+      // If this assumption is violated, must run a global check first
       assert(Fragment != nullptr &&
              "BOLT-ERROR: cannot find landing pad fragment");
+
+      // Update IsFragment:
+      // In stripped mode, always trust LSDA, consider the function that
+      // contains LP as a fragment
+      // In non-stripped mode, use pattern matching (adjustFunctionBoundaries)
+      if (BC.IsStripped)
+        Fragment->IsFragment = true;
+
+      // Update parent-fragment relation, add Fragment as secondary entry of
+      // the current function, not an independent function
       BC.addInterproceduralReference(this, Fragment->getAddress());
       BC.processInterproceduralReferences();
+
+      // In stripped mode, parent-fragment is always established --> skip check
+      // In non-stripped mode, parent-fragment depends on symbol name --> check
+      if (!BC.IsStripped) {
         auto isFragmentOf = [](BinaryFunction *Fragment,
                                BinaryFunction *Parent) -> bool {
           return (Fragment->isFragment() && Fragment->isParentFragment(Parent));
         };
         assert((isFragmentOf(this, Fragment) || isFragmentOf(Fragment, this)) &&
-             "BOLT-ERROR: cannot have landing pads in different "
-             "functions");
+               "BOLT-ERROR: cannot have landing pads in different functions");
+      }
+      // Mark that this fragment reaches LP in another fragment of same function
       setHasIndirectTargetToSplitFragment(true);
       BC.addFragmentsToSkip(this);
     }
 
     // Create a handler entry if necessary.
     MCSymbol *LPLabel = nullptr;
 
     // Special case, consider builtin_unreachable as part of this function

bolt/test/X86/split-landing-pad.s

 # This test reproduces the case where C++ exception handling is used and split
 # function optimization is enabled. In particular, function foo is splitted
 # to two fragments:
 #    foo: contains 2 try blocks, which invokes bar to throw exception
 #    foo.cold.1: contains 2 corresponding catch blocks (landing pad)
 #
 # Similar to split jump table, split landing pad target to different fragment.
 # This test is written to ensure BOLT safely handle these targets, e.g., by
 # marking them as non-simple.
 #
+# This test is for both stripped and non-stripped binaries
+#
 # Steps to write this test:
 # - Create a copy of Inputs/src/unreachable.cpp
 # - Simplify bar(), focus on throw an exception
 # - Create the second switch case in foo() to have multiple landing pads
 # - Compile with clang++ to .s
 # - Move landing pad code from foo to foo.cold.1
 # - Ensure that all landing pads can be reached normally
 #
 # Additional details:
 # .gcc_except_table specify the landing pads for try blocks
 #    LPStart = 255 (omit), which means LPStart = foo start
 # Landing pads .Ltmp2 and .Ltmp5 in call site record are offset to foo start.
 
 
 # REQUIRES: system-linux
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
 # RUN: %clang++ %cxxflags %t.o -o %t.exe -Wl,-q
 # RUN: llvm-bolt -v=3 %t.exe -o %t.out -print-exceptions 2>&1 | FileCheck %s
 
+# RUN: cp %t.exe %t.tmp.exe
+# RUN: llvm-strip -s %t.tmp.exe
+# RUN: llvm-bolt -v=3 %t.tmp.exe -o %t.out -print-exceptions 2>&1 | FileCheck %s
+
 # CHECK: BOLT-INFO: marking [[FOO_COLD:.+]] as a fragment of [[FOO:.+]]
 # CHECK: landing pad label: [[TMP2:.+]]
 # CHECK: landing pad label: [[TMP5:.+]]
 # CHECK: BOLT-WARNING: Ignoring [[FOO]]
 # CHECK: BOLT-WARNING: Ignoring [[FOO_COLD]]
 # CHECK: BOLT-WARNING: skipped 2 functions due to cold fragments
 
   .text