origen 0.40.2 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 641fd0140d976febea8c6cad4cd9c3ad853e0e37d502ed10b98c7a54a1269bb0
-  data.tar.gz: 80da77dd07ca579ac6231bcd4ba2693d3ae0398fc059a3559989a9d9d96f0e22
+  metadata.gz: 7b5ba8eda5e72800d451d575b48242c7483bc07260b41b2a6325e87296c512ac
+  data.tar.gz: 873f0bbcb08ccd34c50b549f30d9932c800cc5b432584e618be5589673f7ad0e
 SHA512:
-  metadata.gz: 71cdc7dbf0257e82ed78b1871b47ca2980d9e83a904dff92f12dab35334e54ed9188e8977561a9242cded10b44458bc6268597e8a7b954f8fc9b1ca8ad9cc82d
-  data.tar.gz: 940f2d51b2137ef1eb639fe00a25fa2e8bb11e32a761722971adce69cf734c2a80071e2a8465bdf58067a795326e319c0754e636d3eda99b3259d58317ec243e
+  metadata.gz: 1cea1d1879bacccf077275bf1c04aba477d39fba1188b2806166baedbf5436e1a0bda85212c4572838b1a4dae22f92bbf7199a91a3c36056a867bf67bc46f0c0
+  data.tar.gz: 1fba58ea8bd16b85c81b154fc4ede78257b355327cf540b802bfd2caf3fd11c98d5f40c6142b3ce3a205b57889c1fb05561b020f0d4e3bdac0b38fd25e6b6876

data/bin/origen~

