diff --git a/docs/cppvtable-classes.md b/docs/cppvtable-classes.md
index d50e794db..a9a10af40 100644
--- a/docs/cppvtable-classes.md
+++ b/docs/cppvtable-classes.md
@@ -60,14 +60,18 @@ these are errors and not warnings.
 | `instanceof`, a cast to or from `any`, a cast to an interface | each asks the object through slot 0, which is a C++ method |
 | `-mm=rc` / `-mm=own` | retains and releases write a count in the word before an object, inside the C++ object |
 | a 32-bit x86 MSVC target | C++ member functions are `__thiscall` there (`this` in ECX) |
-| a method returning a tuple, on a non-MSVC target | the Itanium ABI returns records otherwise (see below) |
+| a method returning a tuple, on a target other than MSVC and Itanium x86-64 / AArch64 | each ABI returns records its own way (see below) |
+| on Itanium, a method returning a trivial tuple other than one or two 8-byte integer or pointer fields | SysV / AAPCS64 pack it into registers by its fields, which a tuple isn't (see below) |
 
 A generic or static class can't be `@cppvtable` either.
 
 ## Writing a binding
 
 - **Slot numbers.** Take them from the compiler, not by counting: MSVC prints a class's vtable
-  with `cl /c /Zs /d1reportSingleClassLayout<Name> file.cpp`. Declare unused slots with
+  with `cl /c /Zs /d1reportSingleClassLayout<Name> file.cpp`; clang (Itanium) with
+  `clang++ -S -emit-llvm -o /dev/null -Xclang -fdump-vtable-layouts file.cpp`, for a class whose
+  vtable the file emits (it defines the first virtual method that isn't inline), where slot N is
+  entry N + 2 (entries 0 and 1 are the offset to top and the RTTI). Declare unused slots with
   placeholder names (`_slot17(): void;`) so the methods you call keep their numbers.
 - **The destructor** is one slot under MSVC (the scalar deleting destructor) and two under the
   Itanium ABI. Don't call it: release objects the way the C++ library does (`Release()`).
@@ -80,6 +84,7 @@ A generic or static class can't be `@cppvtable` either.
 
   ```ts
   type RefCountPtr = [pointer: Opaque | null];          // nvrhi::RefCountPtr<T>
+  @cppnontrivial                                        // it has a destructor
   createBuffer(desc: Ref<BufferDesc>): RefCountPtr;     // const handle = device.createBuffer(Ref(desc))
   ```
 
@@ -90,12 +95,27 @@ A generic or static class can't be `@cppvtable` either.
   instance methods". A method returning a class (`getLayout(): IBindingLayout`, a C++ pointer) or
   a number still returns it in a register.
 
+  The Itanium ABI (g++, clang) decides by the record, and tslang does it on x86-64 and AArch64
+  (Linux, Android):
+
+  - a record with a destructor or a copy constructor - `RefCountPtr<T>` - comes back through a
+    hidden pointer passed *before* `this`, as the call's `sret` argument (in RDI on x86-64, X8 on
+    AArch64). A tuple can't say the C++ type has them, so mark the method `@cppnontrivial`. (A
+    trivial record of more than 16 bytes is returned the same way, so `@cppnontrivial` is right
+    for it too.) MSVC ignores the mark;
+  - a trivial record of one or two 8-byte integer or pointer fields - `nvrhi::Object` - comes
+    back in RAX:RDX / X0:X1, as tslang returns such a tuple: no mark;
+  - any other trivial record of up to 16 bytes is packed into registers by the SysV / AAPCS64
+    classification, which isn't done: such a method is an error, as is any method returning a
+    tuple on another Itanium target (32-bit x86, say).
+
   The record isn't destroyed: a `RefCountPtr` the method returns holds a reference, which the
-  caller gives back with `Release()`. The Itanium ABI passes the pointer before `this`, and only
-  for some records, so on a non-MSVC target such a method is an error. A method stored in a
-  variable and called later takes the hidden pointer as its first argument; call it directly.
-  tslang pre-alpha94 and earlier need the hidden pointer declared as a parameter:
-  `createBuffer(ret: Ref<Opaque | null>, desc: Ref<BufferDesc>): Opaque`.
+  caller gives back with `Release()`. A method stored in a variable and called later takes the
+  hidden pointer as an argument; call it directly. tslang pre-alpha94 and earlier need the hidden
+  pointer declared as a parameter: `createBuffer(ret: Ref<Opaque | null>, desc: Ref<BufferDesc>): Opaque`.
+- **Narrow parameters.** A `bool` is a `boolean`, an `uint8_t` (or an `enum class : uint8_t`) a
+  `u8`, an `int16_t` an `s16`: a call of a `@cppvtable` method extends an argument narrower than
+  32 bits as a C++ caller does (`zeroext`, `signext` for a signed type), which clang's code relies on.
 - **Structs by reference** (`const BufferDesc&`) are a `Ref<T>` to a named tuple with the C++
   layout. That layout depends on the C++ build: `std::string`, for example, is 32 bytes with the
   release CRT and 40 with the debug CRT.
diff --git a/tslang/include/TypeScript/Defines.h b/tslang/include/TypeScript/Defines.h
index 1d89d1b43..20d05eb3a 100644
--- a/tslang/include/TypeScript/Defines.h
+++ b/tslang/include/TypeScript/Defines.h
@@ -194,6 +194,16 @@
 #define LINK_NAME "linkname"
 // A class laid over an existing C++ object: its vtable is the C++ one (see ClassInfo::isCppVTable)
 #define CPP_VTABLE "cppvtable"
+// A @cppvtable method's C++ return type has a destructor or a copy constructor (see
+// mlirGenClassCppVTableHiddenReturn)
+#define CPP_NON_TRIVIAL "cppnontrivial"
+// On a call (CallIndirect, then CallInternal or Invoke): the index of the argument that is the hidden
+// pointer the callee returns a record through, which LowerToLLVM marks `sret` for the target to pass
+// it where the C++ ABI does (X8 on AArch64)
+#define SRET_ARG_ATTR_NAME "ts.sret_arg"
+// On a call: it calls a C++ method (of a @cppvtable class), whose arguments narrower than 32 bits
+// LowerToLLVM marks zeroext / signext, as a C++ caller extends them (clang relies on it)
+#define CPP_CALL_ATTR_NAME "ts.cpp_call"
 
 #if __LP64__
 #define TRAMPOLINE_SIZE 48
