rhs
libcrux_ml_kem_vector_portable_vector_type_PortableVector *rhs) {
lhs.elements[uu____0] = lhs.elements[uu____0] + rhs->elements[i0];
libcrux_ml_kem_vector_portable_vector_type_PortableVector *rhs) {
return libcrux_ml_kem_vector_portable_arithmetic_add(lhs, rhs);
libcrux_ml_kem_vector_portable_vector_type_PortableVector *rhs) {
lhs.elements[uu____0] = lhs.elements[uu____0] - rhs->elements[i0];
libcrux_ml_kem_vector_portable_vector_type_PortableVector *rhs) {
return libcrux_ml_kem_vector_portable_arithmetic_sub(lhs, rhs);
libcrux_ml_kem_vector_portable_vector_type_PortableVector *rhs,
lhs, rhs, zeta0, (size_t)0U, (size_t)1U, &out);
lhs, rhs, -zeta0, (size_t)2U, (size_t)3U, &out);
lhs, rhs, zeta1, (size_t)4U, (size_t)5U, &out);
lhs, rhs, -zeta1, (size_t)6U, (size_t)7U, &out);
lhs, rhs, zeta2, (size_t)8U, (size_t)9U, &out);
lhs, rhs, -zeta2, (size_t)10U, (size_t)11U, &out);
lhs, rhs, zeta3, (size_t)12U, (size_t)13U, &out);
lhs, rhs, -zeta3, (size_t)14U, (size_t)15U, &out);
libcrux_ml_kem_vector_portable_vector_type_PortableVector *rhs,
return libcrux_ml_kem_vector_portable_ntt_ntt_multiply(lhs, rhs, zeta0, zeta1,
Eurydice_slice lhs, Eurydice_slice rhs) {
(uint32_t)Eurydice_slice_index(rhs, i0, uint8_t, uint8_t *));
Eurydice_slice lhs, Eurydice_slice rhs) {
return libcrux_ml_kem_constant_time_ops_compare(lhs, rhs);
Eurydice_slice lhs, Eurydice_slice rhs, uint8_t selector,
((uint32_t)Eurydice_slice_index(rhs, i0, uint8_t, uint8_t *) &
Eurydice_slice lhs, Eurydice_slice rhs, uint8_t selector,
libcrux_ml_kem_constant_time_ops_select_ct(lhs, rhs, selector, ret);
libcrux_ml_kem_polynomial_PolynomialRingElement_f0 *rhs) {
&self->coefficients[i0], &rhs->coefficients[i0],
libcrux_ml_kem_polynomial_PolynomialRingElement_f0 *rhs) {
&rhs->coefficients[i0]);
void ossl_ml_dsa_poly_ntt_mult(const POLY *lhs, const POLY *rhs, POLY *out);
void ossl_ml_dsa_poly_ntt_mult(const POLY *lhs, const POLY *rhs, POLY *out)
out->coeff[i] = reduce_montgomery((uint64_t)lhs->coeff[i] * (uint64_t)rhs->coeff[i]);
poly_add(const POLY *lhs, const POLY *rhs, POLY *out)
out->coeff[i] = reduce_once(lhs->coeff[i] + rhs->coeff[i]);
poly_sub(const POLY *lhs, const POLY *rhs, POLY *out)
out->coeff[i] = mod_sub(lhs->coeff[i], rhs->coeff[i]);
vector_mult_scalar(const VECTOR *lhs, const POLY *rhs, VECTOR *out)
ossl_ml_dsa_poly_ntt_mult(lhs->poly + i, rhs, out->poly + i);
vector_add(const VECTOR *lhs, const VECTOR *rhs, VECTOR *out)
poly_add(lhs->poly + i, rhs->poly + i, out->poly + i);
vector_sub(const VECTOR *lhs, const VECTOR *rhs, VECTOR *out)
poly_sub(lhs->poly + i, rhs->poly + i, out->poly + i);
static void vector_add(scalar *lhs, const scalar *rhs, int rank)
scalar_add(lhs++, rhs++);
static void inner_product(scalar *out, const scalar *lhs, const scalar *rhs,
scalar_mult(out, lhs, rhs);
scalar_mult_add(out, ++lhs, ++rhs);
static void scalar_add(scalar *lhs, const scalar *rhs)
lhs->c[i] = reduce_once(lhs->c[i] + rhs->c[i]);
static void scalar_sub(scalar *lhs, const scalar *rhs)
lhs->c[i] = reduce_once(lhs->c[i] - rhs->c[i] + kPrime);
const scalar *rhs)
const uint16_t *lc = lhs->c, *rc = rhs->c;
const scalar *rhs)
const uint16_t *lc = lhs->c, *rc = rhs->c;
SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
SwigValueWrapper(const SwigValueWrapper<T>& rhs);
if (ctx->rhs) {
*ctx->rhs = '.';
strcpy(ctx->rhs + 1,
if (ctx->rhs)
free(ctx->rhs);
free(ctx->rhs);
const char *rhs;
rhs = name + (p - bindname);
rhs = *rhs_list;
rhs = ctx->rhs;
len += strlen(rhs) + ((rhs[0] != '.') ? 1 : 0);
if (rhs[0] != '.')
strcat(bindname, rhs);
ctx->rhs = strdup(DEF_RHS);
if (ctx->lhs && ctx->rhs)
ctx->rhs = NULL;
? &ctx->lhs : &ctx->rhs;
if (!ctx->rhs || ctx->classes[0] == 0 ||
char *rhs; /* AKA the default hesiod domain */
if (ctx->rhs)
free(ctx->rhs);
ctx->rhs = malloc(strlen(p) + 2);
Guid::operator==(const Guid& rhs) const
return (m_GUID == rhs.m_GUID);
Guid::operator!=(const Guid& rhs) const
return (m_GUID != rhs.m_GUID);
bool operator==(const Guid& rhs) const;
bool operator!=(const Guid& rhs) const;
config::chop_var(char *&buffer, char *&lhs, char *&rhs) const
rhs = walker;
rhs[-2] = '\0';
rhs = walker;
rhs[-1] = '\0';
char *rhs;
if (!chop_var(buffer, lhs, rhs))
set_variable(lhs, rhs);
bool chop_var(char *&buffer, char *&lhs, char *&rhs) const;
#define CHK(lhs, op, rhs, fmt) \
if (lhs op rhs) { \
#lhs, (intmax_t)lhs, #op, #rhs, (intmax_t)rhs); \
scsi_devid_match(uint8_t *lhs, size_t lhs_len, uint8_t *rhs, size_t rhs_len)
rhs_end = rhs + rhs_len;
rhs_id = (struct scsi_vpd_id_descriptor *)rhs;
int scsi_devid_match(uint8_t *rhs, size_t rhs_len,
ktime_sub(ktime_t lhs, ktime_t rhs)
return (lhs - rhs);
ktime_add(ktime_t lhs, ktime_t rhs)
return (lhs + rhs);
timespec_sub(struct timespec lhs, struct timespec rhs)
timespecsub(&lhs, &rhs, &ts);
db_expr_t lhs, rhs;
if (!db_term(&rhs)) {
lhs *= rhs;
lhs &= rhs;
if (rhs == 0) {
lhs /= rhs;
lhs %= rhs;
lhs = roundup(lhs, rhs);
db_expr_t lhs, rhs;
if (!db_mult_expr(&rhs)) {
lhs += rhs;
lhs -= rhs;
lhs |= rhs;
db_expr_t lhs, rhs;
if (!db_add_expr(&rhs)) {
if (rhs < 0) {
db_printf("Negative shift amount %jd\n", (intmax_t)rhs);
lhs <<= rhs;
lhs = (db_addr_t)lhs >> rhs;
db_expr_t lhs, rhs;
if (!db_shift_expr(&rhs)) {
lhs = (lhs == rhs);
lhs = (lhs != rhs);
lhs = (lhs > rhs);
lhs = (lhs >= rhs);
lhs = (lhs < rhs);
lhs = (lhs <= rhs);
db_expr_t lhs, rhs;
if (!db_logical_relation_expr(&rhs)) {
lhs = (lhs && rhs);
db_expr_t lhs, rhs;
if (!db_logical_and_expr(&rhs)) {
lhs = (lhs || rhs);
const struct bhnd_core_info *rhs);
compare_ascending_probe_order(const void *lhs, const void *rhs)
rdev = (*(const device_t *) rhs);
compare_descending_probe_order(const void *lhs, const void *rhs)
return (compare_ascending_probe_order(rhs, lhs));
static int compare_ascending_probe_order(const void *lhs, const void *rhs);
const void *rhs);
const struct bhnd_core_info *rhs)
md = bhnd_core_get_match_desc(rhs);
bhnd_sprom_opcode_sort_idx(const void *lhs, const void *rhs)
r = rhs;
bhnd_nvram_opcode_idx_vid_compare(const void *key, const void *rhs)
entry = rhs;
static int bhnd_sprom_opcode_sort_idx(const void *lhs, const void *rhs);
const void *rhs);
bhnd_nvstore_idx_cmp(const void *lhs, const void *rhs, void *ctx)
r_cookiep = *(void * const *)rhs;
if (order != 0 || lhs == rhs)
static int bhnd_nvstore_idx_cmp(const void *lhs, const void *rhs, void *ctx);
bhnd_nvram_find_vardefn_compare(const void *key, const void *rhs)
const struct bhnd_nvram_vardefn *r = rhs;
#define FCHK(lhs, op, rhs, fmt) \
if (lhs op rhs) { \
#lhs, (intmax_t)lhs, #op, #rhs, (intmax_t)rhs); \
#define WCHK(lhs, op, rhs, fmt) \
if (lhs op rhs) { \
#lhs, (intmax_t)lhs, #op, #rhs, (intmax_t)rhs, wmsg);\
lhs = rhs; \
expression_ptr rhs;
new_left->rhs = std::move(lhs);
result r = (*rhs)();
rhs->dump();
expression_ptr rhs;
result r = (*rhs)();
rhs->dump();
constexpr T operator()(const T &lhs, const T &rhs) const
return lhs << rhs;
constexpr T operator()(const T &lhs, const T &rhs) const
return lhs >> rhs;
result r = (*binary_operator_base::rhs)();
expression_ptr rhs(parse_expression());
if (!rhs)
if (rhs->precedence() < expr->precedence())
expr->rhs = std::move(rhs);
static_cast<binary_operator_base*>(rhs.get());
return rhs;
pci_conf_compar(const void *lhs, const void *rhs)
r = rhs;