Function check_cond

tangle/src/oper.rs:5–82

(&mut self, cond: IntCC)

const STACK: RegSpec = RegSpec::rsp();

    pub fn check_cond(&mut self, cond: IntCC) -> JitValue {
        let flags = match cond {
            IntCC::UnsignedGreaterThan => {
                vec![Flags::CF, Flags::ZF]
            },
            IntCC::UnsignedGreaterThanOrEqual => {
                vec![Flags::CF]
            },
            IntCC::UnsignedLessThan => {
                vec![Flags::CF]
            },
            IntCC::UnsignedLessThanOrEqual => {
                vec![Flags::CF, Flags::ZF]
            },
            IntCC::Equal => {
                vec![Flags::ZF]
            },
            IntCC::NotEqual => {
                vec![Flags::ZF]
            },
            _ => unimplemented!("unimplemented check_cond for {}", cond),
        };
        let mut val = None;
        let mut same = true;
        for flag in flags {
            let flag_cond = &self.context.flags[flag as usize];
            if let Some(set_val) = val {
                if set_val != flag_cond {
                    same = false;
                    break;
                }
            } else {
                val = Some(flag_cond);
            }
        }
        if !same {
            unimplemented!();
        }
        if let Some(JitFlag::Unknown(left, right, res)) = val {
            JitValue::Flag(self.builder.ins().ifcmp(*left, *right))
        } else if let Some(JitFlag::Known(c)) = val {
            println!("constant eflags {:?} with cond {}", c, cond);
            let tmp = match cond {
                IntCC::UnsignedGreaterThan => {
                    // CF=0 and ZF=0
                    let cf = self.context.check_flag(Flags::CF, false, self.builder);
                    let zf = self.context.check_flag(Flags::ZF, false, self.builder);
                    self.band(cf, zf)
                },
                IntCC::UnsignedGreaterThanOrEqual => {
                    // CF=0
                    self.context.check_flag(Flags::CF, false, self.builder)
                },
                IntCC::UnsignedLessThan => {
                    // CF=1
                    self.context.check_flag(Flags::CF, true, self.builder)
                },
                IntCC::UnsignedLessThanOrEqual => {