[IsolatePath] Refactor and improve pass

This commit provides several improvements to the IsolatePath pass:

- Refactors the main processing function into smaller, more focused
  helpers to improve readability and maintainability.
- Fixes a bug where the pass would crash with a 'terminator in the
  middle of a basic block' error due to incorrect instruction mapping in
  cloned blocks.
- Ensures LoopInfo is correctly updated when a block within a loop is
  split, and preserves the analysis.
- Removes stale FIXME comments regarding SwitchInst support.
- Expands the test suite to cover more complex scenarios, including UB
  in loops and blocks terminated by SwitchInst.

Author: bwendling

llvm/include/llvm/Transforms/Scalar/IsolatePath.h

@@ -1,31 +1,49 @@
-//===- IsolatePath.cpp - Code to isolate paths with UB ----------*- C++ -*-===//
+//===- IsolatePath.h - Path isolation for undefined behavior ----*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-// This pass isolates code paths with undefined behavior from paths without
-// undefined behavior, and then add a trap instruction on that path. This
-// prevents code generation where, after the UB instruction's eliminated, the
-// code can wander off the end of a function.
+// This file defines the interface for the IsolatePath pass.
 //
-// For example, a nullptr dereference:
+// The pass identifies undefined behavior (UB) that is reachable via a PHI node
+// that can select a null pointer. It then refactors the control-flow graph to
+// isolate the UB-triggering path from the safe paths.
 //
-//   foo:
-//     %phi.val = phi ptr [ %arrayidx.i, %pred1 ], [ null, %pred2 ]
-//     %load.val = load i32, ptr %phi.val, align 4
+// Once isolated, the UB path is terminated, either with an 'unreachable'
+// instruction or, optionally, with a 'trap' followed by 'unreachable'. This
+// prevents the optimizer from making unsafe assumptions based on the presence
+// of UB, which could otherwise lead to miscompilations.
 //
-// is converted into:
+// For example, a null pointer dereference is transformed from:
 //
-//   foo.ub.path:
-//     %load.val.ub = load volatile i32, ptr null, align 4
-//     tail call void @llvm.trap()
+//   bb:
+//     %phi = phi ptr [ %valid_ptr, %pred1 ], [ null, %pred2 ]
+//     %val = load i32, ptr %phi
+//
+// To:
+//
+//   bb:
+//     %phi = phi ptr [ %valid_ptr, %pred1 ]
+//     %val = load i32, ptr %phi
+//     ...
+//
+//   bb.ub.path:
+//     %phi.ub = phi ptr [ null, %pred2 ]
+//     unreachable
+//
+// Or to this with the optional trap-unreachable flag:
+//
+//   bb.ub.path:
+//     %phi.ub = phi ptr [ null, %pred2 ]
+//     %val.ub = load volatile i32, ptr %phi.ub ; Optional trap
+//     call void @llvm.trap()
 //     unreachable
 //
-// Note: we allow the NULL dereference to actually occur so that code that
-// wishes to catch the signal can do so.
+// This ensures that the presence of the null path does not interfere with
+// valid code paths.
 //
 //===----------------------------------------------------------------------===//
 
@@ -40,14 +58,15 @@ namespace llvm {
 class BasicBlock;
 class DomTreeUpdater;
 class Function;
+class LoopInfo;
 
-/// This pass performs 'path isolation', which looks for undefined behavior and
-/// isolates the path from non-undefined behavior code and converts the UB into
-/// a trap call.
+/// A pass that isolates paths with undefined behavior and converts the UB into
+/// a trap or unreachable instruction.
 class IsolatePathPass : public PassInfoMixin<IsolatePathPass> {
   SmallPtrSet<BasicBlock *, 4> SplitUBBlocks;
 
-  bool ProcessPointerUndefinedBehavior(BasicBlock *BB, DomTreeUpdater *DTU);
+  bool ProcessPointerUndefinedBehavior(BasicBlock *BB, DomTreeUpdater *DTU,
+                                       LoopInfo *LI);
 
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);