adlint 1.10.0 → 1.12.0

data/lib/adlint/c/domain.rb

@@ -31,6 +31,7 @@
 
 require "adlint/traits"
 require "adlint/util"
+require "adlint/c/operator"
 
 module AdLint #:nodoc:
 module C #:nodoc:
@@ -192,7 +193,7 @@ module C #:nodoc:
     def _create_union(lhs_value_domain, rhs_value_domain)
       expected = lhs_value_domain.complexity + rhs_value_domain.complexity
       if expected < COMPOSITE_MAX_COMPLEXITY
-        return UnionValueDomain.new(lhs_value_domain, rhs_value_domain)
+        UnionValueDomain.new(lhs_value_domain, rhs_value_domain)
       else
         of_ambiguous(
           lhs_value_domain.undefined? || rhs_value_domain.undefined?)
@@ -326,22 +327,22 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def narrow(operator_symbol, operand_value_domain)
-      case operator_symbol
-      when :==
+    def narrow(operator, operand_value_domain)
+      case operator
+      when Operator::EQ
         _narrow_by_eq(operand_value_domain)
-      when :!=
+      when Operator::NE
         _narrow_by_ne(operand_value_domain)
-      when :<
+      when Operator::LT
         _narrow_by_lt(operand_value_domain)
-      when :>
+      when Operator::GT
         _narrow_by_gt(operand_value_domain)
-      when :<=
+      when Operator::LE
         _narrow_by_le(operand_value_domain)
-      when :>=
+      when Operator::GE
         _narrow_by_ge(operand_value_domain)
       else
-        self
+        __NOTREACHED__
       end
     end
 
@@ -449,22 +450,22 @@ module C #:nodoc:
       _narrow_by_gt(rhs_domain).union(_narrow_by_eq(rhs_domain))
     end
 
-    def widen(operator_symbol, operand_value_domain)
-      case operator_symbol
-      when :==
+    def widen(operator, operand_value_domain)
+      case operator
+      when Operator::EQ
         _widen_by_eq(operand_value_domain)
-      when :!=
+      when Operator::NE
         _widen_by_ne(operand_value_domain)
-      when :<
+      when Operator::LT
         _widen_by_lt(operand_value_domain)
-      when :>
+      when Operator::GT
         _widen_by_gt(operand_value_domain)
-      when :<=
+      when Operator::LE
         _widen_by_le(operand_value_domain)
-      when :>=
+      when Operator::GE
         _widen_by_ge(operand_value_domain)
       else
-        self
+        __NOTREACHED__
       end
     end
 
@@ -477,11 +478,13 @@ module C #:nodoc:
     end
 
     def _widen_by_lt(rhs_domain, lhs_domain = self)
-      lhs_domain.union(ValueDomain.of_unlimited.narrow(:<, rhs_domain))
+      lhs_domain.union(ValueDomain.of_unlimited.narrow(Operator::LT,
+                                                       rhs_domain))
     end
 
     def _widen_by_gt(rhs_domain, lhs_domain = self)
-      lhs_domain.union(ValueDomain.of_unlimited.narrow(:>, rhs_domain))
+      lhs_domain.union(ValueDomain.of_unlimited.narrow(Operator::GT,
+                                                       rhs_domain))
     end
 
     def _widen_by_le(rhs_domain, lhs_domain = self)
@@ -3074,35 +3077,37 @@ module C #:nodoc:
     end
 
     def _mul_less_than(lhs_domain, rhs_domain = self)
-      if rhs_domain.value == 0
-        ValueDomain.equal_to(0)
+      return ValueDomain.equal_to(0) if rhs_domain.value == 0
+
+      if lhs_domain.value <= 0
+        if rhs_domain.value < 0
+          ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
+        else
+          ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
+        end
       else
-        case
-        when lhs_domain.value <= 0 && rhs_domain.value < 0
+        if rhs_domain.value < 0
           ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
-        when lhs_domain.value > 0 && rhs_domain.value < 0
-          ValueDomain.of_unlimited
-        when lhs_domain.value <= 0 && rhs_domain.value > 0
+        else
           ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
