rggen-systemrdl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2688c26e49be1e67f4901940a3872d9113ae6e6c33fc2920152a7907058e689d
+  data.tar.gz: eff39992ccaa258d5ca4ec00896c986e003ca9478d563aaf4a1f496586f77dad
+SHA512:
+  metadata.gz: 502271d1de11850f8355a59a023307531ccb52ef8f0ccf2be917f544fddb865e870929aaebcba2b21b88ad5c3313b2ee5abbb5dbf0cf3b31ed0199d3c5f10110
+  data.tar.gz: ba07135e0c0473ec599241d9e1b663bab94850e8c2dab22c9fec3a81c13e5eb9c99caec2e756321d294b3fb47b4386a736a2bdadbf0ba0acca6dea750e33e0c0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Taichi Ishitani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+[![Gem Version](https://badge.fury.io/rb/rggen-systemrdl.svg)](https://badge.fury.io/rb/rggen-systemrdl)
+[![CI](https://github.com/rggen/rggen-systemrdl/actions/workflows/ci.yml/badge.svg)](https://github.com/rggen/rggen-systemrdl/actions/workflows/ci.yml)
+[![Discord](https://img.shields.io/discord/1406572699467124806?style=flat&logo=discord)](https://discord.com/invite/KWya83ZZxr)
+
+# RgGen::SystemRDL
+
+RgGen::SystemRDL is a RgGen plugin to load register map descriptions written in [SystemRDL 2.0](https://www.accellera.org/images/downloads/standards/systemrdl/SystemRDL_2.0_Jan2018.pdf).
+
+## Installation
+
+To install RgGen::SystemRDL, use the following command:
+
+```
+$ gem install rggen-systemrdl
+```
+
+## Usage
+
+You need to tell RgGen to load the RgGen::SystemRDL plugin. There are two ways.
+
+### Using the `--plugin` runtime option
+
+```
+$ rggen --plugin rggen-systemrdl your_register_map.rdl
+```
+
+### Using the `RGGEN_PLUGINS` environment variable
+
+```
+$ export RGGEN_PLUGINS=${RGGEN_PLUGINS}:rggen-systemrdl
+$ rggen your_register_map.rdl
+```
+
+## Supported features and limitations
+
+The plugin converts SystemRDL `addrmap`, `regfile`, `reg`, `field`, and `mem` components into the corresponding RgGen register map layers, including a wide range of `field` access types.
+Some SystemRDL constructs have no corresponding concept in RgGen. These are not supported and cause an error.
+
+For the detailed component-to-layer correspondence, the full SystemRDL-property to RgGen-type mapping, and the complete list of unsupported constructs with the reasons behind each decision, see the design notes:
+
+* [SystemRDL to RgGen mapping](notes/systemrdl_to_rggen_mapping.md)
+* [Bit field type matrix](notes/bit_field_type_matrix.md)
+
+### Precedence handling
+
+RgGen fixes precedence to hardware, whereas SystemRDL's precedence is variable and defaults to software.
+A field is therefore rejected unless its precedence is explicitly set to `hw`.
+
+To accept a SystemRDL description without changing it, set the `ignore_precedence` configuration option (default `false`) to `true`.
+Then the `precedence` property in the SystemRDL description is ignored and every field is treated as hardware precedence.
+
+## Contact
+
+Feedbacks, bug reports, questions and etc. are welcome! You can post them by using the following
+ways:
+
+* [GitHub Issue Tracker](https://github.com/rggen/rggen/issues)
+* [GitHub Discussions](https://github.com/rggen/rggen/discussions)
+* [Discord](https://discord.com/invite/KWya83ZZxr)
+* [Mailing List](https://groups.google.com/d/forum/rggen)
+* [Mail](mailto:rggen@googlegroups.com)
+
+## Copyright & License
+
+Copyright © 2026 Taichi Ishitani.
+RgGen::SystemRDL is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for further details.

data/lib/rggen/systemrdl/converter/addrmap.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemRDL
+    module Converter
+      class AddrMap < Base
+        private
+
+        def support_external?
+          true
+        end
+
+        def external?(rdl_model)
+          !rdl_model.parent.nil?
+        end
+
+        def insert_to_root?
+          true
+        end
+
+        def layer_name
+          :register_block
+        end
+
+        def unsupported_properties
+          [:sharedextbus, :bigendian, :littleendian, :rsvdset, :rsvdsetX, :msb0]
+        end
+
+        def convert_rdl_model(rdl_model, _root_data, input_data)
+          convert_addrmap_name(rdl_model, input_data)
+          convert_comment(rdl_model, input_data)
+          convert_byte_size(rdl_model, input_data)
+        end
+
+        def convert_addrmap_name(rdl_model, input_data)
+          check_name(rdl_model)
+
+          name = rdl_model.full_name
+          escaped_name = escape_name(name.gsub('.', '__'))
+          input_data[:name] = to_input_value(escaped_name, rdl_model.token_range)
+        end
+
+        def convert_byte_size(rdl_model, input_data)
+          input_data[:byte_size] = from_property(rdl_model, :size)
+        end
+      end
+    end
+  end
+end

data/lib/rggen/systemrdl/converter/base.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RgGen
+  module SystemRDL
+    module Converter
+      class Base
+        def self.convert(rdl_model, root_data, input_data)
+          (@converter ||= new).convert(rdl_model, root_data, input_data)
+        end
+
+        def convert(rdl_model, root_data, input_data)
+          check_external(rdl_model)
+          check_unsupported_properties(rdl_model)
+          check_property_reference(rdl_model)
+
+          insert_external(rdl_model, input_data) if external?(rdl_model)
+          return if region_only?
+
+          input_data = insert_design_boundary(rdl_model, root_data) if design_boundary_required?(rdl_model)
+          input_data = (insert_to_root? && root_data || input_data).child(layer_name)
+
+          convert_rdl_model(rdl_model, root_data, input_data)
+
+          rdl_model.instances.each do |sub_model|
+            converter = select_converter(sub_model)
+            converter.convert(sub_model, root_data, input_data)
+          end
+        end
+
+        private
+
+        def check_external(rdl_model)
+          return unless !support_external? && external?(rdl_model)
+
+          error "external #{rdl_model.layer} is not supported", rdl_model.token_range
+        end
+
+        def support_external?
+          false
+        end
+
+        def external?(_rdl_model)
+          false
+        end
+
+        def insert_external(rdl_model, input_data)
+          input_data = input_data.child(:register)
+          convert_name(rdl_model, input_data)
+          convert_comment(rdl_model, input_data)
+          convert_offset_address(rdl_model, input_data)
+          convert_external_type(rdl_model, input_data)
+        end
+
+        def convert_external_type(rdl_model, input_data)
+          size = rdl_model.size
+          bus_width = input_data.configuration.bus_width
+
+          if (size % (bus_width / 8)) != 0
+            message =
+              "#{rdl_model.layer} size is not a multiple of the bus width: " \
+              "size #{size} bus width #{bus_width}"
+            error message, rdl_model.token_range
+          end
+
+          input_data[:type] = to_input_value(:external, nil)
+          input_data[:size] = to_input_value(size / (bus_width / 8), nil)
+        end
+
+        def check_unsupported_properties(rdl_model)
+          unsupported_properties&.each do |property|
+            prop = rdl_model.property(property)
+            next unless prop.value
+
+            error "#{property} is not supported", prop.token_range
+          end
+        end
+
+        def unsupported_properties
+        end
+
+        def check_property_reference(rdl_model)
+          rdl_model.properties.each_value do |prop|
+            next unless prop.property_ref?
+
+            error 'property reference is not supported', prop.token_range
+          end
+        end
+
+        def region_only?
+          false
+        end
+
+        def design_boundary_required?(_rdl_model)
+          false
+        end
+
+        def insert_to_root?
+          false
+        end
+
+        def select_converter(rdl_model)
+          {
+            addrmap: AddrMap,
+            regfile: RegFile,
+            reg: Reg,
+            field: Field,
+            mem: Mem
+          }[rdl_model.layer]
+        end
+
+        def error(message, token_range)
+          pos = token_range&.head&.position
+          raise Core::SourceError.new(message, pos)
+        end
+
+        def convert_name(rdl_model, input_data)
+          check_name(rdl_model)
+          input_data[:name] = to_input_value(escape_name(rdl_model.name), rdl_model.token_range)
+        end
+
+        def check_name(rdl_model)
+          return unless rdl_model.name.include?('__')
+
+          error "identifier including __ is not allowed: #{rdl_model.name}", rdl_model.token_range
+        end
+
+        def escape_name(name)
+          name.gsub('[', '__').gsub(']', '')
+        end
+
+        def convert_comment(rdl_model, input_data)
+          input_data[:comment] = from_property(rdl_model, :desc)
+        end
+
+        def convert_offset_address(rdl_model, input_data)
+          input_data[:offset_address] = from_property(rdl_model, :address)
+        end
+
+        def set_true?(rdl_model, property_name)
+          rdl_model.property(property_name).value == true
+        end
+
+        def from_property(rdl_model, property_name)
+          property = rdl_model.property(property_name)
+          return if property.value.nil?
+
+          from_property_value(property)
+        end
+
+        def from_property_value(property)
+          if property.value?
+            to_input_value(property.value, property.token_range)
+          else
+            to_input_value(property.value.full_name(exclude_addrmap: true), property.token_range)
+          end
+        end
+
+        def to_input_value(value, token_range)
+          position = token_range&.head&.position
+          Core::InputBase::InputValue.new(value, position)
+        end
+      end
+    end
+  end
+end