第2章
ハードウェア記述言語 Veryl

module HalfAdder(
  input logic x,        // 入力値X
  input logic y,        // 入力値Y
  output logic c,       // 出力値C
  output logic s        // 出力値S
);
  assign c = x & y; // &はAND演算
  assign s = x ^ y; // ^はXOR演算
endmodule

module Counter(
  input logic clk, // クロック信号
  input logic rst  // リセット信号
);
  // 32ビットのレジスタの定義
  logic [31:0] count;

  always_ff @(posedge clk, negedge rst) begin
    if (!rst) begin
      // rstが0になったとき、countを0に初期化する
      count <= 0;
    end else begin
      // clkが1になったとき、countの値をカウントアップする
      count <= count + 1;
    end
  end
endmodule

  // 1行のコメント
  /* 範囲コメント */
  /*
     範囲コメントは改行してもOK
  */

signed logic<4> // 4ビットの符号付きlogic型
signed bit<2> // 2ビットの符号付きbit型

4'b0101 // 4ビットの数値 (2進数表記)
4'bxxzz // 4ビットの数値 (2進数表記)

12'o34xz // 12ビットの数値 (8進数表記)
32'h89abcdef // 32ビットの数値 (16進数表記)

123 // 10進数の数値
32'd12345 // 32ビットの数値 (10進数表記)

// 数値リテラルの好きな場所に_を挿入できる
1_2_34_567

// xとzは大文字でも良い
4'bxXzZ

// 全ビット0、1、x、zにする
'0
'1
'x
'z

// 指定したビット幅だけ0、1、x、zにする
8'0 // 8ビット0
8'1 // 8ビット1
8'x // 8ビットx
8'z // 8ビットz

// 幅を指定しない場合、幅が自動で推定される
'hffff // 16ビット
'h1fff // 13ビット (13'b1_1111_1111_1111)

"Hello World!" // 文字列リテラル 
"abcdef\nabc"  // エスケープシーケンスを含む文字列リテラル

module HalfAdder (
        x: input  logic, // 1ビットのlogic型の入力
        y: input  logic, // 1ビットのlogic型の入力
        s: output logic, // 1ビットのlogic型の出力
        c: output logic, // 1ビットのlogic型の出力
) {
        always_comb {
                s = x ^ y; // sにx XOR yを代入
                c = x & y; // cにx AND yを代入
        }
}

always_comb {
        x = y;
}

always_comb {
        s = X;
        a = s; // a = X
        s = Y;
        b = a; // b = Y
}

// assign 変数名 = 式;
assign a = b + 100;

// var 変数名 : 型名;
var value : logic<32>;

// let 変数名 : 型名 = 式;
let value : logic<32> = 100 + a;

// var レジスタ名 : 型名;
var reg_value : logic<32>;

// reg_valueにブロッキング代入しない

// レジスタの定義
var value : logic<32>;

// always_ff(クロック信号, リセット信号)
always_ff(clk, rst) {
        if_reset {
                // リセット信号のタイミングで0に初期化する
                value = 0;
        } else {
                // クロック信号のタイミングでカウントアップする
                value = value + 1;
        }
}

module ModuleA(
  clk: input clock,
  rst: input reset,
){
        // always_ff(clk, rst)と等しい
        always_ff {}
}

// 全ての代入文の右辺を評価した後に、AとBが変更される
// その結果、AとBの値が入れ替わる
always_ff(clk, rst) {
        A = B;
}
always_ff(clk, rst) {
        B = A;
}

always_ff {
        // AとBの値を入れ替える
        A = B;
        B = A;
}

module ModuleA {
        // モジュールと接続するための変数の宣言
        let x : logic = 0;
        let y : logic = 1;
        var s : logic;
        var c : logic;

        // inst インスタンス名 : モジュール名(ポートとの接続);
        inst ha1 : HalfAdder(
                x: x, // ポートxに変数xを接続する
                y: y,
                s,    // ポート名と変数名が同じとき、ポート名の指定を省略できる 
                c,
        );
}