-        when lhs_domain.value > 0 && rhs_domain.value > 0
-          ValueDomain.of_unlimited
         end
       end
     end
 
     def _mul_greater_than(lhs_domain, rhs_domain = self)
-      if rhs_domain.value == 0
-        ValueDomain.equal_to(0)
+      return ValueDomain.equal_to(0) if rhs_domain.value == 0
+
+      if lhs_domain.value >= 0
+        if rhs_domain.value < 0
+          ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
+        else
+          ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
+        end
       else
-        case
-        when lhs_domain.value >= 0 && rhs_domain.value < 0
+        if rhs_domain.value < 0
           ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
-        when lhs_domain.value < 0 && rhs_domain.value < 0
-          ValueDomain.of_unlimited
-        when lhs_domain.value >= 0 && rhs_domain.value > 0
+        else
           ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
-        when lhs_domain.value < 0 && rhs_domain.value > 0
-          ValueDomain.of_unlimited
         end
       end
     end
@@ -3941,27 +3946,33 @@ module C #:nodoc:
     end
 
     def _mul_less_than(lhs_domain, rhs_domain = self)
-      if rhs_domain.value > 0
-        ValueDomain.of_unlimited
+      if lhs_domain.value <= 0
+        if rhs_domain.value <= 0
+          ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
+        else
+          ValueDomain.of_unlimited
+        end
       else
-        case
-        when lhs_domain.value <= 0
-          ValueDomain.greater_than(0)
-        when lhs_domain.value > 0
-          ValueDomain.less_than(0)
+        if rhs_domain.value <= 0
+          ValueDomain.of_unlimited
+        else
+          ValueDomain.of_unlimited
         end
       end
     end
 
     def _mul_greater_than(lhs_domain, rhs_domain = self)
-      if rhs_domain.value > 0
-        ValueDomain.of_unlimited
+      if lhs_domain.value >= 0
+        if rhs_domain.value <= 0
+          ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
+        else
+          ValueDomain.of_unlimited
+        end
       else
-        case
-        when lhs_domain.value >= 0
-          ValueDomain.less_than(0)
-        when lhs_domain.value < 0
-          ValueDomain.greater_than(0)
+        if rhs_domain.value <= 0
+          ValueDomain.of_unlimited
+        else
+          ValueDomain.of_unlimited
         end
       end
     end
@@ -4845,14 +4856,17 @@ module C #:nodoc:
     end
 
     def _mul_greater_than(lhs_domain, rhs_domain = self)
-      if rhs_domain.value < 0
-        ValueDomain.of_unlimited
+      if lhs_domain.value >= 0
+        if rhs_domain.value >= 0
+          ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
+        else
+          ValueDomain.of_unlimited
+        end
       else
-        case
-        when lhs_domain.value >= 0
-          ValueDomain.greater_than(0)
-        when lhs_domain.value < 0
-          ValueDomain.less_than(0)
+        if rhs_domain.value >= 0
+          ValueDomain.of_unlimited
+        else
+          ValueDomain.of_unlimited
         end
       end
     end
@@ -5471,7 +5485,8 @@ module C #:nodoc:
     end
 
     def _narrow_by_lt(rhs_domain, lhs_domain = self)
-      lhs_domain.intersection(ValueDomain.of_unlimited.narrow(:<, rhs_domain))
+      lhs_domain.intersection(ValueDomain.of_unlimited.narrow(Operator::LT,
+                                                              rhs_domain))
     end
 
     def _narrow_nil_by_lt(lhs_domain, rhs_domain = self)
@@ -5517,7 +5532,8 @@ module C #:nodoc:
     end
 
     def _narrow_by_gt(rhs_domain, lhs_domain = self)
-      lhs_domain.intersection(ValueDomain.of_unlimited.narrow(:>, rhs_domain))
+      lhs_domain.intersection(ValueDomain.of_unlimited.narrow(Operator::GT,
+                                                              rhs_domain))
     end
 
     def _narrow_nil_by_gt(lhs_domain, rhs_domain = self)