diff --git a/tslang/include/TypeScript/MLIRLogic/MLIRGenStore.h b/tslang/include/TypeScript/MLIRLogic/MLIRGenStore.h
index 09dd23aa2..766115c93 100644
--- a/tslang/include/TypeScript/MLIRLogic/MLIRGenStore.h
+++ b/tslang/include/TypeScript/MLIRLogic/MLIRGenStore.h
@@ -152,9 +152,12 @@ struct MethodInfo
     // @dllname: exported symbol name, empty when the method keeps funcName
     std::string dllName;
     // A @cppvtable method returning a C++ record: the type it is declared with (funcType is the
-    // one its slot is called with, the hidden result pointer after `this`, see
+    // one its slot is called with, the hidden result pointer added, see
     // mlirGenClassCppVTableHiddenReturn); null for any other method.
     mlir_ts::FunctionType declaredFuncType;
+    // @cppnontrivial: the C++ record a @cppvtable method returns has a destructor or a copy
+    // constructor, which decides how the Itanium ABI returns it
+    bool cppNonTrivialReturn = false;
 };
 
 struct GenericMethodInfo
diff --git a/tslang/include/TypeScript/TargetInfo.h b/tslang/include/TypeScript/TargetInfo.h
index a44108fce..4f5f21213 100644
--- a/tslang/include/TypeScript/TargetInfo.h
+++ b/tslang/include/TypeScript/TargetInfo.h
@@ -38,6 +38,12 @@ struct TargetInfo
     // before `this`, and only for some records.
     bool hiddenReturnPointerAfterThis = false;
 
+    // The Itanium ABI on x86-64 and AArch64 returns a record with a destructor or a copy
+    // constructor (marked @cppnontrivial) through a hidden pointer, passed before `this` and marked
+    // `sret` (RDI on x86-64, X8 on AArch64); a record of one or two 8-byte integer or pointer fields
+    // without them comes back in RAX:RDX / X0:X1, as a tuple is returned.
+    bool hiddenReturnPointerBeforeThis = false;
+
     static TargetInfo fromTriple(const llvm::Triple &target, const llvm::Triple &host)
     {
         TargetInfo info;
@@ -62,6 +68,8 @@ struct TargetInfo
             target.getArch() == host.getArch() && target.getOS() == host.getOS();
         info.memberCallsUseThiscall = msvc && x86_32;
         info.hiddenReturnPointerAfterThis = msvc;
+        info.hiddenReturnPointerBeforeThis =
+            !msvc && (target.getArch() == llvm::Triple::x86_64 || target.getArch() == llvm::Triple::aarch64);
 
         return info;
     }
diff --git a/tslang/lib/TypeScript/DeclarationPrinter.cpp b/tslang/lib/TypeScript/DeclarationPrinter.cpp
index 78c7a5638..0abf56bb2 100644
--- a/tslang/lib/TypeScript/DeclarationPrinter.cpp
+++ b/tslang/lib/TypeScript/DeclarationPrinter.cpp
@@ -646,6 +646,13 @@ namespace typescript
                 newline();
             }
 
+            if (method.cppNonTrivialReturn)
+            {
+                os.indent(4);
+                os << "@" CPP_NON_TRIVIAL;
+                newline();
+            }
+
             os.indent(4);
 
             if (method.accessLevel == mlir_ts::AccessLevel::Protected)
diff --git a/tslang/lib/TypeScript/LowerToAffineLoops.cpp b/tslang/lib/TypeScript/LowerToAffineLoops.cpp
index d591ac238..5f70461f2 100644
--- a/tslang/lib/TypeScript/LowerToAffineLoops.cpp
+++ b/tslang/lib/TypeScript/LowerToAffineLoops.cpp
@@ -2220,8 +2220,14 @@ struct CallIndirectOpLowering : public TsPattern<mlir_ts::CallIndirectOp>
                                 : op.getOperands()) llvm::dbgs()
                                << "!! ...call -> invoke operands: " << opit << "\n";);
 
+                auto callAttrs = getCallABIAttrs(op);
                 auto res = rewriter.replaceOpWithNewOp<mlir_ts::InvokeOp>(
                     op, op.getResultTypes(), op.getOperands(), continuationBlock, ValueRange{}, unwind, ValueRange{});
+                for (auto callAttr : callAttrs)
+                {
+                    res->setAttr(callAttr.getName(), callAttr.getValue());
+                }
+
                 return success();
             }
 
@@ -2230,9 +2236,31 @@ struct CallIndirectOpLowering : public TsPattern<mlir_ts::CallIndirectOp>
         }
 
         // just replace
-        rewriter.replaceOpWithNewOp<mlir_ts::CallInternalOp>(op, op.getResultTypes(), op.getOperands());
+        auto callAttrs = getCallABIAttrs(op);
+        auto callInternalOp = rewriter.replaceOpWithNewOp<mlir_ts::CallInternalOp>(op, op.getResultTypes(), op.getOperands());
+        for (auto callAttr : callAttrs)
+        {
+            callInternalOp->setAttr(callAttr.getName(), callAttr.getValue());
+        }
+
         return success();
     }
+
+    // what LowerToLLVM makes the call's argument attributes from (CPP_CALL_ATTR_NAME,
+    // SRET_ARG_ATTR_NAME): the call they are on is replaced, and they go on its replacement
+    static SmallVector<NamedAttribute> getCallABIAttrs(mlir_ts::CallIndirectOp op)
+    {
+        SmallVector<NamedAttribute> callAttrs;
+        for (auto name : {CPP_CALL_ATTR_NAME, SRET_ARG_ATTR_NAME})
+        {
+            if (auto attr = op->getAttr(name))
+            {
+                callAttrs.push_back(NamedAttribute(StringAttr::get(op->getContext(), name), attr));
+            }
+        }
+
+        return callAttrs;
+    }
 };
 
 struct ThrowOpLowering : public TsPattern<mlir_ts::ThrowOp>
diff --git a/tslang/lib/TypeScript/LowerToLLVM.cpp b/tslang/lib/TypeScript/LowerToLLVM.cpp
index 4802704f0..a0404317f 100644
--- a/tslang/lib/TypeScript/LowerToLLVM.cpp
+++ b/tslang/lib/TypeScript/LowerToLLVM.cpp
@@ -2130,6 +2130,65 @@ struct SymbolCallInternalOpLowering : public TsLlvmPattern<mlir_ts::SymbolCallIn
     }
 };
 