module ModuleA #(
        // param パラメータ名 : 型名 = デフォルト値 
        param WIDTH : u32 = 100, // u32型のパラメータ
        param DATA_TYPE : type = logic, // type型のパラメータには型を指定できる
) (
        // ポートの宣言
) {}

inst ma : ModuleA #(
        // パラメータの割り当て
        WIDTH: 10,
        DATA_TYPE: logic<10>
) ( /* ポートの接続 */ );

// const 定数名 : 型名 = 式;
// 式に変数が含まれてはいけない
const SECRET : u32 = 42;

// struct 型名 { フィールドの定義 }
struct MyPair {
        // 名前 : 型
        word: logic<32>,
        half: logic<16>,
}

// 構造体型の変数の宣言
var pair: MyPair;

// フィールドにアクセスする
let w : logic<32> = pair.word;

// フィールドに値を割り当てる
always_comb {
        pair.word = 12345;
}

// enum 型名 : logic<バリアント数を保持できるだけのビット数> { バリアントの定義 }
enum abc : logic<2> {
        // バリアント名 : バリアントを表す値,
        A = 2'd0,
        B = 2'd1,
        C = 2'd2,
        D = 2'd3,
}

enum abc {
        A, B, C, D
}

logic<N>     // Nビットのlogic型
logic<A, B>  // BビットのlogicがA個並ぶ型

// 型名[個数] で、"型名"型が"個数"個の配列になる
logic[32]     // 要素数が32のlogicの配列型
logic[4, 8]   // logicが8個の配列が4個ある配列型

// type 名前 = 型;
type ptr = logic<32>;
type ptr_array = ptr<32>;

v[s +: w]   // = v[s+w-1   : s    ]
v[s -: w]   // = v[s       : s-w+1]
v[i step w] // = v[i*(w+1) : i*w  ] = v[i*w +: w]

// 単項算術演算
a = +1;
a = -1; // 正負を反転させる

// 単項論理演算
a = !1; // 否定 (真偽を反転させる)
a = ~1; // ビット反転 (0を1、1を0にする)

// 単項集約演算
//
// 集約: 左のビットから順に1ビットずつビット演算する
//   例: k = 3'b110のとき、&k = 0
//       &k = 1 & 1 & 0          
//       まず、k[msb]とk[1]をANDして1を得る。
//       次に、その結果とk[0]をANDして0を得る。
//       この値が&kの結果になる。
a = &1;  // AND
a = |1;  // OR
a = ^1;  // XOR
a = ~&1; // NAND
a = ~|1; // NOR
a = ~^1; // XNOR
a = ^~1; // XNOR

// 二項算術演算
a = k ** p; // kのp乗
a = 1 * 1;  // かけ算
a = 1 / 1;  // 割り算
a = 1 % 1;  // 剰余
a = 1 + 1;  // 足し算
a = 1 - 1;  // 引き算

// シフト演算
// 注意 : 右オペランド(シフト数)は符号無しの数として扱われる
a = k <<  n; // kをnビット左シフトする。空いたビットは0で埋める
a = k <<< n; // <<と同じ
a = k >>  n; // kをnビット右シフトする。空いたビットは0で埋める
a = k >>> n; // kが符号無しのとき>>と同じ。符号付きのとき、空いたビットはMSBで埋める

// 比較演算
a = n <: m;  // nはm未満
a = n <= m;  // nはm以下
a = n >: m;  // nはmよりも大きい (mを含まない)
a = n >= m;  // nはm以上 (mを含む)
a = n == m;  // nはmと等しい (xかzを含む場合、x)
a = n != m;  // nはmと等しくない (xかzを含む場合、x)
a = n === m; // nはmと等しい (xとzを含めて完全に一致)
a = n !== m; // nはmと等しくない (xとzを含めて完全に一致)
a = n ==? m; // ===と同じ。ただし、mに含まれるx,zはワイルドカードになる
a = n !=? m; // !(==?)と同じ

