systemrdl 0.1.0

data/lib/systemrdl/evaluator/operation.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class Operation
+      include Common
+
+      attr_reader :token_range
+
+      def evaluate(instance, width: nil, **_optargs)
+        value, type, width = eval_operation(instance, width)
+        Value.new(value, type, width, token_range)
+      end
+
+      private
+
+      def integral_operand?(operand)
+        [:bit, :boolean].include?(operand.type)
+      end
+
+      def check_integral_operand(operand)
+        return if integral_operand?(operand)
+
+        message = "non integral operand is given: #{operand.type}"
+        raise_evaluation_error message, token_range
+      end
+
+      def to_boolean(instance, operand)
+        operand = eval_operand(instance, operand, nil, check: true)
+
+        if operand.type == :boolean
+          operand.value
+        else
+          operand.value != 0
+        end
+      end
+
+      def to_int(instance, operand, width = nil, evaluation: true)
+        operand = eval_operand(instance, operand, width, check: true) if evaluation
+
+        if operand.type == :boolean
+          [(operand.value && 1) || 0, 1]
+        else
+          [operand.value, width || operand.width]
+        end
+      end
+
+      def eval_operand(instance, operand, width, check:)
+        result = operand.evaluate(instance, width:)
+        check_integral_operand(result) if check
+        result
+      end
+
+      def mask(value, width)
+        value & ((1 << width) - 1)
+      end
+    end
+
+    class UnaryOperation < Operation
+      def initialize(operator, operand, token_range)
+        @operator = operator
+        @operand = operand
+        super(token_range)
+      end
+
+      def connect(parent, component)
+        super
+        @operand.connect(self, component)
+      end
+
+      def expression_width
+        if [:~, :+, :-].include?(@operator)
+          @operand.expression_width
+        else
+          1
+        end
+      end
+
+      private
+
+      def eval_operation(instance, width)
+        case @operator
+        when :! then logical_negation(instance)
+        when :+, :-, :~ then general_op(instance, width)
+        when :&, :|, :^ then reduction(instance, @operator, false)
+        when :'~&' then reduction(instance, :&, true)
+        when :'~|' then reduction(instance, :|, true)
+        when :'~^', :'^~' then reduction(instance, :^, true)
+        end
+      end
+
+      def logical_negation(instance)
+        value = to_boolean(instance, @operand)
+        [!value, :boolean]
+      end
+
+      def reduction(instance, operator, negate)
+        value, width = to_int(instance, @operand)
+
+        init_value = { '&': 1, '|': 0, '^': 0 }[operator]
+        result = width.times.inject(init_value) do |r, i|
+          r.__send__(operator, value[i])
+        end
+
+        if negate
+          [mask(~result, 1), :bit, 1]
+        else
+          [result, :bit, 1]
+        end
+      end
+
+      def general_op(instance, width)
+        width ||= @operand.expression_width
+        value, _ = to_int(instance, @operand, width)
+
+        op = { '+': :+@, '-': :-@, '~': :~ }[@operator]
+        result = value.__send__(op)
+        [mask(result, width), :bit, width]
+      end
+    end
+
+    class BinaryOperation < Operation
+      def initialize(operator, l_operand, r_operand, token_range)
+        @operator = operator
+        @l_operand = l_operand
+        @r_operand = r_operand
+        super(token_range)
+      end
+
+      def connect(parent, component)
+        super
+        @l_operand.connect(self, component)
+        @r_operand.connect(self, component)
+      end
+
+      def expression_width
+        if [:'&&', :'||', :==, :!=, :<, :>, :<=, :>=].include?(@operator)
+          1
+        else
+          eval_expression_width
+        end
+      end
+
+      private
+
+      def eval_expression_width
+        lhs_width = @l_operand.expression_width
+        return lhs_width if [:<<, :>>, :**].include?(@operator)
+
+        rhs_width = @r_operand.expression_width
+
+        if lhs_width && rhs_width
+          [lhs_width, rhs_width].max
+        else
+          lhs_width || rhs_width
+        end
+      end
+
+      def eval_operation(instance, width)
+        case @operator
+        when :'&&', :'||' then logical_op(instance)
+        when :==, :!= then equality_op(instance)
+        when :<, :>, :<=, :>= then relational_op(instance)
+        when :<<, :>>, :** then shift_power_op(instance, width)
+        when :'~^', :'^~' then general_op(instance, :^, width, true)
+        else general_op(instance, @operator, width, false)
+        end
+      end
+
+      def logical_op(instance)
+        lhs = to_boolean(instance, @l_operand)
+        rhs = to_boolean(instance, @r_operand)
+        if @operator == :'&&'
+          [lhs && rhs, :boolean]
+        else
+          [lhs || rhs, :boolean]
+        end
+      end
+
+      def equality_op(instance)
+        lhs, rhs = eval_eq_operands(instance)
+        [lhs.__send__(@operator, rhs), :boolean]
+      end
+
+      def eval_eq_operands(instance)
+        width = eval_expression_width
+        l_operand = eval_operand(instance, @l_operand, width, check: false)
+        r_operand = eval_operand(instance, @r_operand, width, check: false)
+
+        if [l_operand, r_operand].all? { integral_operand?(_1) }
+          lhs, _ = to_int(instance, l_operand, evaluation: false)
+          rhs, _ = to_int(instance, r_operand, evaluation: false)
+          [lhs, rhs]
+        elsif l_operand.type == r_operand.type
+          [l_operand.value, r_operand.value]
+        else
+          message = "#{r_operand.type} type is not compatible with #{l_operand.type} type"
+          raise_evaluation_error message, @r_operand.token_range
+        end
+      end
+
+      def relational_op(instance)
+        lhs, rhs, _ = integral_operands(instance, nil)
+        [lhs.__send__(@operator, rhs), :boolean]
+      end
+
+      def shift_power_op(instance, width)
+        width ||= eval_expression_width
+        lhs, _ = to_int(instance, @l_operand, width)
+        rhs, _ = to_int(instance, @r_operand)
+
+        result = lhs.__send__(@operator, rhs)
+        [mask(result, width), :bit, width]
+      end
+
+      def general_op(instance, operator, width, negate)
+        lhs, rhs, width = integral_operands(instance, width)
+
+        if div_by_0?(rhs)
+          message = 'divisor should be non zero value'
+          raise_evaluation_error message, @r_operand.token_range
+        end
+
+        result = lhs.__send__(operator, rhs)
+        result = ~result if negate
+        [mask(result, width), :bit, width]
+      end
+
+      def div_by_0?(rhs)
+        [:/, :%].include?(@operator) && rhs == 0
+      end
+
+      def integral_operands(instance, width)
+        width ||= eval_expression_width
+        lhs, _ = to_int(instance, @l_operand, width)
+        rhs, _ = to_int(instance, @r_operand, width)
+        [lhs, rhs, width]
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/processor.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class Processor < AST::Processor
+      def on_id(node)
+        id = node.children[0].to_sym
+        Value.new(id, nil, nil, node.token_range)
+      end
+
+      def on_boolean(node)
+        Boolean.new(node)
+      end
+
+      def on_number(node)
+        Number.new(node)
+      end
+
+      def on_verilog_number(node)
+        VerilogNumber.new(node)
+      end
+
+      def on_string(node)
+        String.new(node)
+      end
+
+      def on_accesstype(node)
+        AccessType.new(node)
+      end
+
+      def on_onreadtype(node)
+        OnReadType.new(node)
+      end
+
+      def on_onwritetype(node)
+        OnWriteType.new(node)
+      end
+
+      def on_addressingtype(node)
+        AddressingType.new(node)
+      end
+
+      def on_precedencetype(node)
+        PrecedenceType.new(node)
+      end
+
+      def on_unary_operation(node)
+        operator = node.children[0].to_sym
+        operand = process(node.children[1])
+        UnaryOperation.new(operator, operand, node.token_range)
+      end
+
+      def on_binary_operation(node)
+        operator = node.children[0].to_sym
+        l_operand = process(node.children[1])
+        r_operand = process(node.children[2])
+        BinaryOperation.new(operator, l_operand, r_operand, node.token_range)
+      end
+
+      def on_array(node)
+        elements = process_all(node.children)
+        List.new(elements, node.token_range)
+      end
+
+      def on_range(node)
+        elements = process_all(node.children)
+        List.new(elements, node.token_range)
+      end
+
+      def on_instance_ref_element(node)
+        id = process(node.children[0])
+        array = process(node.children[1])
+        InstanceRefElement.new(id, array, node.token_range)
+      end
+
+      def on_instance_ref(node)
+        elements = process_all(node.children)
+        InstanceRef.new(elements, node.token_range)
+      end
+
+      def on_prop_ref(node)
+        instance_ref = process(node.children[0])
+        prop = process(node.children[1])
+        PropRef.new(instance_ref, prop, node.token_range)
+      end
+
+      def on_default_prop_assignment(node)
+        prop_name, value = process_all(node.children)
+        DefaultPropertyAssignment.new(prop_name, value, node.token_range)
+      end
+
+      def on_prop_assignment(node)
+        id, value = process_all(node.children)
+        prop_ref = PropRef.new(nil, id, node.children[0].token_range)
+        PropertyAssignment.new(prop_ref, value, node.token_range)
+      end
+
+      def on_post_prop_assignment(node)
+        prop_ref, value = process_all(node.children)
+        PostPropertyAssignment.new(prop_ref, value, node.token_range)
+      end
+
+      def on_reset_value(node)
+        process(node.children[0])
+      end
+
+      def on_address_assignment(node)
+        process(node.children[0])
+      end
+
+      def on_address_stride(node)
+        process(node.children[0])
+      end
+
+      def on_address_alignment(node)
+        process(node.children[0])
+      end
+
+      def on_component_inst(node)
+        inst_id = process(node.children[0])
+        inst_values =
+          [
+            :array, :range, :reset_value, :address_assignment, :address_stride, :address_alignment
+          ].zip(node.children[1..]).to_h { |k, n| [k, process(n)] }
+        ComponentInst.new(inst_id, inst_values, node.token_range)
+      end
+
+      def on_component_insts(node)
+        insts = process_all(node.children)
+        ComponentInsts.new(insts, node.token_range)
+      end
+
+      def on_explicit_component_inst(node)
+        id = process(node.children[0])
+        insts = process(node.children[1])
+        ExplicitComponentInst.new(id, insts, node.token_range)
+      end
+
+      def on_component_named_def(node)
+        id, *elements = process_all(node.children[1..])
+        component_definition(node).new(id, elements, nil, node.token_range)
+      end
+
+      def on_component_anon_def(node)
+        *elements, insts = process_all(node.children[1..])
+        component_definition(node).new(nil, elements, insts, node.token_range)
+      end
+
+      def on_root(node)
+        elements = process_all(node.children)
+        Root.new(elements, node.token_range)
+      end
+
+      private
+
+      def component_definition(node)
+        case node.children[0].to_sym
+        when :addrmap then AddrMapDefinition
+        when :regfile then RegFileDefinition
+        when :reg then RegDefinition
+        when :field then FieldDefinition
+        end
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/property.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class Property
+      def initialize(instance, definition, value)
+        @instance = instance
+        @definition = definition
+        @value = value
+      end
+
+      attr_reader :value
+
+      def name
+        @definition.name
+      end
+
+      def types
+        @definition.types
+      end
+
+      def to_value(token_range)
+        Value.new(self, :property_reference, nil, token_range)
+      end
+
+      def full_name
+        [@instance.full_name, name].join('.')
+      end
+
+      def ref_target?
+        if @definition.ref_target.is_a?(Proc)
+          instance_exec(&@definition.ref_target)
+        else
+          @definition.ref_target
+        end
+      end
+
+      def dynamic_assign?
+        @definition.dynamic_assign
+      end
+
+      def per_element_assign?
+        @definition.per_element_assign
+      end
+
+      def assign(value)
+        @value = value
+        @assigned = true
+      end
+
+      def assigned?
+        @assigned || false
+      end
+
+      private
+
+      def set?
+        return false if value.nil?
+
+        value.value != false
+      end
+    end
+
+    class PropertyDefinition
+      def initialize(name)
+        @name = name
+        yield(self)
+      end
+
+      attr_reader :name
+      attr_accessor :targets
+      attr_accessor :types
+      attr_accessor :ref_target
+      attr_accessor :dynamic_assign
+      attr_accessor :per_element_assign
+      attr_accessor :default_value
+
+      def target?(instance)
+        return false if instance.root?
+
+        targets.nil? || targets.include?(instance.layer)
+      end
+
+      def create(instance)
+        value = eval_value(instance)
+        Property.new(instance, self, value)
+      end
+
+      private
+
+      def eval_value(instance)
+        value = instance.definition.find_default_property(name)
+        return value if value
+
+        value =
+          if default_value.is_a?(Proc)
+            default_value.call(instance)
+          else
+            default_value
+          end
+
+        return if value.nil?
+
+        create_value(value)
+      end
+
+      def create_value(value)
+        case types[0]
+        when :longint then Value.new(value, :bit, 64, nil)
+        when :boolean then Value.new(value, :boolean, 1, nil)
+        else Value.new(value, types[0], nil, nil)
+        end
+      end
+    end
+  end
+end