+// The argument attributes of a call of a C++ method (a @cppvtable class's), from the ts call's
+// `args` (its operands after the callee):
+// - CPP_CALL_ATTR_NAME: an integer argument narrower than 32 bits, a boolean too, is `zeroext`
+//   (`signext` if signed), as a C++ caller extends it: clang's code relies on it, and tslang's
+//   otherwise leaves the register's upper bits undefined;
+// - SRET_ARG_ATTR_NAME: the hidden pointer the method returns a record through (the Itanium ABI)
+//   is `sret`, so the target passes it where the ABI does: RDI on x86-64, as the first argument
+//   anyway, but X8 on AArch64.
+template <typename LLVMCallOp>
+static void setCallABIArgAttrs(Operation *tsOp, LLVMCallOp llvmOp, mlir::ValueRange args, TypeConverterHelper &tch)
+{
+    auto sretArg = tsOp->getAttrOfType<mlir::IntegerAttr>(SRET_ARG_ATTR_NAME);
+    auto cppCall = tsOp->hasAttr(CPP_CALL_ATTR_NAME);
+    if (!sretArg && !cppCall)
+    {
+        return;
+    }
+
+    auto *context = tsOp->getContext();
+    auto name = [&](StringRef attrName) { return mlir::StringAttr::get(context, attrName); };
+    SmallVector<mlir::Attribute> argAttrs;
+    auto any = false;
+    for (auto [index, arg] : llvm::enumerate(args))
+    {
+        SmallVector<mlir::NamedAttribute> attrs;
+        auto type = arg.getType();
+        if (sretArg && sretArg.getInt() == static_cast<int64_t>(index))
+        {
+            if (auto refType = dyn_cast<mlir_ts::RefType>(type))
+            {
+                attrs.push_back(mlir::NamedAttribute(name(LLVM::LLVMDialect::getStructRetAttrName()),
+                                                     mlir::TypeAttr::get(tch.convertType(refType.getElementType()))));
+            }
+        }
+
+        if (cppCall)
+        {
+            if (isa<mlir_ts::BooleanType>(type))
+            {
+                attrs.push_back(mlir::NamedAttribute(name(LLVM::LLVMDialect::getZExtAttrName()), mlir::UnitAttr::get(context)));
+            }
+            else if (auto intType = dyn_cast<mlir::IntegerType>(type); intType && intType.getWidth() < 32)
+            {
+                attrs.push_back(mlir::NamedAttribute(
+                    name(intType.isSigned() ? LLVM::LLVMDialect::getSExtAttrName() : LLVM::LLVMDialect::getZExtAttrName()),
+                    mlir::UnitAttr::get(context)));
+            }
+        }
+
+        any |= !attrs.empty();
+        argAttrs.push_back(mlir::DictionaryAttr::get(context, attrs));
+    }
+
+    if (any)
+    {
+        llvmOp.setArgAttrsAttr(mlir::ArrayAttr::get(context, argAttrs));
+    }
+}
+
 struct CallInternalOpLowering : public TsLlvmPattern<mlir_ts::CallInternalOp>
 {
     using TsLlvmPattern<mlir_ts::CallInternalOp>::TsLlvmPattern;
@@ -2169,6 +2228,8 @@ struct CallInternalOpLowering : public TsLlvmPattern<mlir_ts::CallInternalOp>
         // generic (TypeRange, ValueRange) builder above does not set it.
         callRes.getProperties().setOperandSegmentSizes({static_cast<int32_t>(transformed.getOperands().size()), 0});
         callRes.setOpBundleSizes({});
+        // the arguments follow the callee pointer, operand #0
+        setCallABIArgAttrs(op, callRes, op.getOperands().drop_front(), tch);
 
         auto returns = callRes.getResults();
         if (returns.size() > 0)
@@ -2326,11 +2387,13 @@ struct InvokeOpLowering : public TsLlvmPattern<mlir_ts::InvokeOp>
         }
         else
         {
-            rewriter.replaceOpWithNewOp<LLVM::InvokeOp>(op, llvmTypes, mlir::FlatSymbolRefAttr(), transformed.getOperands(),
+            auto invokeOp = rewriter.replaceOpWithNewOp<LLVM::InvokeOp>(op, llvmTypes, mlir::FlatSymbolRefAttr(), transformed.getOperands(),
                 op.getNormalDest(), transformed.getNormalDestOperands(), op.getUnwindDest(),
                 transformed.getUnwindDestOperands());
+            // an indirect call: the arguments follow the callee pointer, call operand #0
+            setCallABIArgAttrs(op, invokeOp, op.getCallOperands().drop_front(), tch);
         }
-        
+
         return success();
     }
 };
diff --git a/tslang/lib/TypeScript/MLIRGenAccessCall.cpp b/tslang/lib/TypeScript/MLIRGenAccessCall.cpp
index 52631faf9..c9fe08041 100644
--- a/tslang/lib/TypeScript/MLIRGenAccessCall.cpp
+++ b/tslang/lib/TypeScript/MLIRGenAccessCall.cpp
@@ -1752,6 +1752,14 @@ namespace mlirgen
                 auto thisValue = builder.create<mlir_ts::GetThisOp>(location, calledFuncType.getInput(0), funcRefValue);
                 auto unboundFuncRefValue = builder.create<mlir_ts::GetMethodOp>(location, calledFuncType, funcRefValue);
 
+                // a C++ method's narrow integer arguments are extended as C++ callers extend them
+                // (LowerToLLVM)
+                SmallVector<mlir::NamedAttribute> callAttrs;
+                if (isCppVTableMethod(funcRefValue))
+                {
+                    callAttrs.push_back(builder.getNamedAttr(CPP_CALL_ATTR_NAME, builder.getUnitAttr()));
+                }
+
                 // a @cppvtable method returning a record (mlirGenClassCppVTableHiddenReturn): it
                 // writes it to a local, passed after `this`, which is the call's value
                 if (auto resultType = cppVTableHiddenReturnType(funcRefValue))
@@ -1761,8 +1769,31 @@ namespace mlirgen
                                                                          builder.getIndexAttr(0));
                     SmallVector<mlir::Value, 4> slotOperands;
                     slotOperands.push_back(resultSlot);
