idlc 0.1.1

data/lib/idlc/interfaces.rb

@@ -0,0 +1,135 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require_relative "type"
+
+module Idl
+  # interface for a parameter that may only be known at runtime
+  module RuntimeParam
+    extend T::Sig
+    extend T::Helpers
+    interface!
+
+    include Kernel
+
+    ValueType =
+      T.type_alias { T.any(Integer, T::Boolean, String, T::Array[Integer], T::Array[Integer], T::Array[T::Boolean], T::Array[String]) }
+
+    sig { abstract.returns(String) }
+    def name; end
+
+    sig { abstract.returns(String) }
+    def description; end
+
+    sig { abstract.returns(Schema) }
+    def schema; end
+
+    sig { abstract.returns(T::Boolean) }
+    def value_known?; end
+
+    sig { abstract.returns(ValueType) }
+    def value; end
+
+    sig { abstract.returns(Type) }
+    def idl_type; end
+  end
+
+  # basic interface for objects that are described with JSON Schema
+  module Schema
+    extend T::Sig
+    extend T::Helpers
+    interface!
+
+    sig { abstract.returns(T::Boolean) }
+    def max_val_known?; end
+
+    sig { abstract.returns(Integer) }
+    def max_val; end
+
+    sig { abstract.returns(T::Boolean) }
+    def min_val_known?; end
+
+    sig { abstract.returns(Integer) }
+    def min_val; end
+
+    sig { abstract.returns(Type) }
+    def to_idl_type; end
+  end
+
+  module CsrField
+    extend T::Sig
+    extend T::Helpers
+    interface!
+
+    sig { abstract.returns(String) }
+    def name; end
+
+    # whether or not this field is defined in both RV32 and RV64
+    sig { abstract.returns(T::Boolean) }
+    def defined_in_all_bases?; end
+
+    sig { abstract.returns(T::Boolean) }
+    def defined_in_base32?; end
+
+    sig { abstract.returns(T::Boolean) }
+    def defined_in_base64?; end
+
+    # whether or not this field is defined only in RV64
+    sig { abstract.returns(T::Boolean) }
+    def base64_only?; end
+
+    # whether or not this field is defined only in RV32
+    sig { abstract.returns(T::Boolean) }
+    def base32_only?; end
+
+    # returns the location of the field in the CSR.
+    # base is required when the field moves locations between RV32 and RV64
+    sig { abstract.params(base: T.nilable(Integer)).returns(T::Range[Integer]) }
+    def location(base); end
+
+    sig { abstract.params(base: T.nilable(Integer)).returns(Integer) }
+    def width(base); end
+
+    sig { abstract.params(base: T.nilable(Integer)).returns(T.nilable(String)) }
+    def type(base); end
+
+    # whether or not the field is supposed to exist/be implemented in the
+    # execution context
+    sig { abstract.returns(T::Boolean) }
+    def exists?; end
+
+    sig { abstract.returns(ValueRbType) }
+    def reset_value; end
+  end
+
+  module Csr
+    extend T::Sig
+    extend T::Helpers
+    interface!
+
+    sig { abstract.returns(String) }
+    def name; end
+
+    sig { abstract.params(base: T.nilable(Integer)).returns(T.nilable(Integer)) }
+    def length(base); end
+
+    sig { abstract.returns(Integer) }
+    def max_length; end
+
+    sig { abstract.returns(T::Boolean) }
+    def dynamic_length?; end
+
+    sig { abstract.returns(T::Array[CsrField]) }
+    def fields; end
+
+    # If the entire CSR is read-only with a known reset value, returns the value
+    # otherwise, returns nil
+    sig { abstract.returns(T.nilable(Integer)) }
+    def value; end
+  end
+end

data/lib/idlc/log.rb

@@ -0,0 +1,23 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# typed: true
+# frozen_string_literal: true
+
+require "logger"
+
+require "sorbet-runtime"
+
+module Idl
+  extend T::Sig
+
+  sig { returns(Logger).checked(:tests) }
+  def self.logger
+    @logger ||= Logger.new($stdout, level: :warn)
+  end
+
+  sig { params(logger: Logger).returns(Logger) }
+  def self.set_logger(logger)
+    @logger = logger
+  end
+end

data/lib/idlc/passes/find_referenced_csrs.rb

@@ -0,0 +1,39 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Idl
+  class AstNode
+    extend T::Sig
+    sig { overridable.returns(T::Array[String]) }
+    def find_referenced_csrs
+      csrs = T.let([], T::Array[String])
+      @children.each do |child|
+        csrs += child.find_referenced_csrs
+      end
+      csrs.uniq
+    end
+  end
+
+  class CsrReadExpressionAst < AstNode
+    sig { override.returns(T::Array[String]) }
+    def find_referenced_csrs
+      [csr_name]
+    end
+  end
+
+  class CsrWriteAst < AstNode
+    sig { override.returns(T::Array[String]) }
+    def find_referenced_csrs
+      if idx.is_a?(IntLiteralAst)
+        []
+      else
+        [idx.text_value]
+      end
+    end
+  end
+end

data/lib/idlc/passes/find_return_values.rb

