systemrdl 0.1.0

data/lib/systemrdl/evaluator/container_component.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    module ContainerComponent
+      private
+
+      def check_structural_component_instances(instance)
+        return if instance.instances.any?(&:structural_component?)
+
+        message = "no structural component instances within #{layer}"
+        raise_evaluation_error message, instance.token_range
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/field.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class FieldDefinition < ComponentDefinition
+      def validate(instance)
+        check_fieldwidth(instance)
+        check_reset(instance)
+        check_sw_hw_access_combination(instance)
+        check_onread_exclusivity(instance)
+        check_sw_read_access_required(instance)
+        check_onwrite_exclusivity(instance)
+        check_sw_write_access_required(instance)
+        check_swwe_swwel_exclusivity(instance)
+        check_we_wel_exclusivity(instance)
+        check_we_required(instance)
+      end
+
+      def revalidate(instance)
+        check_reset(instance)
+        check_sw_hw_access_combination(instance)
+        check_onread_exclusivity(instance)
+        check_sw_read_access_required(instance)
+        check_onwrite_exclusivity(instance)
+        check_sw_write_access_required(instance)
+        check_swwe_swwel_exclusivity(instance)
+        check_we_wel_exclusivity(instance)
+        check_we_required(instance)
+      end
+
+      def layer
+        :field
+      end
+
+      private
+
+      def instance_class
+        FieldInstance
+      end
+
+      def apply_inst_values(instance, inst_values)
+        assign_bit_pos(instance, inst_values)
+        apply_reset_value(instance, inst_values)
+        check_address_allocation_operator(inst_values)
+      end
+
+      def assign_bit_pos(instance, inst_values)
+        msb, lsb =
+          if (range = inst_values[:range])
+            range.elements
+          else
+            calc_bit_pos(instance, inst_values)
+          end
+        instance.msb = msb
+        instance.lsb = lsb
+      end
+
+      def calc_bit_pos(instance, inst_values)
+        width = calc_bit_width(instance, inst_values)
+        last_msb = instance.parent.instances.last&.msb
+        lsb = (last_msb&.value || -1) + 1
+        msb = lsb + (width&.value || 1) - 1
+        [msb, lsb].map { |pos| Value.new(pos, :bit, 64, width&.token_range) }
+      end
+
+      def calc_bit_width(instance, inst_values)
+        size = inst_values[:array]
+        return instance.property_value(:fieldwidth) unless size
+
+        if size.size >= 2
+          message = 'multidimensional size specification not allowed for field'
+          raise_evaluation_error message, size.token_range
+        end
+
+        size = size.elements[0]
+        if size.value == 0
+          message = 'bit width must be positive'
+          raise_evaluation_error message, size.token_range
+        end
+
+        size
+      end
+
+      def check_fieldwidth(instance)
+        fieldwidth = instance.property_value(:fieldwidth)
+        return unless fieldwidth
+
+        if fieldwidth.value == 0
+          message = 'fieldwidth must be positive'
+          raise_evaluation_error message, fieldwidth.token_range
+        end
+
+        msb = instance.msb
+        lsb = instance.lsb
+        width = msb.value - lsb.value + 1
+        return if width == fieldwidth.value
+
+        message = "bit width mismatch: instance width #{width} fieldwidth property #{fieldwidth}"
+        raise_evaluation_error message, msb.token_range, lsb.token_range
+      end
+
+      def apply_reset_value(instance, inst_values)
+        value = inst_values[:reset_value]
+        return unless value
+
+        property = instance.property(:reset)
+        property.assign(value)
+      end
+
+      def check_reset(instance)
+        reset_value = instance.property_value(:reset)
+        return unless reset_value
+
+        if reset_value.type in :field_reference | :property_reference
+          # TODO
+          # check width of the specified instance or property
+        else
+          check_reset_value(instance, reset_value)
+        end
+      end
+
+      def check_reset_value(instance, reset_value)
+        width = instance.msb.value - instance.lsb.value + 1
+        range = 0..((2**width) - 1)
+        return if range.include?(reset_value.value)
+
+        message =
+          format(
+            'reset value out of range: value 0x%<reset_value>x range 0x%<begin>x..0x%<end>x',
+            reset_value: reset_value.value, begin: range.begin, end: range.end
+          )
+        raise_evaluation_error message, reset_value.token_range
+      end
+
+      def check_address_allocation_operator(inst_values)
+        [:address_assignment, :address_stride, :address_alignment].each do |op|
+          value = inst_values[op]
+          next unless value
+
+          message = 'address allocation operator not allowed for field instance'
+          raise_evaluation_error message, value.token_range
+        end
+      end
+
+      def check_sw_hw_access_combination(instance)
+        sw = instance.property_value(:sw)
+        hw = instance.property_value(:hw)
+
+        combination = [sw.value, hw.value]
+        return unless combination in [:w, :w] | [:w, :na] | [:na, *]
+
+        message = "invalid sw/hw access combination: sw = #{sw} hw = #{hw}"
+        raise_evaluation_error message, sw.token_range, hw.token_range
+      end
+
+      def check_onread_exclusivity(instance)
+        check_property_exclusivity(instance, [:onread, :rclr, :rset])
+      end
+
+      def check_sw_read_access_required(instance)
+        kind, onread = {
+          onread: instance.property_value(:onread),
+          rclr: instance.property_value(:rclr),
+          rset: instance.property_value(:rset)
+        }.find { |_, v| v&.value }
+
+        return unless onread
+
+        sw = instance.property_value(:sw)
+        return if sw.value in :rw | :r
+
+        onread_normalized = (kind == :onread && onread.value) || kind
+        message = "sw read access required: onread = #{onread_normalized} sw = #{sw}"
+        raise_evaluation_error message, onread.token_range, sw.token_range
+      end
+
+      def check_onwrite_exclusivity(instance)
+        check_property_exclusivity(instance, [:onwrite, :woset, :woclr])
+      end
+
+      def check_sw_write_access_required(instance)
+        kind, onwrite = {
+          onwrite: instance.property_value(:onwrite),
+          woset: instance.property_value(:woset),
+          woclr: instance.property_value(:woclr)
+        }.find { |(_, v)| v&.value }
+
+        return unless onwrite
+
+        sw = instance.property_value(:sw)
+        return if sw.value in :rw | :w
+
+        onwrite_normalized = (kind == :onwrite && onwrite.value) || kind
+        message = "sw write access required: onwrite = #{onwrite_normalized} sw = #{sw}"
+        raise_evaluation_error message, onwrite.token_range, sw.token_range
+      end
+
+      def check_swwe_swwel_exclusivity(instance)
+        check_property_exclusivity(instance, [:swwe, :swwel])
+      end
+
+      def check_we_wel_exclusivity(instance)
+        check_property_exclusivity(instance, [:we, :wel])
+      end
+
+      def check_we_required(instance)
+        sw = instance.property_value(:sw)
+        return if sw.value == :r
+
+        hw = instance.property_value(:hw)
+        return if hw.value in :r | :na
+
+        we = instance.property_value(:we)
+        return if we.value
+
+        wel = instance.property_value(:wel)
+        return if wel.value
+
+        message = "hw write enable required: sw = #{sw} hw = #{hw}"
+        raise_evaluation_error message, sw.token_range, hw.token_range
+      end
+    end
+
+    class FieldInstance < Instance
+      attr_accessor :msb
+      attr_accessor :lsb
+
+      def definable?(_definition)
+        false
+      end
+
+      def instantiable?(_definition)
+        false
+      end
+
+      def sw_readable?
+        property_value(:sw).value in :rw | :rw1 | :r
+      end
+
+      def sw_writable?
+        property_value(:sw).value in :rw | :rw1 | :w | :w1
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/instance.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class Instance
+      def initialize(definition, parent, name, array_info, token_range)
+        @definition = definition
+        @parent = parent
+        @name = name
+        @array_info = array_info
+        @token_range = token_range
+        @properties = []
+        @instances = []
+      end
+
+      attr_reader :definition
+      attr_reader :parent
+      attr_reader :name
+      attr_reader :array_info
+      attr_reader :token_range
+      attr_reader :properties
+      attr_reader :instances
+
+      def to_value(token_range)
+        Value.new(self, :"#{layer}_reference", nil, token_range)
+      end
+
+      def element_name
+        return name.to_s unless array?
+
+        array_info
+          .indices
+          .inject([name]) { |name_elements, index| name_elements << "[#{index}]" }
+          .join
+      end
+
+      def full_name
+        elements = [self]
+        current = parent
+        until current.root?
+          elements.unshift(current)
+          current = current.parent
+        end
+
+        elements.map(&:element_name).join('.')
+      end
+
+      def layer
+        definition.layer
+      end
+
+      def root?
+        layer == :root
+      end
+
+      def addrmap?
+        layer == :addrmap
+      end
+
+      def regfile?
+        layer == :regfile
+      end
+
+      def reg?
+        layer == :reg
+      end
+
+      def field?
+        layer == :field
+      end
+
+      def structural_component?
+        addrmap? || regfile? || reg? || field?
+      end
+
+      def array?
+        !array_info.nil?
+      end
+
+      def array_indices
+        array_info&.indices
+      end
+
+      def array_sizes
+        array_info&.sizes
+      end
+
+      def first_element?
+        !array? || array_info.first
+      end
+
+      def last_element?
+        !array? || array_info.last
+      end
+
+      def property(name)
+        properties.find { |prop| prop.name == name }
+      end
+
+      def property_value(name)
+        property(name)&.value
+      end
+
+      def validate
+        @definition.validate(self)
+        @instances.each(&:revalidate)
+      end
+
+      def revalidate
+        @definition.revalidate(self)
+        @instances.each(&:revalidate)
+      end
+
+      def finalize
+        @definition.finalize(self)
+        @instances.each(&:finalize)
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/list.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class List
+      include Common
+
+      def initialize(elements, token_range)
+        @elements = elements
+        @token_range = token_range
+      end
+
+      attr_reader :elements
+      attr_reader :token_range
+
+      def evaluate(instance, **optargs)
+        elements = @elements.map { |element| element.evaluate(instance, **optargs) }
+        List.new(elements, @token_range)
+      end
+
+      def size
+        @elements.size
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/literal.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class Literal
+      include Common
+
+      def initialize(node)
+        super(node.token_range)
+        @node = node
+        evaluate_literal
+      end
+
+      attr_reader :value
+
+      def evaluate(_instance, **_optargs)
+        @evaluated ||= Value.new(value, type, width, token_range)
+      end
+
+      def expression_width
+        width
+      end
+
+      def token_range
+        @node.token_range
+      end
+
+      private
+
+      def width
+      end
+
+      def token
+        @node.children[0]
+      end
+
+      def text
+        token.text
+      end
+    end
+
+    class Boolean < Literal
+      private
+
+      def type
+        :boolean
+      end
+
+      def width
+        1
+      end
+
+      def evaluate_literal
+        @value = text == 'true'
+      end
+    end
+
+    class Number < Literal
+      private
+
+      def type
+        :bit
+      end
+
+      def width
+        64
+      end
+
+      def evaluate_literal
+        @value = Integer(text)
+      end
+    end
+
+    class VerilogNumber < Literal
+      private
+
+      attr_reader :width
+
+      def type
+        :bit
+      end
+
+      def evaluate_literal
+        match_data, base =
+          case text.tr('_', '')
+          when Parser::Scanner::VERILOG_HEX_NUMBER then [Regexp.last_match, 16]
+          when Parser::Scanner::VERILOG_DEC_NUMBER then [Regexp.last_match, 10]
+          when Parser::Scanner::VERILOG_BIN_NUMBER then [Regexp.last_match, 2]
+          end
+        @width = match_data.captures[0].to_i
+        @value = match_data.captures[1].to_i(base)
+
+        check_bit_width(@value, @width)
+      end
+
+      def check_bit_width(value, width)
+        return if value.bit_length <= width
+
+        message = "value of number does not fit within the specified bit width: #{text}"
+        raise_evaluation_error(message, token_range)
+      end
+    end
+
+    class String < Literal
+      private
+
+      def type
+        :string
+      end
+
+      def evaluate_literal
+        @value = text[1..-2]
+      end
+    end
+
+    class EnumLiteral < Literal
+      private
+
+      def evaluate_literal
+        @value = text.to_sym
+      end
+    end
+
+    class AccessType < EnumLiteral
+      private
+
+      def type
+        :accesstype
+      end
+
+      def evaluate_literal
+        @value =
+          if ['rw', 'wr'].include?(text)
+            :rw
+          else
+            super
+          end
+      end
+    end
+
+    class OnReadType < EnumLiteral
+      private
+
+      def type
+        :onreadtype
+      end
+    end
+
+    class OnWriteType < EnumLiteral
+      private
+
+      def type
+        :onwritetype
+      end
+    end
+
+    class AddressingType < EnumLiteral
+      private
+
+      def type
+        :addressingtype
+      end
+    end
+
+    class PrecedenceType < EnumLiteral
+      private
+
+      def type
+        :precedencetype
+      end
+    end
+  end
+end