@@ -5592,36 +5608,6 @@ module C #:nodoc:
       rhs_domain + lhs_domain
     end
 
-    def _mul_nil(lhs_domain, rhs_domain = self)
-      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
-      #       This method invokes CompositeValueDomain#*.
-      rhs_domain * lhs_domain
-    end
-
-    def _mul_unlimited(lhs_domain, rhs_domain = self)
-      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
-      #       This method invokes CompositeValueDomain#*.
-      rhs_domain * lhs_domain
-    end
-
-    def _mul_equal_to(lhs_domain, rhs_domain = self)
-      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
-      #       This method invokes CompositeValueDomain#*.
-      rhs_domain * lhs_domain
-    end
-
-    def _mul_less_than(lhs_domain, rhs_domain = self)
-      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
-      #       This method invokes CompositeValueDomain#*.
-      rhs_domain * lhs_domain
-    end
-
-    def _mul_greater_than(lhs_domain, rhs_domain = self)
-      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
-      #       This method invokes CompositeValueDomain#*.
-      rhs_domain * lhs_domain
-    end
-
     def _div_nil(lhs_domain, rhs_domain = self)
       _div(lhs_domain, rhs_domain)
     end
@@ -6093,7 +6079,82 @@ module C #:nodoc:
     end
 
     def *(rhs_domain)
-      new_sub_domains = domain_pair.map { |lhs| lhs * rhs_domain }
+      # NOTE: Multiplication of LessThanValueDomain or GreaterThanValueDomain
+      #       always makes UnlimitedValueDomain when the domain contains both
+      #       positive and negative values.
+      #       So, multiplication of IntersectionValueDomain cannot be defined
+      #       in the same manner as other arithmetics.
+      if rhs_domain.kind_of?(IntersectionValueDomain)
+        lhs_domain = self
+
+        lval = [
+          (n = lhs_domain.min_value).integer? ? n - 1 : n - Float::EPSILON,
+          (n = lhs_domain.max_value).integer? ? n + 1 : n + Float::EPSILON
+        ]
+        labs = lval.map { |val| val.abs }.sort
+
+        rval = [
+          (n = rhs_domain.min_value).integer? ? n - 1 : n - Float::EPSILON,
+          (n = rhs_domain.max_value).integer? ? n + 1 : n + Float::EPSILON
+        ]
+        rabs = rval.map { |val| val.abs }.sort
+
+        comp = lambda { |op, nums| nums.all? { |num| num.__send__(op, 0) } }
+        only_negative, only_positive = comp.curry[:<], comp.curry[:>=]
+
+        case lval
+        when only_positive
+          case rval
+          when only_positive
+            _mul_only_positive_and_only_positive(lval, labs, rval, rabs)
+          when only_negative
+            _mul_only_positive_and_only_negative(lval, labs, rval, rabs)
+          else
+            _mul_only_positive_and_positive_negative(lval, labs, rval, rabs)
+          end
+        when only_negative
+          case rval
+          when only_positive
+            _mul_only_positive_and_only_negative(rval, rabs, lval, labs)
+          when only_negative
+            _mul_only_negative_and_only_negative(lval, labs, rval, rabs)
+          else
+            _mul_only_negative_and_positive_negative(lval, labs, rval, rabs)
+          end
+        else
+          _mul_positive_negative_and_positive_negative(lval, labs, rval, rabs)
+        end
+      else
+        rhs_domain * self
+      end
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: NilValueDomain contains no values.
+      #       So, any arithmetic operation with NilValueDomain makes
+      #       NilValueDomain.
+      lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: UnlimitedValueDomain contains everything.
+      #       So, this arithmetic operation with UnlimitedValueDomain makes
+      #       UnlimitedValueDomain.
+      lhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      new_sub_domains = rhs_domain.domain_pair.map { |rhs| lhs_domain * rhs }
+      new_sub_domains.first.intersection(new_sub_domains.last)
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      new_sub_domains = rhs_domain.domain_pair.map { |rhs| lhs_domain * rhs }
+      new_sub_domains.first.intersection(new_sub_domains.last)
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      new_sub_domains = rhs_domain.domain_pair.map { |rhs| lhs_domain * rhs }
       new_sub_domains.first.intersection(new_sub_domains.last)
     end
 
