systemrdl 0.1.0 → 0.2.0

data/lib/systemrdl/evaluator/component_definition.rb

@@ -25,9 +25,7 @@ module SystemRDL
       end
 
       def upper_layers(include_self: false)
-        return [] if layer == :root
-
-        layers = [*component.upper_layers, component]
+        layers = (layer == :root && []) || component.upper_layers(include_self: true)
         layers << self if include_self
         layers
       end
@@ -37,12 +35,9 @@ module SystemRDL
         @insts&.evaluate(instance, @parent, @id, **optargs)
       end
 
-      def create_instances(parent_instance, inst_name, inst_values, token_range, **optargs)
-        eval_array(inst_values) do |array_info|
-          create_instance(
-            parent_instance, inst_name, inst_values,
-            array_info, token_range, **optargs
-          )
+      def create_instances(parent_instance, inst_args, token_range, **optargs)
+        eval_array(inst_args.values) do |array_info|
+          create_instance(parent_instance, inst_args, array_info, token_range, **optargs)
         end
       end
 
@@ -93,8 +88,8 @@ module SystemRDL
       def check_property_exclusivity(instance, names)
         properties =
           names
-            .map { |name| instance.property_value(name) }
-            .select { |v| v&.value }
+          .map { |name| instance.property_value(name) }
+          .select { |v| v&.value }
         return if properties.size <= 1
 
         labels = [names[..-2].join(', '), names[-1]].join(' and ')
@@ -114,17 +109,19 @@ module SystemRDL
         yield(nil, nil)
       end
 
-      def create_instance(parent_instance, inst_name, inst_values, array_info, token_range, **optargs)
-        unless unique_instance?(parent_instance, inst_name, array_info)
-          message = "duplicated instance: #{inst_name}"
+      def create_instance(parent_instance, inst_args, array_info, token_range, **optargs)
+        unless unique_instance?(parent_instance, inst_args.name, array_info)
+          message = "duplicated instance: #{inst_args.name}"
           raise_evaluation_error message, token_range
         end
 
-        instance = instance_class.new(self, parent_instance, inst_name, array_info, token_range)
+        instance = instance_class.new(self, parent_instance, inst_args.name, token_range)
 
         init_properties(instance)
         eval_body(instance, **optargs)
-        apply_inst_values(instance, inst_values)
+        apply_array(instance, array_info)
+        apply_inst_values(instance, inst_args.values)
+        apply_inst_type(instance, inst_args.type)
         post_build(instance)
         instance.validate
 
@@ -149,9 +146,9 @@ module SystemRDL
       def init_properties(instance)
         prop_defs = BuiltinProperties.properties
         prop_defs.each do |prop_def|
-          next unless prop_def.target?(instance)
-
           prop = prop_def.create(instance)
+          next unless prop
+
           instance.properties << prop
         end
       end
@@ -161,9 +158,15 @@ module SystemRDL
         @elements.each { |element| element.evaluate(instance, **optargs) }
       end
 
+      def apply_inst_type(_instance, _inst_type)
+      end
+
       def apply_inst_values(_instance, _inst_values)
       end
 
+      def apply_array(_instance, _array_info)
+      end
+
       def post_build(_instance)
       end
 

data/lib/systemrdl/evaluator/component_insts.rb

@@ -20,10 +20,11 @@ module SystemRDL
       def evaluate(instance, base, id, **optargs)
         component_definition = find_component_definition(base, id, **optargs)
         check_recursive_instance(instance, component_definition)
+        check_inst_type(component_definition)
         check_instantiable(instance, component_definition)
 
         @insts.each do |inst|
-          inst.evaluate(instance, component_definition, **optargs)
+          inst.evaluate(instance, component_definition, inst_type, **optargs)
         end
       end
 
@@ -34,7 +35,7 @@ module SystemRDL
           definition = component.definitions[id.value]
           next unless definition
 
-          unless optargs[:test] || (definition.layer in :reg | :field)
+          unless optargs[:test] || instantiable_component?(definition)
             message = "#{definition.layer} instance not supported yet"
             raise_evaluation_error message, token_range
           end
@@ -45,6 +46,10 @@ module SystemRDL
         raise_evaluation_error "undefined component: #{id.value}", token_range
       end
 
+      def instantiable_component?(definition)
+        definition.layer in :addrmap | :regfile | :mem | :reg | :field
+      end
+
       def check_recursive_instance(instance, component_definition)
         components = instance.definition.upper_layers(include_self: true)
         return if components.none? { |component| component.equal?(component_definition) }
