Update on "Reuse GELU implementation from PyTorch core"

kernels/optimized doesn't need to support embedded systems, so it can just take a header-only dep on PyTorch.

Note that, because we will pick up Sleef internally and ignore it
externally thanks to ATen vec, this PR gets to enable optimized GELU in OSS.

Testing: CI to make sure this doesn't break mobile build modes; happy to take advice on anything not currently covered that might break.

Differential Revision: [D66335522](https://our.internmc.facebook.com/intern/diff/D66335522/)

[ghstack-poisoned]

Author: swolchok

shim/xplat/executorch/codegen/codegen.bzl

@@ -116,7 +116,8 @@ def _prepare_genrule_and_lib(
         custom_ops_yaml_path = None,
         custom_ops_requires_runtime_registration = True,
         manual_registration = False,
-        aten_mode = False):
+        aten_mode = False,
+        support_exceptions = True):
     """
     This function returns two dicts `genrules` and `libs`, derived from the arguments being passed
     to `executorch_generated_lib`. `genrules` contains all information related to what genrules to
@@ -151,12 +152,15 @@ def _prepare_genrule_and_lib(
         "--source-path=$(location //executorch/codegen:templates)",
         "--tags-path $(location {})/aten/src/ATen/native/tags.yaml".format(aten_src_path),
         "--aten_yaml_path $(location {})/aten/src/ATen/native/native_functions.yaml".format(aten_src_path),
-        "--add-exception-boundary",
         "--install_dir=${OUT}",
         # TODO(dbort): Add a second step that verifies that the set of
         # actually-generated files matches GENERATED_FILES.
     ]
 
+    if support_exceptions:
+        genrule_cmd.append("--add-exception-boundary")
+
+
     # Sources for generated kernel registration lib
     sources = MANUAL_REGISTRATION_SOURCES if manual_registration else GENERATED_SOURCES
 
@@ -218,6 +222,7 @@ def _prepare_genrule_and_lib(
 def _prepare_custom_ops_genrule_and_lib(
         name,
         custom_ops_yaml_path = None,
+        support_exceptions = True,
         deps = [],
         kernels = []):
     """Similar to _prepare_genrule_and_lib but for custom ops."""
@@ -248,10 +253,11 @@ def _prepare_custom_ops_genrule_and_lib(
             "--tags-path $(location {})/aten/src/ATen/native/tags.yaml".format(aten_src_path),
             "--aten_yaml_path $(location {})/aten/src/ATen/native/native_functions.yaml".format(aten_src_path),
             "--custom_ops_yaml_path=" + custom_ops_yaml_path,
-            "--add_exception_boundary",
             "--install_dir=${OUT}",
             "--op_selection_yaml_path=$(location :{}[selected_operators.yaml])".format(oplist_dir_name),
         ]
+        if support_exceptions:
+            genrule_cmd.append("--add-exception-boundary")
 
         # Determine what sources custom_ops_<name> target should include
         custom_ops_sources = CUSTOM_OPS_SCHEMA_REGISTRATION_SOURCES + (
@@ -283,6 +289,7 @@ def exir_custom_ops_aot_lib(
         deps = [],
         compiler_flags = [],
         define_static_target = False,
+        support_exceptions = True,
         platforms = get_default_executorch_platforms()):
     """Generates a C++ library that helps to register the custom ops into PyTorch,
     so they are visible to EXIR. To use this, we need to load the generated so file:
@@ -299,11 +306,13 @@ def exir_custom_ops_aot_lib(
         visibility: visibility of the generated library.
         kernels: C++ kernels for these custom ops. They need to be implemented using ATen/c10 basics.
         deps: dependencies of the generated library.
+        support_exceptions: enable try/catch wrapper around operator implemntations to make sure exceptions thrown will not bring down the process. Disable if your use case disables exceptions in the build.
     """
     genrules, libs = _prepare_custom_ops_genrule_and_lib(
         name = name,
         custom_ops_yaml_path = selects.apply(yaml_target, lambda y: "$(location {})".format(y)),
         kernels = kernels,
+        support_exceptions = support_exceptions,
         deps = deps,
     )
     for genrule in genrules:
@@ -448,7 +457,8 @@ def executorch_generated_lib(
         kernel_deps = [],
         dtype_selective_build = False,
         feature = None,
-        expose_operator_symbols = False):
+        expose_operator_symbols = False,
+        support_exceptions = True):
     """Emits 0-3 C++ library targets (in fbcode or xplat) containing code to
     dispatch the operators specified in the provided yaml files.
 
@@ -497,6 +507,7 @@ def executorch_generated_lib(
         compiler_flags: compiler_flags args to runtime.cxx_library
         dtype_selective_build: In additional to operator selection, dtype selective build further selects the dtypes for each operator. Can be used with model or dict selective build APIs, where dtypes can be specified. Note: this is only available in xplat.
         feature: Product-Feature Hierarchy (PFH). For internal use only, required for FoA in production. See: https://fburl.com/wiki/2wzjpyqy
+        support_exceptions: enable try/catch wrapper around operator implemntations to make sure exceptions thrown will not bring down the process. Disable if your use case disables exceptions in the build.
     """
     if functions_yaml_target and aten_mode:
         fail("{} is providing functions_yaml_target in ATen mode, it will be ignored. `native_functions.yaml` will be the source of truth.".format(name))
@@ -536,6 +547,7 @@ def executorch_generated_lib(
         custom_ops_requires_runtime_registration = custom_ops_requires_runtime_registration,
         aten_mode = aten_mode,
         manual_registration = manual_registration,
+        support_exceptions = support_exceptions,
     )
 
     # genrule for selective build from static operator list