systemrdl 0.1.0 → 0.2.0

data/lib/systemrdl/evaluator/reg.rb

@@ -4,6 +4,7 @@ module SystemRDL
   module Evaluator
     class RegDefinition < ComponentDefinition
       include AddressOperation
+      include InstTypeAwareComponent
       include ArrayComponent
       include ContainerComponent
 
@@ -11,7 +12,6 @@ module SystemRDL
         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)
@@ -23,10 +23,22 @@ module SystemRDL
         check_address_operations(instance)
       end
 
+      def finalize(instance)
+        check_field_ordering(instance)
+        allocate_bits(instance)
+        check_overlapping_fields(instance)
+        check_fields_out_of_register(instance)
+        check_fields_spanning_sub_word_boundary(instance)
+      end
+
       def layer
         :reg
       end
 
+      def support_inst_type?(_inst_type)
+        true
+      end
+
       private
 
       def instance_class
@@ -65,6 +77,73 @@ module SystemRDL
         raise_evaluation_error message, accesswidth.token_range, regwidth.token_range
       end
 
+      def check_field_ordering(instance)
+        mode = bit_allocation_mode(instance)
+        instance.instances.each do |field|
+          next unless field.msb
+
+          msb = field.msb
+          lsb = field.lsb
+          next if valid_field_ordering?(mode, msb, lsb)
+
+          message = "invalid field ordering: bit range [#{msb}:#{lsb}] mode #{mode}"
+          raise_evaluation_error message, msb.token_range, lsb.token_range
+        end
+      end
+
+      def bit_allocation_mode(instance)
+        (instance.find_addrmap.property_value(:msb0).value && :msb0) || :lsb0
+      end
+
+      def valid_field_ordering?(mode, msb, lsb)
+        mode == :lsb0 ? msb.value >= lsb.value : msb.value <= lsb.value
+      end
+
+      def allocate_bits(instance)
+        mode = bit_allocation_mode(instance)
+        instance.instances.inject(nil) do |previous_field, field|
+          unless field.msb
+            msb, lsb = allocate_field_bits(mode, instance, previous_field, field)
+            field.msb = msb
+            field.lsb = lsb
+          end
+
+          field
+        end
+      end
+
+      def allocate_field_bits(mode, instance, previous_field, field)
+        msb, lsb =
+          if mode == :lsb0
+            allocate_field_bits_lsb0(previous_field, field)
+          else
+            allocate_field_bits_msb0(instance, previous_field, field)
+          end
+        [msb, lsb].map { |pos| Value.new(pos, :bit, 64, field.width.token_range) }
+      end
+
+      def allocate_field_bits_lsb0(previous_field, field)
+        lsb =
+          if previous_field
+            previous_field.msb.value + 1
+          else
+            0
+          end
+        msb = lsb + field.width.value - 1
+        [msb, lsb]
+      end
+
+      def allocate_field_bits_msb0(instance, previous_field, field)
+        lsb =
+          if previous_field
+            previous_field.msb.value - 1
+          else
+            instance.property_value(:regwidth).value - 1
+          end
+        msb = lsb - field.width.value + 1
+        [msb, lsb]
+      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)
@@ -75,8 +154,8 @@ module SystemRDL
       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)
+        range_a = field_bit_range(field_a)
+        range_b = field_bit_range(field_b)
         return false unless range_a.include?(range_b.begin) || range_b.include?(range_a.begin)
 
         r_a = field_a.sw_readable?
@@ -86,22 +165,34 @@ module SystemRDL
         (r_a && r_b) || (w_a && w_b)
       end
 
+      def field_bit_range(field)
+        pos = [field.msb.value, field.lsb.value].sort
+        pos[0]..pos[1]
+      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
+          next unless field.msb
 
-          message = "field out of register: bit position [#{msb}:#{lsb}] regwidth #{regwidth}"
+          msb = field.msb
+          lsb = field.lsb
+          next if inside_regwidth?(msb, lsb, regwidth)
+
+          message = "field out of register: bit range [#{msb}:#{lsb}] regwidth #{regwidth}"
           raise_evaluation_error message, field.token_range
         end
       end
 
