origen_testers 0.41.0 → 0.42.0

data/lib/origen_testers/igxl_based_tester/decompiler.rb

@@ -0,0 +1,72 @@
+module OrigenTesters
+  module IGXLBasedTester
+    # Currently, we aren't differentiating between J750 and UFLEX testers. They'll both use the same until
+    # there are difference that require forking the decompiler.
+
+    def self.suitable_decompiler_for(pattern: nil, tester: nil, **options)
+      if pattern && (Pathname(pattern).extname == ".#{OrigenTesters::IGXLBasedTester.pat_extension}")
+        OrigenTesters::IGXLBasedTester::Pattern
+      elsif tester && (tester == 'j750' || tester == 'uflex' || tester == 'ultraflex')
+        OrigenTesters::IGXLBasedTester::Pattern
+      end
+    end
+    extend OrigenTesters::Decompiler::API
+    register_decompiler(self)
+
+    class Pattern < OrigenTesters::Decompiler::Pattern
+      require_relative './decompiler/atp'
+      extend Atp
+
+      @platform = 'j750'
+      @splitter_config = {
+        pinlist_start:              /^vector/,
+        vectors_start:              /^{/,
+        vectors_end:                /^}/,
+        vectors_include_start_line: false,
+        vectors_include_end_line:   false
+      }
+
+      @platform_tokens = {
+        comment_start: OrigenTesters::IGXLBasedTester.comment_char
+      }
+    end
+
+    def self._sample_direct_source_
+      [
+        '// Sample pattern text for the J750',
+        '// Source located at: lib/origen_testers/igxl_based_tester/decompiler',
+        '',
+        'import tset tp0;',
+        'svm_only_file = no;',
+        'opcode_mode = extended;',
+        'compressed = yes;',
+        '',
+        'vector ($tset, tclk, tdi, tdo, tms)',
+        '{',
+        'start_label pattern_st:',
+        '// Start of vector body',
+        'repeat 2 > tp0 X X X X ; // First Vector',
+        'repeat 5 > tp0 1 0 X 1 ;',
+        'end_module   > tp0 X X X X ; // Last Vector',
+        '}'
+      ]
+    end
+
+    def self.sample_direct_source
+      _sample_direct_source_.join("\n")
+    end
+
+    def self.write_sample_source
+      unless Dir.exist?(sample_source_atp.dirname)
+        Origen.log.info "Creating directory #{sample_source_atp.dirname}"
+        FileUtils.mkdir_p(sample_source_atp.dirname)
+      end
+      File.open(sample_source_atp, 'w').puts(sample_direct_source)
+      sample_source_atp
+    end
+
+    def self.sample_source_atp
+      Origen.app!.root.join('approved/j750/decompiler/sample/sample.atp')
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/decompiler/atp.rb

@@ -0,0 +1,98 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Pattern
+      require_relative './nodes'
+
+      module Atp
+        def nodes_namespace
+          OrigenTesters::IGXLBasedTester::Decompiler::Atp
+        end
+
+        def parse_frontmatter(raw_frontmatter:, context:)
+          in_header = true
+          header = []
+          comments = []
+          variable_assignments = {}
+          imports = {}
+          raw_frontmatter.each_with_index do |l, i|
+            if l =~ Regexp.new('^\s*//')
+              if in_header
+                # Header Comment
+                header << l.chomp
+              else
+                # Other Comment
+                comments << l.chomp
+              end
+            elsif !(l =~ Regexp.new(/=/)).nil?
+              # Variable Assignment
+              var, val = l.split('=').map(&:strip)
+              variable_assignments[var] = val.gsub(';', '')
+            elsif !(l =~ Regexp.new(/import/)).nil?
+              # Import
+              import, type, val = l.split(/\s+/)
+              imports[val.gsub(';', '')] = type
+            elsif l.strip.empty?
+              # Just whitespace. Ignore this, but don't throw an error
+            else
+              Origen.app!.fail!("Unable to parse pattern frontmatter, at line: #{i}")
+            end
+          end
+          nodes_namespace::Frontmatter.new(context:              self,
+                                           pattern_header:       header,
+                                           variable_assignments: variable_assignments,
+                                           imports:              imports,
+                                           comments:             comments
+                                          )
+        end
+
+        def parse_pinlist(raw_pinlist:, context:)
+          raw_pinlist = raw_pinlist.join('')
+          OrigenTesters::Decompiler::Nodes::Pinlist.new(context: self,
+                                                        pins:    raw_pinlist[raw_pinlist.index('$') + 1..raw_pinlist.index(')') - 1].split(/,\s*/)[1..-1]
+                                                       )
+        end
+
+        def parse_vector(raw_vector:, context:, meta:)
+          if raw_vector =~ Regexp.new('^\s*//')
+            nodes_namespace::CommentBlock.new(context:  self,
+                                              comments: raw_vector.split("\n")
+                                             )
+          elsif raw_vector =~ Regexp.new('^\s*start_label')
+            nodes_namespace::StartLabel.new(context:     self,
+                                            start_label: raw_vector[raw_vector.index('start_label') + 11..-1].strip[0..-2]
+                                           )
+          elsif raw_vector =~ Regexp.new('^\s*global')
+            contents = raw_vector.strip['global'.size + 1..-2].strip.split(/\s+/)
+            nodes_namespace::GlobalLabel.new(context:    self,
+                                             label_type: contents[0],
+                                             label_name: contents[1]
+                                            )
+          elsif raw_vector =~ Regexp.new(':(?!(.*>))')
+            nodes_namespace::Label.new(context:    self,
+                                       # Strip any whitespace from the vector and grab contents up to
+                                       # the ':' symbol.
+                                       label_name: raw_vector.strip[0..-2]
+                                      )
+          else
+
+            opcode_plus_args = raw_vector[0..(raw_vector.index('>') - 1)].rstrip.split(/\s+/)
+            timeset_plus_pins = raw_vector[(raw_vector.index('>') + 1)..(raw_vector.index(';') - 1)].strip.split(/\s+/)
+            nodes_namespace::Vector.new(context:          self,
+                                        timeset:          timeset_plus_pins[0],
+                                        pin_states:       timeset_plus_pins[1..-1],
+                                        opcode:           (opcode_plus_args[0] && opcode_plus_args[0].empty?) ? nil : opcode_plus_args[0],
+                                        opcode_arguments: opcode_plus_args[1..-1],
+                                        comment:          begin
+                if raw_vector =~ Regexp.new('//')
+                  raw_vector[raw_vector.index('//') + 2..-1].strip
+                else
+                  ''
+                end
+              end
+                                       )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/decompiler/nodes.rb

