adlint 3.0.10 → 3.2.0

data/lib/adlint/cc1/conv.rb

@@ -108,7 +108,7 @@ module Cc1 #:nodoc:
       when from_type.pointer?
         void_pointer?(from_type) || void_pointer?(to_type)
       when from_type.integer?
-        !from_type.enum? && from_val.must_be_equal_to?(scalar_value_of(0))
+        !from_type.enum? && from_val.test_must_be_null.true?
       else
         void_pointer?(to_type)
       end
@@ -121,12 +121,12 @@ module Cc1 #:nodoc:
       case
       when orig_var.type.signed? && to_type.unsigned?
         min_val = scalar_value_of(to_type.min)
-        if (orig_var.value < min_val).may_be_true?
+        if (orig_var.value < min_val).test_may_be_true.true?
           return min_val - orig_var.value + scalar_value_of(1)
         end
       when orig_var.type.unsigned? && to_type.signed?
         max_val = scalar_value_of(to_type.max)
-        if (orig_var.value > max_val).may_be_true?
+        if (orig_var.value > max_val).test_may_be_true.true?
           return max_val - orig_var.value + scalar_value_of(1)
         end
       end

data/lib/adlint/cc1/ctrlexpr.rb

@@ -67,10 +67,10 @@ module Cc1 #:nodoc:
     end
 
     def ensure_true_by_narrowing(alt_expr = nil)
-      target_expr = alt_expr || @target_expr
+      expr = alt_expr || @target_expr
 
-      if target_expr
-        new_manip = ValueDomainNarrower.new(@interpreter, target_expr)
+      if expr
+        new_manip = ValueDomainNarrower.new(@interpreter, expr)
         if @branch.implicit_condition?
           eval_quietly { new_manip.prepare! }
         else
@@ -85,10 +85,10 @@ module Cc1 #:nodoc:
     end
 
     def ensure_true_by_widening(alt_expr = nil)
-      target_expr = alt_expr || @target_expr
+      expr = alt_expr || @target_expr
 
-      if target_expr
-        new_manip = ValueDomainWidener.new(@interpreter, target_expr)
+      if expr
+        new_manip = ValueDomainWidener.new(@interpreter, expr)
         if @branch.implicit_condition?
           eval_quietly { new_manip.prepare! }
         else
@@ -124,6 +124,10 @@ module Cc1 #:nodoc:
       @target_expr && !collect_logical_and_expressions(@target_expr).empty?
     end
 
+    def to_expr
+      @target_expr
+    end
+
     private
     def eval_quietly(&block)
       originally_quiet = @interpreter.quiet?
@@ -919,7 +923,7 @@ module Cc1 #:nodoc:
       @phantom_val
     end
 
-    def assign!(val)
+    def assign!(val, *)
       @phantom_val = val
     end
 
@@ -932,6 +936,7 @@ module Cc1 #:nodoc:
     end
 
     Summary = Struct.new(:object_id, :name, :type, :value)
+    private_constant :Summary
   end
 
 end

data/lib/adlint/cc1/environ.rb

@@ -81,8 +81,10 @@ module Cc1 #:nodoc:
     end
 
     def enter_branch_group(*opts)
-      @branch_groups[@branch_depth] =
-        BranchGroup.new(self, @branch_groups[@branch_depth - 1], *opts)
+      if trunk_group = @branch_groups[@branch_depth - 1]
+        trunk = trunk_group.current_branch
+      end
+      @branch_groups[@branch_depth] = BranchGroup.new(self, trunk, *opts)
     end
 
     def current_branch_group
@@ -105,6 +107,14 @@ module Cc1 #:nodoc:
       end
     end
 
+    def current_branch
+      if cur_group = current_branch_group
+        cur_group.current_branch
+      else
+        nil
+      end
+    end
+
     def leave_branch
       # NOTE: Don't delete current branch!
       @branch_depth -= 1

data/lib/adlint/cc1/expr.rb

