systemrdl 0.1.0

data/lib/systemrdl/evaluator/property_assignment.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    module PropertyAssignmentCommon
+      def initialize(value, token_range)
+        super(token_range)
+        @value = value
+      end
+
+      def evaluate(instance, **optargs)
+        properties = find_properties(instance)
+        check_properties(instance, properties)
+
+        properties.each do |property|
+          value = eval_value(instance, property, **optargs)
+          assign_property(instance, property, value)
+        end
+      end
+
+      private
+
+      def check_properties(_instance, _properties)
+      end
+
+      def eval_value(instance, property, **optargs)
+        value =
+          if @value
+            @value.evaluate(instance, **optargs)
+          else
+            # true value is implicitly applied
+            # when the assignment value is omitted.
+            Value.new(true, :boolean, 1, @token_range)
+          end
+        check_value(property, value)
+
+        if match_integral_type?(property, value)
+          cast_integral_value(property, value)
+        else
+          value
+        end
+      end
+
+      def check_value(property, value)
+        check_type_compatibility(property, value)
+      end
+
+      def check_type_compatibility(property, value)
+        return if property.types.include?(value.type) || match_integral_type?(property, value)
+
+        message =
+          "#{value.type} type not supported by #{property.name} property: " \
+          "expected #{type_label(property)}"
+        raise_evaluation_error message, @token_range
+      end
+
+      def type_label(property)
+        types = property.types
+        if types.size == 1
+          types[0]
+        else
+          [types[..-2].join(', '), types[-1]].join(' or ')
+        end
+      end
+
+      def match_integral_type?(property, value)
+        integral_types = [:bit, :longint, :boolean]
+        return false unless integral_types.include?(value.type)
+
+        (integral_types & property.types).any?
+      end
+
+      def cast_integral_value(property, value)
+        if property.types.include?(:bit)
+          to_bit(value)
+        elsif property.types.include?(:longint)
+          to_longint(value)
+        else
+          to_boolean(value)
+        end
+      end
+
+      def to_bit(value)
+        return value if value.type == :bit
+
+        if value.type == :longint
+          Value.new(value.value, :bit, 64, value.token_range)
+        elsif value.value
+          Value.new(1, :bit, 1, value.token_range)
+        else
+          Value.new(0, :bit, 1, value.token_range)
+        end
+      end
+
+      def to_longint(value)
+        return value if value.type == :longint
+
+        if value.type == :bit
+          v = value.value & 0xFFFF_FFFF_FFFF_FFFF
+          Value.new(v, :longint, 64, value.token_range)
+        elsif value.value
+          Value.new(1, :longint, 64, value.token_range)
+        else
+          Value.new(0, :longint, 64, value.token_range)
+        end
+      end
+
+      def to_boolean(value)
+        return value if value.type == :boolean
+
+        Value.new(value.value != 0, :boolean, 1, value.token_range)
+      end
+    end
+
+    class PropertyAssignment
+      include Common
+      include PropertyAssignmentCommon
+
+      def initialize(prop_ref, value, token_range)
+        super(value, token_range)
+        @prop_ref = prop_ref
+      end
+
+      private
+
+      def find_properties(instance)
+        @prop_ref.find(instance, allow_array_ref: false)
+      end
+
+      def check_properties(_instance, properties)
+        property = properties[0]
+        return unless property&.assigned?
+
+        message = "#{property.name} already assigned in this scope"
+        raise_evaluation_error message, token_range
+      end
+
+      def assign_property(_instance, property, value)
+        property.assign(value)
+      end
+    end
+
+    class PostPropertyAssignment
+      include Common
+      include PropertyAssignmentCommon
+
+      def initialize(prop_ref, value, token_range)
+        super(value, token_range)
+        @prop_ref = prop_ref
+      end
+
+      private
+
+      def check_value(property, value)
+        super
+
+        check_ref_target(value)
+      end
+
+      def check_ref_target(value)
+        return if value.type != :property_reference
+
+        property = value.value
+        return if property.ref_target?
+
+        message = "reference to #{property.name} property not allowed"
+        raise_evaluation_error message, @token_range
+      end
+
+      def find_properties(instance)
+        @prop_ref.find(instance, allow_array_ref: true)
+      end
+
+      def check_properties(_instance, properties)
+        properties.each do |property|
+          next unless property
+
+          unless property.dynamic_assign?
+            message = "dynamic assignment to #{property.name} property not allowed"
+            raise_evaluation_error message, token_range
+          end
+
+          if !property.per_element_assign? && @prop_ref.array_select?
+            message = "element assignment to #{property.name} property not allowed"
+            raise_evaluation_error message, token_range
+          end
+        end
+      end
+
+      def assign_property(_instance, property, value)
+        property.assign(value)
+      end
+    end
+
+    class DefaultPropertyAssignment
+      include Common
+      include PropertyAssignmentCommon
+
+      def initialize(prop_name, value, token_range)
+        super(value, token_range)
+        @prop_name = prop_name
+      end
+
+      private
+
+      def find_properties(_instance)
+        prop_def = BuiltinProperties.find(@prop_name.value)
+        return [prop_def] if prop_def
+
+        message = "undefined property: #{@prop_name.value}"
+        raise_evaluation_error message, token_range
+      end
+
+      def assign_property(instance, _property, value)
+        definition = instance.definition
+        definition.assign_default_property(@prop_name.value, value, token_range)
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/reference.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class InstanceRefElement
+      include Common
+
+      def initialize(id, array, token_range)
+        super(token_range)
+        @id = id
+        @array = array
+      end
+
+      attr_reader :id
+      attr_reader :array
+
+      def find(base)
+        result = find_instance(base)
+        return result unless result.empty?
+
+        inst_name =
+          if array_select?
+            array
+              .elements
+              .inject([id.value]) { |elements, select| elements << "[#{select.value}]" }
+              .join
+          else
+            id.value.to_s
+          end
+        raise_evaluation_error "unresolvable instance: #{inst_name}", token_range
+      end
+
+      def array_select?
+        !array.nil?
+      end
+
+      private
+
+      def find_instance(base)
+        base.instances.select do |inst|
+          inst.name == id.value && match_array_indices?(inst)
+        end
+      end
+
+      def match_array_indices?(instance)
+        # non array instance && array select
+        return false if !instance.array? && array_select?
+
+        # non array instance or whole array
+        return true unless array_select?
+
+        # check size
+        return false if instance.array_indices.size != array.size
+
+        instance
+          .array_indices
+          .zip(array.elements)
+          .all? { |index, select| index == select.value }
+      end
+    end
+
+    class InstanceRef
+      include Common
+
+      def initialize(elements, token_range)
+        super(token_range)
+        @elements = elements
+      end
+
+      attr_reader :elements
+
+      def evaluate(instance, **_optargs)
+        find(instance, allow_array_ref: false)[0].to_value(token_range)
+      end
+
+      def find(instance, allow_array_ref: false)
+        result = @elements.inject([instance]) do |instances, element|
+          process_instance_ref_element(instances, element)
+        end
+
+        return result if allow_array_ref || result.size <= 1
+
+        message = 'reference to array instance not allowed'
+        raise_evaluation_error message, token_range
+      end
+
+      def array_select?
+        elements.any?(&:array_select?)
+      end
+
+      private
+
+      def process_instance_ref_element(instances, element)
+        instances.flat_map { |inst| element.find(inst) }
+      end
+    end
+
+    class PropRef
+      include Common
+
+      def initialize(instance_ref, prop, token_range)
+        super(token_range)
+        @instance_ref = instance_ref
+        @prop = prop
+      end
+
+      attr_reader :instance_ref
+      attr_reader :prop
+
+      def evaluate(instance, **_optargs)
+        find(instance, allow_array_ref: false)[0].to_value(token_range)
+      end
+
+      def find(instance, allow_array_ref: false)
+        insts =
+          if @instance_ref
+            @instance_ref.find(instance, allow_array_ref:)
+          else
+            [instance]
+          end
+
+        insts.map do |inst|
+          prop = inst.property(@prop.value)
+          next prop if prop
+
+          raise_evaluation_error "undefined property: #{@prop.value}", token_range
+        end
+      end
+
+      def array_select?
+        @instance_ref&.array_select? || false
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/reg.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class RegDefinition < ComponentDefinition
+      include AddressOperation
+      include ArrayComponent
+      include ContainerComponent
+
+      def validate(instance)
+        check_structural_component_instances(instance)
+        check_regwidth(instance)
+        check_accesswidth(instance)
+        check_overlapping_fields(instance)
+        check_fields_out_of_register(instance)
+        check_fields_spanning_sub_word_boundary(instance)
+        check_address_operations(instance)
+      end
+
+      def revalidate(instance)
+        check_accesswidth(instance)
+        check_fields_spanning_sub_word_boundary(instance)
+        check_address_operations(instance)
+      end
+
+      def layer
+        :reg
+      end
+
+      private
+
+      def instance_class
+        RegInstance
+      end
+
+      def apply_inst_values(instance, inst_values)
+        apply_address_operations(instance, inst_values)
+        check_range(inst_values)
+      end
+
+      def post_build(instance)
+        apply_default_accesswidth(instance)
+      end
+
+      def apply_default_accesswidth(instance)
+        property = instance.property(:accesswidth)
+        return if property.value
+
+        regwidth = instance.property_value(:regwidth)
+        property.assign(regwidth)
+      end
+
+      def check_regwidth(instance)
+        check_power_of_2(instance, :regwidth, 8)
+      end
+
+      def check_accesswidth(instance)
+        check_power_of_2(instance, :accesswidth, 8)
+
+        regwidth = instance.property_value(:regwidth)
+        accesswidth = instance.property_value(:accesswidth)
+        return if accesswidth.value <= regwidth.value
+
+        message = "accesswidth exceeds regwidth: accesswidth = #{accesswidth} regwidth = #{regwidth}"
+        raise_evaluation_error message, accesswidth.token_range, regwidth.token_range
+      end
+
+      def check_overlapping_fields(instance)
+        instance.instances.combination(2).each do |(field_a, field_b)|
+          next unless overlapping_field_pair?(field_a, field_b)
+
+          message = 'overlapping fields not allowed'
+          raise_evaluation_error message, field_a.token_range, field_b.token_range
+        end
+      end
+
+      def overlapping_field_pair?(field_a, field_b)
+        range_a = (field_a.lsb.value..field_a.msb.value)
+        range_b = (field_b.lsb.value..field_b.msb.value)
+        return false unless range_a.include?(range_b.begin) || range_b.include?(range_a.begin)
+
+        r_a = field_a.sw_readable?
+        w_a = field_a.sw_writable?
+        r_b = field_b.sw_readable?
+        w_b = field_b.sw_writable?
+        (r_a && r_b) || (w_a && w_b)
+      end
+
+      def check_fields_out_of_register(instance)
+        regwidth = instance.property_value(:regwidth).value
+        instance.instances.each do |field|
+          msb = field.msb.value
+          lsb = field.lsb.value
+          next if msb < regwidth
+
+          message = "field out of register: bit position [#{msb}:#{lsb}] regwidth #{regwidth}"
+          raise_evaluation_error message, field.token_range
+        end
+      end
+
+      def check_fields_spanning_sub_word_boundary(instance)
+        accesswidth = instance.property_value(:accesswidth).value
+        instance.instances.each do |field|
+          next unless field_with_side_effect?(field)
+
+          msb = field.msb.value
+          lsb = field.lsb.value
+          next if (msb / accesswidth) == (lsb / accesswidth)
+
+          message =
+            'field spanning sub-word boundary not allowed: ' \
+            "bit position [#{msb}:#{lsb}] accesswidth #{accesswidth}"
+          raise_evaluation_error message, field.token_range
+        end
+      end
+
+      def field_with_side_effect?(field)
+        sw = field.property_value(:sw).value
+        return true if sw in :rw | :w
+
+        [:onread, :rclr, :rset]
+          .any? { |prop| field.property_value(prop)&.value }
+      end
+    end
+
+    class RegInstance < Instance
+      attr_accessor :address
+      attr_accessor :stride
+      attr_accessor :alignment
+
+      def definable?(definition)
+        definition.layer in :field
+      end
+
+      def instantiable?(definition)
+        definable?(definition)
+      end
+
+      def accesswidth
+        property_value(:accesswidth).value
+      end
+
+      def size
+        property_value(:regwidth).value / 8
+      end
+
+      def sw_readable?
+        instances.any?(&:sw_readable?)
+      end
+
+      def sw_writable?
+        instances.any?(&:sw_writable?)
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/regfile.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class RegFileDefinition < ComponentDefinition
+      include ContainerComponent
+
+      def validate(instance)
+        check_structural_component_instances(instance)
+      end
+
+      def layer
+        :regfile
+      end
+
+      private
+
+      def instance_class
+        RegFileInstance
+      end
+    end
+
+    class RegFileInstance < Instance
+      def definable?(definition)
+        definition.layer in :regfile | :reg | :field
+      end
+
+      def instantiable?(definition)
+        definition.layer in :regfile | :reg
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/root.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class Root < ComponentDefinition
+      def layer
+        :root
+      end
+
+      def initialize(elements, token_range)
+        super(Value.new(:root, nil, nil, nil), elements, nil, token_range)
+        connect(nil, nil)
+      end
+
+      def evaluate(instance, **optargs)
+        inherit(instance) if instance&.root?
+        root = create_instance(nil, :root, nil, nil, nil, **optargs)
+        root.finalize
+        root
+      end
+
+      private
+
+      def instance_class
+        RootInstance
+      end
+
+      def inherit(instance)
+        definitions.merge!(instance.definition.definitions)
+      end
+    end
+
+    class RootInstance < Instance
+      def definable?(_definition)
+        true
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/value.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    Value = Data.define(:value, :type, :width, :token_range) do
+      def to_s
+        value.to_s
+      end
+    end
+
+    Values = Data.define(:values, :token_range)
+  end
+end

data/lib/systemrdl/evaluator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    def self.evaluate(ast, root = nil, **optargs)
+      evaluator = build_evaluator(ast)
+      evaluator.evaluate(root, **optargs)
+    end
+
+    def self.build_evaluator(ast)
+      Processor.new.process(ast)
+    end
+  end
+end