carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-05 21:11:27 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

improved checking for liveness when reading and writing memory (#448)

Browse Source 
* improved checking for liveness when reading and writing memory

* moving some functions to be methods of State

* finished moving functions into State

* Update executable_semantics/interpreter/interpreter.h

Co-authored-by: Geoff Romer <gromer@google.com>

* moved some comments, other minor edits

Co-authored-by: Geoff Romer <gromer@google.com>
This commit is contained in:
Jeremy G. Siek
2021-04-21 14:10:42 -04:00
committed by GitHub
co-authored by Geoff Romer
parent 7e81fb9c62
commit 27fd9de5bf
8 changed files with 148 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/interpreter/interpreter.cpp
+79 -58
View File
@@ -31,32 +31,52 @@ void HandleValue();
// Auxiliary Functions
//
auto AllocateValue(const Value* v) -> Address {
auto State::AllocateValue(const Value* v) -> Address {
// Putting the following two side effects together in this function
// ensures that we don't do anything else in between, which is really bad!
// Consider whether to include a copy of the input v in this function
// or to leave it up to the caller.
Address a = state->heap.size();
state->heap.push_back(new Value(*v));
state->alive.push_back(true);
Address a = heap.size();
heap.push_back(new Value(*v));
this->alive.push_back(true);
return a;
}
auto State::ReadFromMemory(Address a, int line_num) -> const Value* {
this->CheckAlive(a, line_num);
return heap[a];
}
auto State::WriteToMemory(Address a, const Value* v, int line_num) -> void {
this->CheckAlive(a, line_num);
heap[a] = v;
}
void State::CheckAlive(Address address, int line_num) {
if (!this->alive[address]) {
std::cerr << line_num << ": undefined behavior: access to dead value ";
PrintValue(heap[address], std::cerr);
std::cerr << std::endl;
exit(-1);
}
}
auto CopyVal(const Value* val, int line_num) -> const Value* {
switch (val->tag) {
case ValKind::TupleV: {
auto elts = new std::vector<std::pair<std::string, Address>>();
for (auto& i : *val->u.tuple.elts) {
CheckAlive(i.second, line_num);
const Value* elt = CopyVal(state->heap[i.second], line_num);
Address new_address = AllocateValue(elt);
const Value* elt =
CopyVal(state->ReadFromMemory(i.second, line_num), line_num);
Address new_address = state->AllocateValue(elt);
elts->push_back(make_pair(i.first, new_address));
}
return MakeTupleVal(elts);
}
case ValKind::AltV: {
const Value* arg = CopyVal(state->heap[val->u.alt.argument], line_num);
Address argument_address = AllocateValue(arg);
const Value* arg = CopyVal(
state->ReadFromMemory(val->u.alt.argument, line_num), line_num);
Address argument_address = state->AllocateValue(arg);
return MakeAltVal(*val->u.alt.alt_name, *val->u.alt.choice_name,
argument_address);
}
@@ -102,20 +122,18 @@ auto CopyVal(const Value* val, int line_num) -> const Value* {
}
}
void KillObject(Address address);
// Marks all of the sub-objects of this value as dead.
void KillSubObjects(const Value* val) {
switch (val->tag) {
case ValKind::AltV:
KillObject(val->u.alt.argument);
state->KillObject(val->u.alt.argument);
break;
case ValKind::StructV:
KillSubObjects(val->u.struct_val.inits);
break;
case ValKind::TupleV:
for (auto& elt : *val->u.tuple.elts) {
KillObject(elt.second);
state->KillObject(elt.second);
}
break;
default:
@@ -123,11 +141,10 @@ void KillSubObjects(const Value* val) {
}
}
// Marks the object at this address, and all of its sub-objects, as dead.
void KillObject(Address address) {
if (state->alive[address]) {
state->alive[address] = false;
KillSubObjects(state->heap[address]);
void State::KillObject(Address address) {
if (this->alive[address]) {
this->alive[address] = false;
KillSubObjects(heap[address]);
} else {
std::cerr << "runtime error, killing an already dead value" << std::endl;
exit(-1);
@@ -135,9 +152,9 @@ void KillObject(Address address) {
}
void PrintEnv(Env values, std::ostream& out) {
for (const auto& [name, value] : values) {
for (const auto& [name, address] : values) {
out << name << ": ";
PrintValue(state->heap[value], out);
state->PrintAddress(address, out);
out << ", ";
}
}
@@ -163,7 +180,7 @@ void PrintStack(Stack<Frame*> ls, std::ostream& out) {
}
}
void PrintHeap(const std::vector<const Value*>& heap, std::ostream& out) {
void State::PrintHeap(std::ostream& out) {
for (auto& iter : heap) {
if (iter) {
PrintValue(iter, out);
@@ -184,7 +201,7 @@ void PrintState(std::ostream& out) {
out << "stack: ";
PrintStack(state->stack, out);
out << std::endl << "heap: ";
PrintHeap(state->heap, out);
state->PrintHeap(out);
if (!state->stack.IsEmpty() && !state->stack.Top()->scopes.IsEmpty()) {
out << std::endl << "values: ";
PrintEnv(CurrentEnv(state), out);
@@ -218,7 +235,6 @@ auto ValToBool(const Value* v, int line_num) -> int {
}
auto ValToPtr(const Value* v, int line_num) -> Address {
CheckAlive(v->u.ptr, line_num);
switch (v->tag) {
case ValKind::PtrV:
return v->u.ptr;
@@ -284,7 +300,7 @@ auto ChoiceDeclaration::InitGlobals(Env& globals) const -> void {
alts->push_back(make_pair(kv.first, t));
}
auto ct = MakeChoiceTypeVal(name, alts);
auto a = AllocateValue(ct);
auto a = state->AllocateValue(ct);
globals.Set(name, a);
}
@@ -302,7 +318,7 @@ auto StructDeclaration::InitGlobals(Env& globals) const -> void {
}
}
auto st = MakeStructTypeVal(*definition.name, fields, methods);
auto a = AllocateValue(st);
auto a = state->AllocateValue(st);
globals.Set(*definition.name, a);
}
@@ -310,7 +326,7 @@ auto FunctionDeclaration::InitGlobals(Env& globals) const -> void {
Env values;
auto pt = InterpExp(values, definition->param_pattern);
auto f = MakeFunVal(definition->name, pt, definition->body);
Address a = AllocateValue(f);
Address a = state->AllocateValue(f);
globals.Set(definition->name, a);
}
@@ -318,7 +334,7 @@ auto FunctionDeclaration::InitGlobals(Env& globals) const -> void {
// result of evaluating the initializer.
auto VariableDeclaration::InitGlobals(Env& globals) const -> void {
auto v = InterpExp(globals, initializer);
Address a = AllocateValue(v);
Address a = state->AllocateValue(v);
globals.Set(name, a);
}
@@ -355,9 +371,9 @@ void CallFunction(int line_num, std::vector<const Value*> operas,
}
case ValKind::AltConsV: {
const Value* arg = CopyVal(operas[1], line_num);
const Value* av =
MakeAltVal(*operas[0]->u.alt_cons.alt_name,
*operas[0]->u.alt_cons.choice_name, AllocateValue(arg));
const Value* av = MakeAltVal(*operas[0]->u.alt_cons.alt_name,
*operas[0]->u.alt_cons.choice_name,
state->AllocateValue(arg));
Frame* frame = state->stack.Top();
frame->todo.Push(MakeValAct(av));
break;
@@ -377,7 +393,7 @@ void KillScope(int line_num, Scope* scope) {
std::cerr << "internal error in KillScope" << std::endl;
exit(-1);
}
KillObject(*a);
state->KillObject(*a);
}
}
@@ -393,7 +409,7 @@ void CreateTuple(Frame* frame, Action* act, const Expression* /*exp*/) {
auto elts = new std::vector<std::pair<std::string, Address>>();
auto f = act->u.exp->u.tuple.fields->begin();
for (auto i = act->results.begin(); i != act->results.end(); ++i, ++f) {
Address a = AllocateValue(*i); // copy?
Address a = state->AllocateValue(*i); // copy?
elts->push_back(make_pair(f->first, a));
}
const Value* tv = MakeTupleVal(elts);
@@ -411,7 +427,7 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
-> std::optional<Env> {
switch (p->tag) {
case ValKind::VarPatV: {
Address a = AllocateValue(CopyVal(v, line_num));
Address a = state->AllocateValue(CopyVal(v, line_num));
vars->push_back(*p->u.var_pat.name);
values.Set(*p->u.var_pat.name, a);
return values;
@@ -432,9 +448,9 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
std::cerr << std::endl;
exit(-1);
}
std::optional<Env> matches =
PatternMatch(state->heap[elt.second], state->heap[*a], values,
vars, line_num);
std::optional<Env> matches = PatternMatch(
state->ReadFromMemory(elt.second, line_num),
state->ReadFromMemory(*a, line_num), values, vars, line_num);
if (!matches) {
return std::nullopt;
}
@@ -456,9 +472,10 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
*p->u.alt.alt_name != *v->u.alt.alt_name) {
return std::nullopt;
}
std::optional<Env> matches = PatternMatch(
state->heap[p->u.alt.argument], state->heap[v->u.alt.argument],
values, vars, line_num);
std::optional<Env> matches =
PatternMatch(state->ReadFromMemory(p->u.alt.argument, line_num),
state->ReadFromMemory(v->u.alt.argument, line_num),
values, vars, line_num);
if (!matches) {
return std::nullopt;
}
@@ -498,7 +515,8 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
void PatternAssignment(const Value* pat, const Value* val, int line_num) {
switch (pat->tag) {
case ValKind::PtrV:
state->heap[ValToPtr(pat, line_num)] = CopyVal(val, line_num);
state->WriteToMemory(ValToPtr(pat, line_num), CopyVal(val, line_num),
line_num);
break;
case ValKind::TupleV: {
switch (val->tag) {
@@ -516,8 +534,8 @@ void PatternAssignment(const Value* pat, const Value* val, int line_num) {
std::cerr << std::endl;
exit(-1);
}
PatternAssignment(state->heap[elt.second], state->heap[*a],
line_num);
PatternAssignment(state->ReadFromMemory(elt.second, line_num),
state->ReadFromMemory(*a, line_num), line_num);
}
break;
}
@@ -539,8 +557,9 @@ void PatternAssignment(const Value* pat, const Value* val, int line_num) {
std::cerr << "internal error in pattern assignment" << std::endl;
exit(-1);
}
PatternAssignment(state->heap[pat->u.alt.argument],
state->heap[val->u.alt.argument], line_num);
PatternAssignment(
state->ReadFromMemory(pat->u.alt.argument, line_num),
state->ReadFromMemory(val->u.alt.argument, line_num), line_num);
break;
}
default:
@@ -584,7 +603,6 @@ void StepLvalue() {
exit(-1);
}
const Value* v = MakePtrVal(*pointer);
CheckAlive(*pointer, exp->line_num);
frame->todo.Pop();
frame->todo.Push(MakeValAct(v));
break;
@@ -681,7 +699,7 @@ void StepExp() {
<< *(exp->u.variable.name) << "`" << std::endl;
exit(-1);
}
const Value* pointee = state->heap[*pointer];
const Value* pointee = state->ReadFromMemory(*pointer, exp->line_num);
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(pointee));
break;
@@ -901,7 +919,7 @@ void StepStmt() {
todo.Push(MakeStmtAct(stmt->u.continuation.body));
Frame* continuation_frame = new Frame("__continuation", scopes, todo);
Address continuation_address =
AllocateValue(MakeContinuation({continuation_frame}));
state->AllocateValue(MakeContinuation({continuation_frame}));
// Store the continuation's address in the frame.
continuation_frame->continuation = continuation_address;
// Bind the continuation object to the continuation variable
@@ -924,13 +942,14 @@ void StepStmt() {
paused.push_back(state->stack.Pop());
} while (!paused.back()->IsContinuation());
// Update the continuation with the paused stack.
state->heap[paused.back()->continuation] = MakeContinuation(paused);
state->WriteToMemory(paused.back()->continuation,
MakeContinuation(paused), stmt->line_num);
break;
}
}
auto GetMember(Address a, const std::string& f) -> Address {
const Value* v = state->heap[a];
auto GetMember(Address a, const std::string& f, int line_num) -> Address {
const Value* v = state->ReadFromMemory(a, line_num);
switch (v->tag) {
case ValKind::StructV: {
auto a = FindTupleField(f, v->u.struct_val.inits);
@@ -960,7 +979,7 @@ auto GetMember(Address a, const std::string& f) -> Address {
exit(-1);
}
auto ac = MakeAltCons(f, *v->u.choice_type.name);
return AllocateValue(ac);
return state->AllocateValue(ac);
}
default:
std::cerr << "field access not allowed for value ";
@@ -1013,13 +1032,13 @@ void HandleValue() {
}
switch (act->tag) {
case ActionKind::DeleteTmpAction: {
KillObject(act->u.delete_tmp);
state->KillObject(act->u.delete_tmp);
frame->todo.Pop(2);
frame->todo.Push(val_act);
break;
}
case ActionKind::ExpToLValAction: {
Address a = AllocateValue(act->results[0]);
Address a = state->AllocateValue(act->results[0]);
auto del = MakeDeleteAct(a);
frame->todo.Pop(2);
InsertDelete(del, frame->todo);
@@ -1033,8 +1052,8 @@ void HandleValue() {
// { v :: [].f :: C, E, F} :: S, H}
// -> { { &v.f :: C, E, F} :: S, H }
const Value* str = act->results[0];
Address a =
GetMember(ValToPtr(str, exp->line_num), *exp->u.get_field.field);
Address a = GetMember(ValToPtr(str, exp->line_num),
*exp->u.get_field.field, exp->line_num);
frame->todo.Pop(2);
frame->todo.Push(MakeValAct(MakePtrVal(a)));
break;
@@ -1126,7 +1145,8 @@ void HandleValue() {
exit(-1);
}
frame->todo.Pop(2);
frame->todo.Push(MakeValAct(state->heap[*a]));
const Value* element = state->ReadFromMemory(*a, exp->line_num);
frame->todo.Push(MakeValAct(element));
break;
}
default:
@@ -1143,9 +1163,10 @@ void HandleValue() {
// { { v :: [].f :: C, E, F} :: S, H}
// -> { { v_f :: C, E, F} : S, H}
auto a = GetMember(ValToPtr(act->results[0], exp->line_num),
*exp->u.get_field.field);
*exp->u.get_field.field, exp->line_num);
const Value* element = state->ReadFromMemory(a, exp->line_num);
frame->todo.Pop(2);
frame->todo.Push(MakeValAct(state->heap[a]));
frame->todo.Push(MakeValAct(element));
break;
}
case ExpressionKind::PrimitiveOp: {
executable_semantics/interpreter/interpreter.h
+21 -2
View File
@@ -59,10 +59,30 @@ struct Frame {
continuation(UINT_MAX) {}
};
// TODO(geoffromer): Make this a class, with all members private
struct State {
Stack<Frame*> stack;
std::vector<const Value*> heap;
std::vector<bool> alive;
// Returns the value at the given address in the heap after
// checking that it is alive.
auto ReadFromMemory(Address a, int line_num) -> const Value*;
// Writes the given value at the address in the heap after
// checking that the address is alive.
auto WriteToMemory(Address a, const Value* v, int line_num) -> void;
// Print the value at the given address to the stream `out`.
auto PrintAddress(Address a, std::ostream& out) -> void;
// Signal an error if the address is no longer alive.
void CheckAlive(Address address, int line_num);
// Put the given value on the heap and mark it as alive.
auto AllocateValue(const Value* v) -> Address;
// Marks the object at this address, and all of its sub-objects, as dead.
auto KillObject(Address address) -> void;
// Print all the values on the heap to the stream `out`.
auto PrintHeap(std::ostream& out) -> void;
private:
std::vector<const Value*> heap;
};
extern State* state;
@@ -70,7 +90,6 @@ extern State* state;
auto PrintFrame(Frame* frame, std::ostream& out) -> void;
void PrintStack(Stack<Frame*> ls, std::ostream& out);
void PrintEnv(Env values);
auto AllocateValue(const Value* v) -> Address;
auto CopyVal(const Value* val, int line_num) -> const Value*;
auto ToInteger(const Value* v) -> int;
executable_semantics/interpreter/typecheck.cpp
+12 -9
View File
@@ -58,8 +58,9 @@ auto ReifyType(const Value* t, int line_num) -> const Expression* {
case ValKind::TupleV: {
auto args = new std::vector<std::pair<std::string, const Expression*>>();
for (auto& field : *t->u.tuple.elts) {
args->push_back(
{field.first, ReifyType(state->heap[field.second], line_num)});
args->push_back({field.first, ReifyType(state->ReadFromMemory(
field.second, line_num),
line_num)});
}
return MakeTuple(0, args);
}
@@ -137,7 +138,7 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
std::cerr << std::endl;
exit(-1);
}
auto field_t = state->heap[*field_address];
auto field_t = state->ReadFromMemory(*field_address, e->line_num);
auto new_e = MakeIndex(e->line_num, res.exp, MakeInt(e->line_num, i));
return TCResult(new_e, field_t, res.types);
}
@@ -164,13 +165,13 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
<< arg->first << std::endl;
exit(-1);
}
arg_expected = state->heap[*expected_field];
arg_expected = state->ReadFromMemory(*expected_field, e->line_num);
}
auto arg_res =
TypeCheckExp(arg->second, new_types, values, arg_expected, context);
new_types = arg_res.types;
new_args->push_back(std::make_pair(arg->first, arg_res.exp));
arg_types->push_back({arg->first, AllocateValue(arg_res.type)});
arg_types->push_back({arg->first, state->AllocateValue(arg_res.type)});
}
auto tuple_e = MakeTuple(e->line_num, new_args);
auto tuple_t = MakeTupleVal(arg_types);
@@ -207,7 +208,9 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
if (*e->u.get_field.field == field.first) {
auto new_e =
MakeGetField(e->line_num, res.exp, *e->u.get_field.field);
return TCResult(new_e, state->heap[field.second], res.types);
return TCResult(new_e,
state->ReadFromMemory(field.second, e->line_num),
res.types);
}
}
std::cerr << e->line_num << ": compilation error, struct "
@@ -677,11 +680,11 @@ auto FunctionDeclaration::TopLevel(TypeCheckContext& tops) const -> void {
auto StructDeclaration::TopLevel(TypeCheckContext& tops) const -> void {
auto st = TypeOfStructDef(&definition, tops.types, tops.values);
Address a = AllocateValue(st);
Address a = state->AllocateValue(st);
tops.values.Set(Name(), a); // Is this obsolete?
auto field_types = new std::vector<std::pair<std::string, Address>>();
for (const auto& [field_name, field_value] : *st->u.struct_type.fields) {
field_types->push_back({field_name, AllocateValue(field_value)});
field_types->push_back({field_name, state->AllocateValue(field_value)});
}
auto fun_ty = MakeFunTypeVal(MakeTupleVal(field_types), st);
tops.types.Set(Name(), fun_ty);
@@ -694,7 +697,7 @@ auto ChoiceDeclaration::TopLevel(TypeCheckContext& tops) const -> void {
alts->push_back(std::make_pair(a.first, t));
}
auto ct = MakeChoiceTypeVal(name, alts);
Address a = AllocateValue(ct);
Address a = state->AllocateValue(ct);
tops.values.Set(Name(), a); // Is this obsolete?
tops.types.Set(Name(), ct);
}
executable_semantics/interpreter/value.cpp
+12 -16
View File
@@ -213,7 +213,14 @@ auto MakeChoiceTypeVal(std::string name,
return v;
}
void PrintValue(const Value* val, std::ostream& out) {
auto State::PrintAddress(Address a, std::ostream& out) -> void {
if (!this->alive[a]) {
out << "!!";
}
PrintValue(this->heap[a], out);
}
auto PrintValue(const Value* val, std::ostream& out) -> void {
switch (val->tag) {
case ValKind::AltConsV: {
out << *val->u.alt_cons.choice_name << "." << *val->u.alt_cons.alt_name;
@@ -227,7 +234,7 @@ void PrintValue(const Value* val, std::ostream& out) {
case ValKind::AltV: {
out << "alt " << *val->u.alt.choice_name << "." << *val->u.alt.alt_name
<< " ";
PrintValue(state->heap[val->u.alt.argument], out);
state->PrintAddress(val->u.alt.argument, out);
break;
}
case ValKind::StructV: {
@@ -246,7 +253,7 @@ void PrintValue(const Value* val, std::ostream& out) {
}
out << elt.first << " = ";
PrintValue(state->heap[elt.second], out);
state->PrintAddress(elt.second, out);
out << "@" << elt.second;
}
out << ")";
@@ -336,8 +343,8 @@ auto TypeEqual(const Value* t1, const Value* t2) -> bool {
if (t2_field == std::nullopt) {
return false;
}
if (!TypeEqual(state->heap[(*t1->u.tuple.elts)[i].second],
state->heap[*t2_field])) {
if (!TypeEqual(state->ReadFromMemory((*t1->u.tuple.elts)[i].second, 0),
state->ReadFromMemory(*t2_field, 0))) {
return false;
}
}
@@ -363,8 +370,6 @@ auto ValueEqual(const Value* v1, const Value* v2, int line_num) -> bool {
case ValKind::BoolV:
return v1->u.boolean == v2->u.boolean;
case ValKind::PtrV:
CheckAlive(v1->u.ptr, line_num);
CheckAlive(v2->u.ptr, line_num);
return v1->u.ptr == v2->u.ptr;
case ValKind::FunV:
return v1->u.fun.body == v2->u.fun.body;
@@ -402,13 +407,4 @@ auto ToInteger(const Value* v) -> int {
}
}
void CheckAlive(Address address, int line_num) {
if (!state->alive[address]) {
std::cerr << line_num << ": undefined behavior: access to dead value ";
PrintValue(state->heap[address], std::cerr);
std::cerr << std::endl;
exit(-1);
}
}
} // namespace Carbon
executable_semantics/interpreter/value.h
-1
View File
@@ -160,7 +160,6 @@ auto TypeEqual(const Value* t1, const Value* t2) -> bool;
auto ValueEqual(const Value* v1, const Value* v2, int line_num) -> bool;
auto ToInteger(const Value* v) -> int;
void CheckAlive(Address a, int line_num);
} // namespace Carbon