void *alloc_sockaddr(union sock_addr_union *sa) {
void **result;
switch(sa->s_gen.sa_family) {
#ifdef __linux__
case PF_UNIX:
result = xalloc(8);
ADDR_TYPE(result) = UNIX_ADDR;
ADDR_UNIX(result) = (void *)Cstring_to_string(sa->s_unix.sun_path);
break;
#endif
case PF_INET: {
void **inet_addr;
result = xalloc(8);
inet_addr = xalloc_atomic(8);
inet_addr[0] = (void *) sa->s_inet.sin_addr.s_addr;
inet_addr[1] = (void *) (int) ntohs(sa->s_inet.sin_port);
ADDR_TYPE(result) = INET_ADDR;
ADDR_INET(result) = (void *)inet_addr;
break;
}
default:
result = NULL;
unix_error(__FILE__,__LINE__,"bad family type");
}
return result;
}
bool assembler::compile_single(asmgen & asg, const func_binary & fb, command cmd)
{
int code = COMMAND_CODE(cmd);
int left = 0;
GET_VARIANT_POS(fb, left, m_pos);
m_pos++;
assert(ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_STACK || ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_CONTAINER);
int dest = 0;
GET_VARIANT_POS(fb, dest, m_pos);
m_pos++;
switch (code)
{
case OPCODE_NOT:
asg.variant_not(dest, left);
break;
default:
assert(0);
FKERR("[assembler] compile_single err code %d %s", code, OpCodeStr(code));
break;
}
return true;
}
bool assembler::compile_single_jne(asmgen & asg, const func_binary & fb, command cmd)
{
int code = COMMAND_CODE(cmd);
int left = 0;
GET_VARIANT_POS(fb, left, m_pos);
m_pos++;
assert(ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_STACK || ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_CONTAINER);
int dest = 0;
GET_VARIANT_POS(fb, dest, m_pos);
m_pos++;
int jump_bytecode_pos = COMMAND_CODE(GET_CMD(fb, m_pos));
m_pos++;
// 1.先计算结果
switch (code)
{
case OPCODE_NOT_JNE:
asg.variant_not(dest, left);
break;
default:
assert(0);
FKERR("[assembler] compile_single_jne err code %d %s", code, OpCodeStr(code));
break;
}
// 2.再jne
int jumppos = -1;
if (m_posmap.find(jump_bytecode_pos) != m_posmap.end())
{
jumppos = m_posmap[jump_bytecode_pos];
}
asg.variant_jne(dest, jumppos);
int jmpoffset = asg.size() - sizeof(int);
if (jumppos == -1)
{
// 记录下来
m_caremap[jmpoffset] = jump_bytecode_pos;
FKLOG("compile_single_jne caremap add %d %d", jmpoffset, jump_bytecode_pos);
}
else
{
asg.set_int(jmpoffset, jumppos - asg.size());
FKLOG("compile_single_jne set jne add %d -> %d", jmpoffset, jumppos - asg.size());
}
return true;
}
bool assembler::compile_cmp(asmgen & asg, const func_binary & fb, command cmd)
{
int code = COMMAND_CODE(cmd);
int left = 0;
GET_VARIANT_POS(fb, left, m_pos);
m_pos++;
int right = 0;
GET_VARIANT_POS(fb, right, m_pos);
m_pos++;
assert(ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_STACK || ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_CONTAINER);
int dest = 0;
GET_VARIANT_POS(fb, dest, m_pos);
m_pos++;
switch (code)
{
case OPCODE_AND:
asg.variant_and(dest, left, right);
break;
case OPCODE_OR:
asg.variant_or(dest, left, right);
break;
case OPCODE_LESS:
asg.variant_less(dest, left, right);
break;
case OPCODE_MORE:
asg.variant_more(dest, left, right);
break;
case OPCODE_EQUAL:
asg.variant_equal(dest, left, right);
break;
case OPCODE_MOREEQUAL:
asg.variant_moreequal(dest, left, right);
break;
case OPCODE_LESSEQUAL:
asg.variant_lessequal(dest, left, right);
break;
case OPCODE_NOTEQUAL:
asg.variant_notequal(dest, left, right);
break;
default:
assert(0);
FKERR("[assembler] compile_cmp err code %d %s", code, OpCodeStr(code));
break;
}
return true;
}
void get_sockaddr(void *pop_saddr,
union sock_addr_union *sa /* out */,
int *addr_len /* out */) {
switch (ADDR_TYPE(pop_saddr)) {
#ifdef __linux__
case UNIX_ADDR: {
int len;
len = ADDR_UNIX(pop_saddr)->size;
if (len >= sizeof(((struct sockaddr_un *)sa)->sun_path)) {
unix_error(__FILE__,__LINE__,"invalid path");
}
sa->s_gen.sa_family = PF_UNIX;
memcpy(sa->s_unix.sun_path, ADDR_UNIX(pop_saddr)->chars, (int)len);
sa->s_unix.sun_path[len] = '\0';
*addr_len =
((char *)&(sa->s_unix.sun_path) - (char *)&(sa->s_unix))
+ len;
break;
}
#endif
case INET_ADDR:
sa->s_gen.sa_family = PF_INET;
sa->s_inet.sin_addr.s_addr = ADDR_INET_IP(pop_saddr);
sa->s_inet.sin_port = htons(ADDR_INET_PORT(pop_saddr));
*addr_len = sizeof(struct sockaddr_in);
break;
default:
unix_error(__FILE__,__LINE__,"bad family type");
}
return;
}
bool assembler::compile_assign(asmgen & asg, const func_binary & fb, command cmd)
{
assert (ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_STACK || ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_CONTAINER);
int var = 0;
GET_VARIANT_POS(fb, var, m_pos);
m_pos++;
int value = 0;
GET_VARIANT_POS(fb, value, m_pos);
m_pos++;
asg.variant_assign(var, value);
CHECK_VARIANT_CON_POS(fb, var);
FKLOG("assign from %d to pos %d", var, value);
return true;
}
bool assembler::compile_math(asmgen & asg, const func_binary & fb, command cmd)
{
int code = COMMAND_CODE(cmd);
int left = 0;
GET_VARIANT_POS(fb, left, m_pos);
m_pos++;
int right = 0;
GET_VARIANT_POS(fb, right, m_pos);
m_pos++;
assert (ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_STACK || ADDR_TYPE(COMMAND_CODE(GET_CMD(fb, m_pos))) == ADDR_CONTAINER);
int dest = 0;
GET_VARIANT_POS(fb, dest, m_pos);
m_pos++;
switch (code)
{
case OPCODE_PLUS:
asg.variant_add(dest, left, right);
break;
case OPCODE_MINUS:
asg.variant_sub(dest, left, right);
break;
case OPCODE_MULTIPLY:
asg.variant_mul(dest, left, right);
break;
case OPCODE_DIVIDE:
asg.variant_div(dest, left, right);
break;
case OPCODE_DIVIDE_MOD:
asg.variant_div_mod(dest, left, right);
break;
default:
assert(0);
FKERR("[assembler] compile_math err code %d %s", code, OpCodeStr(code));
break;
}
return true;
}