+      def inside_regwidth?(msb, lsb, regwidth)
+        range = [msb.value, lsb.value]
+        range.none?(&:negative?) && range.sort[1] < regwidth
+      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)
+          next unless field.msb && field_with_side_effect?(field)
 
           msb = field.msb.value
           lsb = field.lsb.value
@@ -109,7 +200,7 @@ module SystemRDL
 
           message =
             'field spanning sub-word boundary not allowed: ' \
-            "bit position [#{msb}:#{lsb}] accesswidth #{accesswidth}"
+            "bit range [#{msb}:#{lsb}] accesswidth #{accesswidth}"
           raise_evaluation_error message, field.token_range
         end
       end
@@ -124,10 +215,17 @@ module SystemRDL
     end
 
     class RegInstance < Instance
+      include ArrayInstance
+      include InstTypeAwareInstance
+
       attr_accessor :address
       attr_accessor :stride
       attr_accessor :alignment
 
+      def virtual_reg?
+        parent.mem?
+      end
+
       def definable?(definition)
         definition.layer in :field
       end

data/lib/systemrdl/evaluator/regfile.rb

@@ -3,24 +3,44 @@
 module SystemRDL
   module Evaluator
     class RegFileDefinition < ComponentDefinition
-      include ContainerComponent
+      include InstTypeAwareComponent
+      include BlockComponent
 
       def validate(instance)
         check_structural_component_instances(instance)
+        check_alignment_property(instance)
+      end
+
+      def finalize(instance)
+        allocate_addresses(instance)
+        check_address_operations(instance)
+        check_overlapping_address_ranges(instance)
       end
 
       def layer
         :regfile
       end
 
+      def support_inst_type?(_inst_type)
+        true
+      end
+
       private
 
       def instance_class
         RegFileInstance
       end
+
+      def apply_inst_values(instance, inst_values)
+        apply_address_operations(instance, inst_values)
+        check_range(inst_values)
+      end
     end
 
     class RegFileInstance < Instance
+      include InstTypeAwareInstance
+      include BlockInstance
+
       def definable?(definition)
         definition.layer in :regfile | :reg | :field
       end

data/lib/systemrdl/evaluator/root.rb

@@ -14,7 +14,7 @@ module SystemRDL
 
       def evaluate(instance, **optargs)
         inherit(instance) if instance&.root?
-        root = create_instance(nil, :root, nil, nil, nil, **optargs)
+        root = create_instance(nil, InstArgs.new(:root, nil, nil), nil, nil, **optargs)
         root.finalize
         root
       end

data/lib/systemrdl/model/instance.rb

@@ -7,8 +7,8 @@ module SystemRDL
         @name = inst.element_name
         @layer = inst.layer
         @parent = parent
-        @instances = build_sub_instances(inst)
-        @properties = build_properties(inst)
+        @instances = build_sub_instances(inst).freeze
+        @properties = build_properties(inst).freeze
         @token_range = inst.token_range
         freeze
       end
@@ -17,6 +17,7 @@ module SystemRDL
       attr_reader :layer
       attr_reader :parent
       attr_reader :instances
+      attr_reader :properties
       attr_reader :token_range
 
       class << self
@@ -24,8 +25,8 @@ module SystemRDL
 
         private
 
-        def def_property(property_name)
-          (@properties ||= []) << property_name
+        def def_property(property_name, value_class = nil, &body)
+          (@properties ||= {})[property_name] = [value_class, body]
           class_eval(<<~M, __FILE__, __LINE__ + 1)
             # def display_name
             #   @properties[:display_name]&.value
@@ -37,17 +38,16 @@ module SystemRDL
         end
       end
 
-      def_property :display_name
-      def_property :desc
-
       def to_s
         "#{name} (#{layer})"
       end
 
-      def full_name
-        elements = [self]
-        current = @parent
+      def full_name(exclude_addrmap: false)
+        elements = []
+        current = self
         while current
+          break if exclude_addrmap && current.layer == :addrmap
+
           elements.unshift(current)
           current = current.parent
         end
@@ -78,6 +78,7 @@ module SystemRDL
         inst.instances.map do |sub_inst|
           case sub_inst.layer
           when :addrmap then AddrMap.new(sub_inst, self)
+          when :mem then Mem.new(sub_inst, self)
           when :regfile then RegFile.new(sub_inst, self)
           when :reg then Reg.new(sub_inst, self)
           when :field then Field.new(sub_inst, self)