@@ -0,0 +1,77 @@
+module OrigenTesters
+  module IGXLBasedTester
+    module Decompiler
+      module Atp
+        class Vector < OrigenTesters::Decompiler::Nodes::Vector
+          PLATFORM_NODES = [:opcode, :opcode_arguments]
+
+          def initialize(**options)
+            @opcode = options[:opcode]
+            @opcode_arguments = options[:opcode_arguments] || []
+            super(repeat: false, **options)
+          end
+
+          def repeat
+            opcode == 'repeat' ? opcode_arguments.first.to_i : 1
+          end
+
+          def opcode
+            @opcode
+          end
+
+          def opcode_arguments
+            @opcode_arguments
+          end
+        end
+
+        class StartLabel < OrigenTesters::Decompiler::Nodes::Node
+          PLATFORM_NODES = [:start_label]
+
+          def initialize(start_label:, context:)
+            @execute = false
+            @start_label = start_label
+
+            super(context: context, type: :start_label)
+          end
+        end
+
+        class Frontmatter < OrigenTesters::Decompiler::Nodes::Frontmatter
+          PLATFORM_NODES = [:variable_assignments, :imports]
+
+          def initialize(pattern_header:, comments:, variable_assignments:, imports:, context:)
+            @variable_assignments = variable_assignments
+            @imports = imports
+
+            super(pattern_header: pattern_header, comments: comments, context: context)
+          end
+        end
+
+        class CommentBlock < OrigenTesters::Decompiler::Nodes::CommentBlock
+        end
+
+        class Label < OrigenTesters::Decompiler::Nodes::Node
+          PLATFORM_NODES = [:label_name]
+
+          def initialize(label_name:, context:)
+            @execute = false
+            @label_name = label_name
+
+            super(context: context, type: :label)
+          end
+        end
+
+        class GlobalLabel < OrigenTesters::Decompiler::Nodes::Node
+          PLATFORM_NODES = [:label_type, :label_name]
+
+          def initialize(label_type:, label_name:, context:)
+            @execute = false
+            @label_type = label_type
+            @label_name = label_name
+
+            super(context: context, type: :global_label)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/j750.rb

@@ -74,7 +74,7 @@ module OrigenTesters
       # * :force_fail_on_timeout (true) - Force a vector mis-compare if the match loop times out
       # * :on_timeout_goto ("") - Optionally supply a label to branch to on timeout, by default will continue from the end of the match loop
       # * :on_block_match_goto ("") - Optionally supply a label to branch to when block condition is met, by default will continue from the end of the match loop.
-      #   A hash will also be accepted for this argument to supply a specific label (or no label) for each block e.g. {0 => "on_block_0_fail"}
+      #   A hash will also be accepted for this argument to supply a specific label (or no label) for each block e.g. <code>{0 => "on_block_0_fail"}</code>
       # * :multiple_entries (false) - Supply an integer to generate multiple entries into the match (each with a unique readcode), this can be useful when debugging patterns with multiple matches
       # * :force_fail_on_timeout (true) - force pattern to fail if timeout occurs
       # * :global_loops (false) - whether match loop loops should use global labels

data/lib/origen_testers/origen_ext/pins/timing.rb

@@ -0,0 +1,57 @@
+require 'origen/pins/timing'
+
+module Origen
+  module Pins
+    module Timing
+      def current_timeset_period=(p)
+        if OrigenTesters::Timing.timeset.nil?
+          Origen.app!.fail!(
+            exception_class: OrigenTesters::Timing::InvalidModification,
+            message:         'No current timeset has been defined! Cannot update the current timeset period!'
+          )
+        else
+          OrigenTesters::Timing.set_timeset(tester.timeset, p)
+        end
+      end
+      alias_method :current_period_in_ns=, :current_timeset_period=
+
+      def current_timeset=(t)
+        OrigenTesters::Timing.set_timeset(t)
+      end
+      alias_method :timeset=, :current_timeset=
+
+      # Returns the current timeset period
+      def current_timeset_period
+        OrigenTesters::Timing.period_in_ns
+      end
+      alias_method :current_period_in_ns, :current_timeset_period
+
+      # Returns the current timeset in seconds
+      # @return [Float] Current period in seconds
+      def current_period_in_secs
+        OrigenTesters::Timing.period_in_secs
+      end
+      alias_method :current_period_in_seconds, :current_period_in_secs
+
+      # Returns the current timeset
+      def current_timeset
+        OrigenTesters::Timing.timeset
+      end
+
+      # If a block is given, defines/redefines the timeset.
+      # If a name is given, retrieves that timeset.
+      # Otherwise, returns the current timeset.
+      def timeset(*args, &block)
+        if block_given?
+          timesets(*args, &block)
+        else
+          if args.first
+            timesets(args.first)
+          else
+            OrigenTesters::Timing.timeset
+          end
+        end
+      end
+    end
+  end
+end