dmd.toir

Convert to Intermediate Representation (IR) for the back-end.

Authors

Walter Bright

License

Boost License 1.0

Source: toir.d

Documentation: https://dlang.org/phobos/dmd_toir.html

Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/toir.d

  • Label

    Declaration

    struct Label;

    Our label symbol

  • IRState

    Declaration

    struct IRState;

    Collect state variables needed by the intermediate representation (IR)

    • arrayBoundsCheck

      Declaration

      bool arrayBoundsCheck();

      Return Value

      true if do array bounds checking for the current function

    • isNothrow

      Declaration

      bool isNothrow();

      Return Value

      true if in a nothrow section of code

  • incUsageElem

    Declaration

    elem* incUsageElem(IRState* irs, ref const Loc loc);

    Produce elem which increments the usage count for a particular line. Sets corresponding bit in bitmap m.covb[linnum]. Used to implement -cov switch (coverage analysis).

    Parameters

    IRState* irs

    context

    Loc loc

    line and file of what line to show usage for

    Return Value

    elem that increments the line count

    References: https://dlang.org/dmd-windows.html#switch-cov

  • getEthis

    Declaration

    elem* getEthis(ref const Loc loc, IRState* irs, Dsymbol fd, Dsymbol fdp = null, Dsymbol origSc = null);

    Return elem that evaluates to the static frame pointer for function fd. If fd is a member function, the returned expression will compute the value of fd's 'this' variable. 'fdp' is the parent of 'fd' if the frame pointer is being used to call 'fd'. 'origSc' is the original scope we inlined from. This routine is critical for implementing nested functions.

  • fixEthis2

    Declaration

    elem* fixEthis2(elem* ethis, FuncDeclaration fd, bool ctxt2 = false);

    Select one context pointer from a dual-context array

    Return Value

    *(ethis + offset);

  • setEthis

    Declaration

    elem* setEthis(ref const Loc loc, IRState* irs, elem* ey, AggregateDeclaration ad, bool setthis2 = false);

    Initialize the hidden aggregate member, vthis, with the context pointer.

    Return Value

    *(ey + (ethis2 ? ad.vthis2 : ad.vthis).offset) = this;

  • intrinsic_op

    Declaration

    int intrinsic_op(FuncDeclaration fd);

    Convert intrinsic function to operator.

    Return Value

    the operator as backend OPER, NotIntrinsic if not an intrinsic function, OPtoPrec if frontend-only intrinsic

  • resolveLengthVar

    Declaration

    elem* resolveLengthVar(VarDeclaration lengthVar, elem** pe, Type t1);

    Given an expression e that is an array, determine and set the 'length' variable.

    Input: lengthVar Symbol of 'length' variable &e expression that is the array t1 Type of the array

    Output: e is rewritten to avoid side effects

    Return Value

    expression that initializes 'length'

  • getParentClosureType

    Declaration

    TYPE* getParentClosureType(Symbol* sthis, FuncDeclaration fd);

    for a nested function 'fd' return the type of the closure of an outer function or aggregate. If the function is a member function the 'this' type is expected to be stored in 'sthis.Sthis'. It is always returned if it is not a void pointer. buildClosure() must have been called on the outer function before.

    Parameters

    Symbol* sthis

    the symbol of the current 'this' derived from fd.vthis

    FuncDeclaration fd

    the nested function

  • setClosureVarOffset

    Declaration

    void setClosureVarOffset(FuncDeclaration fd);

    Go through the variables in function fd that are to be allocated in a closure, and set the .offset fields for those variables to their positions relative to the start of the closure instance. Also turns off nrvo for closure variables.

    Parameters

    FuncDeclaration fd

    function

  • buildClosure

    Declaration

    void buildClosure(FuncDeclaration fd, IRState* irs);

    Closures are implemented by taking the local variables that need to survive the scope of the function, and copying them into a gc allocated chuck of memory. That chunk, called the closure here, is inserted into the linked list of stack frames instead of the usual stack frame.

    Discussion

    buildClosure() inserts code just after the function prolog is complete. It allocates memory for the closure, allocates a local variable (sclosure) to point to it, inserts into it the link to the enclosing frame, and copies into it the parameters that are referred to in nested functions. In VarExp::toElem and SymOffExp::toElem, when referring to a variable that is in a closure, takes the offset from sclosure rather than from the frame pointer.

    getEthis() and NewExp::toElem need to use sclosure, if set, rather than the current frame pointer.

  • buildCapture

    Declaration

    void buildCapture(FuncDeclaration fd);

    build a debug info struct for variables captured by nested functions, but not in a closure. must be called after generating the function to fill stack offsets

    Parameters

    FuncDeclaration fd

    function

  • retStyle

    Declaration

    RET retStyle(TypeFunction tf, bool needsThis);

    Determine return style of function - whether in registers or through a hidden pointer to the caller's stack.

    Parameters

    TypeFunction tf

    function type to check

    bool needsThis

    true if the function type is for a non-static member function

    Return Value

    RET.stack if return value from function is on the stack, RET.regs otherwise