@@ -86,80 +87,118 @@ module SystemRDL
       end
 
       def build_properties(inst)
-        properties.to_h do |prop_name|
-          prop_value =
-            if prop_name == :display_name
-              inst.property_value(:name)
-            elsif (property = inst.property(prop_name))
-              property.value
+        self.class.properties.to_h do |prop_name, (default_class, body)|
+          prop_value, prop_value_class, token_range =
+            if body
+              value, klass = body.call(inst)
+              [value, klass || Value]
             else
-              inst.__send__(prop_name)
+              value = eval_prop_value(prop_name, inst)
+              klass = select_value_class(value, default_class)
+              [value&.value, klass, value&.token_range]
             end
-          [prop_name, create_property_value(prop_name, prop_value)]
+          [prop_name, prop_value_class.new(prop_name.to_s, prop_value, self, token_range)]
         end
       end
 
-      def properties
-        klass = self.class
-        [klass.superclass, klass].flat_map(&:properties)
+      def eval_prop_value(prop_name, inst)
+        if prop_name == :display_name
+          inst.property_value(:name)
+        elsif (property = inst.property(prop_name))
+          property.value
+        else
+          inst.__send__(prop_name)
+        end
       end
 
-      def create_property_value(name, value)
-        klass =
-          if reference_value?(value)
-            ReferenceValue
-          elsif hex_value?(name, value)
-            HexValue
-          else
-            Value
-          end
-        klass.new(name.to_s, value&.value, self, value&.token_range)
+      def select_value_class(value, default_class)
+        if reference_value?(value)
+          ReferenceValue
+        elsif default_class && value&.value
+          default_class
+        else
+          Value
+        end
       end
 
       def reference_value?(value)
-        return false unless value
+        return false unless value.respond_to?(:type)
 
         value.type in :property_reference | :field_reference
       end
-
-      def hex_value?(_name, _value)
-        false
-      end
     end
 
     class AddrMap < Instance
+      def_property :display_name
+      def_property :desc
+      def_property :address, HexValue
+      def_property :size, &:size
+      def_property :accesswidth, &:accesswidth
       def_property :sharedextbus
       def_property :errextbus
       def_property :bigendian
       def_property :littleendian
       def_property :rsvdset
       def_property :rsvdsetX
+      def_property :msb0
+
+      alias_method :regs, :instances
+    end
+
+    class Mem < Instance
+      def_property :display_name
+      def_property :desc
+      def_property :address, HexValue
+      def_property :size, &:size
+      def_property :accesswidth, &:accesswidth
+      def_property :entrywidth, &:entrywidth
+      def_property :memwidth
+      def_property :mementries
+      def_property :sw
+
+      alias_method :regs, :instances
+    end
+
+    class RegFile < Instance
+      def_property :display_name
+      def_property :desc
+      def_property :external, &:external
+      def_property :address, HexValue
+      def_property :size, &:size
+      def_property :accesswidth, &:accesswidth
+      def_property :sharedextbus
+      def_property :errextbus
 
       alias_method :regs, :instances
     end
 
     class Reg < Instance
-      def_property :address
+      def_property :display_name
+      def_property :desc
+      def_property :external, &:external
+      def_property :address, HexValue
+      def_property :size, &:size
       def_property :accesswidth
       def_property :errextbus
       def_property :shared
 
       alias_method :fields, :instances
-
-      private
-
-      def hex_value?(name, _value)
-        name == :address
-      end
     end
 
     class Field < Instance
+      def_property :display_name
+      def_property :desc
       def_property :msb
       def_property :lsb
+      def_property :width do |inst|
+        msb = inst.msb.value
+        lsb = inst.lsb.value
+        msb - lsb + 1
+      end
       def_property :hw
       def_property :sw
       def_property :next
-      def_property :reset
+      def_property :reset, HexValue
       def_property :resetsignal
       def_property :rclr
       def_property :rset
@@ -183,12 +222,6 @@ module SystemRDL
       def_property :hwmask
       def_property :precedence
       def_property :paritycheck
-
-      private
-
-      def hex_value?(name, value)
-        name == :reset && value&.type == :bit
-      end
     end
   end
 end

data/lib/systemrdl/model/value.rb

@@ -2,9 +2,9 @@
 
 module SystemRDL
   module Model
