llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-llvm-support @llvm/pr-subscribers-clang-codegen Author: Daniel Paoliello (dpaoliello) <details> <summary>Changes</summary> #<!-- -->129142 added support for emitting Windows x64 unwind v2 information, but it was "best effort". If any function didn't follow the requirements for v2 it was silently downgraded to v1. There are some parts of Windows (specifically kernel-mode code running on Xbox) that require v2, hence we need the ability to fail the compilation if v2 can't be used. This change also adds a heuristic to check if there might be too many unwind codes, it's currently conservative (i.e., assumes that certain prolog instructions will use the maximum number of unwind codes). Future work: attempting to chain unwind info across multiple tables if there are too many unwind codes due to epilogs and adding a heuristic to detect if an epilog will be too far from the end of the function. --- Patch is 32.26 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/143577.diff 11 Files Affected: - (modified) clang/include/clang/Basic/CodeGenOptions.def (+4-2) - (modified) clang/include/clang/Driver/Options.td (+11-6) - (modified) clang/lib/CodeGen/CodeGenModule.cpp (+4-2) - (modified) clang/lib/Driver/ToolChains/Clang.cpp (+5-4) - (modified) clang/test/CodeGen/epilog-unwind.c (+6-4) - (modified) clang/test/Driver/cl-options.c (+5-1) - (modified) llvm/include/llvm/IR/Module.h (+4) - (modified) llvm/include/llvm/Support/CodeGen.h (+9) - (modified) llvm/lib/IR/Module.cpp (+7) - (modified) llvm/lib/Target/X86/X86WinEHUnwindV2.cpp (+128-23) - (added) llvm/test/CodeGen/X86/win64-eh-unwindv2-errors.mir (+327) ``````````diff diff --git a/clang/include/clang/Basic/CodeGenOptions.def b/clang/include/clang/Basic/CodeGenOptions.def index fa9474d63ae42..32a2ee0e23200 100644 --- a/clang/include/clang/Basic/CodeGenOptions.def +++ b/clang/include/clang/Basic/CodeGenOptions.def @@ -481,8 +481,10 @@ CODEGENOPT(StaticClosure, 1, 0) /// Assume that UAVs/SRVs may alias CODEGENOPT(ResMayAlias, 1, 0) -/// Enables unwind v2 (epilog) information for x64 Windows. -CODEGENOPT(WinX64EHUnwindV2, 1, 0) +/// Controls how unwind v2 (epilog) information should be generated for x64 +/// Windows. +ENUM_CODEGENOPT(WinX64EHUnwindV2, llvm::WinX64EHUnwindV2Mode, + 2, llvm::WinX64EHUnwindV2Mode::Disabled) /// FIXME: Make DebugOptions its own top-level .def file. #include "DebugOptions.def" diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 89c63fb3397d3..d13ce5ce16467 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -2167,11 +2167,14 @@ defm assume_nothrow_exception_dtor: BoolFOption<"assume-nothrow-exception-dtor", LangOpts<"AssumeNothrowExceptionDtor">, DefaultFalse, PosFlag<SetTrue, [], [ClangOption, CC1Option], "Assume that exception objects' destructors are non-throwing">, NegFlag<SetFalse>>; -defm winx64_eh_unwindv2 : BoolFOption<"winx64-eh-unwindv2", - CodeGenOpts<"WinX64EHUnwindV2">, DefaultFalse, - PosFlag<SetTrue, [], [ClangOption, CC1Option], "Enable">, - NegFlag<SetFalse, [], [ClangOption], "Disable">, - BothFlags<[], [ClangOption], " unwind v2 (epilog) information for x64 Windows">>; +def winx64_eh_unwindv2 + : Joined<["-"], "fwinx64-eh-unwindv2=">, Group<f_Group>, + Visibility<[ClangOption, CC1Option]>, + HelpText<"Generate unwind v2 (epilog) information for x64 Windows">, + Values<"disabled,best-effort,required">, + NormalizedValues<["Disabled", "BestEffort", "Required"]>, + NormalizedValuesScope<"llvm::WinX64EHUnwindV2Mode">, + MarshallingInfoEnum<CodeGenOpts<"WinX64EHUnwindV2">, "Disabled">; def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">, Group<f_Group>, Visibility<[ClangOption, CLOption]>, HelpText<"Allows control over excess precision on targets where native " @@ -8968,7 +8971,9 @@ def _SLASH_volatile_Group : OptionGroup<"</volatile group>">, Group<cl_compile_Group>; def _SLASH_d2epilogunwind : CLFlag<"d2epilogunwind">, - HelpText<"Enable unwind v2 (epilog) information for x64 Windows">; + HelpText<"Best effort generate unwind v2 (epilog) information for x64 Windows">; +def _SLASH_d2epilogunwindrequirev2 : CLFlag<"d2epilogunwindrequirev2">, + HelpText<"Require generation of unwind v2 (epilog) information for x64 Windows">; def _SLASH_EH : CLJoined<"EH">, HelpText<"Set exception handling model">; def _SLASH_EP : CLFlag<"EP">, HelpText<"Disable linemarker output and preprocess to stdout">; diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index 16e49aab4fe61..148c31912acbd 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -1314,8 +1314,10 @@ void CodeGenModule::Release() { 1); // Enable unwind v2 (epilog). - if (CodeGenOpts.WinX64EHUnwindV2) - getModule().addModuleFlag(llvm::Module::Warning, "winx64-eh-unwindv2", 1); + if (CodeGenOpts.getWinX64EHUnwindV2() != llvm::WinX64EHUnwindV2Mode::Disabled) + getModule().addModuleFlag( + llvm::Module::Warning, "winx64-eh-unwindv2", + static_cast<unsigned>(CodeGenOpts.getWinX64EHUnwindV2())); // Indicate whether this Module was compiled with -fopenmp if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd) diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index 65f101ddf1d0a..dce5d132b10a7 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -7471,8 +7471,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, } // Unwind v2 (epilog) information for x64 Windows. - Args.addOptInFlag(CmdArgs, options::OPT_fwinx64_eh_unwindv2, - options::OPT_fno_winx64_eh_unwindv2); + Args.AddLastArg(CmdArgs, options::OPT_winx64_eh_unwindv2); // C++ "sane" operator new. Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new, @@ -8529,8 +8528,10 @@ void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType, CmdArgs.push_back("-fms-kernel"); // Unwind v2 (epilog) information for x64 Windows. - if (Args.hasArg(options::OPT__SLASH_d2epilogunwind)) - CmdArgs.push_back("-fwinx64-eh-unwindv2"); + if (Args.hasArg(options::OPT__SLASH_d2epilogunwindrequirev2)) + CmdArgs.push_back("-fwinx64-eh-unwindv2=required"); + else if (Args.hasArg(options::OPT__SLASH_d2epilogunwind)) + CmdArgs.push_back("-fwinx64-eh-unwindv2=best-effort"); for (const Arg *A : Args.filtered(options::OPT__SLASH_guard)) { StringRef GuardArgs = A->getValue(); diff --git a/clang/test/CodeGen/epilog-unwind.c b/clang/test/CodeGen/epilog-unwind.c index 991ff09fb37cf..b2f7497b455b6 100644 --- a/clang/test/CodeGen/epilog-unwind.c +++ b/clang/test/CodeGen/epilog-unwind.c @@ -1,9 +1,11 @@ // RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s -check-prefix=DISABLED -// RUN: %clang_cc1 -fwinx64-eh-unwindv2 -emit-llvm %s -o - | FileCheck %s -check-prefix=ENABLED -// RUN: %clang -fwinx64-eh-unwindv2 -S -emit-llvm %s -o - | FileCheck %s -check-prefix=ENABLED -// RUN: %clang -fno-winx64-eh-unwindv2 -S -emit-llvm %s -o - | FileCheck %s -check-prefix=DISABLED +// RUN: %clang_cc1 -fwinx64-eh-unwindv2=disabled -emit-llvm %s -o - | FileCheck %s -check-prefix=DISABLED +// RUN: %clang_cc1 -fwinx64-eh-unwindv2=best-effort -emit-llvm %s -o - | FileCheck %s -check-prefix=BESTEFFORT +// RUN: %clang_cc1 -fwinx64-eh-unwindv2=required -emit-llvm %s -o - | FileCheck %s -check-prefix=REQUIRED +// RUN: %clang -fwinx64-eh-unwindv2=best-effort -S -emit-llvm %s -o - | FileCheck %s -check-prefix=BESTEFFORT void f(void) {} -// ENABLED: !"winx64-eh-unwindv2", i32 1} +// BESTEFFORT: !"winx64-eh-unwindv2", i32 1} +// REQUIRED: !"winx64-eh-unwindv2", i32 2} // DISABLED-NOT: "winx64-eh-unwindv2" diff --git a/clang/test/Driver/cl-options.c b/clang/test/Driver/cl-options.c index 0535285862b9f..eb079895a0a88 100644 --- a/clang/test/Driver/cl-options.c +++ b/clang/test/Driver/cl-options.c @@ -821,7 +821,11 @@ // ARM64EC_OVERRIDE: warning: /arm64EC has been overridden by specified target: x86_64-pc-windows-msvc; option ignored // RUN: %clang_cl /d2epilogunwind /c -### -- %s 2>&1 | FileCheck %s --check-prefix=EPILOGUNWIND -// EPILOGUNWIND: -fwinx64-eh-unwindv2 +// EPILOGUNWIND: -fwinx64-eh-unwindv2=best-effort + +// RUN: %clang_cl /d2epilogunwindrequirev2 /c -### -- %s 2>&1 | FileCheck %s --check-prefix=EPILOGUNWINDREQUIREV2 +// RUN: %clang_cl /d2epilogunwindrequirev2 /d2epilogunwind /c -### -- %s 2>&1 | FileCheck %s --check-prefix=EPILOGUNWINDREQUIREV2 +// EPILOGUNWINDREQUIREV2: -fwinx64-eh-unwindv2=require // RUN: %clang_cl /funcoverride:override_me1 /funcoverride:override_me2 /c -### -- %s 2>&1 | FileCheck %s --check-prefix=FUNCOVERRIDE // FUNCOVERRIDE: -loader-replaceable-function=override_me1 diff --git a/llvm/include/llvm/IR/Module.h b/llvm/include/llvm/IR/Module.h index 7a26efb74b324..9d90a5755f7ed 100644 --- a/llvm/include/llvm/IR/Module.h +++ b/llvm/include/llvm/IR/Module.h @@ -1061,6 +1061,10 @@ class LLVM_ABI Module { /// Returns target-abi from MDString, null if target-abi is absent. StringRef getTargetABIFromMD(); + + /// Get how unwind v2 (epilog) information should be generated for x64 + /// Windows. + WinX64EHUnwindV2Mode getWinX64EHUnwindV2Mode() const; }; /// Given "llvm.used" or "llvm.compiler.used" as a global name, collect the diff --git a/llvm/include/llvm/Support/CodeGen.h b/llvm/include/llvm/Support/CodeGen.h index 0e42789ba932e..48745f7f4d2a6 100644 --- a/llvm/include/llvm/Support/CodeGen.h +++ b/llvm/include/llvm/Support/CodeGen.h @@ -130,6 +130,15 @@ namespace llvm { Invalid = 2, ///< Not used. }; + enum class WinX64EHUnwindV2Mode { + // Don't use unwind v2 (i.e., use v1). + Disabled = 0, + // Use unwind v2 here possible, otherwise fallback to v1. + BestEffort = 1, + // Use unwind v2 everywhere, otherwise raise an error. + Required = 2, + }; + } // namespace llvm #endif diff --git a/llvm/lib/IR/Module.cpp b/llvm/lib/IR/Module.cpp index 0a47f98619691..7b3a0bb333c05 100644 --- a/llvm/lib/IR/Module.cpp +++ b/llvm/lib/IR/Module.cpp @@ -919,3 +919,10 @@ StringRef Module::getTargetABIFromMD() { TargetABI = TargetABIMD->getString(); return TargetABI; } + +WinX64EHUnwindV2Mode Module::getWinX64EHUnwindV2Mode() const { + Metadata *MD = getModuleFlag("winx64-eh-unwindv2"); + if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD)) + return static_cast<WinX64EHUnwindV2Mode>(CI->getZExtValue()); + return WinX64EHUnwindV2Mode::Disabled; +} diff --git a/llvm/lib/Target/X86/X86WinEHUnwindV2.cpp b/llvm/lib/Target/X86/X86WinEHUnwindV2.cpp index 2c1f9a5746e38..01256ec8995a8 100644 --- a/llvm/lib/Target/X86/X86WinEHUnwindV2.cpp +++ b/llvm/lib/Target/X86/X86WinEHUnwindV2.cpp @@ -20,6 +20,7 @@ #include "llvm/CodeGen/MachineInstrBuilder.h" #include "llvm/CodeGen/TargetInstrInfo.h" #include "llvm/CodeGen/TargetSubtargetInfo.h" +#include "llvm/IR/DiagnosticInfo.h" #include "llvm/IR/Module.h" using namespace llvm; @@ -31,6 +32,15 @@ STATISTIC(MeetsUnwindV2Criteria, STATISTIC(FailsUnwindV2Criteria, "Number of functions that fail Unwind v2 criteria"); +static cl::opt<unsigned> MaximumUnwindCodes( + "x86-wineh-unwindv2-max-unwind-codes", cl::Hidden, + cl::desc("Maximum number of unwind codes permitted in each unwind info."), + cl::init(UINT8_MAX)); + +static cl::opt<unsigned> ForceMode( + "x86-wineh-unwindv2-force-mode", cl::Hidden, + cl::desc("Overwrites the Unwind v2 mode for testing purposes.")); + namespace { class X86WinEHUnwindV2 : public MachineFunctionPass { @@ -44,9 +54,21 @@ class X86WinEHUnwindV2 : public MachineFunctionPass { StringRef getPassName() const override { return "WinEH Unwind V2"; } bool runOnMachineFunction(MachineFunction &MF) override; - bool rejectCurrentFunction() const { - FailsUnwindV2Criteria++; - return false; + +private: + bool rejectCurrentFunction(const MachineFunction &MF, const DebugLoc &Loc, + WinX64EHUnwindV2Mode Mode, + StringRef Reason) const; + + bool rejectCurrentFunction(const MachineFunction &MF, + const MachineBasicBlock &EpilogBlock, + WinX64EHUnwindV2Mode Mode, + StringRef Reason) const { + // If we're in the Epilog, then the generated instructions might not have a + // location, so use the terminator's location. + return rejectCurrentFunction( + MF, EpilogBlock.getFirstTerminator()->getDebugLoc(), Mode, + Reason); } }; @@ -69,8 +91,21 @@ FunctionPass *llvm::createX86WinEHUnwindV2Pass() { return new X86WinEHUnwindV2(); } +DebugLoc findDebugLoc(const MachineBasicBlock &MBB) { + for (const MachineInstr &MI : MBB) + if (MI.getDebugLoc()) + return MI.getDebugLoc(); + + return DebugLoc::getUnknown(); +} + bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { - if (!MF.getFunction().getParent()->getModuleFlag("winx64-eh-unwindv2")) + WinX64EHUnwindV2Mode Mode = + ForceMode.getNumOccurrences() + ? static_cast<WinX64EHUnwindV2Mode>(ForceMode.getValue()) + : MF.getFunction().getParent()->getWinX64EHUnwindV2Mode(); + + if (Mode == WinX64EHUnwindV2Mode::Disabled) return false; // Current state of processing the function. We'll assume that all functions @@ -80,6 +115,7 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { // Prolog information. SmallVector<int64_t> PushedRegs; bool HasStackAlloc = false; + unsigned ApproximatePrologCodeCount = 0; // Requested changes. SmallVector<MachineInstr *> UnwindV2StartLocations; @@ -99,6 +135,7 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { case X86::SEH_PushReg: if (State != FunctionState::InProlog) llvm_unreachable("SEH_PushReg outside of prolog"); + ApproximatePrologCodeCount++; PushedRegs.push_back(MI.getOperand(0).getImm()); break; @@ -106,9 +143,26 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { case X86::SEH_SetFrame: if (State != FunctionState::InProlog) llvm_unreachable("SEH_StackAlloc or SEH_SetFrame outside of prolog"); + // Assume a large alloc... + ApproximatePrologCodeCount += + (MI.getOpcode() == X86::SEH_StackAlloc) ? 3 : 1; HasStackAlloc = true; break; + case X86::SEH_SaveReg: + case X86::SEH_SaveXMM: + if (State != FunctionState::InProlog) + llvm_unreachable("SEH_SaveXMM or SEH_SaveReg outside of prolog"); + // Assume a big reg... + ApproximatePrologCodeCount += 3; + break; + + case X86::SEH_PushFrame: + if (State != FunctionState::InProlog) + llvm_unreachable("SEH_PushFrame outside of prolog"); + ApproximatePrologCodeCount++; + break; + case X86::SEH_EndPrologue: if (State != FunctionState::InProlog) llvm_unreachable("SEH_EndPrologue outside of prolog"); @@ -127,10 +181,14 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { case X86::SEH_EndEpilogue: if (State != FunctionState::InEpilog) llvm_unreachable("SEH_EndEpilogue outside of epilog"); - if ((HasStackAlloc != HasStackDealloc) || - (PoppedRegCount != PushedRegs.size())) - // Non-canonical epilog, reject the function. - return rejectCurrentFunction(); + if (HasStackAlloc != HasStackDealloc) + return rejectCurrentFunction(MF, MBB, Mode, + "The prolog made a stack allocation, " + "but the epilog did not deallocate it"); + if (PoppedRegCount != PushedRegs.size()) + return rejectCurrentFunction(MF, MBB, Mode, + "The prolog pushed more registers than " + "the epilog popped"); // If we didn't find the start location, then use the end of the // epilog. @@ -145,13 +203,25 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { if (State == FunctionState::InEpilog) { // If the prolog contains a stack allocation, then the first // instruction in the epilog must be to adjust the stack pointer. - if (!HasStackAlloc || HasStackDealloc || (PoppedRegCount > 0)) { - return rejectCurrentFunction(); - } + if (!HasStackAlloc) + return rejectCurrentFunction( + MF, MBB, Mode, + "The epilog is deallocating a stack allocation, but the prolog did " + "not allocate one"); + if (HasStackDealloc) + return rejectCurrentFunction( + MF, MBB, Mode, + "The epilog is deallocating the stack allocation more than once"); + if (PoppedRegCount > 0) + llvm_unreachable( + "Should have raised an error: either popping before " + "deallocating or deallocating without an allocation"); + HasStackDealloc = true; } else if (State == FunctionState::FinishedEpilog) - // Unexpected instruction after the epilog. - return rejectCurrentFunction(); + return rejectCurrentFunction( + MF, MBB, Mode, + "Unexpected mov or add instruction after the epilog"); break; case X86::POP64r: @@ -159,12 +229,20 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { // After the stack pointer has been adjusted, the epilog must // POP each register in reverse order of the PUSHes in the prolog. PoppedRegCount++; - if ((HasStackAlloc != HasStackDealloc) || - (PoppedRegCount > PushedRegs.size()) || - (PushedRegs[PushedRegs.size() - PoppedRegCount] != - MI.getOperand(0).getReg())) { - return rejectCurrentFunction(); - } + if (HasStackAlloc != HasStackDealloc) + return rejectCurrentFunction(MF, MBB, Mode, + "Cannot pop registers before the stack " + "allocation has been deallocated"); + if (PoppedRegCount > PushedRegs.size()) + return rejectCurrentFunction( + MF, MBB, Mode, + "The epilog is popping more registers than the prolog pushed"); + if (PushedRegs[PushedRegs.size() - PoppedRegCount] != + MI.getOperand(0).getReg()) + return rejectCurrentFunction( + MF, MBB, Mode, + "The epilog is popping a registers in a different order than the " + "prolog pushed them"); // Unwind v2 records the size of the epilog not from where we place // SEH_BeginEpilogue (as that contains the instruction to adjust the @@ -176,7 +254,9 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { } } else if (State == FunctionState::FinishedEpilog) // Unexpected instruction after the epilog. - return rejectCurrentFunction(); + return rejectCurrentFunction( + MF, MBB, Mode, + "Registers are being popped after the epilog"); break; default: @@ -191,7 +271,9 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { if ((State == FunctionState::FinishedEpilog) || (State == FunctionState::InEpilog)) // Unknown instruction in or after the epilog. - return rejectCurrentFunction(); + return rejectCurrentFunction( + MF, MI.getDebugLoc(), Mode, + "Unexpected instruction in or after the epilog"); } } } @@ -203,6 +285,16 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { return false; } + MachineBasicBlock &FirstMBB = MF.front(); + // Assume +1 for the "header" UOP_Epilog that contains the epilog size, and + // that we won't be able to use the "last epilog at the end of function" + // optimization. + if (ApproximatePrologCodeCount + UnwindV2StartLocations.size() + 1 > + static_cast<unsigned>(MaximumUnwindCodes)) + return rejectCurrentFunction( + MF, findDebugLoc(FirstMBB), Mode, + "The function has too many epilogs"); + MeetsUnwindV2Criteria++; // Emit the pseudo instruction that marks the start of each epilog. @@ -212,10 +304,23 @@ bool X86WinEHUnwindV2::runOnMachineFunction(MachineFunction &MF) { TII->get(X86::SEH_UnwindV2Start)); } // Note that the function is using Unwind v2. - MachineBasicBlock &FirstMBB = MF.front(); - BuildMI(FirstMBB, FirstMBB.front(), FirstMBB.front().getDebugLoc(), + BuildMI(FirstMBB, FirstMBB.front(), findDebugLoc(FirstMBB), TII->get(X86::SEH_UnwindVersion)) .addImm(2); return true; } + +bool X86WinEHUnwindV2::rejectCurrentFunction(const MachineFunction &MF, + const DebugLoc &Loc, + WinX64EHUnwindV2Mode Mode, + StringRef Reason) const { + if (Mode == WinX64EHUnwindV2Mode::Required) + MF.getFunction().getContext().diagnose(DiagnosticInfoGenericWithLoc( + "Windows x64 Unwind v2 is required, but the function '" + MF.getName() + + "' does not meet the criteria: " + Reason, + MF.getFunction(), Loc)); + + FailsUnwindV2Criteria++; + return false; +} diff --git a/llvm/test/CodeGen/X86/win64-eh-unwindv2-errors.mir b/llvm/test/CodeGen/X86/win64-eh-unwindv2-errors.mir new file mode 100644 index 0000000000000..08c0c0fa6c1db --- /dev/null +++ b/llvm/test/CodeGen/X86/win64-eh-unwindv2-er... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/143577 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
