Determine if constant e is all ones or all zeros.
Allocate a temporary, and return temporary elem.
Does any definition of lvalue ed appear in e?
Does symbol s appear in tree e?
Look for symbol that is a base of addressing mode e.
Make a binary operator node.
Allocate an element.
Check for errors in a tree.
Combine e1 and e2 with a comma-expression. Be careful about either or both being null.
Do an array of parameters as a balanced binary tree.
Make a constant elem. ty = type of elem *pconst = union of constant data
Run through a tree converting it to CODGEN.
Convert floating point constant to a read-only symbol. Needed iff floating point code can't load immediate constants.
Convert reference to a string to reference to a symbol stored in the static data segment.
Convert vector constant to a read-only symbol. Needed iff vector code can't load immediate constants.
Copy an element (not the tree!).
Thin wrapper of exp2_copytotemp. Different from el_same, always makes a temporary.
Create and return a duplicate of e, including its leaves. No CSEs.
Count number of commas in the expression.
Create constructor/destructor pair of elems. Caution: The pattern generated here must match that detected in e2ir.c's visit(CallExp).
Insert constructor information into tree. A corresponding el_ddtor() must be called later.
Insert destructor information into tree. e code to destruct the object decl VarDeclaration of variable being destructed (must match decl for corresponding OPctor)
Dehydrate an elem.
Input: ea lvalue (might be an OPbit)
Insert destructor information into tree. edtor pointer to object being destructed e code to do the destruction
Free element
Hydrate an elem.
Initialize el package.
Is elem type-dependent or value-dependent?
Make a constant node out of integral type.
Kludge on el_match(). Same, but ignore differences in OPconst.
Kludge on el_match(). Same, but ignore differences in type modifiers.
Kludge on el_match(). Same, but ignore differences in spelling of var's.
Kludge on el_match(). Same, but regard signed/unsigned as equivalent.
Return a list of the parameters.
Fill an array with the ops.
Do an array of parameters as a tree
Return number of op nodes
Create a quad word out of two dwords.
Combine e1 and e2 as parameters to a function. Be careful about either or both being null.
Fill an array with the parameters.
Create parameter list, terminated by a null.
Do an array of parameters as a balanced binary tree.
Find and return pointer to parent of e starting at *pe. Return null if can't find it.
Initialize for another run through.
Determine if expression may return. Does not detect all cases, errs on the side of saying it returns.
Similar to el_copytree(e). But if e has any side effects, it's replaced with (tmp = e) and tmp is returned.
Scan down commas and return the controlling elem.
Select the e1 child of e.
Select the e2 child of e.
Set new type for elem.
Determine if constant e is a 32 bit or less value, or is a 32 bit value sign extended to 64 bits.
Terminate el package.
Extract long double value from constant elem. Silently ignore types which are not floating point values.
Extract long value from constant elem.
Extract long value from constant parser elem.
Create elem that is the size of a type.
Make a unary operator node.
Create a const integer vector elem
Create an elem of the constant 0, of the type t.
Write out expression elem.
Replace (e) with ((stmp = e),stmp)
If e is a long double constant, and it is perfectly representable as a double constant, convert it to a double constant. Note that this must NOT be done in contexts where there are no further operations, since then it could change the type (eg, in the function call printf("%La", 2.0L); the 2.0 must stay as a long double).
//////////////////////////
Routines to handle elems.
Compiler implementation of the D programming language.