-    Value = Data.define(:name, :value, :instance, :token_range) do
-      def full_name
-        "#{instance.full_name}.#{name}"
+    Value = Struct.new(:name, :value, :instance, :token_range) do
+      def full_name(exclude_addrmap: false)
+        [instance.full_name(exclude_addrmap:), name].reject(&:empty?).join('.')
       end
 
       def to_s
@@ -20,6 +20,18 @@ module SystemRDL
         pp_value(pp)
       end
 
+      def value?
+        true
+      end
+
+      def instance_ref?
+        false
+      end
+
+      def property_ref?
+        false
+      end
+
       private
 
       def pp_value(pp)
@@ -32,6 +44,18 @@ module SystemRDL
         full_name
       end
 
+      def value?
+        false
+      end
+
+      def instance_ref?
+        value.is_a?(Instance)
+      end
+
+      def property_ref?
+        value.is_a?(Value)
+      end
+
       private
 
       def pp_value(pp)

data/lib/systemrdl/model.rb

@@ -2,9 +2,45 @@
 
 module SystemRDL
   module Model
-    def self.build(root)
-      root.instances.map do |addrmap|
-        AddrMap.new(addrmap, nil)
+    class << self
+      def build(root)
+        models = root.instances.map do |addrmap|
+          AddrMap.new(addrmap, nil)
+        end
+
+        finalize(models)
+        models
+      end
+
+      private
+
+      def finalize(models)
+        instances = models.flat_map { |model| collect_instances(model) }
+        properties = instances.flat_map { |inst| inst.properties.values }
+
+        properties.each do |property|
+          resolve_reference(property, instances, properties)
+          property.freeze
+        end
+      end
+
+      def collect_instances(model)
+        model.instances.flat_map { |inst| [inst, *collect_instances(inst)] }
+      end
+
+      def resolve_reference(property, instances, properties)
+        return if property.value?
+
+        path = property.value.full_name
+
+        if (ref = instances.find { |inst| inst.full_name == path })
+          property.value = ref
+          return
+        end
+
+        if (ref = properties.find { |prop| prop.full_name == path })
+          property.value = ref
+        end
       end
     end
   end

data/lib/systemrdl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SystemRDL
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/systemrdl.rb

@@ -25,11 +25,14 @@ require_relative 'systemrdl/evaluator/component_insts'
 require_relative 'systemrdl/evaluator/component_definition'
 require_relative 'systemrdl/evaluator/address_operation'
 require_relative 'systemrdl/evaluator/address_allocation'
+require_relative 'systemrdl/evaluator/inst_type_aware_component'
 require_relative 'systemrdl/evaluator/array_component'
 require_relative 'systemrdl/evaluator/container_component'
+require_relative 'systemrdl/evaluator/block_component'
 require_relative 'systemrdl/evaluator/field'
 require_relative 'systemrdl/evaluator/reg'
 require_relative 'systemrdl/evaluator/regfile'
+require_relative 'systemrdl/evaluator/mem'
 require_relative 'systemrdl/evaluator/addrmap'
 require_relative 'systemrdl/evaluator/root'
 require_relative 'systemrdl/evaluator/processor'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: systemrdl
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Taichi Ishitani
@@ -39,15 +39,18 @@ files:
 - lib/systemrdl/evaluator/address_operation.rb
 - lib/systemrdl/evaluator/addrmap.rb
 - lib/systemrdl/evaluator/array_component.rb
+- lib/systemrdl/evaluator/block_component.rb
 - lib/systemrdl/evaluator/builtin_properties.rb
 - lib/systemrdl/evaluator/common.rb
 - lib/systemrdl/evaluator/component_definition.rb
 - lib/systemrdl/evaluator/component_insts.rb
 - lib/systemrdl/evaluator/container_component.rb
 - lib/systemrdl/evaluator/field.rb
+- lib/systemrdl/evaluator/inst_type_aware_component.rb
 - lib/systemrdl/evaluator/instance.rb
 - lib/systemrdl/evaluator/list.rb
 - lib/systemrdl/evaluator/literal.rb
+- lib/systemrdl/evaluator/mem.rb
 - lib/systemrdl/evaluator/operation.rb
 - lib/systemrdl/evaluator/processor.rb
 - lib/systemrdl/evaluator/property.rb