-                    slotOperands.append(operands.begin(), operands.end());
-                    auto callResult = mlirGenCallFunction(location, calledFuncType, unboundFuncRefValue, thisValue, slotOperands, genContext);
+                    ValueOrLogicalResult callResult(mlir::failure());
+                    if (cppVTableHiddenReturnBeforeThis(funcRefValue))
+                    {
+                        // the Itanium ABI: the slot is called as (Ref<T>, this, args...), the pointer
+                        // `sret`, which the target passes where the ABI does - RDI on x86-64, as the
+                        // first argument would be, but X8 on AArch64
+                        SmallVector<mlir::Type> inputs;
+                        inputs.push_back(calledFuncType.getInput(1));
+                        inputs.push_back(calledFuncType.getInput(0));
+                        inputs.append(calledFuncType.getInputs().begin() + 2, calledFuncType.getInputs().end());
+                        auto swappedFuncType = getFunctionType(inputs, calledFuncType.getResults(), calledFuncType.isVarArg());
+                        auto swappedFuncRefValue = builder.create<mlir_ts::GetMethodOp>(location, swappedFuncType, funcRefValue);
+                        slotOperands.push_back(thisValue);
+                        slotOperands.append(operands.begin(), operands.end());
+                        callAttrs.push_back(builder.getNamedAttr(SRET_ARG_ATTR_NAME, builder.getI32IntegerAttr(0)));
+                        callResult = mlirGenCallFunction(location, swappedFuncType, swappedFuncRefValue, slotOperands, genContext,
+                                                         callAttrs);
+                    }
+                    else
+                    {
+                        slotOperands.append(operands.begin(), operands.end());
+                        callResult = mlirGenCallFunction(location, calledFuncType, unboundFuncRefValue, thisValue, slotOperands, genContext,
+                                                         callAttrs);
+                    }
+
                     if (mlir::failed(callResult))
                     {
                         value = mlir::failure();
@@ -1773,7 +1804,7 @@ namespace mlirgen
                     return;
                 }
 
