bug reproducer

Signed-off-by: Andy Sadler <[email protected]>

Author: sadlerap

src/intrinsic/mod.rs

@@ -819,19 +819,6 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
                 value
             };
 
-        // only break apart 128-bit ints if they're not natively supported
-        // TODO(antoyo): remove this if/when native 128-bit integers land in libgccjit
-        if value_type.is_u128(&self.cx) && !self.cx.supports_128bit_integers {
-            let sixty_four = self.gcc_int(value_type, 64);
-            let right_shift = self.gcc_lshr(value, sixty_four);
-            let high = self.gcc_int_cast(right_shift, self.cx.ulonglong_type);
-            let high = self.pop_count(high);
-            let low = self.gcc_int_cast(value, self.cx.ulonglong_type);
-            let low = self.pop_count(low);
-            let res = high + low;
-            return self.gcc_int_cast(res, result_type);
-        }
-
         // Use Wenger's algorithm for population count, gcc's seems to play better with it
         // for (int counter = 0; value != 0; counter++) {
         //     value &= value - 1;
@@ -844,30 +831,31 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         let counter_type = self.int_type;
         let counter = self.current_func().new_local(None, counter_type, "popcount_counter");
         let val = self.current_func().new_local(None, value_type, "popcount_value");
-        let zero = self.context.new_rvalue_zero(counter_type);
+        let zero = self.gcc_zero(counter_type);
         self.llbb().add_assignment(None, counter, zero);
         self.llbb().add_assignment(None, val, value);
         self.br(loop_head);
 
         // check if value isn't zero
         self.switch_to_block(loop_head);
-        let zero = self.context.new_rvalue_zero(value_type);
-        let cond = self.context.new_comparison(None, ComparisonOp::NotEquals, val.to_rvalue(), zero);
+        let zero = self.gcc_zero(value_type);
+        let cond = self.gcc_icmp(IntPredicate::IntNE, val.to_rvalue(), zero);
         self.cond_br(cond, loop_body, loop_tail);
 
         // val &= val - 1;
         self.switch_to_block(loop_body);
-        let sub = val.to_rvalue() - self.context.new_rvalue_one(value_type);
+        let one = self.gcc_int(value_type, 1);
+        let sub = self.gcc_sub(val.to_rvalue(), one);
         loop_body.add_assignment_op(None, val, BinaryOp::BitwiseAnd, sub);
 
         // counter += 1
-        let one = self.context.new_rvalue_one(counter_type);
+        let one = self.gcc_int(counter_type, 1);
         loop_body.add_assignment_op(None, counter, BinaryOp::Plus, one);
         self.br(loop_head);
 
         // end of loop
         self.switch_to_block(loop_tail);
-        self.context.new_cast(None, counter.to_rvalue(), result_type)
+        self.gcc_int_cast(counter.to_rvalue(), result_type)
     }
 
     // Algorithm from: https://blog.regehr.org/archives/1063

src/lib.rs

@@ -149,7 +149,8 @@ impl LockedTargetInfo {
     }
 
     fn supports_128bit_int(&self) -> bool {
-        self.info.lock().expect("lock").supports_128bit_int()
+        // self.info.lock().expect("lock").supports_128bit_int()
+        false
     }
 }