@@ -304,7 +304,7 @@ module Cc1 #:nodoc:
       notify_sequence_point_reached(SequencePoint.new(node.lhs_operand))
       lhs_val = lhs_var.value
 
-      if lhs_val.scalar? && lhs_val.must_be_false?
+      if lhs_val.scalar? && lhs_val.test_must_be_false.true?
         # NOTE: Doing the short-circuit evaluation.
         notify_variable_value_referred(node, lhs_var)
         return create_tmpvar(int_t, scalar_value_of_false)
@@ -356,7 +356,7 @@ module Cc1 #:nodoc:
       notify_sequence_point_reached(SequencePoint.new(node.lhs_operand))
       lhs_val = lhs_var.value
 
-      if lhs_val.scalar? && lhs_val.must_be_true?
+      if lhs_val.scalar? && lhs_val.test_must_be_true.true?
         # NOTE: Doing the short-circuit evaluation.
         notify_variable_value_referred(node, lhs_var)
         return create_tmpvar(int_t, scalar_value_of_true)
@@ -634,7 +634,7 @@ module Cc1 #:nodoc:
         # _notify_variable_value_referred(node, var)
 
         if var.value.scalar?
-          var.assign!(var.value + scalar_value_of(1))
+          var.assign!(var.value + scalar_value_of(1), node, current_branch)
           _notify_variable_value_updated(node, var)
         end
 
@@ -657,7 +657,7 @@ module Cc1 #:nodoc:
         # _notify_variable_value_referred(node, var)
 
         if var.value.scalar?
-          var.assign!(var.value - scalar_value_of(1))
+          var.assign!(var.value - scalar_value_of(1), node, current_branch)
           _notify_variable_value_updated(node, var)
         end
 
@@ -680,7 +680,7 @@ module Cc1 #:nodoc:
         # _notify_variable_value_referred(node, var)
 
         if var.value.scalar?
-          var.assign!(var.value + scalar_value_of(1))
+          var.assign!(var.value + scalar_value_of(1), node, current_branch)
           _notify_variable_value_updated(node, var)
         end
 
@@ -703,7 +703,7 @@ module Cc1 #:nodoc:
         # _notify_variable_value_referred(node, var)
 
         if var.value.scalar?
-          var.assign!(var.value - scalar_value_of(1))
+          var.assign!(var.value - scalar_value_of(1), node, current_branch)
           _notify_variable_value_updated(node, var)
         end
 
@@ -1166,7 +1166,8 @@ module Cc1 #:nodoc:
         # NOTE: Even if rhs_obj is a NamedVariable, new value will be
         #       instantiated in value-coercing.
         #       So, value-aliasing never occurs.
-        lhs_var.assign!(rhs_conved.value.to_defined_value)
+        defined_val = rhs_conved.value.to_defined_value
+        lhs_var.assign!(defined_val, node, current_branch)
         _notify_variable_value_referred(node, rhs_var)
         _notify_variable_value_updated(node, lhs_var)
 
@@ -1453,7 +1454,8 @@ module Cc1 #:nodoc:
 
         # NOTE: Domain of the arithmetic result value will be restricted by
         #       min-max of the variable type.
-        lhs_var.assign!(rhs_conved.value.to_defined_value)
+        defined_val = rhs_conved.value.to_defined_value
+        lhs_var.assign!(defined_val, node, current_branch)
         _notify_variable_value_updated(node, lhs_var)
 
         notify_assignment_expr_evaled(node, lhs_var, rhs_conved)

data/lib/adlint/cc1/interp.rb

@@ -346,7 +346,7 @@ module Cc1 #:nodoc:
     def_plugin_and_notifier :goto_stmt_evaled, :stmt, :label_name
 
     # NOTE: Notified when the interpreter evaluates a return-statement.
-    def_plugin_and_notifier :return_stmt_evaled, :stmt, :retn_var
+    def_plugin_and_notifier :return_stmt_evaled, :stmt, :ret_var
 
     # NOTE: Notified when the interpreter evaluates an implicit return.
     def_plugin_and_notifier :implicit_return_evaled, :loc
