ruby_rtl 0.0.1

data/lib/ruby_rtl/dsl_printer.rb

@@ -0,0 +1,267 @@
+require_relative 'code'
+require_relative 'visitor'
+
+module RubyRTL
+
+  class DSLPrinter < Visitor
+
+    def print circuit
+      code=Code.new
+      code << "# code generated by DSL printer"
+      if root=circuit.ast
+        code << "circuit #{circuit.name}"
+        #root.ios.each{|io|     code << io.accept(self)}
+        root.decls.each{|decl| code << decl.accept(self)}
+        code << root.body.accept(self)
+        puts code.finalize
+      end
+    end
+
+    def visitComment node,args=nil
+    end
+
+    def visitSig sig,args=nil
+      sig.name
+    end
+
+    def visitInput input,args=nil
+      input.name
+    end
+
+    def visitOutput output,args=nil
+      output.name
+    end
+
+    def visitTypeDecl decl,args=nil
+      definition=decl.definition.accept(self)
+      return "typedef #{decl.name} => #{definition}"
+    end
+
+    def visitSigDecl decl,args=nil
+      name=(sig=decl.sig).accept(self)
+      type=sig.type.accept(self)
+      if (values=$typedefs.values).include?(sig.type)
+        idx=values.index(sig.type)
+        type=$typedefs.keys[idx]
+      end
+      case sig
+      when Input
+        kind="input "
+      when Output
+        kind="output"
+      when Sig
+        kind="wire"
+      end
+      "#{kind} #{name} => #{type}"
+    end
+
+    def visitCompDecl decl,args=nil
+      "component #{decl.name} => #{decl.comp}"
+    end
+
+    def visitCombinatorial comb,args=nil
+      body=comb.body.accept(self)
+      code=Code.new
+      code << "combinatorial(#{comb.label}){"
+      code.indent=2
+      code << body
+      code.indent=0
+      code << "}"
+      code
+    end
+
+    def visitSequential seq,args=nil
+      body=seq.body.accept(self)
+      code=Code.new
+      code << "sequential(#{seq.label}){"
+      code.indent=2
+      code << body
+      code.indent=0
+      code << "}"
+      code
+    end
+
+    # === statements
+    def visitBody body,args=nil
+      code=Code.new
+      body.each{|stmt| code << stmt.accept(self,args)}
+      code
+    end
+
+    def visitAssign node,args=nil
+      lhs=node.lhs.accept(self)
+      rhs=node.rhs.accept(self)
+      "assign(#{lhs} <= #{rhs})"
+    end
+
+    def visitIf node,args=nil
+      cond=node.cond.accept(self)
+      body=node.body.accept(self)
+      elsifs_=Code.new
+      node.elsifs.collect{|elsif_| elsifs_ << elsif_.accept(self)}
+      else_=node.else.accept(self) if node.else
+      code=Code.new
+      code << "if #{cond}{"
+      code.indent=2
+      code << body
+      code.indent=0
+      if elsifs_.size>0 or node.else
+        code << "}"
+      end
+      code << elsifs_
+      code << else_ if node.else
+      code << "}" unless node.else or elsifs_.size>0
+      code
+    end
+
+    def visitElse else_,args=nil
+      body=else_.body.accept(self)
+      code=Code.new
+      code << "else {"
+      code.indent=2
+      code << body
+      code.indent=0
+      code << "}"
+      code
+    end
+
+    def visitElsif elsif_,args=nil
+      cond=elsif_.cond.accept(self)
+      body=elsif_.body.accept(self)
+      code=Code.new
+      code << "elsif #{cond}{"
+      code.indent=2
+      code << body
+      code.indent=0
+      code << "}"
+      code
+    end
+
+    # === fsm
+    def visitFsm fsm,args=nil
+      code=Code.new
+      code << "fsm(#{fsm.name}){"
+      code.indent=2
+      code << fsm.body.accept(self)
+      code.indent=0
+      code << "}"
+      code
+    end
+
+    def visitState state,args=nil
+      code=Code.new
+      code << "state(#{state.name}){"
+      code.indent=2
+      code << state.body.accept(self)
+      code.indent=0
+      code << "}"
+      code
+    end
+
+    def visitNext node,args=nil
+      "next_state #{node.name}"
+    end
+
+    # === expr ===
+    def visitBinary node,args=nil
+      lhs=node.lhs.accept(self)
+      op=node.op
+      rhs=node.rhs.accept(self)
+      "(#{lhs} #{op} #{rhs})"
+    end
+
+    def visitUnary node,args=nil
+      expr=node.expr.accept(self)
+      "(#{node.op} #{expr})"
+    end
+
+    def visitFuncCall func,args=nil
+      name=func.name
+      argus=func.args.collect{|arg| arg.accept(self)}.join(',')
+      "#{name}(#{argus})"
+    end
+
+    def visitIndexed indexed,args=nil
+      lhs=indexed.lhs.accept(self)
+      rhs=indexed.rhs.accept(self)
+      "#{lhs}[#{rhs}]"
+    end
+
+    # === literals ===
+    def visitLiteral node,args=nil
+      node.val
+    end
+
+    def visitBitLit node,args=nil
+      node.super.accept(self)
+    end
+
+    def visitIntLit lit,args=nil
+      lit.val
+    end
+
+    def visitUIntLit lit,args=nil
+      lit.val
+    end
+
+    def visitRIntLit lit,args=nil
+      lit.val
+    end
+
+    def visitRUIntLit lit,args=nil
+      lit.val
+    end
+    # === types ===
+
+    def visitBitType node,args=nil
+      "bit"
+    end
+
+    def visitBitVectorType bvt,args=nil
+      "bv#{bvt.bitwidth}"
+    end
+
+    def visitIntType node,args=nil
+      "int#{node.bitwidth}"
+    end
+
+    def visitRIntType node,args=nil
+      "rint#{node.bitwidth}"
+    end
+
+    def visitRUintType node,args=nil
+      "ruint#{node.bitwidth}"
+    end
+
+    def visitUIntType node,args=nil
+      "uint#{node.bitwidth}"
+    end
+
+    def visitRecordType rec_type,args=nil
+      items=[]
+      rec_type.hash.each{|item,type|
+        items << "#{item} => #{type}"
+      }
+      "Record(#{items.join(",")})"
+    end
+
+    def visitEnumType enum_type,args=nil
+      "Enum(#{enum_type.items.join(",")})"
+    end
+
+    def visitMemoryType mem_type,args=nil
+      typename=mem_type.type
+      "Memory(#{mem_type.size},#{typename})"
+    end
+
+    def visitCase case_,args=nil
+      code=Code.new
+      code << "Case(){"
+      code.indent=2
+      code << case_.body.accept(self)
+      code.indent=0
+      code << "}"
+      code
+    end
+  end
+end