// ビット演算 (ビット単位, bitwise)
a = 1 & 1;  // ビット単位AND
a = 1 ^ 1;  // ビット単位XOR
a = 1 ~^ 1; // ビット単位XNOR
a = 1 ^~ 1; // ビット単位XNOR
a = 1 | 1;  // ビット単位OR

// 二項論理演算
a = x && y; // xとyの両方が真のとき真
a = x || y; // xまたはyが真のとき真

var v : logic<32>;
always_comb {
        if WIDTH == 0 {
                // WIDTH == 0のとき
                v = 0;
        } else if WIDTH == 1 {
                // WIDTH != 0かつWIDTH == 1のとき
                v = 1;
        } else {
                // WIDTH != 0かつWIDTH != 1のとき
                v = if WIDTH == 3 { // ifは式にもなる
                        3
                } else {
                        // if式はelseが必須
                        4
                };
        }
}

var v : logic<32>;
always_comb {
        switch {
                // WIDTH == 0のとき
                WIDTH == 0: {
                        v = 0;
                }
                // WIDTH != 0かつWIDTH == 1のとき
                WIDTH == 1: v = 1; // 要素が1つの文のとき、{}は省略できる
                // WIDTH != 0かつWIDTH != 1のとき
                default: 
                        // switch式
                        v = switch {
                                WIDTH == 3: 3, // カンマで区切る
                                default : 4, // switch式はdefaultが必須
                        };
        }
}

var v: logic<32>;
always_comb {
        case WIDTH {
                // WIDTH == 0のとき
                0: {
                        v = 0;
                }
                // WIDTH != 0かつWIDTH == 1のとき
                1: v = 1; // 要素が1つの文のとき、{}は省略できる
                // WIDTH != 0かつWIDTH != 1のとき
                default: 
                        // case式
                        v = case WIDTH {
                                3: 3, // カンマで区切る
                                default : 4, // case式はdefaultが必須
                        };
        }
}

{12'h123, 32'habcd0123} // 44'h123_abcde0123になる
{"Hello", " ", "World!"} // "Hello World!"になる

// {繰り返したい要素 repeat 繰り返す回数}
{4'0011 repeat 3, 4'b1111} // 16'b0011_0011_0011_1111になる
{"Happy" repeat 3} // "HappyHappyHappy"になる

// for ループ変数名: 型 in 範囲 { 処理 }
for i: u32 in 0..32 { ... }

var x: u32;
always_comb {
    x = 0;
    for _: u32 in 0..1024 {
        if x == 256 {
            break;
        }
        x += 1;
    }
}

inside n {0..10}    // nが0以上10未満のとき1
inside n {0..=10}   // nが0以上10以下のとき1
inside n {0, 1, 3}  // nが0、1、3のいずれかのとき1
inside n {0, 2..10} // nが0、または2以上10未満のとき1

// outsideはinsideの逆
outside n {0..10}   // nが0未満、または10より大きいとき1
outside n {0, 1, 3} // nが0、1、3以外の値のとき1

// べき乗を返す関数
function get_power(
        a : input u32,
        b : input u32,
) -> u32 {
        return a ** b;
}

val v1 : logic<32>;
val v2 : logic<32>;

always_comb {
        v1 = get_power(2, 10); // v1 = 1024
        v2 = get_power(3, 3); // v2 = 27
}



// a + 1をbに代入する関数
function assign_plus1(
        a : input  logic<32>,
        b : output logic<32>,
) { // 戻り値はないので省略
        b = a + 1;
}

val v3 : logic<32>;

always_comb {
        assign_plus1(v1, v3); // v3 = v1 + 1
}