@@ -554,7 +554,7 @@ module Cc1 #:nodoc:
         dcl.mark_as_referred_by(node.identifier)
       end
 
-      var = declare_variable(node)
+      var = declare_variable(node, current_branch)
       notify_variable_declared(node, var)
       evaluate_sequence_point(node.declarator)
     end
@@ -572,21 +572,23 @@ module Cc1 #:nodoc:
           # NOTE: Unable to define variable of incomplete type such as an array
           #       without length.
           init_var, init_conved = evaluate_initializer(node)
-          var = define_variable(node, init_conved.value.to_defined_value)
+          var = define_variable(node, current_branch,
+                                init_conved.value.to_defined_value)
         else
           # NOTE: Declare variable first in order to correctly evaluate
           #       sizeof-expression that refers to the defining variable in the
           #       initializer.
-          declare_variable(node)
+          declare_variable(node, current_branch)
           init_var, init_conved = evaluate_initializer(node)
-          var = define_variable(node, init_conved.value.to_defined_value)
+          var = define_variable(node, current_branch,
+                                init_conved.value.to_defined_value)
         end
 
         notify_variable_value_referred(node, init_var)
         notify_variable_defined(node, var)
         notify_variable_initialized(node, var, init_var)
       else
-        notify_variable_defined(node, define_variable(node))
+        notify_variable_defined(node, define_variable(node, current_branch))
       end
 
       evaluate_sequence_point(node.init_declarator.declarator)
@@ -859,7 +861,7 @@ module Cc1 #:nodoc:
       end
 
       if id
-        var = define_variable(node.to_variable_definition,
+        var = define_variable(node.to_variable_definition, nil,
                               node.type.parameter_value)
         notify_parameter_defined(node, var)
       end
@@ -1013,11 +1015,11 @@ module Cc1 #:nodoc:
       notify_if_ctrlexpr_evaled(node, ctrlexpr_val)
 
       case
-      when ctrlexpr_val.must_be_true?
+      when ctrlexpr_val.test_must_be_true.true?
         branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
           interpret(node.statement)
         end
-      when ctrlexpr_val.may_be_true?
+      when ctrlexpr_val.test_may_be_true.true?
         branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND) do
           interpret(node.statement)
         end
@@ -1047,12 +1049,12 @@ module Cc1 #:nodoc:
       notify_if_else_ctrlexpr_evaled(node, ctrlexpr_val)
 
       case
-      when ctrlexpr_val.must_be_true?
+      when ctrlexpr_val.test_must_be_true.true?
         branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
           interpret(node.then_statement)
         end
         return
-      when ctrlexpr_val.may_be_true?
+      when ctrlexpr_val.test_may_be_true.true?
         branched_eval(ctrlexpr, NARROWING, IMPLICIT_COND) do
           interpret(node.then_statement)
         end
@@ -1074,11 +1076,10 @@ module Cc1 #:nodoc:
       node.executed = true
       notify_while_stmt_started(node)
 
-      widen_varying_variable_value_domain(node)
-
-      ctrlexpr_obj = interpret(node.expression)
+      ctrlexpr_obj = interpret_iteration_ctrlexpr(node, node.expression)
       ctrlexpr_var = object_to_variable(ctrlexpr_obj, node.expression)
       ctrlexpr_val = value_of(ctrlexpr_var)
+
       notify_variable_value_referred(node.expression, ctrlexpr_var)
       notify_sequence_point_reached(SequencePoint.new(node.expression))
       notify_while_ctrlexpr_evaled(node, ctrlexpr_val)
@@ -1086,7 +1087,7 @@ module Cc1 #:nodoc:
       orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
 
       case
-      when ctrlexpr_val.must_be_true?
+      when ctrlexpr_val.test_must_be_true.true?
         begin
           enter_iteration_statement(orig_ctrlexpr)
           branch_opts = [ITERATION, NARROWING, FINAL, IMPLICIT_COND, COMPLETE]