data/lib/ruby_rtl/ruby_rtl_package.vhd

@@ -0,0 +1,77 @@
+library ieee;
+use ieee.std_logic_1164.all;
+use ieee.numeric_std.all;
+
+package ruby_rtl_package is
+
+  function to_bit( v:integer  ; n:natural) return std_logic;
+
+  function to_uint(v:std_logic; n:natural) return unsigned;
+
+  function to_int( v:std_logic; n:natural) return signed;
+  function to_int( v:integer  ; n:natural) return signed;
+  function to_int(v : signed; n:natural) return signed;
+
+  function to_bv(v: unsigned;n : natural) return std_logic_vector;
+  function to_bv(v: integer ;n : natural) return std_logic_vector;
+
+end package;
+
+package body ruby_rtl_package is
+
+  function to_bit(v:integer;n:natural) return std_logic is
+  begin
+    if v=0 then
+      return '0';
+    else
+      return '1';
+    end if;
+  end function;
+
+  function to_uint(v : std_logic; n:natural) return unsigned is
+    variable ret : unsigned(n-1 downto 0) := (others=>'0');
+  begin
+    ret(0):=v;
+    return ret;
+  end function;
+
+  function to_int(v : std_logic; n:natural) return signed is
+    variable ret : signed(n-1 downto 0) := (others=>'0');
+  begin
+    ret(0):=v;
+    return ret;
+  end function;
+
+  function to_int(v : integer; n:natural) return signed is
+    variable ret : signed(n-1 downto 0) := (others=>'0');
+  begin
+    ret:=to_signed(v,n);
+    return ret;
+  end function;
+
+  function to_int(v : signed; n:natural) return signed is
+    variable ret : signed(n-1 downto 0) := (others=>'0');
+  begin
+    ret:=resize(v,n);
+    return ret;
+  end function;
+
+  function to_bv(v: unsigned;n : natural) return std_logic_vector is
+    variable resize_v : unsigned(n-1 downto 0);
+    variable tmp : std_logic_vector(n-1 downto 0);
+  begin
+    resize_v:=resize(v,n);
+    tmp := std_logic_vector(resize_v);
+    return tmp;
+  end function;
+
+  function to_bv(v: integer ;n : natural) return std_logic_vector is
+    variable s1 : signed(n-1 downto 0);
+    variable tmp : std_logic_vector(n-1 downto 0);
+  begin
+    s1:=to_signed(v,n);
+    tmp:=std_logic_vector(s1);
+    return tmp;
+  end function;
+
+end package body;

