view release on metacpan or  search on metacpan

libjit/jit/jit-rules-x86.ins  view on Meta::CPAN

				x86_mov_reg_membase(inst, X86_EAX, $1, 0, 4);
				x86_widen_membase(inst, X86_ECX, $1, 4, 0, 1);
				x86_widen_membase(inst, X86_EDX, $1, 6, 0, 0);
			}
			x86_shift_reg_imm(inst, X86_SHL, X86_EDX, 16);
			x86_alu_reg_reg(inst, X86_OR, X86_EDX, X86_ECX);
			break;

		case 8:
			if(X86_EAX == $1)
			{
				x86_mov_reg_membase(inst, X86_EDX, $1, 4, 4);
				x86_mov_reg_membase(inst, X86_EAX, $1, 0, 4);
			}
			else
			{
				x86_mov_reg_membase(inst, X86_EAX, $1, 0, 4);
				x86_mov_reg_membase(inst, X86_EDX, $1, 4, 4);
			}
			break;
		}

		inst = jump_to_epilog(gen, inst, block);
	}

JIT_OP_SETUP_FOR_NESTED: branch
	[] -> {
		jit_nint nest_reg = jit_value_get_nint_constant(insn->value1);
		if(nest_reg == -1)
		{
			x86_push_reg(inst, X86_EBP);
		}
		else
		{
			x86_mov_reg_reg(inst, _jit_reg_info[nest_reg].cpu_reg,
							X86_EBP, sizeof(void *));
		}
	}

JIT_OP_SETUP_FOR_SIBLING: branch
	[] -> {
		jit_value_t parent;
		jit_nint level = jit_value_get_nint_constant(insn->value1);
		jit_nint nest_reg = jit_value_get_nint_constant(insn->value2);
		int cpu_reg;
		if(nest_reg == -1)
		{
			cpu_reg = X86_EAX;
		}
		else
		{
			cpu_reg = _jit_reg_info[nest_reg].cpu_reg;
		}
		parent = func->builder->parent_frame;
		if(parent->in_register)
		{
			x86_mov_reg_reg(inst, cpu_reg,
							_jit_reg_info[parent->reg].cpu_reg,
							sizeof(void *));
		}
		else if(parent->in_global_register)
		{
			x86_mov_reg_reg(inst, cpu_reg,
							_jit_reg_info[parent->global_reg].cpu_reg,
							sizeof(void *));
		}
		else
		{
			_jit_gen_fix_value(parent);
			x86_mov_reg_membase(inst, cpu_reg, X86_EBP,
							    parent->frame_offset, sizeof(void *));
		}
		while(level > 0)
		{
			gen->ptr = inst;
			_jit_gen_check_space(gen, 16);
			x86_mov_reg_membase(inst, cpu_reg, cpu_reg, 0, sizeof(void *));
			--level;
		}
		if(nest_reg == -1)
		{
			x86_push_reg(inst, cpu_reg);
		}
	}

JIT_OP_IMPORT: manual
	[] -> {
		unsigned char *inst;
		int reg;
		jit_nint level = jit_value_get_nint_constant(insn->value2);
		_jit_gen_fix_value(insn->value1);
		reg = _jit_regs_load_value
			(gen, func->builder->parent_frame, 1, 0);
		inst = gen->ptr;
		_jit_gen_check_space(gen, 32 + level * 8);
		reg = _jit_reg_info[reg].cpu_reg;
		while(level > 0)
		{
			x86_mov_reg_membase(inst, reg, reg, 0, sizeof(void *));
			--level;
		}
		if(insn->value1->frame_offset != 0)
		{
			x86_alu_reg_imm(inst, X86_ADD, reg, insn->value1->frame_offset);
		}
		gen->ptr = inst;
	}

/*
 * Exception handling.
 */

JIT_OP_THROW: branch
	[reg] -> {
		x86_push_reg(inst, $1);
		if(func->builder->setjmp_value != 0)
		{
			/* We have a "setjmp" block in the current function,
			   so we must record the location of the throw first */
			_jit_gen_fix_value(func->builder->setjmp_value);
			if(func->builder->position_independent)
			{
				x86_call_imm(inst, 0);
				x86_pop_membase(inst, X86_EBP,