@@ -1094,7 +1095,7 @@ module Cc1 #:nodoc:
         ensure
           leave_iteration_statement(orig_ctrlexpr)
         end
-      when ctrlexpr_val.may_be_true?
+      when ctrlexpr_val.test_may_be_true.true?
         begin
           enter_iteration_statement(orig_ctrlexpr)
           branch_opts = [ITERATION, NARROWING, FINAL, IMPLICIT_COND]
@@ -1150,9 +1151,9 @@ module Cc1 #:nodoc:
       end
 
       case
-      when ctrlexpr_val.must_be_true?
+      when ctrlexpr_val.test_must_be_true.true?
         interpret_for_body_statement(node, true)
-      when ctrlexpr_val.may_be_true?
+      when ctrlexpr_val.test_may_be_true.true?
         interpret_for_body_statement(node, false)
       end
     ensure
@@ -1175,9 +1176,9 @@ module Cc1 #:nodoc:
         end
 
         case
-        when ctrlexpr_val.must_be_true?
+        when ctrlexpr_val.test_must_be_true.true?
           interpret_for_body_statement(node, true)
-        when ctrlexpr_val.may_be_true?
+        when ctrlexpr_val.test_may_be_true.true?
           interpret_for_body_statement(node, false)
         end
       end
@@ -1221,11 +1222,11 @@ module Cc1 #:nodoc:
       notify_variable_value_referred(node.expression, var)
 
       if active_fun = interpreter._active_function and
-          retn_type = active_fun.type.return_type
-        if var.type.same_as?(retn_type)
+          ret_type = active_fun.type.return_type
+        if var.type.same_as?(ret_type)
           conved = var
         else
-          conved = do_conversion(var, retn_type) || create_tmpvar(retn_type)
+          conved = do_conversion(var, ret_type) || create_tmpvar(ret_type)
           notify_implicit_conv_performed(node.expression, var, conved)
         end
       else
@@ -1246,9 +1247,8 @@ module Cc1 #:nodoc:
         ctrlexpr_var = object_to_variable(ctrlexpr_obj, ctrlexpr)
         ctrlexpr_val = value_of(ctrlexpr_var)
 
-        widen_varying_variable_value_domain(node)
-        ctrlexpr_var = interpret(ctrlexpr)
-
+        ctrlexpr_obj = interpret_iteration_ctrlexpr(node, ctrlexpr)
+        ctrlexpr_var = object_to_variable(ctrlexpr_obj, ctrlexpr)
         notify_variable_value_referred(ctrlexpr, ctrlexpr_var)
         notify_sequence_point_reached(SequencePoint.new(ctrlexpr))
       else
@@ -1314,27 +1314,35 @@ module Cc1 #:nodoc:
       end
     end
 
-    def widen_varying_variable_value_domain(iteration_stmt)
-      varying_vars = {}
-      iteration_stmt.varying_variable_names.each do |name|
-        if var = variable_named(name)
-          varying_vars[var] = var.value.dup
-          var.widen_value_domain!(Operator::EQ, var.type.arbitrary_value)
-        end
+    def interpret_iteration_ctrlexpr(iter_stmt, ctrlexpr)
+      environment.enter_branch(FINAL).execute(interpreter, nil) do
+        widen_varying_variable_value_domain(iter_stmt)
       end
+      interpret(ctrlexpr)
+    ensure
+      environment.leave_branch_group
+      environment.leave_branch
+    end
+
+    def widen_varying_variable_value_domain(iter_stmt)
+      iter_stmt.varying_variable_names.each do |name|
+        if var = variable_named(name)
+          widened_sval = var.type.arbitrary_value
+
+          case deduct_variable_varying_path(var, iter_stmt)
+          when :increase
+            widened_sval.narrow_domain!(Operator::GE, var.value)
+          when :decrease
+            widened_sval.narrow_domain!(Operator::LE, var.value)
+          end
 
