clash-systemverilog-0.6.6: primitives/CLaSH.Sized.Vector.json

[ { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.head"
    , "type"      : "head :: Vec (n + 1) a -> a"
    , "templateD" :
"// head begin
~SIGD[~GENSYM[vec][0]][0];
assign ~SYM[0] = ~ARG[0];

assign ~RESULT = ~FROMBV[~SYM[0][\\0\\]][~TYPO];
// head end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.tail"
    , "type"      : "tail :: Vec (n + 1) a -> Vec n a"
    , "templateD" :
"// tail begin
~SIGD[~GENSYM[vec][0]][0];
assign ~SYM[0] = ~ARG[0];

assign ~RESULT = ~SYM[0][1 : $high(~SYM[0])];
// tail end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.last"
    , "type"      : "Vec (n + 1) a -> a"
    , "templateD" :
"// last begin
~SIGD[~GENSYM[vec][0]][0];
assign ~SYM[0] = ~ARG[0];

assign ~RESULT = ~FROMBV[~SYM[0][\\$high(~SYM[0])\\]][~TYPO];
// last end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.init"
    , "type"      : "Vec (n + 1) a -> Vec n a"
    , "templateD" :
"// init begin
~SIGD[~GENSYM[vec][0]][0];
assign ~SYM[0] = ~ARG[0];

assign ~RESULT = ~SYM[0][0 : $high(~SYM[0]) - 1];
// init end"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.select"
    , "type" :
"select :: (CmpNat (i + s) (s * n) ~ GT) -- ARG[0]
        => SNat f                        -- ARG[1]
        -> SNat s                        -- ARG[2]
        -> SNat n                        -- ARG[3]
        -> Vec i a                       -- ARG[4]
        -> Vec n a"
    , "templateD" :
"// select begin
~SIGD[~GENSYM[vec][0]][4];
assign ~SYM[0] = ~ARG[4];

genvar ~GENSYM[n][1];
~GENERATE
  for (~SYM[1]=0; ~SYM[1] < ~LIT[3]; ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[select][2]
    assign ~RESULT[~SYM[1]] = ~SYM[0][~LIT[1] + (~LIT[2] * ~SYM[1])];
  end
~ENDGENERATE
// select end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.++"
    , "type"      : "(++) :: Vec n a -> Vec m a -> Vec (n + m) a"
    , "templateE" : "~FROMBV[{~TOBV[~ARG[0]][~TYP[0]],~TOBV[~ARG[1]][~TYP[1]]}][~TYPO]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.concat"
    , "type"      : "concat :: Vec n (Vec m a) -> Vec (n * m) a"
    , "templateD" :
"// concat begin
~SIGD[~GENSYM[vec][0]][0];
assign ~SYM[0] = ~ARG[0];

genvar ~GENSYM[n][1];
~GENERATE
  for (~SYM[1]=0; ~SYM[1] < $size(~SYM[0]); ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[concat][2]
    assign ~RESULT[~SYM[1]*~LENGTH[~TYPEL[~TYP[0]]] : ~SYM[1]*~LENGTH[~TYPEL[~TYP[0]]]+(~LENGTH[~TYPEL[~TYP[0]]]-1)] = ~FROMBV[~SYM[0][\\~SYM[1]\\]][~TYPEL[~TYP[0]]];
  end
~ENDGENERATE
// concat end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.splitAt"
    , "type"      : "splitAt :: SNat m -> Vec (m + n) a -> (Vec m a, Vec n a)"
    , "templateD" :
"// splitAt begin
logic [0:~LENGTH[~TYP[1]]-1] [0:~SIZE[~TYPEL[~TYP[1]]]-1] ~GENSYM[vec][0];
assign ~SYM[0] = ~TOBV[~ARG[1]][~TYP[1]];

assign ~RESULT = {~SYM[0][0:~LIT[0]-1]
                 ,~SYM[0][~LIT[0]:~LENGTH[~TYP[1]]-1]
                 };
// splitAt end"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.unconcat"
    , "type" :
 "unconcat :: KnownNat n     -- ARG[0]
           => SNat m         -- ARG[1]
           -> Vec (n * m) a  -- ARG[2]
           -> Vec n (Vec m a)"
    , "templateD" :
"// unconcat begin
~SIGD[~GENSYM[vec][0]][2];
assign ~SYM[0] = ~ARG[2];

genvar ~GENSYM[n][1];
~GENERATE
  for (~SYM[1] = 0; ~SYM[1] < $size(~RESULT); ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[unconcat][2]
    assign ~RESULT[~SYM[1]] = ~TOBV[~SYM[0][\\(~SYM[1] * ~LIT[1]) : ((~SYM[1] * ~LIT[1]) + ~LIT[1] - 1)\\]][~TYPEL[~TYPO]];
  end
~ENDGENERATE
// unconcat end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.map"
    , "type"      : "map :: (a -> b) -> Vec n a -> Vec n b"
    , "templateD" :
"// map begin
~SIGD[~GENSYM[vec][0]][1];
assign ~SYM[0] = ~ARG[1];

genvar ~GENSYM[n][1];
~GENERATE
  for (~SYM[1]=0; ~SYM[1] < $size(~RESULT); ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[map][2]
    ~TYPEL[~TYP[1]] ~GENSYM[map_in][3];
    ~TYPEL[~TYPO] ~GENSYM[map_out][4];
    assign ~SYM[3] = ~FROMBV[~SYM[0][\\~SYM[1]\\]][~TYPEL[~TYP[1]]];
    ~INST 0
      ~OUTPUT <= ~SYM[4]~ ~TYPEL[~TYPO]~
      ~INPUT  <= ~SYM[3]~ ~TYPEL[~TYP[1]]~
    ~INST
    assign ~RESULT[~SYM[1]] = ~TOBV[~SYM[4]][~TYPEL[~TYPO]];
  end
~ENDGENERATE
// map end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.imap"
    , "type"      : "imap :: KnownNat n => (Index n -> a -> b) -> Vec n a -> Vec n b"
    , "templateD" :
"// imap begin
~SIGD[~GENSYM[vec][0]][2];
assign ~SYM[0] = ~ARG[2];

genvar ~GENSYM[n][1];
~GENERATE
  for (~SYM[1]=0; ~SYM[1] < $size(~RESULT); ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[imap][2]
    ~INDEXTYPE[~LIT[0]] ~GENSYM[i][3];
    assign ~SYM[3] = ~SYM[1];
    ~TYPEL[~TYP[2]] ~GENSYM[imap_in][4];
    ~TYPEL[~TYPO] ~GENSYM[imap_out][5];
    assign ~SYM[4] = ~FROMBV[~SYM[0][\\~SYM[1]\\]][~TYPEL[~TYP[2]]];
    ~INST 1
      ~OUTPUT <= ~SYM[5]~ ~TYPEL[~TYPO]~
      ~INPUT  <= ~SYM[3]~ ~INDEXTYPE[~LIT[0]]~
      ~INPUT  <= ~SYM[4]~ ~TYPEL[~TYP[2]]~
    ~INST
    assign ~RESULT[~SYM[1]] = ~TOBV[~SYM[5]][~TYPEL[~TYPO]];
  end
~ENDGENERATE
// imap end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.zipWith"
    , "type"      : "zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c"
    , "templateD" :
"// zipWith begin
~SIGD[~GENSYM[vec1][0]][1];
~SIGD[~GENSYM[vec2][1]][2];
assign ~SYM[0] = ~ARG[1];
assign ~SYM[1] = ~ARG[2];

genvar ~GENSYM[n][2];
~GENERATE
  for (~SYM[2] = 0; ~SYM[2] < $size(~RESULT); ~SYM[2] = ~SYM[2] + 1) begin : ~GENSYM[zipWith][3]
    ~TYPEL[~TYP[1]] ~GENSYM[zipWith_in1][4];
    ~TYPEL[~TYP[2]] ~GENSYM[zipWith_in2][5];
    ~TYPEL[~TYPO] ~GENSYM[zipWith_out][6];
    assign ~SYM[4] = ~FROMBV[~SYM[0][\\~SYM[2]\\]][~TYPEL[~TYP[1]]];
    assign ~SYM[5] = ~FROMBV[~SYM[1][\\~SYM[2]\\]][~TYPEL[~TYP[2]]];
    ~INST 0
      ~OUTPUT <= ~SYM[6]~ ~TYPEL[~TYPO]~
      ~INPUT  <= ~SYM[4]~ ~TYPEL[~TYP[1]]~
      ~INPUT  <= ~SYM[5]~ ~TYPEL[~TYP[2]]~
    ~INST
    assign ~RESULT[~SYM[2]] = ~TOBV[~SYM[6]][~TYPEL[~TYPO]];
  end
~ENDGENERATE
// zipWith end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.foldr"
    , "type"      : "foldr :: (a -> b -> b) -> b -> Vec n a -> b"
    , "templateD" :
"// foldr start~IF ~LENGTH[~TYP[2]] ~THEN
~SIGDO[~GENSYM[intermediate][0]] [0:~LENGTH[~TYP[2]]];
assign ~SYM[0][~LENGTH[~TYP[2]]] = ~ARG[1];

~SIGD[~GENSYM[xs][2]][2];
assign ~SYM[2] = ~ARG[2];

genvar ~GENSYM[i][3];
~GENERATE
for (~SYM[3]=0; ~SYM[3] < ~LENGTH[~TYP[2]]; ~SYM[3]=~SYM[3]+1) begin : ~GENSYM[foldr_loop][4]
  ~TYPEL[~TYP[2]] ~GENSYM[foldr_in][5];
  assign ~SYM[5] = ~FROMBV[~SYM[2][\\~SYM[3]\\]][~TYPEL[~TYP[2]]];
  ~INST 0
    ~OUTPUT <= ~SYM[0][~SYM[3]]~ ~TYP[1]~
    ~INPUT <= ~SYM[5]~ ~TYPEL[~TYP[2]]~
    ~INPUT <= ~SYM[0][~SYM[3]+1]~ ~TYP[1]~
  ~INST
end
~ENDGENERATE

assign ~RESULT = ~SYM[0][0];
~ELSE
assign ~RESULT = ~ARG[1];
~FI// foldr end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.fold"
    , "type"      : "fold :: (a -> a -> a) -> Vec (n+1) a -> a"
    , "comment"   : "THIS ONLY WORKS FOR POWER OF TWO LENGTH VECTORS"
    , "templateD" :
"// fold begin
// put flat input array into the first half of the intermediate array
~SIGDO[~GENSYM[intermediate][0]] [0:(2*~LENGTH[~TYP[1]])-2];
assign ~SYM[0][0:~LENGTH[~TYP[1]]-1] = ~ARG[1];

// calculate the depth of the tree
localparam ~GENSYM[levels][4] = $clog2(~LENGTH[~TYP[1]]);

// given a level and a depth, calculate the corresponding index into the
// intermediate array
function integer ~GENSYM[depth2Index][8];
  input integer levels;
  input integer depth;

  ~SYM[8] = (2 ** levels) - (2 ** depth);
endfunction

// Create the tree of instantiated components
genvar ~GENSYM[d][5];
genvar ~GENSYM[i][6];
~GENERATE
if (~SYM[4] != 0) begin : ~GENSYM[make_tree][7]
  for (~SYM[5] = (~SYM[4] - 1); ~SYM[5] >= 0; ~SYM[5]=~SYM[5]-1) begin : tree_depth
    for (~SYM[6] = 0; ~SYM[6] < (2**~SYM[5]); ~SYM[6] = ~SYM[6]+1) begin : tree_depth_loop
        ~INST 0
          ~OUTPUT <= ~SYM[0][~SYM[8](~SYM[4]+1,~SYM[5]+1)+~SYM[6]]~ ~TYPO~
          ~INPUT  <= ~SYM[0][~SYM[8](~SYM[4]+1,~SYM[5]+2)+(2*~SYM[6])]~ ~TYPO~
          ~INPUT  <= ~SYM[0][~SYM[8](~SYM[4]+1,~SYM[5]+2)+(2*~SYM[6])+1]~ ~TYPO~
        ~INST
    end
  end
end
~ENDGENERATE

// The last element of the intermediate array holds the result
assign ~RESULT = ~SYM[0][(2*~LENGTH[~TYP[1]])-2];
// fold end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.index_int"
    , "type"      : "index_integer :: KnownNat n => Vec n a -> Int -> a"
    , "templateD" :
"// indexVec begin
~SIGD[~GENSYM[vec][0]][1];
assign ~SYM[0] = ~ARG[1];

assign ~RESULT = ~FROMBV[~SYM[0][\\~ARG[2]\\]][~TYPO];
// indexVec end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.replace_int"
    , "type"      : "replace_int :: KnownNat n => Vec n a -> Int -> a -> Vec n a"
    , "templateD" :
"// replaceVec start
~SIGD[~GENSYM[vec][0]][1];

always_comb begin
  ~SYM[0] = ~ARG[1];
  ~SYM[0][~ARG[2]] = ~TOBV[~ARG[3]][~TYP[3]];
end

assign ~RESULT = ~SYM[0];
// replaceVec end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.maxIndex"
    , "type"      : "maxIndex :: KnownNat n => Vec n a -> Int"
    , "templateE" : "~SIZE[~TYPO]'sd~LIT[0] - ~SIZE[~TYPO]'sd1"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.length"
    , "type"      : "length :: KnownNat n => Vec n a -> Int"
    , "templateE" : "~SIZE[~TYPO]'sd~LIT[0]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.replicate"
    , "type"      : "replicate :: SNat n -> a -> Vec n a"
    , "templateE" : "'{~LIT[0] {~TOBV[~ARG[1]][~TYP[1]]}}"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.transpose"
    , "type"      : "transpose :: KnownNat n => Vec m (Vec n a) -> Vec n (Vec m a)"
    , "templateD" :
"// transpose begin
~SIGD[~GENSYM[matrix][0]][1];
assign ~SYM[0] = ~ARG[1];

genvar ~GENSYM[row_index][1];
genvar ~GENSYM[col_index][2];
~GENERATE
  for (~SYM[1] = 0; ~SYM[1] < $size(~SYM[0]); ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[transpose_outer][3]
    for (~SYM[2] = 0; ~SYM[2] < $size(~RESULT); ~SYM[2] = ~SYM[2] + 1) begin : ~GENSYM[transpose_inner][4]~IF ~VIVADO ~THEN
      assign ~RESULT[~SYM[2]][($size(~SYM[0])-~SYM[1])*~SIZE[~TYPEL[~TYPEL[~TYPO]]]-1 : ($size(~SYM[0])-~SYM[1]-1)*~SIZE[~TYPEL[~TYPEL[~TYPO]]]] = ~SYM[0][~SYM[1]][($size(~RESULT)-~SYM[2])*~SIZE[~TYPEL[~TYPEL[~TYPO]]]-1 : ($size(~RESULT)-~SYM[2]-1)*~SIZE[~TYPEL[~TYPEL[~TYPO]]]];~ELSE
      assign ~RESULT[~SYM[2]][~SYM[1]] = ~SYM[0][~SYM[1]][~SYM[2]];~FI
    end
  end
~ENDGENERATE
// transpose end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.reverse"
    , "type"      : "reverse :: Vec n a -> Vec n a"
    , "templateD" :
"// reverse begin
~SIGD[~GENSYM[vec][0]][0];
assign ~SYM[0] = ~ARG[0];

genvar ~GENSYM[n][1];
~GENERATE
  for (~SYM[1] = 0; ~SYM[1] < $size(~SYM[0]); ~SYM[1] = ~SYM[1] + 1) begin : ~GENSYM[reverse][2]
    assign ~RESULT[$high(~SYM[0]) - ~SYM[1]] = ~SYM[0][~SYM[1]];
  end
~ENDGENERATE
// reverse end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.lazyV"
    , "type"      : "lazyV :: KnownNat n => Vec n a -> Vec n a"
    , "templateE" : "~ARG[1]"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.concatBitVector#"
    , "type" :
"concatBitVector# :: KnownNat m           -- ARG[0]
                  => Vec n (BitVector m)  -- ARG[1]
                  -> BitVector (n * m)"
    , "templateE" : "~TOBV[~ARG[1]][~TYP[1]]"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.unconcatBitVector#"
    , "type" :
"unconcatBitVector# :: (KnownNat n, KnownNat m) -- (ARG[0],ARG[1])
                    => BitVector (n * m)        -- ARG[2]
                    -> Vec n (BitVector m)"
    , "templateE" : "~FROMBV[~ARG[2]][~TYPO]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.rotateLeftS"
    , "type"      : "rotateLeftS :: KnownNat n => Vec n a -> SNat d -> Vec n a"
    , "templateD" :
"// rotateLeftS begin
~SIGD[~GENSYM[vec][1]][1];
localparam ~GENSYM[shift_amount][2] = ~LIT[2] % ~LIT[0];

assign ~SYM[1] = ~ARG[1];

~GENERATE
if (~SYM[2] == 0) begin : ~GENSYM[no_shift][3]
  assign ~RESULT = ~SYM[1];
end else begin : ~GENSYM[do_shift][4]
  assign ~RESULT[0:~LIT[0]-~SYM[2]-1] = ~SYM[1][~SYM[2]:~LIT[0]-1];
  assign ~RESULT[~SYM[2]:~LIT[0]-1] = ~SYM[1][0 to ~SYM[2]-1];
end
~ENDGENERATE
// rotateLeftS end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.rotateRightS"
    , "type"      : "rotateRightS :: KnownNat n => Vec n a -> SNat d -> Vec n a"
    , "templateD" :
"// rotateRightS begin
~SIGD[~GENSYM[vec][1]][1];
localparam ~GENSYM[shift_amount][2] = ~LIT[2] % ~LIT[0];

assign ~SYM[1] = ~ARG[1];

~GENERATE
if (~SYM[2] == 0) begin : ~GENSYM[no_shift][3]
  assign ~RESULT = ~SYM[1];
end else begin : ~GENSYM[do_shift][4]
  assign ~RESULT[0:~SYM[2]-1] = ~SYM[1][~LIT[0]-~SYM[2]:~LIT[0]-1];
  assign ~RESULT[~SYM[2]:~LIT[0]-1] = ~SYM[1][0:~LIT[0]-~SYM[2]-1];
end
~ENDGENERATE
// rotateRightS end"
    }
  }
]