@@ -53,6 +58,21 @@ module SystemRDL
         raise_evaluation_error message, token_range
       end
 
+      def check_inst_type(component_definition)
+        return if component_definition.support_inst_type?(inst_type)
+
+        message =
+          if inst_type
+            "#{component_definition.layer} instance with #{inst_type} not allowed"
+          else
+            "#{component_definition.layer} instance without instance type not allowed"
+          end
+        raise_evaluation_error message, token_range
+      end
+
+      def inst_type
+      end
+
       def check_instantiable(instance, component_definition)
         return if instance.instantiable?(component_definition)
 
@@ -61,6 +81,24 @@ module SystemRDL
       end
     end
 
+    class InternalComponentInsts < ComponentInsts
+      private
+
+      def inst_type
+        :internal
+      end
+    end
+
+    class ExternalComponentInsts < ComponentInsts
+      private
+
+      def inst_type
+        :external
+      end
+    end
+
+    InstArgs = Data.define(:name, :type, :values)
+
     class ComponentInst
       include Common
 
@@ -72,9 +110,10 @@ module SystemRDL
 
       attr_reader :inst_id
 
-      def evaluate(instance, component_definition, **optargs)
+      def evaluate(instance, component_definition, inst_type, **optargs)
         inst_values = eval_inst_values(instance, **optargs)
-        component_definition.create_instances(instance, @inst_id.value, inst_values, @token_range, **optargs)
+        args = InstArgs.new(@inst_id.value, inst_type, inst_values)
+        component_definition.create_instances(instance, args, @token_range, **optargs)
       end
 
       private

data/lib/systemrdl/evaluator/field.rb

@@ -32,6 +32,10 @@ module SystemRDL
         :field
       end
 
+      def support_inst_type?(inst_type)
+        inst_type.nil?
+      end
+
       private
 
       def instance_class
@@ -39,33 +43,30 @@ module SystemRDL
       end
 
       def apply_inst_values(instance, inst_values)
-        assign_bit_pos(instance, inst_values)
+        assign_bit_range(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) }
+      def assign_bit_range(instance, inst_values)
+        if (range = inst_values[:range])
+          msb, lsb = range.elements
+          instance.msb = msb
+          instance.lsb = lsb
+        else
+          instance.width = bit_width(instance, inst_values)
+        end
       end
 
-      def calc_bit_width(instance, inst_values)
+      def bit_width(instance, inst_values)
         size = inst_values[:array]
-        return instance.property_value(:fieldwidth) unless size
+        unless size
+          if (fieldwidth = instance.property_value(:fieldwidth))
+            return fieldwidth
+          else
+            return Value.new(1, :bit, 64, nil)
+          end
+        end
 
         if size.size >= 2
           message = 'multidimensional size specification not allowed for field'
@@ -90,13 +91,21 @@ module SystemRDL
           raise_evaluation_error message, fieldwidth.token_range
         end
 
-        msb = instance.msb
-        lsb = instance.lsb
-        width = msb.value - lsb.value + 1
+        width, width_token_range = extract_width(instance)
         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
+        raise_evaluation_error message, *width_token_range
+      end
+
+      def extract_width(instance)
+        if instance.msb
+          pos = [instance.msb.value, instance.lsb.value].sort
+          width = pos[1] - pos[0] + 1
+          [width, [instance.msb.token_range, instance.lsb.token_range]]
+        else
+          [instance.width.value, [instance.width.token_range].compact]
+        end
       end
 
       def apply_reset_value(instance, inst_values)
@@ -120,7 +129,7 @@ module SystemRDL
       end
 
       def check_reset_value(instance, reset_value)
-        width = instance.msb.value - instance.lsb.value + 1
+        width, _ = extract_width(instance)
         range = 0..((2**width) - 1)
         return if range.include?(reset_value.value)
 
@@ -224,6 +233,11 @@ module SystemRDL
     class FieldInstance < Instance
       attr_accessor :msb
       attr_accessor :lsb
+      attr_accessor :width
+
+      def virtual_field?
+        parent.virtual_reg?
+      end
 
       def definable?(_definition)
         false

data/lib/systemrdl/evaluator/inst_type_aware_component.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    module InstTypeAwareComponent
+      private
+
+      def apply_inst_type(instance, inst_type)
+        instance.external = inst_type == :external
+      end
+    end
+
+    module InstTypeAwareInstance
+      attr_accessor :external
+    end
+  end
+end

