Module TranslatedExpr

Holds if the translation of expr will not directly generate any Instruction for use as result. For such instructions we can synthesize a CopyValue instruction to ensure that there is a 1-to-1 mapping between expressions and result-bearing instructions.

Gets the TranslatedExpr for the specified expression. If expr is a load or synthesized temporary object, the result is the TranslatedExpr for the load or synthetic temporary object portion.

Abstract class implemented by any TranslatedElement that has a child expression that is a call to a constructor or destructor, in order to provide a pointer to the object being constructed or destroyed.

The IR translation of the allocation size argument passed to operator new in a new expression.

The IR translation of a call to operator new as part of a new or new[] expression.

IR translation of an array access expression (e.g. a[i]). The array being accessed will either be a prvalue of pointer type (possibly due to an implicit array-to-pointer conversion), or a glvalue of a GNU vector type.

The IR translation of an __assume expression. We currently translate these as NoOp. In the future, we will probably want to do something better. At a minimum, we can model __assume(0) as Unreached.

The IR translation of a two-operand conditional operator (a ?: b). This is a GCC language extension. This version of the conditional expression returns its first operand (the condition) if that condition is non-zero. Since we’ll be reusing the value of the condition, we’ll compute that value directly before branching, even if that value was a short-circuit logical expression.

IR translation of a simple binary operation.

Represents the translation of a BoolConversion expression, which generates a comparison with zero.

The IR translation of a built-in operation (i.e. anything that extends BuiltInOperation).

IR translation of co_await.

IR translation of co_yield.

The IR translation of a ConditionDeclExpr, which represents the value of the declared variable after conversion to bool in code such as: if (int* p = &x) { }

The IR translation of the ?: operator. This class has the portions of the implementation that are shared between the standard three-operand form (a ? b : c) and the GCC-extension two-operand form (a ?: c).

The IR translation of a constant allocation size.

IR translation of an expression with a compile-time constant value. This includes not only literals, but also “integral constant expressions” (e.g. 1 + 2).

The IR translation of the “core” part of an expression. This is the part of the expression that produces the result value of the expression, before any lvalue-to-rvalue conversion on the result. Every expression has a single TranslatedCoreExpr.

The IR translation of a delete or delete[] expression.

Represents the IR translation of the destruction of a field from within the destructor of the field’s declaring class.

The IR translation of the destructor calls of the parent TranslatedThrow.

Represents the translation of a dynamic_cast expression.

The IR translation of some part of an expression. A single Expr may consist of multiple TranslatedExpr objects. Every Expr has a single TranslatedCoreExpr, which produces the result of the expression before any implicit lvalue-to-rvalue conversion. Any expression with an lvalue-to-rvalue conversion will also have a TranslatedLoad to perform that conversion on the original result. A few expressions have additional TranslatedExpr objects that compute intermediate values, such as the TranslatedAllocatorCall and TranslatedAllocationSize within the translation of a NewExpr.

Represents the translation of a BaseClassConversion or DerivedClassConversion expression.

The IR translation of a lambda expression. This initializes a temporary variable whose type is that of the lambda, using the initializer list that represents the captures of the lambda.

IR translation of an implicit lvalue-to-rvalue conversion on the result of an expression.

The IR translation of a new[] expression.

The IR translation of a new expression.

The IR translation of a new or new[] expression.

The IR translation of a non-constant allocation size.

IR translation of an expression whose value is not known at compile time.

IR translation of a throw expression with no argument (e.g. throw;).

IR translation of an expression that simply returns its result. We generate an otherwise useless CopyValue instruction for these expressions so that there is at least one instruction associated with the expression.

IR translation of a ReuseExpr.

Represents the translation of a conversion expression that generates a Convert instruction.

Represents the translation of a conversion expression that generates a single instruction.

IR translation of an expression that performs a single operation on its operands and returns the result.

The IR translation of StmtExpr (the GNU statement expression extension to C/C++), such as ({ doSomething(); a + b; })

The IR translation of a variable access of a structured binding, where the type of the structured binding is not of a reference type, e.g., x0 and x1 in auto [x0, x1] = xs where xs is an array. Although the type of the structured binding is a non-reference type, the structured binding behaves like a reference. Hence, the translation requires a VariableAddress followed by a Load instead of only a VariableAddress as produced by TranslatedVariableAccess.

The IR translation of a temporary object synthesized by the IR to hold a class prvalue on which a member access is going to be performed. This differs from TranslatedTemporaryObjectExpr in that instances of TranslatedSyntheticTemporaryObject are synthesized during IR construction, whereas TranslatedTemporaryObjectExpr instances are created from TemporaryObjectExpr nodes from the AST.

IR translation of the materialization of a temporary object.

The IR translation of the ternary conditional operator (a ? b : c). For this version, we expand the condition as a TranslatedCondition, rather than a TranslatedExpr, to simplify the control flow in the presence of short-circuit logical operators.

IR translation of a throw expression.

IR translation of a throw expression with an argument (e.g. throw std::bad_alloc()).

The IR translation of a vacuous destructor call. That is, an expression that looks like a destructor call, but has no effect.

The IR translation of a node synthesized to adjust the value category of its operand. One of: - TranslatedLoad - Convert from glvalue to prvalue by loading from the location. - TranslatedSyntheticTemporaryObject - Convert from prvalue to glvalue by storing to a temporary variable.

The IR translation of a BuiltInVarArg expression.

The IR translation of a BuiltInVarArgCopy expression.

The IR translation of a BuiltInVarArgsEnd expression.

The IR translation of a BuiltInVarArgsStart expression.