-      varying_vars.each do |var, orig_val|
-        case deduct_variable_varying_path(var, iteration_stmt)
-        when :increase
-          var.narrow_value_domain!(Operator::GE, orig_val)
-        when :decrease
-          var.narrow_value_domain!(Operator::LE, orig_val)
+          var.widen_value_domain!(Operator::EQ, widened_sval)
         end
       end
     end
 
-    def deduct_variable_varying_path(var, iteration_stmt)
-      histogram = iteration_stmt.varying_expressions.map { |expr|
+    def deduct_variable_varying_path(var, iter_stmt)
+      histogram = iter_stmt.varying_expressions.map { |expr|
         case expr
         when SimpleAssignmentExpression
           deduct_ctrl_var_path_by_simple_assignment_expr(var, expr)
@@ -1491,9 +1499,9 @@ module Cc1 #:nodoc:
       end
 
       case
-      when ctrlexpr_val.must_be_true?
+      when ctrlexpr_val.test_must_be_true.true?
         branch_opts.push(FINAL, COMPLETE)
-      when ctrlexpr_val.must_be_false?
+      when ctrlexpr_val.test_must_be_false.true?
         # NOTE: To end the current branch group of switch-statement if this
         #       case-clause is the final one.
         branched_eval(ctrlexpr, *branch_opts) {}
@@ -1555,14 +1563,13 @@ module Cc1 #:nodoc:
         ctrlexpr_val = value_of(interpret(ctrlexpr, QUIET))
 
         case
-        when ctrlexpr_val.must_be_true?
+        when ctrlexpr_val.test_must_be_true.true?
           branch_opts.push(FINAL, COMPLETE)
-        when ctrlexpr_val.must_be_false?
+        when ctrlexpr_val.test_must_be_false.true?
           return
         end
 
-        value_domain_manip =
-          branch.controlling_expression.ensure_true_by_widening(ctrlexpr)
+        value_domain_manip = branch.ctrlexpr.ensure_true_by_widening(ctrlexpr)
       end
 
       value_domain_manip.commit!
@@ -1689,7 +1696,7 @@ module Cc1 #:nodoc:
       ctrlexpr = ctrlexpr.to_normalized_logical
 
       then_var = nil
-      if ctrlexpr_val.may_be_true?
+      if ctrlexpr_val.test_may_be_true.true?
         branched_eval(ctrlexpr, NARROWING, IMPLICIT_COND) do
           then_var = object_to_variable(interpret(node.then_expression),
                                         node.then_expression)
@@ -1697,7 +1704,7 @@ module Cc1 #:nodoc:
       end
 
       else_var = nil
-      if ctrlexpr_val.may_be_false?
+      if ctrlexpr_val.test_may_be_false.true?
         branched_eval(nil, NARROWING, FINAL, COMPLETE) do
           else_var = object_to_variable(interpret(node.else_expression),
                                         node.else_expression)

data/lib/adlint/cc1/mediator.rb

@@ -254,6 +254,10 @@ module Cc1 #:nodoc:
       environment.reset
     end
 
+    def current_branch
+      environment.current_branch
+    end
+
     def scalar_value_of(numeric)
       ScalarValue.of(numeric, logical_right_shift?)
     end
@@ -307,12 +311,12 @@ module Cc1 #:nodoc:
     end
 
     def branched_eval(expr = nil, *opts, &block)
-      current_branch = environment.enter_branch(*opts)
-      interpreter.notify_branch_started(current_branch)
-      current_branch.execute(interpreter, expr, &block)
+      cur_branch = environment.enter_branch(*opts)
+      interpreter.notify_branch_started(cur_branch)
+      cur_branch.execute(interpreter, expr, &block)
     ensure
-      interpreter.notify_branch_ended(current_branch)
-      environment.leave_branch_group if current_branch.final?
+      interpreter.notify_branch_ended(cur_branch)
+      environment.leave_branch_group if cur_branch.final?
       environment.leave_branch
     end