data/lib/systemrdl/evaluator/instance.rb

@@ -3,11 +3,10 @@
 module SystemRDL
   module Evaluator
     class Instance
-      def initialize(definition, parent, name, array_info, token_range)
+      def initialize(definition, parent, name, token_range)
         @definition = definition
         @parent = parent
         @name = name
-        @array_info = array_info
         @token_range = token_range
         @properties = []
         @instances = []
@@ -35,14 +34,13 @@ module SystemRDL
       end
 
       def full_name
-        elements = [self]
-        current = parent
-        until current.root?
-          elements.unshift(current)
-          current = current.parent
-        end
+        upper_instances(include_root: false, include_self: true).map(&:element_name).join('.')
+      end
 
-        elements.map(&:element_name).join('.')
+      def upper_instances(include_root: false, include_self: false)
+        instances = (root? && []) || parent.upper_instances(include_root:, include_self: true)
+        instances << self if (root? && include_root) || (!root? && include_self)
+        instances
       end
 
       def layer
@@ -61,6 +59,10 @@ module SystemRDL
         layer == :regfile
       end
 
+      def mem?
+        layer == :mem
+      end
+
       def reg?
         layer == :reg
       end
@@ -70,27 +72,19 @@ module SystemRDL
       end
 
       def structural_component?
-        addrmap? || regfile? || reg? || field?
+        addrmap? || regfile? || mem? || 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
+      def find_addrmap
+        if RUBY_VERSION >= '4.0'
+          upper_instances(include_root: false, include_self: true).rfind(&:addrmap?)
+        else
+          upper_instances(include_root: false, include_self: true).reverse_each.find(&:addrmap?)
+        end
       end
 
-      def last_element?
-        !array? || array_info.last
+      def array?
+        false
       end
 
       def property(name)
@@ -112,8 +106,8 @@ module SystemRDL
       end
 
       def finalize
-        @definition.finalize(self)
         @instances.each(&:finalize)
+        @definition.finalize(self)
       end
     end
   end

