Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
52 changes: 52 additions & 0 deletions tslang/lib/TypeScript/OwnershipInferenceEdgeReleases.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -512,6 +512,58 @@ namespace own_inference
}

edgeReleases.clear();

for (auto &clear : slotClears)
{
mlir::OpBuilder builder(clear.after->getContext());
builder.setInsertionPointAfter(clear.after);
auto loc = clear.after->getLoc();
auto elementType = mlir::cast<mlir_ts::RefType>(clear.slot.getType()).getElementType();
auto empty = builder.create<mlir_ts::DefaultOp>(loc, elementType);
builder.create<mlir_ts::StoreOp>(loc, empty, clear.slot);
}

slotClears.clear();
}

mlir::Operation *OwnershipInferencePass::clearsOnUnwind(mlir_ts::VariableOp varOp, mlir_ts::LoadOp load,
mlir::Operation *acquire, mlir::Operation *taker,
mlir::Operation *release,
const llvm::SmallPtrSet<mlir::Block *, 8> &handler)
{
// a hoisted owned local: no initializer, so VariableOpLowering starts it as null
auto &body = getFunction().getFunctionBody();
if (!varOp || !varOp->hasAttr(OWNED_LOCAL_ATTR_NAME) || varOp.getInitializer() ||
varOp.getCaptured().value_or(false) || varOp->getParentRegion() != &body)
{
return nullptr;
}

if (!handler.contains(release->getBlock()))
{
return nullptr;
}

// the read, the taker and rc's retain in one block of the body, with nothing between that
// could unwind with the value read but not yet taken: a call that takes it may throw having
// taken it or not
auto *block = load->getBlock();
if (block->getParent() != &body || taker->getBlock() != block || acquire->getBlock() != block ||
handler.contains(block) || !load->isBeforeInBlock(taker) || isCall(taker))
{
return nullptr;
}

auto *last = taker->isBeforeInBlock(acquire) ? acquire : taker;
for (auto *op = load->getNextNode(); op && op != last->getNextNode(); op = op->getNextNode())
{
if (isCall(op) || op->hasTrait<mlir::OpTrait::IsTerminator>())
{
return nullptr;
}
}

return last;
}

llvm::SmallVector<mlir::Operation *> OwnershipInferencePass::slotAssignments(mlir::Value slot)
Expand Down
24 changes: 24 additions & 0 deletions tslang/lib/TypeScript/OwnershipInferenceMoves.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -1376,6 +1376,8 @@ namespace own_inference

auto *acquire = mlir::isa<mlir_ts::RetainSlotOp>(retain) ? taker : retain;
llvm::SmallVector<mlir::Operation *> moved;
mlir::Operation *clearAfter = nullptr;
std::optional<llvm::SmallPtrSet<mlir::Block *, 8>> handler;
for (auto *use : slot.getUsers())
{
if (!mlir::isa<mlir_ts::ReleaseSlotOp>(use) || !reachableAfter(acquire, use, kills))
Expand All @@ -1400,6 +1402,23 @@ namespace own_inference

if (someMoved)
{
// ...the scope's release on the unwind leg, reached from before the move and after
// it: the slot is emptied at the move, and the release stays for the paths that
// did not move it
if (placeReleases)
{
if (!handler)
{
handler = handlerBlocks();
}

if (auto *after = clearsOnUnwind(varOp, load, acquire, taker, use, *handler))
{
clearAfter = after;
continue;
}
}

// ...but the paths that did not move it can release it before they join the
// others (spec 30)
if (placeReleases && placeOnUnmovedEdges(varOp, acquire, retain, taker, assignments, toErase))
Expand All @@ -1414,6 +1433,11 @@ namespace own_inference
moved.push_back(use);
}

if (clearAfter)
{
slotClears.push_back({slot, clearAfter});
}

toErase.insert(moved.begin(), moved.end());
return true;
}
Expand Down
1 change: 1 addition & 0 deletions tslang/lib/TypeScript/OwnershipInferencePass.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -375,6 +375,7 @@ namespace own_inference
auto f = getFunction();
drops.clear();
edgeReleases.clear();
slotClears.clear();
derivedCache.clear();
closures.clear();
literalBoxes.clear();
Expand Down
23 changes: 22 additions & 1 deletion tslang/lib/TypeScript/OwnershipInferencePass.h
Original file line number Diff line number Diff line change
Expand Up @@ -1223,9 +1223,30 @@ class OwnershipInferencePass
const llvm::SetVector<mlir::Block *> &releasedInto);

// Puts in the releases placeOnUnmovedEdges decided: at the end of a block that goes only to the
// join, else in a block of its own on the edge.
// join, else in a block of its own on the edge - and the clears clearsOnUnwind decided.
void placeEdgeReleases();