@@ -0,0 +1,76 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# frozen_string_literal: true
+
+# pass to find all the possible return values from a function body
+
+module Idl
+
+  class AstNode
+    def pass_find_return_values(values, current_conditions)
+      children.each do |c|
+        c.pass_find_return_values(values, current_conditions)
+      end
+    end
+  end
+
+  class ReturnStatementAst < AstNode
+    def pass_find_return_values(values, current_conditions, symtab)
+      # if the action is a ternary operator, there is another condition to consider
+      if first.is_a?(TernaryOperatorExpressionAst)
+        current_conditions.push first.condition
+        values << [first.true_expression, current_conditions.clone]
+        current_conditions.pop
+        current_conditions.push first.condition.invert(symtab)
+        values << [first.false_expression, current_conditions.clone]
+        current_conditions.pop
+      else
+        values << [self, current_conditions.clone]
+      end
+    end
+  end
+
+  class IfAst < AstNode
+    def pass_find_return_values(values, current_conditions, symtab)
+      current_conditions.push if_cond
+      if_body.elements.each do |e|
+        e.e.pass_find_return_values(values, current_conditions, symtab)
+      end
+      current_conditions.pop
+
+      unless elseifs.empty?
+        elseifs.elements.each do |eif|
+          current_conditions.push eif.expression
+
+          eif.body.elements.each do |e|
+            e.e.pass_find_return_values(values, current_conditions, symtab)
+          end
+
+          current_conditions.pop
+        end
+      end
+
+      unless final_else.empty?
+        current_conditions.push if_cond.invert(symtab)
+
+        final_else.body.elements.each do |e|
+          e.e.pass_find_return_values(values, current_conditions, symtab)
+        end
+        current_conditions.pop
+      end
+    end
+  end
+
+  class FunctionBodyAst < AstNode
+    # @return [Array<Ast, Array<Ast>>] List of possible return values, along with the condition it occurs under
+    def pass_find_return_values(symtab)
+      values = []
+      current_conditions = []
+      statements.each do |s|
+        s.pass_find_return_values(values, current_conditions, symtab)
+      end
+      values
+    end
+  end
+end

data/lib/idlc/passes/find_src_registers.rb

@@ -0,0 +1,125 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# frozen_string_literal: true
+
+module Idl
+  class ComplexRegDetermination < RuntimeError
+  end
+
+  class AstNode
+    def find_src_registers(symtab)
+      # if is_a?(Executable)
+      #   value_result = value_try do
+      #     execute(symtab)
+      #   end
+      #   value_else(value_result) do
+      #     execute_unknown(symtab)
+      #   end
+      # end
+      add_symbol(symtab) if is_a?(Declaration)
+
+      srcs = []
+      @children.each do |child|
+        srcs.concat(child.find_src_registers(symtab))
+      end
+      srcs.uniq
+    end
+
+    def find_dst_registers(symtab)
+      # if is_a?(Executable)
+      #   value_result = value_try do
+      #     execute(symtab)
+      #   end
+      #   value_else(value_result) do
+      #     execute_unknown(symtab)
+      #   end
+      # end
+      add_symbol(symtab) if is_a?(Declaration)
+
+      srcs = []
+      @children.each do |child|
+        srcs.concat(child.find_dst_registers(symtab))
+      end
+      srcs.uniq
+    end
+  end
+
+  class ForLoopAst
+    # we don't unroll, but we don't add the index variable to the symtab, either
+    # that will cause any register accesses dependent on the index variable to raise Complex
+    def find_src_registers(symtab)
+      srcs = init.find_src_registers(symtab)
+      # don't add init to the symtab, since we don't want to use it...
+      srcs += condition.find_src_registers(symtab)
+
+      stmts.each do |stmt|
+        srcs += stmt.find_src_registers(symtab)
+      end
+      srcs += update.find_src_registers(symtab)
+
+      srcs
+    end
+
+    # we don't unroll, but we don't add the index variable to the symtab, either
+    # that will cause any register accesses dependent on the index variable to raise Complex
+    def find_dst_registers(symtab)
+      dsts = init.find_dst_registers(symtab)
+      # don't add init to the symtab, since we don't want to use it...
+      dsts += condition.find_dst_registers(symtab)
+
+      stmts.each do |stmt|
+        dsts += stmt.find_dst_registers(symtab)
+      end
+      dsts += update.find_dst_registers(symtab)
+
+      dsts
+    end
+  end
+
+  class AryElementAccessAst
+    def find_src_registers(symtab)
+      value_result = value_try do
+        if var.text_value == "X"
+          return [index.value(symtab)]
+        else
+          return []
+        end
+      end
+      value_else(value_result) do
+        if var.text_value == "X"
+          if index.type(symtab).const?
+            return [index.gen_cpp(symtab, 0)]
+          else
+            raise ComplexRegDetermination
+          end
+        else
+          return []
+        end
+      end
+    end
+  end
+
+  class AryElementAssignmentAst
+    def find_dst_registers(symtab)
+      value_result = value_try do
+        if lhs.text_value == "X"
+          return [idx.value(symtab)]
+        else
+          return []
+        end
+      end
+      value_else(value_result) do
+        if lhs.text_value == "X"
+          if idx.type(symtab).const?
+            return [idx.gen_cpp(symtab, 0)]
+          else
+            raise ComplexRegDetermination
+          end
+        else
+          return []
+        end
+      end
+    end
+  end
+end