@@ -6235,6 +6296,57 @@ module C #:nodoc:
     memoize :to_s
 
     private
+    def _mul_only_positive_and_only_positive(lval, labs, rval, rabs)
+      # NOTE: (++) * (++) makes a new IntersectionValueDomain;
+      #         lower bound: (labs.min * rabs.min)
+      #         upper bound: (labs.max * rabs.max)
+      ValueDomain.greater_than(labs.first * rabs.first).intersection(
+        ValueDomain.less_than(labs.last * rabs.last))
+    end
+
+    def _mul_only_positive_and_only_negative(lval, labs, rval, rabs)
+      # NOTE: (++) * (--) makes a new IntersectionValueDomain;
+      #         lower bound: -(labs.max * rabs.max)
+      #         upper bound: -(labs.min * rabs.min)
+      ValueDomain.greater_than(-(labs.last * rabs.last)).intersection(
+        ValueDomain.less_than(-(labs.first * rabs.first)))
+    end
+
+    def _mul_only_positive_and_positive_negative(lval, labs, rval, rabs)
+      # NOTE: (++) * (-+) makes a new IntersectionValueDomain;
+      #         lower bound: (labs.max * rval.min)
+      #         upper bound: (labs.max * rval.max)
+      ValueDomain.greater_than(labs.last * rval.first).intersection(
+        ValueDomain.less_than(labs.last * rval.last))
+    end
+
+    def _mul_only_negative_and_only_negative(lval, labs, rval, rabs)
+      # NOTE: (--) * (--) makes a new IntersectionValueDomain;
+      #         upper bound: (labs.min * rabs.min)
+      #         lower bound: (labs.max * rabs.max)
+      ValueDomain.greater_than(labs.first * rabs.first).intersection(
+        ValueDomain.less_than(labs.last * rabs.last))
+    end
+
+    def _mul_only_negative_and_positive_negative(lval, labs, rval, rabs)
+      # NOTE: (--) * (-+) makes a new IntersectionValueDomain;
+      #         lower bound: -(labs.max * rval.max)
+      #         upper_bound: -(labs.max * rval.min)
+      ValueDomain.greater_than(-(labs.last * rval.last)).intersection(
+        ValueDomain.less_than(-(labs.last * rval.first)))
+    end
+
+    def _mul_positive_negative_and_positive_negative(lval, labs, rval, rabs)
+      # NOTE: (-+) * (-+) makes a new IntersectionValueDomain;
+      #         lower bound: ([lval.min * rval.max, lval.max * rval.min].min)
+      #         upper bound: ([lval.min * rval.min, lval.max * rval.max].max)
+      ValueDomain.greater_than(
+        [lval.first * rval.last, lval.last * rval.first].min
+      ).intersection(ValueDomain.less_than(
+        [lval.first * rval.first, lval.last, rval.last].max
+      ))
+    end
+
     def _div(lhs_domain, rhs_domain = self)
       new_sub_domains = rhs_domain.domain_pair.map { |rhs| lhs_domain / rhs }
       new_sub_domains.first.intersection(new_sub_domains.last)
@@ -6380,6 +6492,36 @@ module C #:nodoc:
       new_sub_domains.first.union(new_sub_domains.last)
     end
 
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
     def /(rhs_domain)
       new_sub_domains = domain_pair.map { |lhs| lhs / rhs_domain }
       new_sub_domains.first.union(new_sub_domains.last)
@@ -7113,7 +7255,7 @@ module C #:nodoc:
       rhs_domain.intersect?(lhs_domain)
     end
 
-    def narrow(operator_symbol, operand_value_domain)
+    def narrow(operator, operand_value_domain)
       self
     end
 
