SystemVerilog中byte数组转logic [5:0]数组的无损转换问题

Hey George, great question—since a standard byte is 8 bits wide and logic [5:0] only holds 6 bits, we can’t just directly cast each byte to a 6-bit element without risking data loss. Let’s break down two common scenarios to solve this, depending on your exact needs:

Scenario 1: Preserve Every Bit of the Original Byte Array #

If you need to retain all the data from your byte array (no bits discarded), the solution is to treat the entire byte array as a continuous bit stream and split it into 6-bit chunks. Here’s how you can implement this in SystemVerilog:

function logic [5:0][] byte_to_logic6_full_preserve(byte input_array[]);
    int total_bits = input_array.size() * 8;
    int num_6bit_elements = (total_bits + 5) / 6; // Round up to account for partial chunks
    logic [5:0][] output_array = new[num_6bit_elements];
    logic [total_bits-1:0] packed_data;

    // First, pack all bytes into a single contiguous bit vector
    for (int i = 0; i < input_array.size(); i++) begin
        packed_data[i*8 +: 8] = input_array[i]; // Assign each byte to its 8-bit slice
    end

    // Split the packed vector into 6-bit elements
    for (int i = 0; i < num_6bit_elements; i++) begin
        int start_bit = i * 6;
        if (start_bit + 6 <= total_bits) begin
            output_array[i] = packed_data[start_bit +: 6]; // Full 6-bit chunk
        end else begin
            // Handle the final partial chunk (adjust padding as needed for your use case)
            output_array[i] = packed_data[start_bit +: (total_bits - start_bit)];
            // Alternatively, pad with zeros to make it 6 bits:
            // output_array[i] = { {(6 - (total_bits - start_bit)){1'b0}}, packed_data[start_bit +: (total_bits - start_bit)] };
        end
    end

    return output_array;
endfunction

Key Notes: #

• This method ensures no data is lost—every bit from the original byte array ends up in the logic [5:0] array.
• The last element might be shorter than 6 bits (if the total number of bits isn’t a multiple of 6). You can pad it with zeros (as shown in the commented line) or handle it based on your system’s requirements.

Scenario 2: Map Each Byte to a Single logic [5:0] Element #

If your use case requires one logic [5:0] element per byte, you need to guarantee that each byte’s value fits within the 6-bit range (0 to 63, since logic [5:0] is an unsigned 6-bit type). Here’s a safe implementation with overflow checking:

function logic [5:0][] byte_to_logic6_one_to_one(byte input_array[]);
    logic [5:0][] output_array = new[input_array.size()];

    for (int i = 0; i < input_array.size(); i++) begin
        if (input_array[i] > 6'h3F) begin // 6'h3F is 63 in decimal, max value for logic [5:0]
            // Handle overflow—choose the behavior that fits your design
            $error("Byte at index %d (%0d) exceeds 6-bit maximum value (63)", i, input_array[i]);
            // Optional: Clamp the value to the 6-bit max instead of erroring
            // output_array[i] = 6'h3F;
            // Or flag the error with a separate signal if you're in a module context
        end else begin
            output_array[i] = input_array[i][5:0]; // Safe cast since value is within range
        end
    end

    return output_array;
endfunction

Key Notes: #

• This only works if your input byte values are guaranteed (or validated) to be ≤ 63. If any byte is larger than 63, you’ll lose the top 2 bits unless you add overflow handling.
• The error check ensures you catch unexpected values before data loss occurs.

Pick the approach that aligns with your design goals—either full bit preservation via chunking, or one-to-one mapping with range validation.

内容的提问来源于stack exchange，提问作者George