module ModuleA (
        req_a: output logic,
        req_b: output logic,
        req_c: output logic,
){}
module ModuleB (
        resp_a: input logic,
        resp_b: input logic,
        resp_c: input logic,
){}
module Top{
        var a: logic;
        var b: logic;
        var c: logic;
        inst ma : ModuleA (
                req_a:a,
                req_b:b,
                req_c:c,
        );
        inst mb : ModuleB (
                resp_a:a,
                resp_b:b,
                resp_c:c,
        );
}

// interface インターフェース名 { }
interface iff_ab {
        var a : logic;
        var b : logic;
        var c : logic;

        modport req {
                a: input,
                b: input,
                c: input,
        }
        modport resp {
                a: output,
                b: output,
                c: output,
        }
}

module ModuleA (
        req : modport iff_ab::req,
){}
module ModuleB (
        resp : modport iff_ab::resp,
){}
module Top{
        // インターフェースのインスタンス化
        inst iab : iff_ab;
        inst ma : ModuleA (req: iab);
        inst mb : ModuleB (resp: iab);
}

// interface インターフェース名 #( パラメータの定義 ) { }
interface iff_params # (
        param PARAM_A : u32 = 100,
        param PARAM_B : u64 = 200,
){ }

package PackageA {
        const WIDTH : u32 = 1234;
        type foo = logic<WIDTH>;
        function bar () -> u32 {
                return 1234;
        }
}

module ModuleA {
        const W : u32 = PackageA::WIDTH;
        var value1 : PackageA::foo;
        let value2 : u32 = PackageA::bar();
}

import PackageA::WIDTH; // 特定の要素をimportする
import PackageA::*; // 全ての要素をimportする

module ModuleA {
        // ::<>でジェネリックパラメータを定義する
        // constで数値を受け取る
        struct StructA::<W: const> {
            A: logic<W>,
        }

        // 複数のジェネリックパラメータを定義できる
        // typeで型を受け取る
        // デフォルト値を設定できる
        struct StructB::<W: const, T: type, D:const = 100> {
                A: logic<W>,
                B: T,
                C: logic<D>
        }

        // ::<>でジェネリックパラメータを指定する
        type A = StructA::<16>;
        type B = StructB::<17, A>;
        type C = StructB::<18, B, 19>;
}

module ModuleA {
        initial {
                // シミュレーション開始時に実行される
        }
        final {
                // シミュレーション終了時に実行される
        }
}

module ModuleA {
        // SystemVerilogでsvpackageとして
        // 定義されているパッケージを利用する
        let x = $sv::svpackage::X;
        let y = $sv::svpackage::Y;

        var s: logic;
        var c: logic;

        // SystemVerilogでHalfAdderとして
        // 定義されているモジュールをインスタンス化する
        inst ha : $sv::HalfAdder(
                x, y, s, c
        );

        // SystemVerilogでsvinterfaceとして
        // 定義されているインターフェースをインスタンス化する
        inst c: $sv::svinterface;
}

// SystemVerilog記述を直接埋め込む
embed (inline) sv{{{
        module ModuleA(
                output logic a
        );
                assign a = 0;
        endmodule
}}}

// SystemVerilogのソースファイルを展開する
// パスは相対パス
include(inline, "filename.sv");

const w1 : u32 = $clog2(32); // 5
const w2 : u32 = $clog2(35); // 6

var array : logic<4,8>;
const s1 : u32 = $size(array); // 4
const s2 : u32 = $bits(array); // 32

var uvalue : u32;
let svalue : i32 = $signed(uvalue) + 1;

initial {
        $readmemh("file.hex", array);
        $display("Hello World!");
        $error("Error!");
        $finish();
}

#[sv("keep=\"true\"")]
var aaa : logic;

#[ifdef(IS_DEBUG)]
var bbb : logic;

#[ifndef(TEST)]
var ccc : logic;

(* keep="true" *)
logic aaa;

`ifdef IS_DEBUG
logic bbb;
`endif

`ifndef TEST
logic ccc;
`endif