Function adc

tangle/src/oper.rs:123–219

Add with carry

(&mut self, left: JitTemp, right: JitTemp, carry: JitTemp)

    /// Add with carry
    pub fn adc<const FLAG:bool>(&mut self, left: JitTemp, right: JitTemp, carry: JitTemp) -> JitTemp {
        use JitTemp::*;
        use Flags::*;
        let flags = vec![OF, SF, ZF, AF, PF, CF];
        match (left.clone(), right.clone(), carry.clone()) {
            (Value(val_left, typ_left), Value(val_right, _), Flag(val_carry)) => {
                let (res, flag) = self.builder.ins().iadd_carry(val_left, val_right, val_carry);
                self.context.set_flags(flags, (val_left, val_right, flag));
                Value(res, typ_left)
            },
            (_, _, carry) if carry.is_const() => {
                // basically, this sucks a lot:
                // iadd_carry is broken on cranelift (#2860), so we work around
                // it by lowering to a normal iadd_cout in the CF=false case,
                // and to two iadd_cout's in the CF=true case (and then have to
                // fixup our carry flag so the spliced +1 doesn't break).
                let carry = carry.into_usize(self.builder).unwrap();
                if carry == 0 {
                    return self.add::<FLAG>(left, right);
                } else {
                    let left_plus_one = self.add::<FLAG>(left, Const8(1));
                    // track if the +1 overflowed
                    let carried = self.context.check_flag(Flags::CF, true, self.builder);

                    let res = self.add::<FLAG>(left_plus_one, right);
                    if(FLAG) {
                        // if the +1 definitely carried, we know that carry has to
                        // be set.
                        println!("carried = {:?}", carried);
                        if let JitTemp::Const64(1) = carried {
                            self.context.flags[Flags::CF as usize] = JitFlag::Known(1 << Flags::CF as usize);
                        } else if let JitTemp::Const64(0) = carried {
                            ();
                        } else if let JitTemp::Value(val, typ) = carried {
                            unimplemented!("double check this");
                            // but if we don't know, then we have to OR it with
                            // the other carry flag (which sucks!)
                            let other_carried = self.context.check_flag(Flags::CF, true, self.builder);
                            let maybe_carried = self.bor(other_carried, carried);
                            self.context.set_flags(vec![Flags::CF],
                                (left_plus_one.into_ssa(typ, self.builder),
                                 right.into_ssa(typ, self.builder),
                                 maybe_carried.into_ssa(typ, self.builder)));
                        } else {
                            unimplemented!();
                        }
                    }
                    return res;
                }
            },
            (left @ Value(_, _), right @ _, carry @ _) |
            (left @ _, right @ Value(_, _), carry @ _) |
            (left @ _, right @ _, carry @ Flag(_)) => {
                let typ = Type::int((left.width() * 8) as u16).unwrap();
                let _left = left.into_ssa(typ, self.builder);
                let _right = right.zero_extend(self.builder, left.width()).into_ssa(typ, self.builder);
                let mut _carry = carry.into_ssa(types::IFLAGS, self.builder);
                let (res, flag) = self.builder.ins().iadd_ifcarry(_left, _right, _carry);