data/lib/ruby_rtl/sexp_generator.rb

@@ -0,0 +1,132 @@
+require_relative 'code'
+
+module RubyRTL
+
+  class SexpGenerator < DSLPrinter
+
+    def generate circuit
+      puts "[+] S-exp code generation"
+      root=circuit.ast
+      code=Code.new
+      code << "(circuit #{circuit.name}"
+      code.indent=2
+      root.decls.each{|decl| code << decl.accept(self)}
+      code << root.body.accept(self)
+      code.indent=0
+      code << ")"
+      puts code.finalize
+    end
+
+    def visitSigDecl sig_decl,args=nil
+      name=sig_decl.name
+      type=sig_decl.sig.type.accept(self)
+      "(input #{name} #{type})"
+    end
+
+    # statements
+    def visitBody body,args=nil
+      code=Code.new
+      body.each{|stmt| code << stmt.accept(self)}
+      code
+    end
+
+    def visitAssign assign,args=nil
+      lhs=assign.lhs.accept(self)
+      rhs=assign.rhs.accept(self)
+      "(assign #{lhs} #{rhs})"
+    end
+
+    def visitIf if_,args=nil
+      code=Code.new
+      cond=if_.cond.accept(self)
+      code << "(if #{cond}"
+      code.indent=2
+      code << "(then"
+      code.indent=4
+      code << if_.body.accept(self)
+      code.indent=2
+      code << ")"
+      code.indent=0
+      code << ")"
+      code
+    end
+
+    # fsm
+    def visitFsm fsm,args=nil
+      code=Code.new
+      code << "(fsm #{fsm.name}"
+      code.indent=2
+      fsm.states.each{|state| code << state.accept(self)}
+      code.indent=0
+      code << ")"
+      code
+    end
+
+    def visitState state,args=nil
+      code=Code.new
+      code << "(state #{state.name}"
+      code.indent=2
+      code << state.body.accept(self)
+      code.indent=0
+      code << ")"
+      code
+    end
+
+    def visitNext node,args=nil
+      "(next_state #{node.name})"
+    end
+
+    # === expr ===
+    def visitBinary node,args=nil
+      lhs=node.lhs.accept(self)
+      op=node.op
+      rhs=node.rhs.accept(self)
+      "(#{op} #{lhs} #{rhs})"
+    end
+
+    def visitUnary node,args=nil
+      expr=node.expr.accept(self)
+      "(#{node.op} #{expr})"
+    end
+
+    def visitFuncCall func,args=nil
+      name=func.name
+      argus=func.args.collect{|arg| arg.accept(self)}.join(" ")
+      "(call #{name} #{argus})"
+    end
+
+    def visitIndexed indexed,args=nil
+      lhs=indexed.lhs.accept(self)
+      rhs=indexed.rhs.accept(self)
+      "(indexed #{lhs} #{rhs})"
+    end
+
+
+    def visitRecordType rec_type,args=nil
+      items=[]
+      rec_type.hash.each{|item,type|
+        items << "#{item} => #{type}"
+      }
+      "Record(#{items.join(",")})"
+    end
+
+    def visitEnumType enum_type,args=nil
+      "Enum(#{enum_type.items.join(",")})"
+    end
+
+    def visitMemoryType mem_type,args=nil
+      typename=mem_type.type
+      "Memory(#{mem_type.size},#{typename})"
+    end
+
+    def visitCase case_,args=nil
+      code=Code.new
+      code << "Case(){"
+      code.indent=2
+      code << case_.body.accept(self)
+      code.indent=0
+      code << "}"
+      code
+    end
+  end
+end

