type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | void dec_xor(DisasContext *dc)
{
if (!dc->type_b && (dc->imm & (1 << 10))) {
dec_pattern(dc);
return;
} |
functions | void msr_read(DisasContext *dc, TCGv d)
{
tcg_gen_mov_tl(d, cpu_SR[SR_MSR]);
} |
functions | void msr_write(DisasContext *dc, TCGv v)
{
dc->cpustate_changed = 1;
tcg_gen_mov_tl(cpu_SR[SR_MSR], v);
/* PVR, we have a processor version register. */
tcg_gen_ori_tl(cpu_SR[SR_MSR], cpu_SR[SR_MSR], (1 << 10));
} |
functions | void dec_msr(DisasContext *dc)
{
TCGv t0, t1;
unsigned int sr, to, rn;
int mem_index = cpu_mmu_index(dc->env);
sr = dc->imm & ((1 << 14) - 1);
to = dc->imm & (1 << 14);
dc->type_b = 1;
if (to)
dc->cpustate_changed = 1;
/* msrclr and msrset. */
if (!(dc->imm & (1 << 15))) {... |
functions | endif
if (to) {
LOG_DIS("m%ss sr%x r%d imm=%x\n", to ? "t" : "f", sr, dc->ra, dc->imm);
switch (sr) {
case 0:
break;
case 1:
msr_write(dc, cpu_R[dc->ra]);
break;
case 0x3:
tcg_gen_mov_tl(cpu_SR[SR_EA... |
functions | void t_gen_muls(TCGv d, TCGv d2, TCGv a, TCGv b)
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
tcg_gen_ext_i32_i64(t0, a);
tcg_gen_ext_i32_i64(t1, b);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(d, t0);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_... |
functions | void t_gen_mulu(TCGv d, TCGv d2, TCGv a, TCGv b)
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
tcg_gen_extu_i32_i64(t0, a);
tcg_gen_extu_i32_i64(t1, b);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(d, t0);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i6... |
functions | void dec_mul(DisasContext *dc)
{
TCGv d[2];
unsigned int subcode;
if ((dc->tb_flags & MSR_EE_FLAG)
&& (dc->env->pvr.regs[2] & PVR2_ILL_OPCODE_EXC_MASK)
&& !(dc->env->pvr.regs[0] & PVR0_USE_HW_MUL_MASK)) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_ILLEGAL_OP);
t_gen_raise_exce... |
functions | void dec_div(DisasContext *dc)
{
unsigned int u;
u = dc->imm & 2;
LOG_DIS("div\n");
if ((dc->env->pvr.regs[2] & PVR2_ILL_OPCODE_EXC_MASK)
&& !((dc->env->pvr.regs[0] & PVR0_USE_DIV_MASK))) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_ILLEGAL_OP);
t_gen_raise_exception(dc, EXCP_HW... |
functions | void dec_barrel(DisasContext *dc)
{
TCGv t0;
unsigned int s, t;
if ((dc->tb_flags & MSR_EE_FLAG)
&& (dc->env->pvr.regs[2] & PVR2_ILL_OPCODE_EXC_MASK)
&& !(dc->env->pvr.regs[0] & PVR0_USE_BARREL_MASK)) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_ILLEGAL_OP);
t_gen_raise_exce... |
functions | void dec_bit(DisasContext *dc)
{
TCGv t0, t1;
unsigned int op;
int mem_index = cpu_mmu_index(dc->env);
op = dc->ir & ((1 << 8) - 1);
switch (op) {
case 0x21:
/* src. */
t0 = tcg_temp_new();
LOG_DIS("src r%d r%d\n", dc->rd, dc->ra);
tcg_gen_a... |
functions | void sync_jmpstate(DisasContext *dc)
{
if (dc->jmp == JMP_DIRECT || dc->jmp == JMP_DIRECT_CC) {
if (dc->jmp == JMP_DIRECT) {
tcg_gen_movi_tl(env_btaken, 1);
} |
functions | void dec_imm(DisasContext *dc)
{
LOG_DIS("imm %x\n", dc->imm << 16);
tcg_gen_movi_tl(env_imm, (dc->imm << 16));
dc->tb_flags |= IMM_FLAG;
dc->clear_imm = 0;
} |
functions | void gen_load(DisasContext *dc, TCGv dst, TCGv addr,
unsigned int size)
{
int mem_index = cpu_mmu_index(dc->env);
if (size == 1) {
tcg_gen_qemu_ld8u(dst, addr, mem_index);
} |
functions | else if (size == 2) {
tcg_gen_qemu_ld16u(dst, addr, mem_index);
} |
functions | else if (size == 4) {
tcg_gen_qemu_ld32u(dst, addr, mem_index);
} |
functions | else if (dc->rb == 0) {
return &cpu_R[dc->ra];
} |
functions | void dec_byteswap(DisasContext *dc, TCGv dst, TCGv src, int size)
{
if (size == 4) {
tcg_gen_bswap32_tl(dst, src);
} |
functions | else if (size == 2) {
TCGv t = tcg_temp_new();
/* bswap16 assumes the high bits are zero. */
tcg_gen_andi_tl(t, src, 0xffff);
tcg_gen_bswap16_tl(dst, t);
tcg_temp_free(t);
} |
functions | void dec_load(DisasContext *dc)
{
TCGv t, *addr;
unsigned int size, rev = 0;
size = 1 << (dc->opcode & 3);
if (!dc->type_b) {
rev = (dc->ir >> 9) & 1;
} |
functions | void gen_store(DisasContext *dc, TCGv addr, TCGv val,
unsigned int size)
{
int mem_index = cpu_mmu_index(dc->env);
if (size == 1)
tcg_gen_qemu_st8(val, addr, mem_index);
else if (size == 2) {
tcg_gen_qemu_st16(val, addr, mem_index);
} |
functions | else if (size == 4) {
tcg_gen_qemu_st32(val, addr, mem_index);
} |
functions | void dec_store(DisasContext *dc)
{
TCGv t, *addr;
unsigned int size, rev = 0;
size = 1 << (dc->opcode & 3);
if (!dc->type_b) {
rev = (dc->ir >> 9) & 1;
} |
functions | void eval_cc(DisasContext *dc, unsigned int cc,
TCGv d, TCGv a, TCGv b)
{
switch (cc) {
case CC_EQ:
tcg_gen_setcond_tl(TCG_COND_EQ, d, a, b);
break;
case CC_NE:
tcg_gen_setcond_tl(TCG_COND_NE, d, a, b);
break;
case CC... |
functions | void eval_cond_jmp(DisasContext *dc, TCGv pc_true, TCGv pc_false)
{
int l1;
l1 = gen_new_label();
/* Conditional jmp. */
tcg_gen_mov_tl(cpu_SR[SR_PC], pc_false);
tcg_gen_brcondi_tl(TCG_COND_EQ, env_btaken, 0, l1);
tcg_gen_mov_tl(cpu_SR[SR_PC], pc_true);
gen_set_label(l1);
} |
functions | void dec_bcc(DisasContext *dc)
{
unsigned int cc;
unsigned int dslot;
cc = EXTRACT_FIELD(dc->ir, 21, 23);
dslot = dc->ir & (1 << 25);
LOG_DIS("bcc%s r%d %x\n", dslot ? "d" : "", dc->ra, dc->imm);
dc->delayed_branch = 1;
if (dslot) {
dc->delayed_branch = 2;
dc->tb_flags |= D... |
functions | void dec_br(DisasContext *dc)
{
unsigned int dslot, link, abs;
int mem_index = cpu_mmu_index(dc->env);
dslot = dc->ir & (1 << 20);
abs = dc->ir & (1 << 19);
link = dc->ir & (1 << 18);
LOG_DIS("br%s%s%s%s imm=%x\n",
abs ? "a" : "", link ? "l" : "",
dc->type_b ? "i" : ""... |
functions | void do_rti(DisasContext *dc)
{
TCGv t0, t1;
t0 = tcg_temp_new();
t1 = tcg_temp_new();
tcg_gen_shri_tl(t0, cpu_SR[SR_MSR], 1);
tcg_gen_ori_tl(t1, cpu_SR[SR_MSR], MSR_IE);
tcg_gen_andi_tl(t0, t0, (MSR_VM | MSR_UM));
tcg_gen_andi_tl(t1, t1, ~(MSR_VM | MSR_UM));
tcg_gen_or_tl(t1, t1, t0);
... |
functions | void do_rtb(DisasContext *dc)
{
TCGv t0, t1;
t0 = tcg_temp_new();
t1 = tcg_temp_new();
tcg_gen_andi_tl(t1, cpu_SR[SR_MSR], ~MSR_BIP);
tcg_gen_shri_tl(t0, t1, 1);
tcg_gen_andi_tl(t0, t0, (MSR_VM | MSR_UM));
tcg_gen_andi_tl(t1, t1, ~(MSR_VM | MSR_UM));
tcg_gen_or_tl(t1, t1, t0);
msr_w... |
functions | void do_rte(DisasContext *dc)
{
TCGv t0, t1;
t0 = tcg_temp_new();
t1 = tcg_temp_new();
tcg_gen_ori_tl(t1, cpu_SR[SR_MSR], MSR_EE);
tcg_gen_andi_tl(t1, t1, ~MSR_EIP);
tcg_gen_shri_tl(t0, t1, 1);
tcg_gen_andi_tl(t0, t0, (MSR_VM | MSR_UM));
tcg_gen_andi_tl(t1, t1, ~(MSR_VM | MSR_UM));
... |
functions | void dec_rts(DisasContext *dc)
{
unsigned int b_bit, i_bit, e_bit;
int mem_index = cpu_mmu_index(dc->env);
i_bit = dc->ir & (1 << 21);
b_bit = dc->ir & (1 << 22);
e_bit = dc->ir & (1 << 23);
dc->delayed_branch = 2;
dc->tb_flags |= D_FLAG;
tcg_gen_st_tl(tcg_const_tl(dc->type_b && (dc->t... |
functions | else if (b_bit) {
LOG_DIS("rtbd ir=%x\n", dc->ir);
if ((dc->tb_flags & MSR_EE_FLAG)
&& mem_index == MMU_USER_IDX) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_PRIVINSN);
t_gen_raise_exception(dc, EXCP_HW_EXCP);
} |
functions | else if (e_bit) {
LOG_DIS("rted ir=%x\n", dc->ir);
if ((dc->tb_flags & MSR_EE_FLAG)
&& mem_index == MMU_USER_IDX) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_PRIVINSN);
t_gen_raise_exception(dc, EXCP_HW_EXCP);
} |
functions | int dec_check_fpuv2(DisasContext *dc)
{
int r;
r = dc->env->pvr.regs[2] & PVR2_USE_FPU2_MASK;
if (!r && (dc->tb_flags & MSR_EE_FLAG)) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_FPU);
t_gen_raise_exception(dc, EXCP_HW_EXCP);
} |
functions | void dec_fpu(DisasContext *dc)
{
unsigned int fpu_insn;
if ((dc->tb_flags & MSR_EE_FLAG)
&& (dc->env->pvr.regs[2] & PVR2_ILL_OPCODE_EXC_MASK)
&& !((dc->env->pvr.regs[2] & PVR2_USE_FPU_MASK))) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_ILLEGAL_OP);
t_gen_raise_exception(dc, EXC... |
functions | void dec_null(DisasContext *dc)
{
if ((dc->tb_flags & MSR_EE_FLAG)
&& (dc->env->pvr.regs[2] & PVR2_ILL_OPCODE_EXC_MASK)) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_ILLEGAL_OP);
t_gen_raise_exception(dc, EXCP_HW_EXCP);
return;
} |
functions | void dec_stream(DisasContext *dc)
{
int mem_index = cpu_mmu_index(dc->env);
TCGv_i32 t_id, t_ctrl;
int ctrl;
LOG_DIS("%s%s imm=%x\n", dc->rd ? "get" : "put",
dc->type_b ? "" : "d", dc->imm);
if ((dc->tb_flags & MSR_EE_FLAG) && (mem_index == MMU_USER_IDX)) {
tcg_gen_movi_tl(cpu_... |
functions | void decode(DisasContext *dc)
{
uint32_t ir;
int i;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP)))
tcg_gen_debug_insn_start(dc->pc);
dc->ir = ir = ldl_code(dc->pc);
LOG_DIS("%8.8x\t", dc->ir);
if (dc->ir)
dc->nr_nops = 0;
else {
if ((dc->tb_flags & MSR_EE_FLAG)
... |
functions | void check_breakpoint(CPUState *env, DisasContext *dc)
{
CPUBreakpoint *bp;
if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == dc->pc) {
t_gen_raise_exception(dc, EXCP_DEBUG);
dc->is_jmp = DISAS_UPDA... |
functions | void
gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb,
int search_pc)
{
uint16_t *gen_opc_end;
uint32_t pc_start;
int j, lj;
struct DisasContext ctx;
struct DisasContext *dc = &ctx;
uint32_t next_page_start, org_flags;
target_ulong npc;
in... |
functions | else if (dc->jmp == JMP_DIRECT) {
t_sync_flags(dc);
gen_goto_tb(dc, 0, dc->jmp_pc);
dc->is_jmp = DISAS_TB_JUMP;
} |
functions | else if (dc->jmp == JMP_DIRECT_CC) {
int l1;
t_sync_flags(dc);
l1 = gen_new_label();
/* Conditional jmp. */
tcg_gen_brcondi_tl(TCG_COND_NE, env_btaken, 0, l1);
gen_goto_tb(dc, 1, dc->pc);
... |
functions | void gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
{
gen_intermediate_code_internal(env, tb, 0);
} |
functions | void gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
{
gen_intermediate_code_internal(env, tb, 1);
} |
functions | void cpu_dump_state (CPUState *env, FILE *f, fprintf_function cpu_fprintf,
int flags)
{
int i;
if (!env || !f)
return;
cpu_fprintf(f, "IN: PC=%x %s\n",
env->sregs[SR_PC], lookup_symbol(env->sregs[SR_PC]));
cpu_fprintf(f, "rmsr=%x resr=%x rear=%x debug=%x im... |
functions | void cpu_reset (CPUState *env)
{
if (qemu_loglevel_mask(CPU_LOG_RESET)) {
qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
log_cpu_state(env, 0);
} |
functions | void restore_state_to_opc(CPUState *env, TranslationBlock *tb, int pc_pos)
{
env->sregs[SR_PC] = gen_opc_pc[pc_pos];
} |
includes |
#include <stdio.h> |
includes | #include <time.h> |
defines |
#define ACC_TIME_FORMAT_SIZE 128 |
defines | #define get_ft_body( _ft_hdr) \ |
defines |
#define SET_EMPTY_VAL(_i) \ |
defines |
#define SET_LOG_ATTR(_n,_atr) \ |
defines | #define UINT4 uint32_t |
defines |
#define ADD_RAD_AVPAIR(_attr,_val,_len) \ |
defines |
#define AA_REQUEST 265 |
defines | #define AA_ANSWER 265 |
defines |
#define ACCOUNTING_REQUEST 271 |
defines | #define ACCOUNTING_ANSWER 271 |
functions | int core2strar(struct sip_msg *req, str *c_vals, int *i_vals, char *t_vals)
{
struct to_body *ft_body;
struct hdr_field *from;
struct hdr_field *to;
/* method : request/reply - cseq parsed in acc_preparse_req() */
c_vals[0] = get_cseq(req)->method;
t_vals[0] = TYPE_STR;
/* from/to URI and TAG */
if (req->msg_... |
functions | void acc_log_init(void)
{
struct acc_extra *extra;
int n;
n = 0;
/* fixed core attributes */
SET_LOG_ATTR(n,METHOD);
SET_LOG_ATTR(n,FROMTAG);
SET_LOG_ATTR(n,TOTAG);
SET_LOG_ATTR(n,CALLID);
SET_LOG_ATTR(n,CODE);
SET_LOG_ATTR(n,STATUS);
/* init the extra db keys */
for(extra=log_extra; extra ; extra=extra-... |
functions | int acc_log_request( struct sip_msg *rq)
{
static char log_msg[MAX_SYSLOG_SIZE];
static char *log_msg_end=log_msg+MAX_SYSLOG_SIZE-2;
char *p;
int n;
int m;
int o;
int i;
struct tm *t;
/* get default values */
m = core2strar( rq, val_arr, int_arr, type_arr);
/* get extra values */
o = extra2strar( log_extr... |
functions | else if(acc_time_mode==2) {
LM_GEN2(log_facility, log_level, "%.*stimestamp=%lu;%s=%.3f%s",
acc_env.text.len, acc_env.text.s,(unsigned long)acc_env.ts,
acc_time_attr.s,
(((double)(acc_env.tv.tv_sec * 1000)
+ (acc_env.tv.tv_usec / 1000)) / 1000),
log_msg);
} |
functions | else if(acc_time_mode==3 || acc_time_mode==4) {
if(acc_time_mode==3) {
t = localtime(&acc_env.ts);
} |
functions | int acc_get_db_handlers(void **vf, void **vh) {
if(db_handle==0)
return -1;
*vf = (void*)&acc_dbf;
*vh = (void*)db_handle;
return 0;
} |
functions | void acc_db_init_keys(void)
{
struct acc_extra *extra;
int time_idx;
int i;
int n;
/* init the static db keys */
n = 0;
/* caution: keys need to be aligned to core format */
db_keys[n++] = &acc_method_col;
db_keys[n++] = &acc_fromtag_col;
db_keys[n++] = &acc_totag_col;
db_keys[n++] = &acc_callid_col;
db_ke... |
functions | else if(acc_time_mode==2) {
VAL_TYPE(db_vals+time_idx+1)=DB1_DOUBLE;
} |
functions | else if(acc_time_mode==3 || acc_time_mode==4) {
VAL_TYPE(db_vals+time_idx+1)=DB1_STRING;
} |
functions | int acc_db_init(const str* db_url)
{
if (db_bind_mod(db_url, &acc_dbf)<0){
LM_ERR("bind_db failed\n");
return -1;
} |
functions | int acc_db_init_child(const str *db_url)
{
db_handle=acc_dbf.init(db_url);
if (db_handle==0){
LM_ERR("unable to connect to the database\n");
return -1;
} |
functions | void acc_db_close(void)
{
if (db_handle && acc_dbf.close)
acc_dbf.close(db_handle);
} |
functions | int acc_db_request( struct sip_msg *rq)
{
int m;
int n;
int i;
int o;
struct tm *t;
/* formated database columns */
m = core2strar( rq, val_arr, int_arr, type_arr );
for(i=0; i<m; i++)
VAL_STR(db_vals+i) = val_arr[i];
/* time value */
VAL_TIME(db_vals+(m++)) = acc_env.ts;
/* extra time value */
if(acc_t... |
functions | else if(acc_time_mode==2) {
VAL_DOUBLE(db_vals+(m++)) = ((double)(acc_env.tv.tv_sec * 1000)
+ (acc_env.tv.tv_usec / 1000)) / 1000;
i++;
} |
functions | else if(acc_time_mode==3 || acc_time_mode==4) {
if(acc_time_mode==3) {
t = localtime(&acc_env.ts);
} |
functions | else if(acc_db_insert_mode==2 && acc_dbf.insert_async!=NULL) {
if (acc_dbf.insert_async(db_handle, db_keys, db_vals, m) < 0) {
LM_ERR("failed to insert async into database\n");
goto error;
} |
functions | else if(acc_db_insert_mode==2 && acc_dbf.insert_async!=NULL) {
if(acc_dbf.insert_async(db_handle,db_keys,db_vals,m+n)<0) {
LM_ERR("failed to insert async into database\n");
goto error;
} |
functions | UINT4 phrase2code(str *phrase)
{
UINT4 code;
int i;
if (phrase->len<3) return 0;
code=0;
for (i=0;i<3;i++) {
if (!(phrase->s[i]>='0' && phrase->s[i]<'9'))
return 0;
code=code*10+phrase->s[i]-'0';
} |
functions | int init_acc_rad(char *rad_cfg, int srv_type)
{
int n;
memset(rd_attrs, 0, sizeof(rd_attrs));
memset(rd_vals, 0, sizeof(rd_vals));
rd_attrs[RA_ACCT_STATUS_TYPE].n = "Acct-Status-Type";
rd_attrs[RA_SERVICE_TYPE].n = "Service-Type";
rd_attrs[RA_SIP_RESPONSE_CODE].n = "Sip-Response-Code";
rd_attrs[RA_SIP_MET... |
functions | UINT4 rad_status( struct sip_msg *req, int code )
{
str tag;
unsigned int in_dialog_req = 0;
tag = get_to(req)->tag_value;
if(tag.s!=0 && tag.len!=0)
in_dialog_req = 1;
if (req->REQ_METHOD==METHOD_INVITE && in_dialog_req == 0
&& code>=200 && code<300)
return rd_vals[... |
functions | int acc_rad_request( struct sip_msg *req )
{
int attr_cnt;
VALUE_PAIR *send;
UINT4 av_type;
int offset;
int i;
int m;
int o;
send=NULL;
attr_cnt = core2strar( req, val_arr, int_arr, type_arr );
/* not interested in the last 2 values */
attr_cnt -= 2;
av_type = rad_status( req, acc_env.code); /* RADIUS st... |
functions | int acc_diam_init()
{
int n;
int m;
n = 0;
/* caution: keep these aligned to core acc output */
diam_attrs[n++] = AVP_SIP_METHOD;
diam_attrs[n++] = AVP_SIP_FROM_TAG;
diam_attrs[n++] = AVP_SIP_TO_TAG;
diam_attrs[n++] = AVP_SIP_CALLID;
diam_attrs[n++] = AVP_SIP_STATUS;
m = extra2int( dia_extra, diam_attrs+n);... |
functions | long diam_status(struct sip_msg *rq, int code)
{
if ((rq->REQ_METHOD==METHOD_INVITE || rq->REQ_METHOD==METHOD_ACK)
&& code>=200 && code<300)
return AAA_ACCT_START;
if ((rq->REQ_METHOD==METHOD_BYE || rq->REQ_METHOD==METHOD_CANCEL))
return AAA_ACCT_STOP;
if (code>=200 && code <=300)
return AAA_ACCT_EVEN... |
functions | int acc_diam_request( struct sip_msg *req )
{
int attr_cnt;
int cnt;
AAAMessage *send = NULL;
AAA_AVP *avp;
struct sip_uri puri;
str *uri;
int ret;
int i;
int status;
char tmp[2];
unsigned int mid;
int m;
int o;
attr_cnt = core2strar( req, val_arr, int_arr, type_arr );
/* last value is not used */
attr... |
functions | int acc_run_engines(struct sip_msg *msg, int type, int *reset)
{
acc_info_t inf;
acc_engine_t *e;
e = acc_api_get_engines();
if(e==NULL)
return 0;
memset(&inf, 0, sizeof(acc_info_t));
inf.env = &acc_env;
inf.varr = val_arr;
inf.iarr = int_arr;
inf.tarr = type_arr;
inf.leg_info = leg_info;
while(e) {
... |
functions | void acc_api_set_arrays(acc_info_t *inf)
{
inf->varr = val_arr;
inf->iarr = int_arr;
inf->tarr = type_arr;
inf->leg_info = leg_info;
} |
defines |
#define AESx(x) ( ((SPH_C32(x) >> 24) & SPH_C32(0x000000FF)) \ |
defines |
#define AES0 AES0_BE |
defines | #define AES1 AES1_BE |
defines | #define AES2 AES2_BE |
defines | #define AES3 AES3_BE |
defines |
#define AES_ROUND_BE(X0, X1, X2, X3, K0, K1, K2, K3, Y0, Y1, Y2, Y3) do { \ |
defines |
#define AES_ROUND_NOKEY_BE(X0, X1, X2, X3, Y0, Y1, Y2, Y3) \ |
defines |
#define AESx(x) SPH_C32(x) |
defines | #define AES0 AES0_LE |
defines | #define AES1 AES1_LE |
defines | #define AES2 AES2_LE |
defines | #define AES3 AES3_LE |
defines |
#define AES_ROUND_LE(X0, X1, X2, X3, K0, K1, K2, K3, Y0, Y1, Y2, Y3) do { \ |
defines |
#define AES_ROUND_NOKEY_LE(X0, X1, X2, X3, Y0, Y1, Y2, Y3) \ |
includes |
#include <linux/err.h> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.