[PATCH] D102817: [Windows SEH]: HARDWARE EXCEPTION HANDLING (MSVC -EHa) - Part 2

Wed May 19 17:07:09 PDT 2021

tentzen created this revision.
tentzen added reviewers: asmith, rnk, JosephTremoulet, andrew.w.kaylor, majnemer, pengfei, lebedev.ri, rsmith, aaron.ballman, rjmccall, jansvoboda11, eli.friedman, jdoerfert.
Herald added subscribers: dexonsmith, kbarton, hiraditya, nemanjai.
tentzen requested review of this revision.
Herald added a project: LLVM.
Herald added a subscriber: llvm-commits.

This patch is the Part-2 (BE LLVM) implementation of HW Exception handling.
Part-1 (FE Clang) was committed in 797ad701522988e212495285dade8efac41a24d4 <https://reviews.llvm.org/rG797ad701522988e212495285dade8efac41a24d4>.

This new feature adds the support of Hardware Exception for Microsoft Windows
SEH (Structured Exception Handling).

  Compiler options:
  For clang-cl.exe, the option is -EHa, the same as MSVC.
  For clang.exe, the extra option is -fasync-exceptions,
  plus -triple x86_64-windows -fexceptions and -fcxx-exceptions as usual.

  NOTE:: Without the -EHa or -fasync-exceptions, this patch is a NO-DIFF change.

The rules for C code:
For C-code, one way (MSVC approach) to achieve SEH -EHa semantic is to follow three rules:

- First, no exception can move in or out of _try region., i.e., no "potential faulty instruction can be moved across _try boundary.
- Second, the order of exceptions for instructions 'directly' under a _try must be preserved (not applied to those in callees).
- Finally, global states (local/global/heap variables) that can be read outside of _try region must be updated in memory (not just in register) before the subsequent exception occurs.

The impact to C++ code:

  Although SEH is a feature for C code, -EHa does have a profound effect on C++
  side. When a C++ function (in the same compilation unit with option -EHa ) is
  called by a SEH C function, a hardware exception occurs in C++ code can also
  be handled properly by an upstream SEH _try-handler or a C++ catch(...).
  As such, when that happens in the middle of an object's life scope, the dtor
  must be invoked the same way as C++ Synchronous Exception during unwinding process.

Design:

  A natural way to achieve the rules above in LLVM today is to allow an EH edge
  added on memory/computation instruction (previous iload/istore idea) so that
  exception path is modeled in Flow graph preciously. However, tracking every
  single memory instruction and potential faulty instruction can create many
  Invokes, complicate flow graph and possibly result in negative performance
  impact for downstream optimization and code generation. Making all
  optimizations be aware of the new semantic is also substantial.

  This design does not intend to model exception path at instruction level.
  Instead, the proposed design tracks and reports EH state at BLOCK-level to
  reduce the complexity of flow graph and minimize the performance-impact on CPP
  code under -EHa option.

One key element of this design is the ability to compute State number at
block-level. Our algorithm is based on the following rationales:

  A _try scope is always a SEME (Single Entry Multiple Exits) region as jumping
  into a _try is not allowed. The single entry must start with a seh_try_begin()
  invoke with a correct State number that is the initial state of the SEME.
  Through control-flow, state number is propagated into all blocks. Side exits
  marked by seh_try_end() will unwind to parent state based on existing SEHUnwindMap[].
  Note side exits can ONLY jump into parent scopes (lower state number).
  Thus, when a block succeeds various states from its predecessors, the lowest
  State triumphs others.  If some exits flow to unreachable, propagation on those
  paths terminate, not affecting remaining blocks.
  For CPP code, object lifetime region is usually a SEME as SEH _try.
  However there is one rare exception: jumping into a lifetime that has Dtor but
  has no Ctor is warned, but allowed:

  Warning: jump bypasses variable with a non-trivial destructor

  In that case, the region is actually a MEME (multiple entry multiple exits).
  Our solution is to inject a eha_scope_begin() invoke in the side entry block to
  ensure a correct State.

Implementation:
Part-1: Clang implementation (already in):
Please see commit 797ad701522988e212495285dade8efac41a24d4 <https://reviews.llvm.org/rG797ad701522988e212495285dade8efac41a24d4>).

Part-2 : LLVM implementation described below.

  For both C++ & C-code, the state of each block is computed at the same place in
  BE (WinEHPreparing pass) where all other EH tables/maps are calculated.
  In addition to _scope_begin & _scope_end, the computation of block state also
  rely on the existing State tracking code (UnwindMap and InvokeStateMap).

  For both C++ & C-code, the state of each block with potential trap instruction
  is marked and reported in DAG Instruction Selection pass, the same place where
  the state for -EHsc (synchronous exceptions) is done.
  If the first instruction in a reported block scope can trap, a Nop is injected
  before this instruction. This nop is needed to accommodate LLVM Windows EH
  implementation, in which the address in IPToState table is offset by +1.
  (note the purpose of that is to ensure the return address of a call is in the
  same scope as the call address.

  The handler for catch(...) for -EHa must handle HW exception. So it is
  'adjective' flag is reset (it cannot be IsStdDotDot (0x40) that only catches
  C++ exceptions).
  Suppress push/popTerminate() scope (from noexcept/noTHrow) so that HW
  exceptions can be passed through.

  Original llvm-dev [RFC] discussions can be found in these two threads below:
  https://lists.llvm.org/pipermail/llvm-dev/2020-March/140541.html
  https://lists.llvm.org/pipermail/llvm-dev/2020-April/141338.html

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D102817

Files:
  llvm/include/llvm/CodeGen/SelectionDAGISel.h
  llvm/include/llvm/CodeGen/WinEHFuncInfo.h
  llvm/include/llvm/IR/BasicBlock.h
  llvm/lib/Analysis/EHPersonalities.cpp
  llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
  llvm/lib/CodeGen/AsmPrinter/WinException.cpp
  llvm/lib/CodeGen/BranchFolding.cpp
  llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
  llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
  llvm/lib/CodeGen/WinEHPrepare.cpp
  llvm/lib/IR/BasicBlock.cpp
  llvm/test/CodeGen/X86/windows-seh-EHa-CppCatchDotDotDot.ll
  llvm/test/CodeGen/X86/windows-seh-EHa-CppCondiTemps.ll
  llvm/test/CodeGen/X86/windows-seh-EHa-CppDtors01.ll
  llvm/test/CodeGen/X86/windows-seh-EHa-TryInFinally.ll

-------------- next part --------------
A non-text attachment was scrubbed...
Name: D102817.346600.patch
Type: text/x-patch
Size: 81610 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20210520/43a74ddf/attachment.bin>