-                value = mlirGenCallFunction(location, calledFuncType, unboundFuncRefValue, thisValue, operands, genContext);
+                value = mlirGenCallFunction(location, calledFuncType, unboundFuncRefValue, thisValue, operands, genContext, callAttrs);
             })
             .Case<mlir_ts::ExtensionFunctionType>([&](auto calledExtentFuncType) {
                 auto calledFuncType =
diff --git a/tslang/lib/TypeScript/MLIRGenClasses.cpp b/tslang/lib/TypeScript/MLIRGenClasses.cpp
index 621982dd6..1ab5b346d 100644
--- a/tslang/lib/TypeScript/MLIRGenClasses.cpp
+++ b/tslang/lib/TypeScript/MLIRGenClasses.cpp
@@ -376,14 +376,30 @@ namespace mlirgen
     // called as (this, Ref<T>, args...) -> Ref<T>, the type kept in the MethodInfo, and a call
     // (mlirGenCall) passes a local of T and reads it back. The declared type stays for
     // DeclarationPrinter, so an importer lowers it again.
+    //
+    // The Itanium ABI on x86-64 and AArch64 (clang's ItaniumCXXABI::classifyReturnType, then the
+    // SysV or AAPCS64 classification) passes the pointer before `this`, for a record with a
+    // destructor or a copy constructor - nonTrivial, the method's @cppnontrivial, as a tuple can't
+    // say so - and the call swaps the two and marks the pointer `sret` (X8 on AArch64). A trivial
+    // record of one or two 8-byte integer or pointer fields comes back in RAX:RDX / X0:X1, as tslang
+    // returns such a tuple, so the method keeps its declared type; other trivial records are packed
+    // into registers or returned in memory, which isn't done here.
     mlir::LogicalResult MLIRGenImpl::mlirGenClassCppVTableHiddenReturn(mlir::Location location, ClassInfo::TypePtr newClassPtr,
-                                                          StringRef funcName)
+                                                          StringRef funcName, bool nonTrivial)
     {
         if (!newClassPtr->isCppVTable)
         {
+            if (nonTrivial)
+            {
+                emitError(location) << "@" CPP_NON_TRIVIAL " is for a method of a @" CPP_VTABLE " class returning a struct";
+                return mlir::failure();
+            }
+
             return mlir::success();
         }
 
+        cppVTableMethods.insert(funcName);
+
         auto method = llvm::find_if(newClassPtr->methods, [&](auto &method) { return method.funcName == funcName; });
         if (method == newClassPtr->methods.end() || method->declaredFuncType)
         {
@@ -393,17 +409,43 @@ namespace mlirgen
         auto funcType = method->funcType;
         if (funcType.getNumResults() != 1 || !isa<mlir_ts::TupleType>(funcType.getResult(0)) || funcType.getNumInputs() < 1)
         {
+            if (nonTrivial)
+            {
+                emitError(location) << "@" CPP_NON_TRIVIAL " is for a method of a @" CPP_VTABLE " class returning a struct";
+                return mlir::failure();
+            }
+
             return mlir::success();
         }
 
-        if (!compileOptions.targetInfo.hiddenReturnPointerAfterThis)
+        auto resultType = funcType.getResult(0);
+        auto &targetInfo = compileOptions.targetInfo;
+        auto beforeThis = false;
+        method->cppNonTrivialReturn = nonTrivial;
+        if (targetInfo.hiddenReturnPointerBeforeThis)
+        {
+            if (!nonTrivial)
+            {
+                if (isCppRecordReturnedInIntegerRegisters(mlir::cast<mlir_ts::TupleType>(resultType)))
+                {
+                    return mlir::success();
+                }
+
+                emitError(location) << "on this target a method of a @" CPP_VTABLE " class returns a struct in registers by its fields, "
+                                    << "which is supported for one or two 8-byte integer or pointer fields; one with a destructor or a "
+                                    << "copy constructor is returned through a pointer: mark the method @" CPP_NON_TRIVIAL;
+                return mlir::failure();
+            }
+
+            beforeThis = true;
+        }
+        else if (!targetInfo.hiddenReturnPointerAfterThis)
         {
-            emitError(location) << "a method of a @" CPP_VTABLE " class returning a struct needs the MSVC ABI, which returns it "
-                                << "through a pointer after 'this'";
+            emitError(location) << "a method of a @" CPP_VTABLE " class returning a struct needs the MSVC ABI, or the Itanium ABI on "
+                                << "x86-64 or AArch64, which return it through a pointer next to 'this'";
             return mlir::failure();
         }
 
-        auto resultType = funcType.getResult(0);
         auto resultRefType = mlir_ts::RefType::get(resultType);
         SmallVector<mlir::Type> inputs;
         inputs.push_back(funcType.getInput(0));
@@ -413,9 +455,48 @@ namespace mlirgen
         method->declaredFuncType = funcType;
         method->funcType = getFunctionType(inputs, {resultRefType}, funcType.isVarArg());
         cppVTableHiddenReturns[funcName] = resultType;
+        if (beforeThis)
+        {
+            cppVTableHiddenReturnsBeforeThis.insert(funcName);
+        }
+
         return mlir::success();
     }
 
+    // The SysV (AAPCS64) classification of a trivial C++ record, as far as tslang returns a tuple the
+    // same way: one or two eightbytes of class INTEGER, each a whole field (an LLVM struct of i64s
+    // and pointers comes back in RAX:RDX / X0:X1; smaller fields would be packed into one register).
+    bool MLIRGenImpl::isCppRecordReturnedInIntegerRegisters(mlir_ts::TupleType recordType)
+    {
+        auto fields = recordType.getFields();
+        if (fields.empty() || fields.size() > 2)
+        {
+            return false;
+        }
+
+        auto isEightbyteInteger = [&](mlir::Type type) {
+            if (auto intType = dyn_cast<mlir::IntegerType>(type))
+            {
+                return intType.getWidth() == 64;
+            }
+
+            return isa<mlir_ts::OpaqueType, mlir_ts::ClassType, mlir_ts::RefType, mlir::IndexType>(type);
+        };
+
+        return llvm::all_of(fields, [&](auto &field) {
+            auto type = field.type;
+            // Opaque | null: a pointer that may be null
+            if (auto unionType = dyn_cast<mlir_ts::UnionType>(type))
+            {
+                return llvm::all_of(unionType.getTypes(), [&](mlir::Type member) {
+                    return isa<mlir_ts::NullType>(member) || isEightbyteInteger(member);
+                });
+            }
+
+            return isEightbyteInteger(type);
+        });
+    }
+
     // A @cppvtable class only names the slots of a vtable made by C++, so everything that would add
     // a slot, a field initializer or code of its own is an error, and so is a hierarchy mixing it
     // with ordinary classes: a slot number off by one calls the wrong C++ method, with no error.
@@ -2449,7 +2530,8 @@ genContext);
             classMethodMemberInfo.setFuncOp(funcOp);
             if (classMethodMemberInfo.registerClassMethodMember(loc(funcLikeDeclaration), orderWeight, accessLevel))
             {
-                if (mlir::failed(mlirGenClassCppVTableHiddenReturn(loc(funcLikeDeclaration), newClassPtr, funcOp.getName())))
+                if (mlir::failed(mlirGenClassCppVTableHiddenReturn(loc(funcLikeDeclaration), newClassPtr, funcOp.getName(),
+                                                                   MLIRHelper::hasDecorator(funcLikeDeclaration, CPP_NON_TRIVIAL))))
                 {
                     return mlir::failure();
                 }
diff --git a/tslang/lib/TypeScript/MLIRGenImpl.h b/tslang/lib/TypeScript/MLIRGenImpl.h
index 45d2168f3..98f2c9a82 100644
--- a/tslang/lib/TypeScript/MLIRGenImpl.h
+++ b/tslang/lib/TypeScript/MLIRGenImpl.h
@@ -5352,6 +5352,28 @@ class MLIRGenImpl
         return mlir::Type();
     }
 
+    // Whether that hidden pointer goes before `this` (the Itanium ABI), not after it (MSVC's)
+    bool cppVTableHiddenReturnBeforeThis(mlir::Value funcRef)
+    {
+        if (auto virtualSymbolRef = funcRef.getDefiningOp<mlir_ts::ThisVirtualSymbolRefOp>())
+        {
+            return cppVTableHiddenReturnsBeforeThis.contains(virtualSymbolRef.getIdentifier());
+        }
+
+        return false;
+    }
+
+    // Whether a call of funcRef calls a C++ method: a method of a @cppvtable class
+    bool isCppVTableMethod(mlir::Value funcRef)
+    {
+        if (auto virtualSymbolRef = funcRef.getDefiningOp<mlir_ts::ThisVirtualSymbolRefOp>())
+        {
+            return cppVTableMethods.contains(virtualSymbolRef.getIdentifier());
+        }
+
+        return false;
+    }
+
     // A @cppvtable class's objects are C++ objects: their slot 0 is a C++ method (the destructor),
     // not `.instanceOf`, and the class has no RTTI, so nothing may ask one what it is - not
     // `instanceof`, nor boxing into `any` (unboxed by asking), nor an interface (made by asking).
@@ -8306,15 +8328,17 @@ class MLIRGenImpl
 
     template <typename T = mlir_ts::FunctionType>
     ValueOrLogicalResult mlirGenCallFunction(mlir::Location location, T calledFuncType, mlir::Value funcRefValue,
-                                             SmallVector<mlir::Value, 4> &operands, const GenContext &genContext)
+                                             SmallVector<mlir::Value, 4> &operands, const GenContext &genContext,
+                                             ArrayRef<mlir::NamedAttribute> callAttrs = {})
     {
-        return mlirGenCallFunction(location, calledFuncType, funcRefValue, mlir::Value(), operands, genContext);
+        return mlirGenCallFunction(location, calledFuncType, funcRefValue, mlir::Value(), operands, genContext, callAttrs);
     }
 
