dmd.escape

Most of the logic to implement scoped pointers and scoped references is here.

Members

Functions

checkArrayLiteralEscape
bool checkArrayLiteralEscape(Scope* sc, ArrayLiteralExp ae, bool gag)

Array literal is going to be allocated on the GC heap. Check its elements to see if any would escape by going on the heap.

checkAssignEscape
bool checkAssignEscape(Scope* sc, Expression e, bool gag)

Given an AssignExp, determine if the lvalue will cause the contents of the rvalue to escape. Print error messages when these are detected. Infer scope attribute for the lvalue where possible, in order to eliminate the error.

checkAssocArrayLiteralEscape
bool checkAssocArrayLiteralEscape(Scope* sc, AssocArrayLiteralExp ae, bool gag)

Associative array literal is going to be allocated on the GC heap. Check its elements to see if any would escape by going on the heap.

checkConstructorEscape
bool checkConstructorEscape(Scope* sc, CallExp ce, bool gag)

Check struct constructor of the form s.this(args), by checking each return parameter to see if it gets assigned to s.

checkMutableArguments
bool checkMutableArguments(Scope* sc, FuncDeclaration fd, TypeFunction tf, Expression ethis, Expressions* arguments, bool gag)

Checks memory objects passed to a function. Checks that if a memory object is passed by ref or by pointer, all of the refs or pointers are const, or there is only one mutable ref or pointer to it. References: DIP 1021

checkNewEscape
bool checkNewEscape(Scope* sc, Expression e, bool gag)

Detect cases where pointers to the stack can escape the lifetime of the stack frame by being placed into a GC allocated object. Print error messages when these are detected.

checkParamArgumentEscape
bool checkParamArgumentEscape(Scope* sc, FuncDeclaration fdc, Parameter par, Expression arg, bool assertmsg, bool gag)

Function parameter par is being initialized to arg, and par may escape. Detect if scoped values can escape this way. Print error messages when these are detected.

checkParamArgumentReturn
bool checkParamArgumentReturn(Scope* sc, Expression firstArg, Expression arg, bool gag)

Function argument initializes a return parameter, and that parameter gets assigned to firstArg. Essentially, treat as firstArg = arg;

checkReturnEscape
bool checkReturnEscape(Scope* sc, Expression e, bool gag)

Detect cases where pointers to the stack can escape the lifetime of the stack frame by returning e by value. Print error messages when these are detected.

checkReturnEscapeRef
bool checkReturnEscapeRef(Scope* sc, Expression e, bool gag)

Detect cases where returning e by ref can result in a reference to the stack being returned. Print error messages when these are detected.

checkThrowEscape
bool checkThrowEscape(Scope* sc, Expression e, bool gag)

Detect cases where pointers to the stack can escape the lifetime of the stack frame when throwing e. Print error messages when these are detected.

eliminateMaybeScopes
void eliminateMaybeScopes(VarDeclaration[] array)

Have some variables that are maybescopes that were assigned values from other maybescope variables. Now that semantic analysis of the function is complete, we can finalize this by turning off maybescope for array elements that cannot be scope.

escapeByRef
void escapeByRef(Expression e, EscapeByResults* er, bool live = false)

e is an expression to be returned by 'ref'. Walk e to determine which variables are possibly being returned by ref, such as: ref int function(int i) { return i; } If e is a form of *p, determine which variables have content which is being returned as ref, such as: ref int function(int* p) { return *p; } Multiple variables can be inserted, because of expressions like this: ref int function(bool b, int i, int* p) { return b ? i : *p; }

escapeByValue
void escapeByValue(Expression e, EscapeByResults* er, bool live = false)

e is an expression to be returned by value, and that value contains pointers. Walk e to determine which variables are possibly being returned by value, such as: int* function(int* p) { return p; } If e is a form of &p, determine which variables have content which is being returned as ref, such as: int* function(int i) { return &i; } Multiple variables can be inserted, because of expressions like this: int function(bool b, int i, int* p) { return b ? &i : p; }

findAllOuterAccessedVariables
void findAllOuterAccessedVariables(FuncDeclaration fd, VarDeclarations* vars)

Find all variables accessed by this delegate that are in functions enclosing it.

isReferenceToMutable
bool isReferenceToMutable(Type t)

Is type a reference to a mutable value?

isReferenceToMutable
bool isReferenceToMutable(Parameter p, Type t)

Is parameter a reference to a mutable value?

notMaybeScope
void notMaybeScope(VarDeclaration v)

Turn off STC.maybescope for variable v.

Structs

EscapeByResults
struct EscapeByResults

Aggregate the data collected by the escapeBy??() functions.

Meta