@@ -7213,7 +7355,7 @@ module C #:nodoc:
       ValueDomain.of_ambiguous(@undefined)
     end
 
-    def widen(operator_symbol, operand_value_domain)
+    def widen(operator, operand_value_domain)
       self
     end
 
@@ -7769,131 +7911,3 @@ module C #:nodoc:
 
 end
 end
-
-if $0 == __FILE__
-  include AdLint::C
-
-  d1 = ValueDomain.equal_to(-2147483647)
-  d2 = ValueDomain.equal_to(-2147483647)
-  p d1.contain?(d2)
-
-  puts "---"
-  d1 = ValueDomain.of_undefined(-10..10)
-  d2 = ValueDomain.equal_to(-5).union(ValueDomain.equal_to(5))
-  p d1, d2, d1.contain?(d2), !d2.contain?(d1)
-
-  puts "---"
-  d2 = d2.intersection(ValueDomain.greater_than_or_equal_to(-10))
-  d2 = d2.intersection(ValueDomain.less_than_or_equal_to(10))
-  p d1, d2, d1.contain?(d2), !d2.contain?(d1)
-
-  puts "---"
-  d1 = d1.intersection(ValueDomain.less_than(0))
-  p d1, d2, !d1.contain?(d2), !d2.contain?(d1)
-
-  puts "---"
-  d2 = d2.intersection(ValueDomain.less_than(0))
-  p d1, d2, d1.contain?(d2), !d2.contain?(d1)
-
-  puts "---"
-  d1 = ValueDomain.greater_than(-2147483647)
-  d1 = d1.intersection(ValueDomain.less_than(0))
-  d1 = d1.union(ValueDomain.equal_to(0))
-  d2 = ValueDomain.equal_to(-2147483647)
-  d2 = d2.union(ValueDomain.equal_to(0))
-  p d1, d2
-  d1 = d1.union(d2)
-  p d1
-
-  puts "---"
-  d1 = ValueDomain.equal_to(-2147483647).union(ValueDomain.equal_to(0))
-  d2 = ValueDomain.equal_to(-2147483647).union(ValueDomain.equal_to(0))
-  p d1, d2
-  p d1.contain?(d2)
-  p d1.contain?(ValueDomain.equal_to(-2147483647))
-  p d1.contain?(ValueDomain.equal_to(0))
-
-  puts "---"
-  d1 = ValueDomain.greater_than(-2147483648)
-  d1 = d1.intersection(ValueDomain.less_than(2147483647))
-  d1 = d1.union(ValueDomain.equal_to(2147483647))
-  d2 = d1.dup
-  p d1, d2
-  p d1.contain?(d2)
-  p d1.intersection(d2)
-
-  puts "---"
-  d1 = ValueDomain.greater_than(1)
-  d1 = d1.intersection(ValueDomain.less_than(2147483647))
-  d1 = d1.union(ValueDomain.equal_to(1))
-  d2 = ValueDomain.equal_to(2147483647)
-  d2 = d2.union(ValueDomain.equal_to(1))
-  p d1, d2
-  p d1.union(d2)
-
-  puts "---"
-  d1 = ValueDomain.greater_than(0).intersection(ValueDomain.less_than(429))
-  d1 = d1.union(ValueDomain.equal_to(429))
-  d2 = ValueDomain.equal_to(0)
-  p d1.intersection(d2)
-
-  puts "---"
-  d1 = UndefinedValueDomain.new(0..10)
-  d2 = UndefinedValueDomain.new(0..10)
-  p d1 + d2
-
-  puts "---"
-  d1 = ValueDomain.greater_than_or_equal_to(-10).intersection(
-    ValueDomain.less_than_or_equal_to(10))
-  d2 = ValueDomain.equal_to(0)
-  p d1, d2
-  p d1.intersect?(d2)
-  p d1 < d2
-
-  puts "---"
-  d1 = ValueDomain.greater_than(1)
-  d1 = d1.intersection(ValueDomain.less_than(11))
-  d1 = d1.union(ValueDomain.equal_to(11))
-  d2 = ValueDomain.greater_than(0)
-  d2 = d2.intersection(ValueDomain.less_than(10))
-  d2 = d2.union(ValueDomain.equal_to(0))
-  d2 = d2.union(ValueDomain.equal_to(10))
-  p d1, d2
-  p d1.narrow(:==, d2)
-
-  puts "---"
-  d1 = ValueDomain.greater_than(-129)
-  d1 = d1.intersection(ValueDomain.less_than(128))
-  d2 = ValueDomain.equal_to(-128)
-  p d1, d2
-  p d1.intersect?(d2)
-  p d1 < d2
-
-  puts "---"
-  d1 = ValueDomain.greater_than(-129)
-  d1 = d1.intersection(ValueDomain.less_than(128))
-  d2 = ValueDomain.equal_to(127)
-  p d1, d2
-  p d1.intersect?(d2)
-  p d1 > d2
-
-  puts "---"
-  d1 = ValueDomain.greater_than(-129)
-  d2 = ValueDomain.equal_to(127)
-  p d1, d2
-  p d1 < d2
-
-  puts "---"
-  d1 = ValueDomain.less_than(128)
-  d2 = ValueDomain.equal_to(127)
-  p d1, d2
-  p d1 < d2
-
-  puts "---"
-  d1 = ValueDomain.greater_than_or_equal_to(-2147483648)
-  d1 = d1.intersection(ValueDomain.less_than_or_equal_to(2147483647))
-  d1 = ValueDomain.of_undefined(d1)
-  d2 = ValueDomain.equal_to(1)
-  p d1, d2
-  p d1.narrow(:!=, d2)
-end