+    // `callAttrs` go on the call (CallIndirectOp): CPP_CALL_ATTR_NAME, SRET_ARG_ATTR_NAME
     template <typename T = mlir_ts::FunctionType>
     ValueOrLogicalResult mlirGenCallFunction(mlir::Location location, T calledFuncType, mlir::Value funcRefValue,
                                              mlir::Value thisValue, SmallVector<mlir::Value, 4> &operands,
-                                             const GenContext &genContext)
+                                             const GenContext &genContext, ArrayRef<mlir::NamedAttribute> callAttrs = {})
     {
         // `thisValue` is the one operand a call gets that the user did not write: the object of
         // a method or constructor call (a bound function), the capture of a closure (also a
@@ -8389,6 +8413,10 @@ class MLIRGenImpl
             auto callIndirectOp = builder.create<mlir_ts::CallIndirectOp>(
                 MLIRHelper::getCallSiteLocation(funcRefValue, location),
                 funcRefValue, operands);
+            for (auto callAttr : callAttrs)
+            {
+                callIndirectOp->setAttr(callAttr.getName(), callAttr.getValue());
+            }
 
             if (calledFuncType.getResults().size() > 0)
             {
@@ -11219,7 +11247,9 @@ class MLIRGenImpl
     }
 
     mlir::LogicalResult mlirGenClassCppVTableHiddenReturn(mlir::Location location, ClassInfo::TypePtr newClassPtr,
-                                                          StringRef funcName);
+                                                          StringRef funcName, bool nonTrivial);
+
+    bool isCppRecordReturnedInIntegerRegisters(mlir_ts::TupleType recordType);
 
     mlir::LogicalResult mlirGenClassCppVTableCheck(mlir::Location location,
                                                    ClassLikeDeclaration classDeclarationAST,
@@ -14091,6 +14121,10 @@ class MLIRGenImpl
 
     // the @cppvtable methods returning a C++ record (by function name): the record's type
     llvm::StringMap<mlir::Type> cppVTableHiddenReturns;
+    // those of them whose hidden pointer goes before `this` (the Itanium ABI)
+    llvm::StringSet<> cppVTableHiddenReturnsBeforeThis;
+    // the methods of @cppvtable classes (by function name), C++ methods
+    llvm::StringSet<> cppVTableMethods;
 
     llvm::ScopedHashTable<StringRef, GenericClassInfo::TypePtr> fullNameGenericClassesMap;
 
diff --git a/tslang/test/tester/CMakeLists.txt b/tslang/test/tester/CMakeLists.txt
index 82eee4173..34fbb5f9d 100644
--- a/tslang/test/tester/CMakeLists.txt
+++ b/tslang/test/tester/CMakeLists.txt
@@ -2751,9 +2751,9 @@ add_test(NAME test-compile-cppvtable-memory-model-none
 set_tests_properties(test-compile-cppvtable-memory-model-none
                      PROPERTIES FAIL_REGULAR_EXPRESSION "error:|Stack dump|Assertion failed")
 
-# A method returning a record (tests/00cppvtable_hidden_return.ts) is MSVC's: the Itanium ABI
-# returns a record through a pointer before `this`, and only some records, so it is an error
-# anywhere else and its tests run on Windows only.
+# A method returning a record: tests/00cppvtable_hidden_return.ts's slots, made by hand, return it as
+# MSVC does, through a pointer after `this`, so they run on Windows only; the Itanium ABI's way is
+# tested against C++ below (test-jit-cppvtable-abi).
 if (WIN32)
     tslang_add_test(NAME test-compile-00-cppvtable-hidden-return COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00cppvtable_hidden_return.ts")
     tslang_add_test(NAME test-jit-00-cppvtable-hidden-return COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00cppvtable_hidden_return.ts")
@@ -2761,12 +2761,59 @@ if (WIN32)
     tslang_add_test(NAME test-jit-shared-export-import-cppvtable-hidden-return COMMAND test-runner -jit -shared "${PROJECT_SOURCE_DIR}/test/tester/tests/import_cppvtable_hidden_return.ts" "${PROJECT_SOURCE_DIR}/test/tester/tests/export_cppvtable_hidden_return.ts")
 endif()
 add_test(NAME test-compile-cppvtable-hidden-return-target
-         COMMAND $<TARGET_FILE:tslang> --emit=obj --no-default-lib -mm=none -mtriple=x86_64-unknown-linux-gnu
+         COMMAND $<TARGET_FILE:tslang> --emit=obj --no-default-lib -mm=none -mtriple=i686-unknown-linux-gnu
                  "${PROJECT_SOURCE_DIR}/test/tester/cppvtable/hidden_return_target.ts"
                  -o "${CMAKE_CURRENT_BINARY_DIR}/cppvtable-hidden-return-target.obj")
 set_tests_properties(test-compile-cppvtable-hidden-return-target
-                     PROPERTIES PASS_REGULAR_EXPRESSION "hidden_return_target\\.ts:7:5: error: a method of a @cppvtable class returning a struct needs the MSVC ABI"
+                     PROPERTIES PASS_REGULAR_EXPRESSION "hidden_return_target\\.ts:7:5: error: a method of a @cppvtable class returning a struct needs the MSVC ABI, or the Itanium ABI on x86-64 or AArch64"
+                                FAIL_REGULAR_EXPRESSION "Stack dump|Assertion failed")
+# x86-64 Itanium: a trivial record tslang can't return as the SysV classification does, unmarked
+add_test(NAME test-compile-cppvtable-itanium-record
+         COMMAND $<TARGET_FILE:tslang> --emit=obj --no-default-lib -mm=none -mtriple=x86_64-unknown-linux-gnu
+                 "${PROJECT_SOURCE_DIR}/test/tester/cppvtable/itanium_record.ts"
+                 -o "${CMAKE_CURRENT_BINARY_DIR}/cppvtable-itanium-record.obj")
+set_tests_properties(test-compile-cppvtable-itanium-record
+                     PROPERTIES PASS_REGULAR_EXPRESSION "itanium_record\\.ts:7:5: error: on this target a method of a @cppvtable class returns a struct in registers by its fields.*mark the method @cppnontrivial"
                                 FAIL_REGULAR_EXPRESSION "Stack dump|Assertion failed")
+add_test(NAME test-compile-cppvtable-nontrivial-no-struct
+         COMMAND $<TARGET_FILE:tslang> --emit=obj --no-default-lib -mm=none
+                 "${PROJECT_SOURCE_DIR}/test/tester/cppvtable/nontrivial_no_struct.ts"
+                 -o "${CMAKE_CURRENT_BINARY_DIR}/cppvtable-nontrivial-no-struct.obj")
+set_tests_properties(test-compile-cppvtable-nontrivial-no-struct
+                     PROPERTIES PASS_REGULAR_EXPRESSION "nontrivial_no_struct\\.ts:[0-9]+:[0-9]+: error: @cppnontrivial is for a method of a @cppvtable class returning a struct"
+                                FAIL_REGULAR_EXPRESSION "Stack dump|Assertion failed")
+
+# The Itanium calls' argument attributes, on any host: the hidden result pointer `sret` (X8 on
+# AArch64), narrow integers extended as a C++ caller extends them (clang's code relies on it)
+foreach(cppvtable_itanium_triple x86_64-unknown-linux-gnu aarch64-unknown-linux-android29)
+    add_test(NAME test-compile-cppvtable-itanium-call-${cppvtable_itanium_triple}
+             COMMAND $<TARGET_FILE:tslang> --emit=llvm --no-default-lib -mm=none -mtriple=${cppvtable_itanium_triple}
+                     "${PROJECT_SOURCE_DIR}/test/tester/cppvtable/abi_itanium.ts" -o -)
+    set_tests_properties(test-compile-cppvtable-itanium-call-${cppvtable_itanium_triple}
+                         PROPERTIES PASS_REGULAR_EXPRESSION "i1 zeroext %[0-9]+, i8 zeroext %[0-9]+, i8 signext %[0-9]+\\).*\\(ptr sret\\(\\{ ptr \\}\\) %[0-9]+, ptr %[0-9]+, i32 3\\)"
+                                    FAIL_REGULAR_EXPRESSION "error:|Stack dump|Assertion failed")
+endforeach()
+
+# A @cppvtable class calling the methods of an object C++ made (cppvtable/abi_host.cpp), built by
+# the host's compiler: its vtable, and the way its methods return records, are that compiler's ABI -
+# MSVC's (abi_msvc.ts), or the Itanium one of g++ and clang on x86-64 and AArch64 (abi_itanium.ts) -
+# not a vtable made by hand in tslang, which follows tslang's own idea of the ABI.
+if (CMAKE_SIZEOF_VOID_P EQUAL 8 AND (MSVC OR (NOT WIN32 AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|amd64|aarch64|arm64)$")))
+    add_library(tslang_cppvtable_abi SHARED cppvtable/abi_host.cpp)
+    if (MSVC)
+        set(cppvtable_abi msvc)
+    else()
+        set(cppvtable_abi itanium)
+    endif()
+    add_test(NAME test-jit-cppvtable-abi
+             COMMAND $<TARGET_FILE:tslang> --emit=jit --no-default-lib -mm=none
+                     --shared-libs=$<TARGET_FILE:TypeScriptRuntime>
+                     --shared-libs=$<TARGET_FILE:tslang_cppvtable_abi>
+                     "${PROJECT_SOURCE_DIR}/test/tester/cppvtable/abi_${cppvtable_abi}.ts")
+    set_tests_properties(test-jit-cppvtable-abi
+                         PROPERTIES PASS_REGULAR_EXPRESSION "done\\."
+                                    FAIL_REGULAR_EXPRESSION "error:|Stack dump|Segmentation|Assertion failed")
+endif()
 
 # MSVC member functions are __thiscall on 32-bit x86, which a class method call isn't.
 add_test(NAME test-compile-cppvtable-thiscall-target
diff --git a/tslang/test/tester/cppvtable/abi_host.cpp b/tslang/test/tester/cppvtable/abi_host.cpp
new file mode 100644
index 000000000..449a01ca9
--- /dev/null
+++ b/tslang/test/tester/cppvtable/abi_host.cpp
@@ -0,0 +1,60 @@
+// A C++ object whose methods a @cppvtable class calls (abi_msvc.ts, abi_itanium.ts): built by the
+// host's C++ compiler, so its vtable and the way its methods return records are that compiler's
+// ABI - MSVC's, or the Itanium one of g++ and clang - not a vtable made by hand in tslang.
+
+#include <cstdint>
+
+#ifdef _WIN32
+#define ABI_EXPORT extern "C" __declspec(dllexport)
+#else
+#define ABI_EXPORT extern "C" __attribute__((visibility("default")))
+#endif
+
+// non-trivial, as nvrhi::RefCountPtr<T>: the Itanium ABI returns it through a pointer before `this`
+struct Ptr
+{
+    void *p;
+    Ptr(void *v) : p(v) {}
+    Ptr(const Ptr &other) : p(other.p) {}
+    ~Ptr() {}
+};
+
+// trivial, 8 bytes, as nvrhi::Object: RAX
+struct Obj
+{
+    void *p;
+};
+
+// trivial, 16 bytes: RAX:RDX
+struct Two
+{
+    uint64_t a;
+    void *b;
+};
+
+static char storage[64];
+
+// MSVC returns every one of these records through a pointer after `this`
+struct Methods
+{
+    virtual ~Methods() {}
+    virtual Ptr make(int x) { return Ptr(&storage[x]); }
+    virtual Obj obj(int x) { return Obj{&storage[x + 1]}; }
+    virtual Two two(int x) { return Two{0x1234567890ull + x, &storage[x + 2]}; }
+    virtual int plain(int a, int b) { return a * b + value; }
+    // narrow arguments: clang's code takes them as extended to 32 bits by the caller
+    virtual int narrow(bool b, uint8_t u, int8_t s) { return (b ? 1000 : 0) + u * 10 + s; }
+    int value = 7;
+};
+
+ABI_EXPORT Methods *abi_object()
+{
+    static Methods methods;
+    return &methods;
+}
+
+// whether p is &storage[index]
+ABI_EXPORT int abi_is_storage(void *p, int index)
+{
+    return p == &storage[index] ? 1 : 0;
+}
diff --git a/tslang/test/tester/cppvtable/abi_itanium.ts b/tslang/test/tester/cppvtable/abi_itanium.ts
new file mode 100644
index 000000000..75e243184
--- /dev/null
+++ b/tslang/test/tester/cppvtable/abi_itanium.ts
@@ -0,0 +1,41 @@
+// The methods of a C++ object made by g++ or clang on x86-64 (abi_host.cpp): two destructor slots;
+// a record with a destructor returned through a pointer before `this` (@cppnontrivial), trivial
+// records of one or two 8-byte fields in RAX:RDX.
+
+type Ptr = [p: Opaque | null];
+type Obj = [p: Opaque | null];
+type Two = [a: u64, b: Opaque | null];
+
+declare function abi_object(): Opaque;
+declare function abi_is_storage(p: Opaque | null, index: s32): s32;
+
+@cppvtable
+class Methods {
+    value: s32;
+    completeDestructor(): void;             // slot 0
+    deletingDestructor(): void;             // slot 1
+    @cppnontrivial
+    make(x: s32): Ptr;                      // slot 2
+    obj(x: s32): Obj;                       // slot 3
+    two(x: s32): Two;                       // slot 4
+    plain(a: s32, b: s32): s32;             // slot 5
+    narrow(b: boolean, u: u8, s: s8): s32;  // slot 6
+}
+
+// arguments made from a wider value: the register's upper bits aren't zero
+function callNarrow(methods: Methods, big: s32): s32 {
+    return methods.narrow(big > 0, <u8>big, <s8>(big - 0x1237));
+}
+
+function main() {
+    const methods = <Methods>abi_object();
+    assert(methods.value == 7, "the first field follows the vtable pointer");
+    assert(abi_is_storage(methods.make(3).p, 3) == 1, "a record with a destructor");
+    assert(abi_is_storage(methods.obj(4).p, 5) == 1, "a trivial 8-byte record");
+    const two = methods.two(7);
+    assert(two.a == 0x1234567890 + 7 && abi_is_storage(two.b, 9) == 1, "a trivial 16-byte record");
+    assert(methods.plain(6, 7) == 49, "a number");
+    assert(callNarrow(methods, 0x1234) == 1000 + 0x34 * 10 - 3, "narrow arguments, extended");
+
+    print("done.");
+}
diff --git a/tslang/test/tester/cppvtable/abi_msvc.ts b/tslang/test/tester/cppvtable/abi_msvc.ts
new file mode 100644
index 000000000..15748be2e
--- /dev/null
+++ b/tslang/test/tester/cppvtable/abi_msvc.ts
@@ -0,0 +1,39 @@
+// The methods of a C++ object made by MSVC (abi_host.cpp): one destructor slot, and every record
+// returned through a pointer after `this`.
+
+type Ptr = [p: Opaque | null];
+type Obj = [p: Opaque | null];
+type Two = [a: u64, b: Opaque | null];
+
+declare function abi_object(): Opaque;
+declare function abi_is_storage(p: Opaque | null, index: s32): s32;
+
+@cppvtable
+class Methods {
+    value: s32;
+    destructor(): void;                     // slot 0: the scalar deleting destructor
+    @cppnontrivial
+    make(x: s32): Ptr;                      // slot 1
+    obj(x: s32): Obj;                       // slot 2
+    two(x: s32): Two;                       // slot 3
+    plain(a: s32, b: s32): s32;             // slot 4
+    narrow(b: boolean, u: u8, s: s8): s32;  // slot 5
+}
+
+// arguments made from a wider value: the register's upper bits aren't zero
+function callNarrow(methods: Methods, big: s32): s32 {
+    return methods.narrow(big > 0, <u8>big, <s8>(big - 0x1237));
+}
+
+function main() {
+    const methods = <Methods>abi_object();
+    assert(methods.value == 7, "the first field follows the vtable pointer");
+    assert(abi_is_storage(methods.make(3).p, 3) == 1, "a record with a destructor");
+    assert(abi_is_storage(methods.obj(4).p, 5) == 1, "a trivial 8-byte record");
+    const two = methods.two(7);
+    assert(two.a == 0x1234567890 + 7 && abi_is_storage(two.b, 9) == 1, "a trivial 16-byte record");
+    assert(methods.plain(6, 7) == 49, "a number");
+    assert(callNarrow(methods, 0x1234) == 1000 + 0x34 * 10 - 3, "narrow arguments, extended");
+
+    print("done.");
+}
diff --git a/tslang/test/tester/cppvtable/hidden_return_target.ts b/tslang/test/tester/cppvtable/hidden_return_target.ts
index b03dc526d..69b79d022 100644
--- a/tslang/test/tester/cppvtable/hidden_return_target.ts
+++ b/tslang/test/tester/cppvtable/hidden_return_target.ts
@@ -1,5 +1,5 @@
-// Compiled for Linux: the Itanium ABI returns a record from a method otherwise than MSVC, through
-// a pointer before `this`, and only some records.
+// Compiled for 32-bit x86 Linux: the Itanium ABI passes the hidden pointer a record is returned
+// through on the stack there, and the callee pops it, which isn't done.
 type Pair = [first: s32, second: s32];
 
 @cppvtable
diff --git a/tslang/test/tester/cppvtable/itanium_record.ts b/tslang/test/tester/cppvtable/itanium_record.ts
new file mode 100644
index 000000000..1c05d1329
--- /dev/null
+++ b/tslang/test/tester/cppvtable/itanium_record.ts
@@ -0,0 +1,12 @@
+// Compiled for x86-64 Linux: a trivial record of two 4-byte fields comes back packed into RAX,
+// which a tuple of them isn't; without @cppnontrivial it is an error, not a wrong call.
+type Pair = [first: s32, second: s32];
+
+@cppvtable
+class Methods {
+    pair(x: s32): Pair;
+}
+
+function main() {
+    print("done.");
+}
diff --git a/tslang/test/tester/cppvtable/nontrivial_no_struct.ts b/tslang/test/tester/cppvtable/nontrivial_no_struct.ts
new file mode 100644
index 000000000..05d7c0159
--- /dev/null
+++ b/tslang/test/tester/cppvtable/nontrivial_no_struct.ts
@@ -0,0 +1,11 @@
+// @cppnontrivial says how a returned C++ record is returned: on a method returning a number it is
+// a mistake.
+@cppvtable
+class Methods {
+    @cppnontrivial
+    count(): s32;
+}
+
+function main() {
+    print("done.");
+}
diff --git a/tslang/test/tester/tests/export_cppvtable_hidden_return.ts b/tslang/test/tester/tests/export_cppvtable_hidden_return.ts
index e65119d3a..ec0dfc66e 100644
--- a/tslang/test/tester/tests/export_cppvtable_hidden_return.ts
+++ b/tslang/test/tester/tests/export_cppvtable_hidden_return.ts
@@ -2,7 +2,8 @@ namespace M {
 
     // A @cppvtable method returning a record (00cppvtable_hidden_return.ts), exported from one
     // module and called from another: the declaration embedded in the binary (__decls) keeps the
-    // declared tuple, so the importer passes the hidden result pointer too. MSVC only.
+    // declared tuple, and @cppnontrivial, so the importer passes the hidden result pointer too.
+    // MSVC only (it ignores @cppnontrivial, which the Itanium ABI needs).
 
     export type Pair = [first: s32, second: s32];
 
@@ -14,6 +15,7 @@ namespace M {
 
     @cppvtable
     export class Derived extends Base {
+        @cppnontrivial
         pair(x: s32): Pair;  // slot 1: a record, returned through a pointer after `this`
     }