data/lib/ruby_rtl/type_checker.rb

@@ -0,0 +1,209 @@
+require_relative 'code'
+require_relative 'visitor'
+
+module RubyRTL
+  class TypeChecker < Visitor
+    def initialize
+      @ppr=DSLPrinter.new
+    end
+
+    def check circuit
+      puts "[+] type checking"
+      root=circuit.ast
+      if root=circuit.ast
+        #root.ios.each{|io| io.accept(self)}
+        root.decls.each{|decl| decl.accept(self)}
+        root.body.accept(self)
+      end
+    end
+
+    def cast t1,t2
+      pair=[t1.class,t2.class]
+      cast=nil
+      case pair
+      when [BitType,BitType]
+      when [BitType,UIntType]
+        cast=[:to_bit,1]
+      when [BitType,IntType]
+        cast=[:to_bit,1]
+
+      when [BitType,RUIntType]
+        cast=[:to_bit,1]
+
+      when [IntType,BitType]
+        cast=[:to_bit,1]
+      when [IntType,IntType]
+        if t1.bitwidth==t2.bitwidth
+          return #nothing to do
+        else
+          cast=[:to_int,t1.bitwidth]
+        end
+      when [IntType,UIntType]
+        unless t1.bitwidth==t2.bitwidth
+          cast=[:to_int,t1.bitwidth]
+        end
+      when [IntType,RUIntType]
+        unless t1.bitwidth == t2.bitwidth
+          cast=[:to_int,t1.bitwidth]
+        end
+      when [UIntType,BitType]
+        cast=[:to_uint,t1.bitwidth]
+      when [UIntType,RIntType]
+        cast=[:to_uint,t1.bitwidth]
+      when [UIntType,RUIntType]
+        cast=[:to_uint,t1.bitwidth]
+
+      when [UIntType,IntType]
+        u_bw,s_bw=t1.bitwidth,t2.bitwidth
+        cast=[:to_uint,u_bw]
+      when [UIntType,UIntType]
+        if t1.bitwidth==t2.bitwidth
+          return #nothing to do
+        else
+          cast=[:to_uint,t1.bitwidth]
+        end
+      #============ bit vector =============
+      when [BitVectorType,UIntType]
+        cast=[:to_bv,t1.bitwidth]
+      when [BitVectorType,RUIntType]
+        cast=[:to_bv,t1.bitwidth]
+      when [RecordType,RecordType]
+      else
+        raise "NIY cast #{pair}"
+      end
+      return cast
+    end
+
+    def visitAssign assign,args=nil
+      puts "- assign : #{assign.accept(@ppr)}"
+      lhs=assign.lhs.accept(self)
+      rhs=assign.rhs.accept(self)
+      puts "\ttypes : #{lhs.to_s} <= #{rhs.to_s}"
+      cast_func=cast(lhs,rhs)
+      if cast_func
+        name,bw=*cast_func
+        assign.rhs=FuncCall.new(name,[assign.rhs,bw])
+      end
+    end
+
+    def homogenize t1,op,t2
+      pair=[t1.class,t2.class]
+      conv=[nil,nil,t1]
+      case pair
+      when [BitType,BitType]
+        unless ["&","|","^"].include?(op)
+          raise "illegal operation '#{op}' between 2 bits"
+        end
+      when [BitType,UIntType]
+        conv=[["to_uint",t2.bitwidth],nil,t2]
+      when [BitType,IntType]
+        conv=[["to_int",t2.bitwidth],nil,t2]
+      when [BitType,RIntType]
+        conv=[["to_int",t2.bitwidth],nil,t2]
+      when [BitType,RUIntType]
+        conv=[["to_uint",t2.bitwidth],nil,t2]
+
+      when [IntType,BitType]
+        conv=[nil,["to_int",t1.bitwidth],t1]
+      when [IntType,IntType]
+        unless t1.bitwidth==t2.bitwidth
+          max=[t1.bitwidth,t2.bitwidth].max
+          if t1==max
+            conv=[nil,["to_int",max],t1]
+          else
+            conv=[["to_int",max],nil,t2]
+          end
+        end
+      when [IntType,UIntType]
+        max=[t1.bitwidth,t2.bitwidth].max
+        if t1==max
+          conv=[nil,["to_int",max],t1]
+        else
+          conv=[["to_uint",max],nil,t2]
+        end
+      when [IntType,RUIntType]
+        unless t1.bitwidth >= t2.bitwidth # note >=
+          max=[t1.bitwidth,t2.bitwidth].max
+          if t1==max
+            conv=[nil,["to_int",max],t1]
+          else
+            conv=[["to_int",max],nil,t2]
+          end
+        end
+      when [UIntType,BitType]
+        conv=[nil,["to_uint",t1.bitwidth],t1]
+      when [UIntType,IntType]
+        u_bw,s_bw=t1.bitwidth,t2.bitwidth
+        max=[u_bw,s_bw].max
+        type=IntType.new(max)
+        conv=[["to_int",max],["to_int",max],type]
+      when [UIntType,UIntType]
+        unless t1.bitwidth==t2.bitwidth
+          max=[t1.bitwidth,t2.bitwidth].max
+          if t1==max
+            conv=[nil,["to_uint",max],t1]
+          else
+            conv=[["to_uint",max],nil,t2]
+          end
+        end
+      when [RecordType,RecordType]
+      else
+        raise "NIY homogenize #{pair}"
+      end
+      pp conv
+      return conv
+    end
+
+    def visitBinary bin,args=nil
+      puts "- binary #{bin.accept(@ppr)}"
+      lhs_t=bin.lhs.accept(self)
+      rhs_t=bin.rhs.accept(self)
+      puts "\ttypes : #{lhs_t} #{bin.op} #{rhs_t}"
+      conv_funcs=homogenize(lhs_t,bin.op,rhs_t)
+      pp conv_funcs
+      if conv=conv_funcs[0]
+        name,bitwidth=*conv
+        bin.lhs=FuncCall.new(name,[bin.lhs,bitwidth])
+      end
+      if conv=conv_funcs[1]
+        name,bitwidth=*conv
+        bin.rhs=FuncCall.new(name,[bin.rhs,bitwidth])
+      end
+      bin.type=conv_funcs[2]
+    end
+
+    def visitSig sig,args=nil
+      sig.type
+    end
+
+    def visitIndexed indexed, args=nil
+      indexed.type
+    end
+
+    def visitInput input,args=nil
+      input.type
+    end
+
+    def visitOutput output,args=nil
+      output.type
+    end
+
+    # literals
+    def visitIntLit lit,args=nil
+      lit.type
+    end
+
+    def visitUIntLit lit,args=nil
+      lit.type
+    end
+
+    def visitRIntLit lit,args=nil
+      lit.type
+    end
+
+    def visitRUIntLit lit,args=nil
+      lit.type
+    end
+
+  end
+end

data/lib/ruby_rtl/version.rb

@@ -0,0 +1,3 @@
+module RubyRTL
+  VERSION="0.0.1"
+end