// A slot emptied right after the move out of it, put in after the analysis (clearsOnUnwind).
struct SlotClear
{
mlir::Value slot;
mlir::Operation *after;
};

llvm::SmallVector<SlotClear> slotClears;

// The move out of `varOp` at `taker` (rc's retain at `acquire`) reaches `release`, in an exception
// handler, on some paths only: the scope's release on the unwind leg of a block wrapped in a TryOp
// - an explicit `try`, or on Itanium any block with a typed `catch` - is reached from before the
// move and after it. No release can go on an unwind edge, but the slot of a hoisted owned local
// starts null and a release of null does nothing, so emptying the slot right after the move
// leaves the handler's release with the value only on the paths that did not move it. The op to
// put the clear after, or null when the slot is not such a local or the move could unwind
// part-way (a call taking the value, or one between the read and the taker).
mlir::Operation *clearsOnUnwind(mlir_ts::VariableOp varOp, mlir_ts::LoadOp load, mlir::Operation *acquire,
mlir::Operation *taker, mlir::Operation *release,
const llvm::SmallPtrSet<mlir::Block *, 8> &handler);

// The stores of the assignments to an owning local: rc releases what the slot holds right
// before it stores the new value (an assignment, and a `var` declaration met again).
static llvm::SmallVector<mlir::Operation *> slotAssignments(mlir::Value slot);
Expand Down
16 changes: 16 additions & 0 deletions tslang/test/tester/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -925,6 +925,8 @@ tslang_add_test(NAME test-compile-own-00-generic-literal-inference COMMAND test-
tslang_add_test(NAME test-compile-own-00-new-alias-and-ctor-overloads COMMAND test-runner -mm=own "${PROJECT_SOURCE_DIR}/test/tester/tests/00new_alias_and_ctor_overloads.ts")
tslang_add_test(NAME test-compile-00-own-throw-param-await-borrow COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00own_throw_param_await_borrow.ts")
tslang_add_test(NAME test-compile-own-00-own-throw-param-await-borrow COMMAND test-runner -mm=own "${PROJECT_SOURCE_DIR}/test/tester/tests/00own_throw_param_await_borrow.ts")
tslang_add_test(NAME test-compile-00-own-move-in-unwound-scope COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00own_move_in_unwound_scope.ts")
tslang_add_test(NAME test-compile-own-00-own-move-in-unwound-scope COMMAND test-runner -mm=own "${PROJECT_SOURCE_DIR}/test/tester/tests/00own_move_in_unwound_scope.ts")
tslang_add_test(NAME test-compile-load-store-decorators COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/load_store_decorators.ts")
tslang_add_test(NAME test-compile-reference-null-bug COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00reference_null_bug.ts")
tslang_add_test(NAME test-compile-reference-index-bug COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00reference_index_bug.ts")
Expand Down Expand Up @@ -1578,6 +1580,19 @@ tslang_add_test(NAME test-jit-own-00-generic-literal-inference COMMAND test-runn
tslang_add_test(NAME test-jit-own-00-new-alias-and-ctor-overloads COMMAND test-runner -jit -mm=own "${PROJECT_SOURCE_DIR}/test/tester/tests/00new_alias_and_ctor_overloads.ts")
tslang_add_test(NAME test-jit-00-own-throw-param-await-borrow COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00own_throw_param_await_borrow.ts")
tslang_add_test(NAME test-jit-own-00-own-throw-param-await-borrow COMMAND test-runner -jit -mm=own "${PROJECT_SOURCE_DIR}/test/tester/tests/00own_throw_param_await_borrow.ts")
tslang_add_test(NAME test-jit-00-own-move-in-unwound-scope COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00own_move_in_unwound_scope.ts")
tslang_add_test(NAME test-jit-own-00-own-move-in-unwound-scope COMMAND test-runner -jit -mm=own "${PROJECT_SOURCE_DIR}/test/tester/tests/00own_move_in_unwound_scope.ts")
# On Itanium a function body with a typed `catch` is wrapped in a TryOp for its cleanup, so a move at
# its top level meets the unwind leg's release there too: checked on every host, for both triples
foreach(own_unwind_triple x86_64-pc-windows-msvc x86_64-unknown-linux-gnu)
add_test(NAME test-compile-own-move-in-unwound-scope-${own_unwind_triple}
COMMAND $<TARGET_FILE:tslang> --emit=llvm -mm=own -mtriple=${own_unwind_triple}
"${PROJECT_SOURCE_DIR}/test/tester/tests/00own_move_in_unwound_scope.ts" -o -)
set_tests_properties(test-compile-own-move-in-unwound-scope-${own_unwind_triple}
PROPERTIES PASS_REGULAR_EXPRESSION "define [^
]*@main"
FAIL_REGULAR_EXPRESSION "error:|Stack dump|Assertion failed")
endforeach()
tslang_add_test(NAME test-jit-load-store-decorators COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/load_store_decorators.ts")
tslang_add_test(NAME test-jit-reference-null-bug COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00reference_null_bug.ts")
tslang_add_test(NAME test-jit-reference-index-bug COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00reference_index_bug.ts")
Expand Down Expand Up @@ -2173,6 +2188,7 @@ set(TSLANG_CORPUS
00generic_literal_inference.ts
00new_alias_and_ctor_overloads.ts
00own_throw_param_await_borrow.ts
00own_move_in_unwound_scope.ts
00any_truthiness_objects.ts
00add_promotes_both_operands.ts
00conditional_owned_result.ts
Expand Down
142 changes: 142 additions & 0 deletions tslang/test/tester/tests/00own_move_in_unwound_scope.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,142 @@
// -mm=own: a local moved to another inside a block whose scope is also released on the unwind leg -
// a `try` body, or on Itanium (Linux) a function body that holds a typed `catch` - was "moved here on
// some paths only": the unwind leg's release is reached from before the move and after it. The
// moved-from slot is emptied at the move, so that release frees the value only if the move has not
// run. Each case runs many times so a double free or a use of a freed block shows.

class E {
constructor(public m: string) {}
}

function make(n: int): int[] {
return [n, n + 1];
}

function check(a: int[], fail: boolean): int {
if (fail) {
throw new E("check");
}

return a.length;
}

async function twice(n: int): Promise<int> {
return n * 2;
}

async function pair(n: int): Promise<int[]> {
return [n, n * 2];
}

// Promise.all's shape: the values, already settled
function all(values: int[]): int[] {
const settled: int[] = [];
for (const value of values) {
settled.push(value);
}

return settled;
}

// the move in a `try` body; the throw before it, or after it, unwinds through the body's scope
function inTry(failBefore: boolean, failAfter: boolean): int {
let n = 0;
try {
const a = make(1);
check(a, failBefore);
const b = a;
n = check(b, failAfter);
} catch (e: E) {
n = -1;
}

return n;
}

// the move and a typed catch in one function body: on Itanium the body is wrapped for its cleanup
function besideCatch(fail: boolean): int {
const first = make(1);
const a = make(2);
const b = a;
let caught = false;
try {
const none: int[] = [];
check(none, fail);
} catch (e: E) {
caught = true;
}

return first.length + b.length + (caught ? 10 : 0);
}

// an awaited value moved out of the await's slot, beside a typed catch
function awaitBesideCatch(fail: boolean): int {
const first = make(1);
const awaited = await pair(3);
let caught = false;
try {
check(first, fail);
} catch (e: E) {
caught = true;
}

return awaited[0] + awaited[1] + (caught ? 100 : 0);
}

// the shape from DefaultLib's promise test: an array literal of async calls, awaited
function awaitAllBesideCatch(fail: boolean): int {
const both = [twice(2), twice(5)];
const awaited = await all([twice(3), twice(4)]);
let caught = false;
try {
const none: int[] = [];
check(none, fail);
} catch (e: E) {
caught = true;
}

return both[0] + awaited[0] + awaited[1] + (caught ? 100 : 0);
}

// the unwind leaves the function: its own scope's release on the way out, after the move
function moveThenThrow(): int {
const a = make(4);
const b = a;
let caught = false;
try {
check(b, false);
} catch (e: E) {
caught = true;
}

check(b, true);
return caught ? 1 : 0;
}

function main() {
for (let i = 0; i < 1000; i++) {
assert(inTry(false, false) == 2, "in try, no throw");
assert(inTry(true, false) == -1, "in try, thrown before the move");
assert(inTry(false, true) == -1, "in try, thrown after the move");

assert(besideCatch(false) == 4, "beside a catch");
assert(besideCatch(true) == 14, "beside a catch, caught");

assert(awaitBesideCatch(false) == 9, "an await beside a catch");
assert(awaitBesideCatch(true) == 109, "an await beside a catch, caught");

assert(awaitAllBesideCatch(false) == 18, "an awaited array of async calls beside a catch");
assert(awaitAllBesideCatch(true) == 118, "an awaited array of async calls beside a catch, caught");

let caught = "";
try {
moveThenThrow();
} catch (e: E) {
caught = e.m;
}

assert(caught == "check", "moved, then thrown out of the function");
}

print("done.");
}
Loading