Rvalues
-
gccjit::rvalue
A gccjit::rvalue is an expression that can be computed. It is a
subclass of gccjit::object, and is a thin wrapper around
:c:type:`gcc_jit_rvalue *` from the C API.
It can be simple, e.g.:
- an integer value e.g. 0 or 42
- a string literal e.g. “Hello world”
- a variable e.g. i. These are also lvalues (see below).
or compound e.g.:
- a unary expression e.g. !cond
- a binary expression e.g. (a + b)
- a function call e.g. get_distance (&player_ship, &target)
- etc.
Every rvalue has an associated type, and the API will check to ensure
that types match up correctly (otherwise the context will emit an error).
-
gccjit::type gccjit::rvalue::get_type ()
- Get the type of this rvalue.
Simple expressions
-
gccjit::rvalue \
-
gccjit::context::new_rvalue (gccjit::type numeric_type, \
-
int value) const
- Given a numeric type (integer or floating point), build an rvalue for
the given constant :c:type:`int` value.
-
gccjit::rvalue \
-
gccjit::context::new_rvalue (gccjit::type numeric_type, \
-
long value) const
- Given a numeric type (integer or floating point), build an rvalue for
the given constant :c:type:`long` value.
-
gccjit::rvalue \
-
gccjit::context::zero (gccjit::type numeric_type) const
Given a numeric type (integer or floating point), get the rvalue for
zero. Essentially this is just a shortcut for:
ctxt.new_rvalue (numeric_type, 0)
-
gccjit::rvalue \
-
gccjit::context::one (gccjit::type numeric_type) const
Given a numeric type (integer or floating point), get the rvalue for
one. Essentially this is just a shortcut for:
ctxt.new_rvalue (numeric_type, 1)
-
gccjit::rvalue \
-
gccjit::context::new_rvalue (gccjit::type numeric_type, \
-
double value) const
- Given a numeric type (integer or floating point), build an rvalue for
the given constant :c:type:`double` value.
-
gccjit::rvalue \
-
gccjit::context::new_rvalue (gccjit::type pointer_type, \
-
void *value) const
- Given a pointer type, build an rvalue for the given address.
-
gccjit::rvalue \
-
gccjit::context::new_rvalue (const std::string &value) const
- Generate an rvalue of type :c:data:`GCC_JIT_TYPE_CONST_CHAR_PTR` for
the given string. This is akin to a string literal.
Vector expressions
-
gccjit::rvalue \
-
gccjit::context::new_rvalue (gccjit::type vector_type, \
-
std::vector<gccjit::rvalue> elements) const
Given a vector type, and a vector of scalar rvalue elements, generate a
vector rvalue.
The number of elements needs to match that of the vector type.
Unary Operations
-
gccjit::rvalue \
-
gccjit::context::new_unary_op (enum gcc_jit_unary_op, \
-
gccjit::type result_type, \
-
gccjit::rvalue rvalue, \
-
gccjit::location loc)
Build a unary operation out of an input rvalue.
Parameter loc is optional.
This is a thin wrapper around the C API’s
:c:func:`gcc_jit_context_new_unary_op` and the available unary
operations are documented there.
There are shorter ways to spell the various specific kinds of unary
operation:
-
gccjit::rvalue \
-
gccjit::context::new_minus (gccjit::type result_type, \
-
gccjit::rvalue a, \
-
gccjit::location loc)
Negate an arithmetic value; for example:
gccjit::rvalue negpi = ctxt.new_minus (t_double, pi);
builds the equivalent of this C expression:
-
gccjit::rvalue \
-
new_bitwise_negate (gccjit::type result_type, \
-
gccjit::rvalue a, \
-
gccjit::location loc)
Bitwise negation of an integer value (one’s complement); for example:
gccjit::rvalue mask = ctxt.new_bitwise_negate (t_int, a);
builds the equivalent of this C expression:
-
gccjit::rvalue \
-
new_logical_negate (gccjit::type result_type, \
-
gccjit::rvalue a, \
-
gccjit::location loc)
Logical negation of an arithmetic or pointer value; for example:
gccjit::rvalue guard = ctxt.new_logical_negate (t_bool, cond);
builds the equivalent of this C expression:
The most concise way to spell them is with overloaded operators:
-
gccjit::rvalue operator- (gccjit::rvalue a)
gccjit::rvalue negpi = -pi;
-
gccjit::rvalue operator~ (gccjit::rvalue a)
gccjit::rvalue mask = ~a;
-
gccjit::rvalue operator! (gccjit::rvalue a)
gccjit::rvalue guard = !cond;
Binary Operations
-
gccjit::rvalue\
-
gccjit::context::new_binary_op (enum gcc_jit_binary_op, \
-
gccjit::type result_type, \
-
gccjit::rvalue a, \
-
gccjit::rvalue b, \
-
gccjit::location loc)
Build a binary operation out of two constituent rvalues.
Parameter loc is optional.
This is a thin wrapper around the C API’s
:c:func:`gcc_jit_context_new_binary_op` and the available binary
operations are documented there.
There are shorter ways to spell the various specific kinds of binary
operation:
-
gccjit::rvalue \
-
gccjit::context::new_plus (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_minus (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_mult (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_divide (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_modulo (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_bitwise_and (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_bitwise_xor (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_bitwise_or (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_logical_and (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_logical_or (gccjit::type result_type, \
-
gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
The most concise way to spell them is with overloaded operators:
-
gccjit::rvalue operator+ (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue sum = a + b;
-
gccjit::rvalue operator- (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue diff = a - b;
-
gccjit::rvalue operator* (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue prod = a * b;
-
gccjit::rvalue operator/ (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue result = a / b;
-
gccjit::rvalue operator% (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue mod = a % b;
-
gccjit::rvalue operator& (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue x = a & b;
-
gccjit::rvalue operator^ (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue x = a ^ b;
-
gccjit::rvalue operator| (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue x = a | b;
-
gccjit::rvalue operator&& (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue cond = a && b;
-
gccjit::rvalue operator|| (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue cond = a || b;
These can of course be combined, giving a terse way to build compound
expressions:
gccjit::rvalue discriminant = (b * b) - (four * a * c);
Comparisons
-
gccjit::rvalue \
-
gccjit::context::new_comparison (enum gcc_jit_comparison,\
-
gccjit::rvalue a, \
-
gccjit::rvalue b, \
-
gccjit::location loc)
Build a boolean rvalue out of the comparison of two other rvalues.
Parameter loc is optional.
This is a thin wrapper around the C API’s
:c:func:`gcc_jit_context_new_comparison` and the available kinds
of comparison are documented there.
There are shorter ways to spell the various specific kinds of binary
operation:
-
gccjit::rvalue \
-
gccjit::context::new_eq (gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_ne (gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_lt (gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_le (gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_gt (gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
-
gccjit::rvalue \
-
gccjit::context::new_ge (gccjit::rvalue a, gccjit::rvalue b, \
-
gccjit::location loc)
The most concise way to spell them is with overloaded operators:
-
gccjit::rvalue \
-
operator== (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue cond = (a == ctxt.zero (t_int));
-
gccjit::rvalue \
-
operator!= (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue cond = (i != j);
-
gccjit::rvalue \
-
operator< (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue cond = i < n;
-
gccjit::rvalue \
-
operator<= (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue cond = i <= n;
-
gccjit::rvalue \
-
operator> (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue cond = (ch > limit);
-
gccjit::rvalue \
-
operator>= (gccjit::rvalue a, gccjit::rvalue b)
gccjit::rvalue cond = (score >= ctxt.new_rvalue (t_int, 100));
Function calls
-
gcc_jit_rvalue *\
-
gcc_jit_context_new_call (gcc_jit_context *ctxt,\
-
gcc_jit_location *loc,\
-
gcc_jit_function *func,\
-
int numargs , gcc_jit_rvalue **args)
Given a function and the given table of argument rvalues, construct a
call to the function, with the result as an rvalue.
Note
gccjit::context::new_call() merely builds a
gccjit::rvalue i.e. an expression that can be evaluated,
perhaps as part of a more complicated expression.
The call won’t happen unless you add a statement to a function
that evaluates the expression.
For example, if you want to call a function and discard the result
(or to call a function with void return type), use
gccjit::block::add_eval():
/* Add "(void)printf (arg0, arg1);". */
block.add_eval (ctxt.new_call (printf_func, arg0, arg1));
Function pointers
-
gccjit::rvalue \
-
gccjit::function::get_address (gccjit::location loc)
- Get the address of a function as an rvalue, of function pointer
type.
Type-coercion
-
gccjit::rvalue \
-
gccjit::context::new_cast (gccjit::rvalue rvalue,\
-
gccjit::type type, \
-
gccjit::location loc)
Given an rvalue of T, construct another rvalue of another type.
Currently only a limited set of conversions are possible:
- int <-> float
- int <-> bool
- P* <-> Q*, for pointer types P and Q
Lvalues
-
gccjit::lvalue
An lvalue is something that can of the left-hand side of an assignment:
a storage area (such as a variable). It is a subclass of
gccjit::rvalue, where the rvalue is computed by reading from the
storage area.
It iss a thin wrapper around :c:type:`gcc_jit_lvalue *` from the C API.
-
gccjit::rvalue \
-
gccjit::lvalue::get_address (gccjit::location loc)
Take the address of an lvalue; analogous to:
in C.
Parameter “loc” is optional.
Global variables
-
gccjit::lvalue \
-
gccjit::context::new_global (enum gcc_jit_global_kind,\
-
gccjit::type type, \
-
const char *name, \
-
gccjit::location loc)
Add a new global variable of the given type and name to the context.
This is a thin wrapper around :c:func:`gcc_jit_context_new_global` from
the C API; the “kind” parameter has the same meaning as there.
Working with pointers, structs and unions
-
gccjit::lvalue \
-
gccjit::rvalue::dereference (gccjit::location loc)
Given an rvalue of pointer type T *, dereferencing the pointer,
getting an lvalue of type T. Analogous to:
in C.
Parameter “loc” is optional.
If you don’t need to specify the location, this can also be expressed using
an overloaded operator:
-
gccjit::lvalue \
-
gccjit::rvalue::operator* ()
gccjit::lvalue content = *ptr;
Field access is provided separately for both lvalues and rvalues:
-
gccjit::lvalue \
-
gccjit::lvalue::access_field (gccjit::field field, \
-
gccjit::location loc)
Given an lvalue of struct or union type, access the given field,
getting an lvalue of the field’s type. Analogous to:
in C.
-
gccjit::rvalue \
-
gccjit::rvalue::access_field (gccjit::field field, \
-
gccjit::location loc)
Given an rvalue of struct or union type, access the given field
as an rvalue. Analogous to:
in C.
-
gccjit::lvalue \
-
gccjit::rvalue::dereference_field (gccjit::field field, \
-
gccjit::location loc)
Given an rvalue of pointer type T * where T is of struct or union
type, access the given field as an lvalue. Analogous to:
in C, itself equivalent to (*EXPR).FIELD.
-
gccjit::lvalue \
-
gccjit::context::new_array_access (gccjit::rvalue ptr, \
-
gccjit::rvalue index, \
-
gccjit::location loc)
Given an rvalue of pointer type T *, get at the element T at
the given index, using standard C array indexing rules i.e. each
increment of index corresponds to sizeof(T) bytes.
Analogous to:
in C (or, indeed, to PTR + INDEX).
Parameter “loc” is optional.
For array accesses where you don’t need to specify a gccjit::location,
two overloaded operators are available:
gccjit::lvalue gccjit::rvalue::operator[] (gccjit::rvalue index)
gccjit::lvalue element = array[idx];
gccjit::lvalue gccjit::rvalue::operator[] (int index)
gccjit::lvalue element = array[0];