@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby
+$VERBOSE = nil  # Don't care about world writable dir warnings and the like
+
+require 'pathname'
+require 'fileutils'
+#require 'byebug' # Un-comment to debug this file
+
+class OrigenBootError < StandardError
+end
+
+# Keep a note of the pwd at the time when Origen was first loaded, this is initially used
+# by the site_config lookup.
+$_origen_invocation_pwd ||= Pathname.pwd
+
+load File.expand_path('../../lib/origen/operating_systems.rb', __FILE__)
+load File.expand_path('../../lib/origen/site_config.rb', __FILE__)
+
+# This will be referenced later in ruby_version_check, the origen used to launch
+# the process is different than the one that actually runs under bundler
+$origen_launch_root = Pathname.new(File.dirname(__FILE__)).parent
+
+# Override any influence from $LANG in the users environment
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+ENV['LC_ALL'] = nil
+ENV['LANG'] = nil
+ENV['LANG'] = 'en_US.UTF-8'
+
+# Work out what Origen.root is if we are running inside an Origen application, this will be
+# later used to execute from that app's bundle even if the origen executable lives somewhere
+# else (e.g. in the tools repository)
+app_config = File.join('config', 'application.rb')
+if File.exist?(app_config)
+  origen_root = Dir.pwd
+else
+  path = Pathname.new(Dir.pwd)
+  until path.root? || origen_root
+    if File.exist?(File.join(path, app_config))
+      origen_root = path.to_s
+    else
+      path = path.parent
+    end
+  end
+end
+
+# If running inside an application workspace
+if origen_root
+  # Force everyone to have a consistent way of installing gems with bundler
+  ENV['BUNDLE_GEMFILE'] = File.join(origen_root, 'Gemfile')
+  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
+  ENV['BUNDLE_BIN'] = File.join(origen_root, 'lbin')
+
+  # If it looks like a bundled binstub of origen exists, and we have not been invoked through that,
+  # then run that instead.
+  if Origen.site_config.gem_manage_bundler && File.exist?("#{origen_root}/lbin/origen") && !ENV['BUNDLE_BIN_PATH'] &&
+     File.exist?(File.expand_path(Origen.site_config.gem_install_dir))
+    exec Gem.ruby, "#{origen_root}/lbin/origen", *ARGV
+    exit 0
+  end
+  
+  boot_app = true
+
+# If running outside an application and a user or central tool Origen bundle is to be used
+elsif Origen.site_config.gem_manage_bundler && (Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
+  # Force everyone to have a consistent way of installing gems with bundler.
+  # In this case, we aren't running from an Origen application, so build everything at Origen.home instead
+  # Have two options here: if user_install_enable is true, use user_install_dir. Otherwise, use the tool_repo_install_dir
+  Origen.site_config.user_install_enable ? origen_root = File.expand_path(Origen.site_config.user_install_dir) : origen_root = File.expand_path(Origen.site_config.tool_repo_install_dir)
+  unless Dir.exists?(origen_root)
+    load File.expand_path('../../lib/origen/utility/input_capture.rb', __FILE__)
+    include Origen::Utility::InputCapture
+    
+    puts "Root directory '#{origen_root}' does not exist. Would you like to create it?"
+    if get_text(confirm: :return_boolean)
+      FileUtils.mkdir(origen_root)
+    else
+      puts "Exiting with creating Origen install"
+      exit!
+    end
+  end
+  
+  gemfile = File.join(origen_root, 'Gemfile')
+  unless File.exists?(gemfile)
+    # Create a default Gemfile that can be further customized by the user.
+    # Initial Gemfile only requires Origen. Nothing else. Essentially a blank installation.
+    Dir.chdir(origen_root) do
+      `bundle init`
+    end
+    # The above will give a general Gemfile from Bundler. We'll just append "gem 'origen' to the end.
+    File.open(gemfile, 'a') do |f|
+     f << "gem 'origen'\n"
+    end
+  end
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
+  ENV['BUNDLE_BIN'] = File.join(origen_root, 'lbin')
+
+  origen_exec = File.join(ENV['BUNDLE_BIN'], 'origen')
+
+  # If the user/tool bundle already exists but we have not been invoked through that, abort this thread
+  # and re-launch under the required bundler environment
+  if File.exist?(origen_exec) && !ENV['BUNDLE_BIN_PATH'] && File.exist?(ENV['BUNDLE_PATH'])
+    exec Gem.ruby, origen_exec, *ARGV
+    exit 0
+  else
+    boot_app = false
+  end
+end
+
+if origen_root && File.exist?(ENV['BUNDLE_GEMFILE']) && Origen.site_config.gem_manage_bundler && (boot_app || Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
+  # Overriding bundler here so that bundle install can be automated as required
+  require 'bundler/shared_helpers'
+  if Bundler::SharedHelpers.in_bundle?
+    require 'bundler'
+    if STDOUT.tty?
+      begin
+        fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
+        Bundler.setup
+        fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
+      rescue Gem::LoadError, Bundler::BundlerError, OrigenBootError => e
+        cmd = "bundle install --gemfile #{ENV['BUNDLE_GEMFILE']} --binstubs #{ENV['BUNDLE_BIN']} --path #{ENV['BUNDLE_PATH']}"
+        # puts cmd
+        puts 'Installing required gems...'
+        puts
+        `chmod o-w #{origen_root}` # Stops some annoying world writable warnings during install
+        `chmod o-w #{origen_root}/bin` if File.exist?("#{origen_root}/bin")
+        `chmod o-w #{origen_root}/.bin` if File.exist?("#{origen_root}/.bin")
+        result = false
+
+        Bundler.with_clean_env do
+          if Origen.os.unix?
+            if Origen.site_config.gem_build_switches
+              Origen.site_config.gem_build_switches.each do |switches|
+                `bundle config build.#{switches}`
+              end
+            end
+          end
+          result = system(cmd)
+        end
+        `chmod o-w #{ENV['BUNDLE_BIN']}`
+        # Make .bat versions of all executables, Bundler should really be doing this when running
+        # on windows
+        if Origen.os.windows?
+          bat_present = File.exist? "#{origen_root}/lbin/origen.bat"
+          Dir.glob("#{origen_root}/lbin/*").each do |bin|
+            unless bin =~ /.bat$/
+              bat = "#{bin}.bat"
+              unless File.exist?(bat)
+                File.open(bat, 'w') { |f| f.write('@"ruby.exe" "%~dpn0" %*') }
+              end
+            end
+          end
+          if !bat_present && !result
+            puts 'Some Windows specific updates to your workspace were required, please re-run the last command'
+            exit 0
+          end
+        end
+        if result
+          exec "origen #{ARGV.join(' ')}"
+          exit 0
+        else
+          puts
+          puts "If you have just updated a gem version and are now getting an error that Bundler cannot find compatible versions for it then first try running 'bundle update <gemname>'."
+          puts "For example if you have just changed the version of origen_core run 'bundle update origen_core'."
+          exit 1
+        end
+      end
+    else
+      Bundler.setup
+    end
+  end
+  require 'bundler/setup'
+  if Origen.site_config.use_bootsnap && !Origen.os.windows?
+    puts 'Gettin bootsnappy up in here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
+    ENV["BOOTSNAP_CACHE_DIR"] ||= "#{origen_root}/tmp/cache"
+    require 'bootsnap/setup'
+  else
+    puts 'NOT SO SNAPPY'
+  end
+  require 'origen'
+else
+  $LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../lib"
+  require 'origen'
+end
+
+begin
+  # If this script has been invoked from within an Origen application then open
+  # up all commands, if not then only allow the command to create a new Origen
+  # application.
+  if origen_root && boot_app
+    require 'origen/commands'
+  else
+    require 'origen/commands_global'
+  end
+rescue Exception => e
+  # A formatted stack dump will not be printed if the application ends via 'exit 0' or 'exit 1'. In that
+  # case the application code is responsible for printing a helpful error message.
+  # This will intercept all other exits, e.g. via 'fail "Something has done wrong"', and split the stack
+  # dump to separate all in-application references from Origen core/plugin references.
+  if e.is_a?(SystemExit)
+    exit e.status
+  else
+    puts
+    if Origen.app_loaded?
+      puts 'COMPLETE CALL STACK'
+      puts '-------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      puts e.backtrace
+
+      puts
+      puts 'APPLICATION CALL STACK'
+      puts '----------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      # Only print out the application stack trace by default, if verbose logging is
+      # enabled then output the full thing
+      e.backtrace.each do |line|
+        path = Pathname.new(line)
+        if path.absolute?
+          if line =~ /^#{Origen.root}/ && line !~ /^#{Origen.root}\/lbin/
+            puts line
+          end
+        else
+          puts line unless line =~ /^.\/lbin/
+        end
+      end
+    else
+      puts 'COMPLETE CALL STACK'
+      puts '-------------------'
+      puts e.message unless e.is_a?(SystemExit)
+      puts e.backtrace
+    end
+    exit 1
+  end
+ensure
+  if Origen.app_loaded?
+    Origen.app.listeners_for(:on_origen_shutdown).each(&:on_origen_shutdown)
+    Origen.app.runner.shutdown
+  end
+end

data/config/version.rb

@@ -1,7 +1,7 @@
 module Origen
   MAJOR = 0
-  MINOR = 40
-  BUGFIX = 2
+  MINOR = 41
+  BUGFIX = 0
   DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')

data/lib/origen/model/exporter.rb

@@ -247,16 +247,21 @@ module Origen
         unless reg.description.empty?
           reg.description.each { |l| lines << indent + "# #{l}" }
         end
-        lines << indent + "model.add_reg :#{id}, #{reg.offset.to_hex}, size: #{reg.size} do |reg|"
+        lines << indent + "model.add_reg :#{id}, #{reg.offset.to_hex}, size: #{reg.size} #{reg.bit_order == :msb0 ? ', bit_order: :msb0' : ''} do |reg|"
         indent = ' ' * ((options[:indent] || 0) + 2)
         reg.named_bits.each do |name, bits|
           unless bits.description.empty?
             bits.description.each { |l| lines << indent + "# #{l}" }
           end
+          position = reg.bit_order == :msb0 ? (reg.size - bits.position - 1) : bits.position
           if bits.size == 1
-            line = indent + "reg.bit #{bits.position}, :#{name}"
+            line = indent + "reg.bit #{position}, :#{name}"
           else
-            line = indent + "reg.bit #{bits.position + bits.size - 1}..#{bits.position}, :#{name}"
+            if reg.bit_order == :msb0
+              line = indent + "reg.bit #{position - bits.size + 1}..#{position}, :#{name}"
+            else
+              line = indent + "reg.bit #{position + bits.size - 1}..#{position}, :#{name}"
+            end
           end
           unless bits.access == :rw
             line << ", access: :#{bits.access}"

data/lib/origen/ports/port.rb

@@ -68,6 +68,11 @@ module Origen
         end
       end
 
+      # Prevent infinite loop if a child bit collection checks bit_order
+      def bit_order
+        parent.bit_order
+      end
+
       def drive(value = nil, options = {})
         value, options = nil, value if value.is_a?(Hash)
         if options[:index]

data/lib/origen/registers/bit_collection.rb

@@ -19,12 +19,13 @@ module Origen
       attr_accessor :name
       alias_method :id, :name
 
-      def initialize(reg, name, data = []) # :nodoc:
+      def initialize(reg, name, data = [], options = {}) # :nodoc:
         if reg.respond_to?(:has_bits_enabled_by_feature?) && reg.has_parameter_bound_bits?
           reg.update_bound_bits unless reg.updating_bound_bits?
         end
         @reg = reg
         @name = name
+        @with_bit_order = options[:with_bit_order] || :lsb0
         [data].flatten.each { |item| self << item }
       end
 
@@ -33,6 +34,31 @@ module Origen
         parent.bit_order
       end
 
+      # Returns the bit numbering order to use when interpreting indeces
+      def with_bit_order
+        @with_bit_order
+      end
+
+      # Allow bit number interpreting to be explicitly set to msb0
+      def with_msb0
+        @with_bit_order = :msb0
+        self
+      end
+
+      # Allow bit number interpreting to be explicitly set to lsb0
+      def with_lsb0
+        if block_given?
+          # run just the code block with lsb0 numbering (for internal methods)
+          saved_wbo = @with_bit_order
+          @with_bit_order = :lsb0
+          yield
+          @with_bit_order = saved_wbo
+        else
+          @with_bit_order = :lsb0
+          self
+        end
+      end
+
       def terminal?
         true
       end
@@ -41,6 +67,24 @@ module Origen
         parent.bind(name, live_parameter)
       end
 
+      # Access bits by index
+      #
+      # **Note** This method behaves differently depending on the setting of @with_bit_order
+      #
+      # If @with_bit_order == :lsb0 (default) index 0 refers to the lsb of the bit collection
+      # If @with_bit_order == :msb0 index 0 refers to the msb of the bit collection
+      #
+      # ==== Example
+      #   dut.reg(:some_reg).bits(:some_field).with_msb0[0..1] # returns 2 most significant bits
+      #   dut.reg(:some_reg).bits(:some_field)[0..1]           # returns 2 least significant bits
+      #
+      # **Note**  Internal methods should call this method using a with_lsb0 block around the code
+      # or alternatively use the shift_out methods
+      # ==== Example
+      #   with_lsb0 do
+      #     saved_bit = [index]
+      #     [index] = some_new_bit_or_operation
+      #   end
       def [](*indexes)
         return self if indexes.empty?
         b = BitCollection.new(parent, name)
@@ -52,7 +96,8 @@ module Origen
         if b.size == 1
           b.first
         else
-          b
+          # maintain downstream bit numbering setting
+          @with_bit_order == :msb0 ? b.with_msb0 : b
         end
       end
       alias_method :bits, :[]
@@ -174,16 +219,18 @@ module Origen
             puts
             fail 'Mismatched size for bit collection copy'
           end
-          size.times do |i|
-            source_bit = reg.bit[i]
-            if source_bit
-              self[i].overlay(source_bit.overlay_str) if source_bit.has_overlay?
-              self[i].write(source_bit.data)
-
-              self[i].read if source_bit.is_to_be_read?
-              self[i].store if source_bit.is_to_be_stored?
+          # safely handle collections with differing with_bit_order settings
+          with_lsb0 do
+            reg.shift_out_with_index do |source_bit, i|
+              if source_bit
+                self[i].overlay(source_bit.overlay_str) if source_bit.has_overlay?
+                self[i].write(source_bit.data)
+
+                self[i].read if source_bit.is_to_be_read?
+                self[i].store if source_bit.is_to_be_stored?
+              end
             end
-          end
+          end # of with_lsb0
         else
           write(reg)
           clear_flags
@@ -331,8 +378,10 @@ module Origen
         end
         value = value.data if value.respond_to?('data')
 
-        size.times do |i|
-          self[i].write(value[i], options)
+        with_lsb0 do
+          size.times do |i|
+            self[i].write(value[i], options)
+          end
         end
         self
       end
@@ -402,38 +451,26 @@ module Origen
       #       bist_shift(bit)
       #   end
       def shift_out_left
-        if bit_order == :msb0
-          each { |bit| yield bit }
-        else
-          reverse_each { |bit| yield bit }
-        end
+        # This is functionally equivalent to reverse_shift_out
+        reverse_each { |bit| yield bit }
       end
 
       # Same as Reg#shift_out_left but includes the index counter
       def shift_out_left_with_index
-        if bit_order == :msb0
-          each.with_index { |bit, i| yield bit, i }
-        else
-          reverse_each.with_index { |bit, i| yield bit, i }
-        end
+        # This is functionally equivalent to reverse_shift_out_with_index
+        reverse_each.with_index { |bit, i| yield bit, i }
       end
 
-      # Same as Reg#shift_out_left but starts from the MSB
+      # Same as Reg#shift_out_left but starts from the LSB
       def shift_out_right
-        if bit_order == :msb0
-          reverse_each { |bit| yield bit }
-        else
-          each { |bit| yield bit }
-        end
+        # This is functionally equivalent to shift_out, actually sends LSB first
+        each { |bit| yield bit }
       end
 
       # Same as Reg#shift_out_right but includes the index counter
       def shift_out_right_with_index
-        if bit_order == :msb0
-          reverse_each.with_index { |bit, i| yield bit, i }
-        else
-          each_with_index { |bit, i| yield bit, i }
-        end
+        # This is functionally equivalent to shift_out_with_index
+        each_with_index { |bit, i| yield bit, i }
       end
 
       # Yields each bit in the register, LSB first.
@@ -985,7 +1022,13 @@ module Origen
             ixs << index
           end
         end
-        ixs.flatten.sort
+        ixs.flatten!
+        # ixs.sort!
+        # convert msb0 numbering (if provided) to lsb0 numbering to get the correct bits
+        if @with_bit_order == :msb0
+          ixs.each_index { |i| ixs[i] = size - ixs[i] - 1 }
+        end
+        ixs.sort
       end
     end
   end

data/lib/origen/registers/msb0_delegator.rb

@@ -0,0 +1,47 @@
+module Origen
+  module Registers
+    require 'delegate'
+
+    # Thin wrapper around register objects to modify bit number interpretation
+    #
+    # This is provided as a convenience to make user code more readable
+    class Msb0Delegator < ::Delegator
+      def initialize(reg_object, bits)
+        @reg_object = reg_object
+        @bits = bits
+      end
+
+      def __getobj__
+        @reg_object
+      end
+
+      def __object__
+        @reg_object
+      end
+
+      def __setobj__(obj)
+        @reg_object = obj
+      end
+
+      def inspect(options = {})
+        options[:with_bit_order] = :msb0
+        @reg_object.inspect(options)
+      end
+
+      def method_missing(method, *args, &block)
+        if args.last.is_a?(Hash)
+          args.last[:with_bit_order] = :msb0
+        else
+          args << { with_bit_order: :msb0 }
+        end
+        @reg_object.method_missing(method, *args, &block)
+      end
+
+      def bit(*args)
+        @reg_object.bit(args, with_bit_order: :msb0)
+      end
+      alias_method :bits, :bit
+      alias_method :[], :bit
+    end
+  end
+end

data/lib/origen/registers/reg.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'origen/registers/msb0_delegator'
 module Origen
   module Registers
     # The register class can be used to represent not only h/ware resgisters,
@@ -91,7 +92,20 @@ module Origen
           @bits << Bit.new(self, n, writable: @init_as_writable, undefined: true)
         end
 
+        # Internally re-map msb0 register descriptions as lsb0
+        options.each_value { |bit_desc| bit_desc[:pos] = @size - bit_desc[:pos] - bit_desc[:bits] } if bit_order == :msb0
+
         add_bits_from_options(options)
+
+        @msb0_delegator = Msb0Delegator.new(self, @bits)
+      end
+
+      def with_msb0
+        @msb0_delegator
+      end
+
+      def with_lsb0
+        self
       end
 
       # Returns the bit order attribute of the register (either :msb0 or :lsb0). If
@@ -134,6 +148,18 @@ module Origen
       end
 
       def inspect(options = {})
+        wbo = options[:with_bit_order] || :lsb0
+        domsb0 = wbo == :msb0
+        dolsb0 = !domsb0
+        if wbo != bit_order
+          Origen.log.warn "Register displayed with #{wbo} numbering, but defined with #{bit_order} numbering"
+          Origen.log.warn 'Access (and display) this register with explicit numbering like this:'
+          Origen.log.warn ''
+          Origen.log.warn "   reg(:#{name}).with_msb0        # bit numbering scheme is msb0"
+          Origen.log.warn "   reg(:#{name}).with_lsb0        # bit numbering scheme is lsb0 (default)"
+          Origen.log.warn "   reg(:#{name})                  # bit numbering scheme is lsb0 (default)"
+        end
+
         # This fancy_output option is passed in via option hash
         #  Even better, the output could auto-detect 7-bit vs 8-bit terminal output and adjust the parameter, but that's for another day
         fancy_output = options[:fancy_output].nil? ? true : options[:fancy_output]
@@ -173,14 +199,10 @@ module Origen
         bit_width = 13
         desc = ["\n0x%X - :#{name}" % address]
         r = size % 8
-        if r == 0 || (size > 8 && bit_order == :msb0)
+        if r == 0 # || (size > 8 && domsb0)
           desc << ('  ' + corner_double_up_left + ((horiz_double_line * bit_width + horiz_double_tee_down) * 8)).chop + corner_double_up_right
         else
-          if bit_order == :lsb0
-            desc << ('  ' + (' ' * (bit_width + 1) * (8 - r)) + corner_double_up_left + ((horiz_double_line * bit_width + horiz_double_tee_down) * r)).chop + corner_double_up_right
-          else
-            desc << ('  ' + corner_double_up_left + ((horiz_double_line * bit_width + horiz_double_tee_down) * r)).chop + corner_double_up_right
-          end
+          desc << ('  ' + (' ' * (bit_width + 1) * (8 - r)) + corner_double_up_left + ((horiz_double_line * bit_width + horiz_double_tee_down) * r)).chop + corner_double_up_right
         end
 
         # "<#{self.class}: #{self.name}>"
@@ -188,32 +210,22 @@ module Origen
         num_bytes.times do |byte_index|
           # Need to add support for little endian regs here?
           byte_number = num_bytes - byte_index
-          if bit_order == :lsb0
-            max_bit = (byte_number * 8) - 1
-            min_bit = max_bit - 8 + 1
-          else
-            min_bit = (byte_index * 8)
-            max_bit = min_bit + 7
-          end
+          max_bit = (byte_number * 8) - 1
+          min_bit = max_bit - 8 + 1
 
           # BIT INDEX ROW
           line = '  '
           line_complete = false
           8.times do |i|
-            if bit_order == :lsb0
-              bit_num = (byte_number * 8) - i - 1
-            else
-              bit_num = (byte_index * 8) + i
-            end
+            bit_num = (byte_number * 8) - i - 1
             if bit_num > size - 1
-              if bit_order == :msb0 && bit_num == size
-                line += vert_single_line
-                line_complete = true
+              line << ' ' + ''.center(bit_width) unless line_complete
+            else
+              if dolsb0
+                line << vert_single_line + "#{bit_num}".center(bit_width)
               else
-                line << ' ' + ''.center(bit_width) unless line_complete
+                line << vert_single_line + "#{size - bit_num - 1}".center(bit_width)
               end
-            else
-              line << vert_single_line + "#{bit_num}".center(bit_width)
             end
           end
           line += vert_single_line unless line_complete
@@ -225,11 +237,9 @@ module Origen
           line_complete = false
           named_bits include_spacers: true do |name, bit, bitcounter|
             if _bit_in_range?(bit, max_bit, min_bit)
-              if bit_order == :lsb0
-                if max_bit > (size - 1) && !first_done
-                  (max_bit - (size - 1)).times do
-                    line << ' ' * (bit_width + 1)
-                  end
+              if max_bit > (size - 1) && !first_done
+                (max_bit - (size - 1)).times do
+                  line << ' ' * (bit_width + 1)
                 end
               end
 
@@ -237,17 +247,13 @@ module Origen
 
                 if name
                   if bitcounter.nil?
-                    if bit_order == :lsb0
-                      bit_name = "#{name}[#{_max_bit_in_range(bit, max_bit, min_bit)}:#{_min_bit_in_range(bit, max_bit, min_bit)}]"
-                    else
-                      bit_name = "#{name}[#{_min_bit_in_range(bit, max_bit, min_bit)}:#{_max_bit_in_range(bit, max_bit, min_bit)}]"
-                    end
+                    bit_name = "#{name}[#{_max_bit_in_range(bit, max_bit, min_bit, options)}:#{_min_bit_in_range(bit, max_bit, min_bit, options)}]"
                     bit_span = _num_bits_in_range(bit, max_bit, min_bit)
 
                   else
-                    upper = _max_bit_in_range(bit, max_bit, min_bit) + bitcounter - bit.size
-                    lower = _min_bit_in_range(bit, max_bit, min_bit) + bitcounter - bit.size
-                    if bit_order == :lsb0
+                    upper = _max_bit_in_range(bit, max_bit, min_bit, options) + bitcounter - bit.size
+                    lower = _min_bit_in_range(bit, max_bit, min_bit, options) + bitcounter - bit.size
+                    if dolsb0
                       bit_name = "#{name}[#{upper}:#{lower}]"
                     else
                       bit_name = "#{name}[#{upper}:#{lower}]"
@@ -293,11 +299,9 @@ module Origen
           first_done = false
           named_bits include_spacers: true do |name, bit, _bitcounter|
             if _bit_in_range?(bit, max_bit, min_bit)
-              if bit_order == :lsb0
-                if max_bit > (size - 1) && !first_done
-                  (max_bit - (size - 1)).times do
-                    line << ' ' * (bit_width + 1)
-                  end
+              if max_bit > (size - 1) && !first_done
+                (max_bit - (size - 1)).times do
+                  line << ' ' * (bit_width + 1)
                 end
               end
 
@@ -348,12 +352,8 @@ module Origen
 
           if size >= 8
             r = size % 8
-            if byte_index == 0 && r != 0 && bit_order == :lsb0
+            if byte_index == 0 && r != 0
               desc << ('  ' + corner_double_up_left + ((horiz_double_line * bit_width + horiz_double_tee_down) * (8 - r)).chop + horiz_double_cross + (horiz_single_line * (bit_width + 1) * r)).chop + vert_single_tee_left
-            elsif (byte_index == num_bytes - 1) && r != 0 && bit_order == :msb0
-              desc << ('  ' + corner_single_down_left + ((horiz_single_line * bit_width + horiz_single_tee_up) * r)).chop + corner_single_down_right
-            elsif (byte_index == num_bytes - 2) && r != 0 && bit_order == :msb0
-              desc << '  ' + vert_single_tee_right + ((horiz_single_line * bit_width + horiz_single_cross) * r) + ((horiz_single_line * bit_width + horiz_single_tee_up) * (8 - r)).chop + corner_single_down_right
             else
               if byte_index == num_bytes - 1
                 desc << ('  ' + corner_single_down_left + ((horiz_single_line * bit_width + horiz_single_tee_up) * 8)).chop + corner_single_down_right
@@ -362,11 +362,7 @@ module Origen
               end
             end
           else
-            if bit_order == :lsb0
-              desc << ('  ' + (' ' * (bit_width + 1) * (8 - size)) + corner_single_down_left + ((horiz_single_line * bit_width + horiz_single_tee_up) * size)).chop + corner_single_down_right
-            else
-              desc << ('  ' + corner_single_down_left + ((horiz_single_line * bit_width + horiz_single_tee_up) * size)).chop + corner_single_down_right
-            end
+            desc << ('  ' + (' ' * (bit_width + 1) * (8 - size)) + corner_single_down_left + ((horiz_single_line * bit_width + horiz_single_tee_up) * size)).chop + corner_single_down_right
           end
         end
         desc.join("\n")
@@ -584,24 +580,13 @@ module Origen
         @lookup.each { |_k, v| split_bits = true if v.is_a? Array }
 
         if split_bits == false
-          if bit_order == :lsb0
-            current_pos = size
-          else
-            current_pos = 0
-          end
+          current_pos = size
+
           # Sort by position
-          @lookup.sort_by { |_name, details| bit_order == :lsb0 ? -details[:pos] : details[:pos] }.each do |name, details|
-            if bit_order == :lsb0
-              pos = details[:bits] + details[:pos]
-            else
-              pos = details[:pos]
-            end
+          @lookup.sort_by { |_name, details| -details[:pos] }.each do |name, details|
+            pos = details[:bits] + details[:pos]
             if options[:include_spacers] && (pos != current_pos)
-              if bit_order == :lsb0
-                collection = BitCollection.dummy(self, nil, size: current_pos - pos, pos: pos)
-              else
-                collection = BitCollection.dummy(self, nil, size: pos - current_pos, pos: current_pos)
-              end
+              collection = BitCollection.dummy(self, nil, size: current_pos - pos, pos: pos)
               unless collection.size == 0
                 if block_given?
                   yield nil, collection
@@ -621,19 +606,10 @@ module Origen
                 result << [name, collection]
               end
             end
-            if bit_order == :lsb0
-              current_pos = details[:pos]
-            else
-              current_pos = details[:bits] + details[:pos]
-            end
+            current_pos = details[:pos]
           end
-          if options[:include_spacers] && ((bit_order == :lsb0 && current_pos != 0) ||
-                                            bit_order == :msb0 && current_pos != size)
-            if bit_order == :lsb0
-              collection = BitCollection.dummy(self, nil, size: current_pos, pos: 0)
-            else
-              collection = BitCollection.dummy(self, nil, size: size - current_pos, pos: current_pos)
-            end
+          if options[:include_spacers] && (current_pos != 0)
+            collection = BitCollection.dummy(self, nil, size: current_pos, pos: 0)
             unless collection.size == 0
               if block_given?
                 yield nil, collection
@@ -1061,10 +1037,12 @@ module Origen
       alias_method :delete_bits, :delete_bit
 
       # @api private
-      def expand_range(range)
+      def expand_range(range, wbo = :lsb0)
         if range.first > range.last
           range = Range.new(range.last, range.first)
         end
+        range = range.to_a
+        range.reverse! if wbo == :msb0
         range.each do |i|
           yield i
         end
@@ -1086,13 +1064,22 @@ module Origen
       #   reg(:control).bit(1)                  # => Returns a BitCollection containing status bit
       #   reg(:control).bit(1,2)                # => Returns a BitCollection containing both status bits
       def bit(*args)
+        # allow msb0 bit numbering if requested
+        wbo = :lsb0
+        if args.last.is_a?(Hash)
+          wbo = args.last.delete(:with_bit_order) || :lsb0
+          args.pop if args.last.size == 0
+        end
+
         multi_bit_names = false
         # return get_bits_with_constraint(nil,:default) if args.size == 0
         constraint = extract_feature_params(args)
         if constraint.nil?
           constraint = :default
         end
-        collection = BitCollection.new(self, :unknown)
+
+        collection = BitCollection.new(self, :unknown, [], with_bit_order: wbo)
+
         if args.size == 0
           collection.add_name(name)
           @bits.each do |bit|
@@ -1101,13 +1088,14 @@ module Origen
         else
           args.flatten!
           args.sort!
+          args.reverse! if wbo == :msb0
           args.each do |arg_item|
             if arg_item.is_a?(Integer)
-              b = get_bits_with_constraint(arg_item, constraint)
+              b = get_bits_with_constraint(arg_item, constraint, with_bit_order: wbo)
               collection << b if b
             elsif arg_item.is_a?(Range)
-              expand_range(arg_item) do |bit_number|
-                collection << get_bits_with_constraint(bit_number, constraint)
+              expand_range(arg_item, wbo) do |bit_number|
+                collection << get_bits_with_constraint(bit_number, constraint, with_bit_order: wbo)
               end
             else
               multi_bit_names = args.size > 1
@@ -1140,14 +1128,21 @@ module Origen
         else
           if multi_bit_names
             collection.sort_by!(&:position)
+            wbo == :msb0 ? collection.with_msb0 : collection.with_lsb0
           end
-          collection
+          wbo == :msb0 ? collection.with_msb0 : collection.with_lsb0
         end
       end
       alias_method :bits, :bit
       alias_method :[], :bit
 
-      def get_bits_with_constraint(number, params)
+      def get_bits_with_constraint(number, params, options = {})
+        options = { with_bit_order: :lsb0 }.merge(options)
+        # remap to lsb0 number to grab correct bit
+        if options[:with_bit_order] == :msb0
+          number = size - number - 1
+        end
+
         return nil unless @bits[number]
         if (params == :default || !params) && @bits[number].enabled?
           @bits[number]
@@ -1268,23 +1263,28 @@ module Origen
 
       # All other Reg methods are delegated to BitCollection
       def method_missing(method, *args, &block) # :nodoc:
+        wbo = :lsb0
+        if args.last.is_a?(Hash)
+          wbo = args.last[:with_bit_order] if args.last.key?(:with_bit_order)
+        end
+
         if method.to_sym == :to_ary || method.to_sym == :to_hash
           nil
         elsif meta_data_method?(method)
           extract_meta_data(method, *args)
         else
           if BitCollection.instance_methods.include?(method)
-            to_bit_collection.send(method, *args, &block)
+            to_bit_collection(with_bit_order: wbo).send(method, *args, &block)
           elsif has_bits?(method)
-            bits(method)
+            bits(method, with_bit_order: wbo)
           else
             super
           end
         end
       end
 
-      def to_bit_collection
-        BitCollection.new(self, name, @bits)
+      def to_bit_collection(options = {})
+        BitCollection.new(self, name, @bits, options)
       end
 
       # Recognize that Reg responds to all BitCollection methods methods based on
@@ -1555,14 +1555,22 @@ module Origen
         end
       end
 
-      def _max_bit_in_range(bits, max, _min)
+      def _max_bit_in_range(bits, max, _min, options = { with_bit_order: false })
         upper = bits.position + bits.size - 1
-        [upper, max].min - bits.position
+        if options[:with_bit_order] == :msb0
+          bits.size - ([upper, max].min - bits.position) - 1
+        else
+          [upper, max].min - bits.position
+        end
       end
 
-      def _min_bit_in_range(bits, _max, min)
+      def _min_bit_in_range(bits, _max, min, options = { with_bit_order: false })
         lower = bits.position
-        [lower, min].max - bits.position
+        if options[:with_bit_order] == :msb0
+          bits.size - ([lower, min].max - lower) - 1
+        else
+          [lower, min].max - bits.position
+        end
       end
 
       # Returns true if some portion of the given bits falls

data/vendor/lib/models/origen/export1.rb

@@ -69,7 +69,7 @@ module Origen
       model.add_virtual_pin :relay1
       model.add_virtual_pin :relay2, packages: { bga: {} }
 
-      model.sub_block :block1, file: 'origen/export1/block1.rb', dir: '/scratch/nxa21353/Code/github/origen/vendor/lib/models', lazy: true
+      model.sub_block :block1, file: 'origen/export1/block1.rb', dir: '/home/origen/users/pderouen/origen/vendor/lib/models', lazy: true
 
     end
   end

data/vendor/lib/models/origen/export1/block1.rb

@@ -4,7 +4,7 @@ module Origen
   module Export1
     module Block1
       def self.extended(model)
-        model.sub_block :x, file: 'origen/export1/block1/x.rb', dir: '/scratch/nxa21353/Code/github/origen/vendor/lib/models', lazy: true, base_address: 0x40000000
+        model.sub_block :x, file: 'origen/export1/block1/x.rb', dir: '/home/origen/users/pderouen/origen/vendor/lib/models', lazy: true, base_address: 0x40000000
 
       end
     end

data/vendor/lib/models/origen/export1/block1/x.rb

@@ -8,7 +8,7 @@ module Origen
           # ** Some Control Register **
           # Blah, blah,
           # and some more blah
-          model.add_reg :ctrl, 0x24, size: 16 do |reg|
+          model.add_reg :ctrl, 0x24, size: 16  do |reg|
             reg.bit 7, :coco, access: :ro
             reg.bit 6, :aien
             # **Some Diff Bit** - This is a...
@@ -19,6 +19,15 @@ module Origen
             reg.bit 5, :diff
             reg.bit 4..0, :adch, reset: 0x1F
           end
+          # ** A MSB0 Test Case **
+          # Blah-ba-bi-blah
+          # just following the comment pattern above
+          model.add_reg :msb0_test, 0x28, size: 16 , bit_order: :msb0 do |reg|
+            reg.bit 8, :ale
+            reg.bit 9, :xsfg
+            reg.bit 10, :yml
+            reg.bit 11..15, :field, reset: 0x1F
+          end
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.40.2
+  version: 0.41.0
 platform: ruby
 authors:
 - Stephen McGinty
@@ -383,6 +383,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/origen
+- bin/origen~
 - config/application.rb
 - config/boot.rb
 - config/commands.rb
@@ -561,6 +562,7 @@ files:
 - lib/origen/registers/bit_collection.rb
 - lib/origen/registers/container.rb
 - lib/origen/registers/domain.rb
+- lib/origen/registers/msb0_delegator.rb
 - lib/origen/registers/reg.rb
 - lib/origen/registers/reg_collection.rb
 - lib/origen/regression_manager.rb