Verilogにおけるビット拡張の基本知識と発展12選

module bit_extension_example(
    input [3:0] in_4bit,
    output [7:0] out_zero_extended,
    output [7:0] out_sign_extended
);

    // ゼロ拡張
    assign out_zero_extended = {4'b0000, in_4bit};

    // 符号拡張
    assign out_sign_extended = {{4{in_4bit[3]}}, in_4bit};

endmodule

module bit_selection_example(
    input [7:0] data_in,
    output wire single_bit,
    output reg [3:0] upper_bits
);

    // wireを使用したビット指定
    assign single_bit = data_in[2];

    // regを使用したビット範囲の指定
    always @(data_in) begin
        upper_bits = data_in[7:4];
    end

endmodule

module bit_concatenation_example(
    input [3:0] a, b,
    output [7:0] combined
);

    // ビット連結
    assign combined = {a, b};

endmodule

module advanced_concatenation_example(
    input [3:0] a, b,
    input c,
    output [12:0] result
);

    // 複雑なビット連結
    assign result = {2'b11, a, 1'b0, b, c, 3'b101};

endmodule

module dynamic_width_example #(
    parameter INPUT_WIDTH = 8,
    parameter OUTPUT_WIDTH = 16
)(
    input [INPUT_WIDTH-1:0] data_in,
    output [OUTPUT_WIDTH-1:0] data_out
);

    // 動的なビット拡張
    assign data_out = {{(OUTPUT_WIDTH-INPUT_WIDTH){data_in[INPUT_WIDTH-1]}}, data_in};

endmodule

module basic_bit_operations(
    input [7:0] a, b,
    output [7:0] and_result, or_result, xor_result, not_result,
    output [7:0] left_shift, right_shift
);
    assign and_result = a & b;    // ビットごとのAND
    assign or_result = a | b;     // ビットごとのOR
    assign xor_result = a ^ b;    // ビットごとのXOR
    assign not_result = ~a;       // ビットごとのNOT
    assign left_shift = a << 2;   // 左に2ビットシフト
    assign right_shift = b >> 1;  // 右に1ビットシフト
endmodule

module advanced_bit_operations(
    input [7:0] data,
    input [2:0] bit_position,
    output [7:0] set_bit, clear_bit, toggle_bit,
    output is_power_of_two
);
    assign set_bit = data | (1 << bit_position);  // 特定のビットを1にセット
    assign clear_bit = data & ~(1 << bit_position);  // 特定のビットを0にクリア
    assign toggle_bit = data ^ (1 << bit_position);  // 特定のビットを反転
    assign is_power_of_two = (data != 0) && ((data & (data - 1)) == 0);  // 2のべき乗かチェック
endmodule

module optimized_bit_extension(
    input [7:0] data_in,
    output [15:0] data_out_zero_ext,
    output [15:0] data_out_sign_ext
);
    // ゼロ拡張（リソース効率が高い）
    assign data_out_zero_ext = {8'b0, data_in};

    // 符号拡張（条件分岐を避けてリソース効率を高める）
    assign data_out_sign_ext = {{8{data_in[7]}}, data_in};
endmodule

module systemverilog_bit_operations(
    input logic [31:0] data,
    output logic [7:0] reversed_bytes[4],
    output logic [31:0] rotated_left
);
    // バイト単位での逆順
    always_comb begin
        for (int i = 0; i < 4; i++)
            reversed_bytes[i] = data[8*i +: 8];
    end

    // 左ローテート
    assign rotated_left = {data[30:0], data[31]};
endmodule

module bit_width_mismatch_example(
    input [7:0] data_8bit,
    input [15:0] data_16bit,
    output [15:0] result
);
    // エラーの例
    // assign result = data_8bit + data_16bit;  // ビット幅の不一致

    // 正しい実装
    assign result = {8'b0, data_8bit} + data_16bit;
endmodule

module signed_unsigned_mixing(
    input signed [7:0] signed_data,
    input [7:0] unsigned_data,
    output [8:0] correct_result,
    output [8:0] incorrect_result
);
    // 正しい実装（明示的に符号付き拡張を行う）
    assign correct_result = $signed({signed_data[7], signed_data}) + {1'b0, unsigned_data};

    // 誤った実装（暗黙の型変換により予期せぬ結果になる）
    assign incorrect_result = signed_data + unsigned_data;
endmodule

module overflow_underflow_detection(
    input [7:0] a, b,
    output [7:0] sum,
    output overflow,
    output underflow
);
    wire [8:0] full_sum = a + b;
    assign sum = full_sum[7:0];
    assign overflow = (a[7] == b[7]) && (a[7] != sum[7]);
    assign underflow = (a[7] != b[7]) && (b[7] == sum[7]);
endmodule

module efficient_datapath(
    input [7:0] data_in,
    input [2:0] opcode,
    output reg [15:0] result
);
    wire [15:0] extended_data = {8'b0, data_in};  // ゼロ拡張

    always @(*) begin
        case(opcode)
            3'b000: result = extended_data;  // パススルー
            3'b001: result = extended_data << 1;  // 左シフト
            3'b010: result = extended_data * 2;   // 2倍
            3'b011: result = extended_data + 16'h100;  // 256を加算
            3'b100: result = {data_in, data_in};  // データの複製
            default: result = 16'b0;  // デフォルト値
        endcase
    end
endmodule

module flexible_alu(
    input [7:0] a, b,
    input [2:0] op,
    output reg [15:0] result,
    output overflow
);
    wire [15:0] a_ext = {8'b0, a};
    wire [15:0] b_ext = {8'b0, b};
    wire [16:0] sum = a_ext + b_ext;  // キャリーを含む和

    always @(*) begin
        case(op)
            3'b000: result = a_ext + b_ext;  // 加算
            3'b001: result = a_ext - b_ext;  // 減算
            3'b010: result = a_ext * b_ext;  // 乗算
            3'b011: result = a_ext & b_ext;  // ビットごとのAND
            3'b100: result = a_ext | b_ext;  // ビットごとのOR
            3'b101: result = a_ext ^ b_ext;  // ビットごとのXOR
            3'b110: result = ~a_ext;         // ビットごとのNOT
            3'b111: result = a_ext << b[2:0];  // 左シフト
        endcase
    end

    assign overflow = sum[16];  // キャリーが発生したらオーバーフロー
endmodule

module memory_interface(
    input [31:0] data_in,
    input [1:0] byte_enable,
    output reg [7:0] memory_write_data,
    output reg [3:0] memory_write_mask
);
    always @(*) begin
        case(byte_enable)
            2'b00: begin
                memory_write_data = data_in[7:0];
                memory_write_mask = 4'b0001;
            end
            2'b01: begin
                memory_write_data = data_in[15:8];
                memory_write_mask = 4'b0010;
            end
            2'b10: begin
                memory_write_data = data_in[23:16];
                memory_write_mask = 4'b0100;
            end
            2'b11: begin
                memory_write_data = data_in[31:24];
                memory_write_mask = 4'b1000;
            end
        endcase
    end
endmodule

module variable_length_shift_register #(
    parameter MAX_LENGTH = 16
)(
    input clk,
    input reset,
    input [3:0] length,  // 現在のレジスタ長
    input serial_in,
    output [MAX_LENGTH-1:0] parallel_out
);
    reg [MAX_LENGTH-1:0] shift_reg;

    always @(posedge clk or posedge reset) begin
        if (reset)
            shift_reg <= 0;
        else begin
            shift_reg <= {shift_reg[MAX_LENGTH-2:0], serial_in};
            shift_reg[MAX_LENGTH-1:length] <= 0;  // 未使用ビットをクリア
        end
    end

    assign parallel_out = shift_reg;
endmodule