data/lib/systemrdl/evaluator/mem.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Evaluator
+    class MemDefinition < ComponentDefinition
+      include InstTypeAwareComponent
+      include BlockComponent
+
+      def validate(instance)
+        check_positive_value(instance, :mementries)
+        check_memwidth(instance)
+        check_regwidth(instance)
+        check_virtual_field_sw(instance)
+      end
+
+      def revalidate(instance)
+        check_virtual_field_sw(instance)
+      end
+
+      def finalize(instance)
+        check_virtual_field_pos(instance)
+        allocate_addresses(instance)
+        check_address_operations(instance)
+        check_reg_size(instance)
+      end
+
+      def layer
+        :mem
+      end
+
+      def support_inst_type?(inst_type)
+        inst_type == :external
+      end
+
+      private
+
+      def instance_class
+        MemInstance
+      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_memwidth(instance)
+      end
+
+      def apply_default_memwidth(instance)
+        return if no_regs?(instance)
+
+        property = instance.property(:memwidth)
+        return if property.value
+
+        entrywidth = Value.new(instance.entrywidth, :bit, 64, nil)
+        property.assign(entrywidth)
+      end
+
+      def check_memwidth(instance)
+        check_positive_value(instance, :memwidth)
+
+        memwidth = instance.property_value(:memwidth)
+        return if memwidth || !no_regs?(instance)
+
+        message = 'omitting memwidth without virtual regs not allowed'
+        raise_evaluation_error message, instance.token_range
+      end
+
+      def check_positive_value(instance, prop_name)
+        value = instance.property_value(prop_name)
+        return if value.nil? || value.value >= 1
+
+        message = "#{prop_name} must be positive"
+        raise_evaluation_error message, value.token_range
+      end
+
+      def check_regwidth(instance)
+        return if no_regs?(instance)
+
+        entrywidth = instance.entrywidth
+        instance.instances.each do |reg|
+          regwidth = reg.property_value(:regwidth).value
+          next if regwidth <= entrywidth
+
+          memwidth = instance.property_value(:memwidth)
+          message =
+            'regwidth larger than entry width not allowed: ' \
+            "entry width #{entrywidth} (memwidth #{memwidth}) regwidth #{regwidth}"
+          raise_evaluation_error message, reg.token_range
+        end
+      end
+
+      def check_virtual_field_pos(instance)
+        return if no_regs?(instance)
+
+        memwidth = instance.property_value(:memwidth).value
+        instance.instances.flat_map(&:instances).each do |field|
+          next if valid_virtual_field_pos?(field, memwidth)
+
+          message =
+            'virtual field outside memwidth not allowed: ' \
+            "memwidth #{memwidth} msb #{field.msb} lsb #{field.lsb}"
+          raise_evaluation_error message, field.token_range
+        end
+      end
+
+      def valid_virtual_field_pos?(field, memwidth)
+        [field.msb.value, field.lsb.value].sort[1] < memwidth
+      end
+
+      def check_virtual_field_sw(instance)
+        return if no_regs?(instance)
+
+        mem_sw = instance.property_value(:sw).value
+        instance.instances.flat_map(&:instances).each do |field|
+          field_sw = field.property_value(:sw).value
+          next if field_sw == mem_sw
+
+          message =
+            'mismatch between mem sw and virtual field sw: ' \
+            "mem #{mem_sw} virtual field #{field_sw}"
+          raise_evaluation_error message, field.token_range
+        end
+      end
+
+      def check_reg_size(instance)
+        return if no_regs?(instance)
+
+        size = instance.size
+        instance.instances.each do |reg|
+          reg_addr = reg.address.value
+          reg_size = reg.size
+          next if (reg_addr + reg_size) <= size
+
+          message =
+            'virtual reg outside mem area not allowed: ' \
+            "mem size #{size} reg address 0x#{reg_addr.to_s(16)} reg size #{reg_size}"
+          raise_evaluation_error message, reg.token_range
+        end
+      end
+
+      def no_regs?(instance)
+        instance.instances.empty?
+      end
+    end
+
+    class MemInstance < Instance
+      include InstTypeAwareInstance
+      include BlockInstance
+
+      def entrywidth
+        @entrywidth ||=
+          if (memwidth = property_value(:memwidth)&.value)
+            if memwidth <= 8
+              8
+            elsif memwidth.nobits?(memwidth - 1)
+              memwidth
+            else
+              2**memwidth.bit_length
+            end
+          else
+            instances
+              .map { |inst| inst.property_value(:regwidth).value }
+              .max
+          end
+      end
+
+      def accesswidth
+        (instances.empty? && entrywidth) || super
+      end
+
+      def size
+        @size ||= begin
+          width = entrywidth / 8
+          entries = property_value(:mementries).value
+          width * entries
+        end
+      end
+
+      def definable?(definition)
+        definition.layer in :reg | :field
+      end
+
+      def instantiable?(definition)
+        definition.layer in :reg
+      end
+    end
+  end
+end

data/lib/systemrdl/evaluator/processor.rb

@@ -130,6 +130,16 @@ module SystemRDL
         ComponentInsts.new(insts, node.token_range)
       end
 
+      def on_internal_component_insts(node)
+        insts = process_all(node.children)
+        InternalComponentInsts.new(insts, node.token_range)
+      end
+
+      def on_external_component_insts(node)
+        insts = process_all(node.children)
+        ExternalComponentInsts.new(insts, node.token_range)
+      end
+
       def on_explicit_component_inst(node)
         id = process(node.children[0])
         insts = process(node.children[1])
@@ -157,6 +167,7 @@ module SystemRDL
         case node.children[0].to_sym
         when :addrmap then AddrMapDefinition
         when :regfile then RegFileDefinition
+        when :mem then MemDefinition
         when :reg then RegDefinition
         when :field then FieldDefinition
         end

data/lib/systemrdl/evaluator/property.rb

@@ -69,25 +69,36 @@ module SystemRDL
 
       attr_reader :name
       attr_accessor :targets
+      attr_accessor :exist
       attr_accessor :types
       attr_accessor :ref_target
       attr_accessor :dynamic_assign
       attr_accessor :per_element_assign
       attr_accessor :default_value
 
+      def create(instance)
+        return unless target?(instance) && exist?(instance)
+
+        value = eval_value(instance)
+        Property.new(instance, self, value)
+      end
+
+      private
+
       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)
+      def exist?(instance)
+        if @exist.is_a?(Proc)
+          @exist.call(instance)
+        else
+          @exist
+        end
       end
 
-      private
-
       def eval_value(instance)
         value = instance.definition.find_default_property(name)
         return value if value
@@ -101,7 +112,7 @@ module SystemRDL
 
         return if value.nil?
 
-        create_value(value)
+        value.is_a?(Value) ? value : create_value(value)
       end
 
       def create_value(value)