data/lib/adlint/c/expr.rb

@@ -374,7 +374,7 @@ module C #:nodoc:
       when "!"
         result = temporary_variable(int_type, !variable.value)
       else
-        # NOTREACHED
+        __NOTREACHED__
       end
       _notify_variable_value_referred(node, variable)
 
@@ -445,7 +445,7 @@ module C #:nodoc:
         result = temporary_variable(lhs_converted.type,
                                     lhs_converted.value % rhs_converted.value)
       else
-        # NOTREACHED
+        __NOTREACHED__
       end
       _notify_variable_value_referred(node, lhs_variable)
       _notify_variable_value_referred(node, rhs_variable)
@@ -497,7 +497,7 @@ module C #:nodoc:
         result = temporary_variable(lhs_converted.type,
                                     lhs_converted.value - rhs_converted.value)
       else
-        # NOTREACHED
+        __NOTREACHED__
       end
       _notify_variable_value_referred(node, lhs_variable)
       _notify_variable_value_referred(node, rhs_variable)
@@ -557,7 +557,7 @@ module C #:nodoc:
         result = temporary_variable(lhs_converted.type,
                                     lhs_converted.value >> rhs_converted.value)
       else
-        # NOTREACHED
+        __NOTREACHED__
       end
       _notify_variable_value_referred(node, lhs_variable)
       _notify_variable_value_referred(node, rhs_variable)
@@ -615,8 +615,7 @@ module C #:nodoc:
         result = temporary_variable(int_type,
                                     lhs_converted.value >= rhs_converted.value)
       else
-        # NOTREACHED
-        result = temporary_variable(int_type, ScalarValue.of_arbitrary)
+        __NOTREACHED__
       end
       _notify_variable_value_referred(node, lhs_variable)
       _notify_variable_value_referred(node, rhs_variable)
@@ -668,8 +667,7 @@ module C #:nodoc:
         result = temporary_variable(int_type,
                                     lhs_converted.value != rhs_converted.value)
       else
-        # NOTREACHED
-        result = temporary_variable(int_type, ScalarValue.of_arbitrary)
+        __NOTREACHED__
       end
       _notify_variable_value_referred(node, lhs_variable)
       _notify_variable_value_referred(node, rhs_variable)