View source code
Display the source code in dmd/escape.d from which this
page was generated on github.
Report a bug
If you spot a problem with this page, click here to create a
Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page.
Requires a signed-in GitHub account. This works well for small changes.
If you'd like to make larger changes you may want to consider using
local clone.
Module dmd.escape
Most of the logic to implement scoped pointers and scoped references is here.
Documentation
https://dlang.org/phobos/dmd_escape.html
Coverage
https://codecov.io/gh/dlang/dmd/src/master/src/dmd/escape.d
Functions
Name | Description |
---|---|
checkArrayLiteralEscape(sc, ae, 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(sc, e, gag, byRef)
|
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(sc, ae, 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(sc, ce, gag)
|
Check struct constructor of the form s , by
checking each return parameter to see if it gets
assigned to s .
|
checkMutableArguments(sc, fd, tf, ethis, arguments, 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. |
checkNewEscape(sc, e, 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(sc, fdc, parId, vPar, parStc, arg, assertmsg, 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(sc, firstArg, arg, param, gag)
|
Function argument initializes a return parameter,
and that parameter gets assigned to firstArg .
Essentially, treat as firstArg = arg;
|
checkReturnEscape(sc, e, 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(sc, e, 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(sc, e, 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.
|
escapeByRef(e, er, live, retRefTransition)
|
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(e, er, live, retRefTransition)
|
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(fd, vars)
|
Find all variables accessed by this delegate that are in functions enclosing it. |
finishScopeParamInference(funcdecl, f)
|
After semantic analysis of the function body,
try to infer scope / return on the parameters
|
inferScope(va)
|
Infer scope for a variable
|
isReferenceToMutable(t)
|
Is type a reference to a mutable value? |
isReferenceToMutable(p, t)
|
Is parameter a reference to a mutable value? |
printScopeFailure(printFunc, v, recursionLimit)
|
A scope variable was assigned to non-scope parameter v .
If applicable, print why the parameter was not inferred scope .
|
returnParamDest(tf, tthis)
|
Find out if instead of returning a return parameter via a return statement,
it is returned via assignment to either this or the first parameter.
|
Structs
Name | Description |
---|---|
EscapeByResults
|
Aggregate the data collected by the escapeBy??() functions. |
Enums
Name | Description |
---|---|
ReturnParamDest
|
How a return parameter escapes its pointer value
|
Authors
License
Copyright © 1999-2024 by the D Language Foundation | Page generated by ddox.