Add the two AOTI shims PyTorch 2.14 links against, and export all three

Lowering a CUDA model for a Windows target fails at link time:

    x86_64-w64-mingw32-ld: undefined reference to `aoti_torch_dtype_uint8'
    x86_64-w64-mingw32-ld: undefined reference to `aoti_torch_empty_strided_pinned'
    x86_64-w64-mingw32-ld: undefined reference to `aoti_torch_is_defined'
    collect2: error: ld returned 1 exit status

PyTorch generates a wrapper for the model and links it against this project's
shims. The wrapper's own header started calling these three in 2.14, where it
called none of them before, so the link now needs all three present.

Two did not exist here:

`aoti_torch_is_defined` asks whether a handle refers to a real tensor. PyTorch has
an undefined-tensor state with no equivalent here, so this is a null check.

`aoti_torch_empty_strided_pinned` asks for page-locked host memory, which lets the
copy of the model's constants to the device overlap with filling the next buffer.
There is no allocator for that memory here, so this reports that and the caller
takes the plain synchronous copy it already falls back to. That path is not an
error case: the calling code is named for trying, and every way it can fail logs
that it is falling back and carries on. Adding a real pinned allocator means
teaching the storage layer a new kind of memory and a matching way to release it,
which is a change of its own rather than part of moving a version pin.

The third, `aoti_torch_dtype_uint8`, was already implemented and simply missing
from the list of names the Windows link stub exports, along with the other two.
That stub is a checked-in file, so it is regenerated here. Every previous pin
bump has had to do the same.

Test Plan:
Read the requirement from the generated wrapper's header on both branches rather
than inferring it from the link error: it names these three in 2.14 and none of
them in 2.13, which is why this appears only after the pin moves.

Compiled the common shims and confirmed with the symbol table that
`aoti_torch_is_defined` is defined rather than merely declared. Checked its
signature against PyTorch's own header parameter by parameter, and matched the
pointer spelling the neighbouring shims already use for a tensor handle.

Regenerated the link stub from the names it already exported plus these three, so
it went from 42 to 45. Confirmed the result is a strict superset, that nothing was
dropped, that the counts of the two kinds of entry agree, and that all three names
are now in it.

Confirmed the caller treats a refusal as an ordinary outcome by reading it: it
returns empty and logs that it is falling back to the synchronous copy.

Formatting is clean on the changed files.

The CUDA shim file needs the CUDA headers to compile, which this machine does not
have, so that half is for CI to confirm. Whether a Windows target now links is
also for CI, since it needs the cross toolchain.

Author: pytorchbot

backends/aoti/common_shims.cpp

@@ -159,6 +159,11 @@ AOTITorchError aoti_torch_get_numel(Tensor* tensor, int64_t* ret_numel) {
   return Error::Ok;
 }
 
+AOTITorchError aoti_torch_is_defined(Tensor* tensor, bool* ret_is_defined) {
+  *ret_is_defined = tensor != nullptr;
+  return Error::Ok;
+}
+
 // Device and layout utility functions
 int32_t aoti_torch_device_type_cpu() {
   // Let's say cpu is 0 for ET as well

backends/aoti/common_shims.h

@@ -62,6 +62,11 @@ aoti_torch_get_dim(Tensor* tensor, int64_t* ret_dim);
 AOTI_SHIM_EXPORT AOTITorchError
 aoti_torch_get_numel(Tensor* tensor, int64_t* ret_numel);
 
+// Reports whether the handle refers to a real tensor. PyTorch has an undefined
+// tensor state that ExecuTorch has no equivalent for, so this is a null check.
+AOTI_SHIM_EXPORT AOTITorchError
+aoti_torch_is_defined(Tensor* tensor, bool* ret_is_defined);
+
 // Utility functions for device and layout information
 AOTI_SHIM_EXPORT int32_t aoti_torch_device_type_cpu();
 AOTI_SHIM_EXPORT int32_t aoti_torch_layout_strided();

backends/cuda/runtime/aoti_cuda_shims.lib

@@ -195,6 +195,24 @@ AOTITorchError aoti_torch_empty_strided(
   return Error::Ok;
 }
 
+AOTITorchError aoti_torch_empty_strided_pinned(
+    int64_t ndim,
+    const int64_t* sizes_ptr,
+    const int64_t* strides_ptr,
+    int32_t dtype,
+    int32_t device_type,
+    int32_t device_index,
+    SlimTensor** ret_new_tensor) {
+  (void)ndim;
+  (void)sizes_ptr;
+  (void)strides_ptr;
+  (void)dtype;
+  (void)device_type;
+  (void)device_index;
+  (void)ret_new_tensor;
+  return Error::NotSupported;
+}
+
 AOTITorchError aoti_torch_delete_tensor_object(SlimTensor* tensor) {
   ET_CHECK_OR_RETURN_ERROR(
       tensor != nullptr,

backends/cuda/runtime/shims/memory.cpp

@@ -95,6 +95,26 @@ AOTI_SHIM_EXPORT AOTITorchError aoti_torch_empty_strided(
     int32_t device_index,
     SlimTensor** ret_new_tensor);
 
+/**
+ * Reports that pinned host memory is unavailable.
+ *
+ * Generated wrappers call this to stage constants through page-locked host
+ * memory, which lets the copy to the device run asynchronously. There is no
+ * pinned allocator here, so this always fails and the caller uses the
+ * synchronous copy it already falls back to. Correct, and slower only while
+ * loading.
+ *
+ * @return Error::NotSupported
+ */
+AOTI_SHIM_EXPORT AOTITorchError aoti_torch_empty_strided_pinned(
+    int64_t ndim,
+    const int64_t* sizes_ptr,
+    const int64_t* strides_ptr,
+    int32_t dtype,
+    int32_t device_type,
+    int32_t device_index,
+    SlimTensor** ret_new_tensor);
+
 /**
  * Deletes a tensor object and frees associated resources.
  *