Shift operators in VHDL - Step-by-Step Execution

Concept Flow - Shift operators

Input Vector

↓

Select Shift Type

↓

Shift Left

↓

Shift Bits by N Positions

↓

Output Shifted Vector

The input vector is shifted left or right by a specified number of positions, producing a new shifted vector as output.

Execution Sample

VHDL

signal data_in : std_logic_vector(7 downto 0) := "10110011";
signal data_out : std_logic_vector(7 downto 0);

-- Shift left by 2
 data_out <= data_in sll 2;

This code shifts the 8-bit vector data_in left by 2 positions and stores the result in data_out.

Execution Table

Step	Operation	Input Vector	Shift Amount	Result Vector	Explanation
1	Initial value	10110011	N/A	10110011	Starting vector before shift
2	Shift left by 2	10110011	2	11001100	Bits shifted left 2 places, zeros fill right
3	Shift right by 3	10110011	3	00010110	Bits shifted right 3 places, zeros fill left
4	Shift left by 0	10110011	0	10110011	Shift by zero leaves vector unchanged
5	Shift right by 8	10110011	8	00000000	Shift by full length results in all zeros

💡 All shifts complete; output vectors show shifted results with zeros filling vacated bits.

Variable Tracker

Variable	Start	After Shift Left 2	After Shift Right 3	After Shift Left 0	After Shift Right 8
data_in	10110011	10110011	10110011	10110011	10110011
data_out	undefined	11001100	00010110	10110011	00000000

Key Moments - 3 Insights

Why do zeros fill in the bits when shifting?

In VHDL shift operators, when bits move out of the vector range, zeros fill the empty positions to keep the vector size constant, as shown in execution_table rows 2 and 3.

What happens if the shift amount is zero?

If the shift amount is zero, the vector remains unchanged, as seen in execution_table row 4 where the output equals the input.

Why does shifting right by the vector length produce all zeros?

Shifting right by the full vector length moves all bits out, leaving only zeros, demonstrated in execution_table row 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is data_out after shifting left by 2?

A 00010110

B 11001100

C 10110011

D 00000000

💡 Hint

Check execution_table row 2 under Result Vector.

At which step does shifting right produce '00010110'?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Look at execution_table row 3 for the Result Vector.

If we shift left by 8 on an 8-bit vector, what would data_out be?

A Original vector unchanged

B Vector shifted left by 1

C All zeros

D Vector shifted right by 8

💡 Hint

Refer to the pattern in execution_table row 5 for full-length shifts.

Concept Snapshot

Shift operators in VHDL move bits left (sll) or right (srl).
Bits shifted out are lost; zeros fill the empty positions.
Syntax: result <= input_vector sll n; or srl n;
Shift amount n must be integer.
Shifting by zero leaves vector unchanged.
Shifting by vector length results in all zeros.

Full Transcript

This visual execution trace shows how VHDL shift operators work on an 8-bit vector. The vector is shifted left or right by a given number of positions. When bits move out of the vector, zeros fill the empty spots to keep the size the same. For example, shifting left by 2 moves bits two places left and adds zeros on the right. Shifting right by 3 moves bits three places right and adds zeros on the left. Shifting by zero does not change the vector. Shifting by the full vector length results in all zeros. The variable tracker shows how data_in stays the same while data_out changes after each shift. Key moments clarify why zeros fill in and what happens with zero or full-length shifts. The quiz questions help check understanding by referencing the execution steps and results.

Practice

1. What does the shift_left operator do in VHDL?

easy

A. Inverts all bits in the vector

B. Moves bits to the left, filling with zeros on the right

C. Rotates bits without changing their order

D. Moves bits to the right, filling with zeros on the left

Solution

1. Step 1: Understand the shift_left operator

   The shift_left operator moves all bits in a vector to the left by a specified number of positions.

2. Step 2: Identify what fills the empty positions

   When bits move left, zeros fill the rightmost positions to keep the vector size constant.

3. Final Answer:

   Moves bits to the left, filling with zeros on the right -> Option B

4. Quick Check:

   shift_left = left shift with zero fill [OK]

Hint: Left shift moves bits left, adds zeros on right [OK]

Common Mistakes:

• Confusing shift_left with shift_right
• Thinking bits rotate instead of filling zeros
• Assuming bits are inverted

2. Which of the following is the correct syntax to shift a 8-bit std_logic_vector data 3 bits to the right in VHDL?

easy

A. data <= shift_right(data, 3);

B. data <= shift_left(data, 3);

C. data <= data >> 3;

D. data <= shift(data, -3);

Solution

1. Step 1: Identify the correct shift function for right shift

   In VHDL, shift_right is used to shift bits to the right.

2. Step 2: Check the syntax for shifting

   The syntax is variable <= shift_right(variable, number_of_bits); so data <= shift_right(data, 3); is correct.

3. Final Answer:

   data <= shift_right(data, 3); -> Option A

4. Quick Check:

   shift_right(data, 3) is correct syntax [OK]

Hint: Use shift_right(variable, count) to shift right [OK]

Common Mistakes:

• Using shift_left instead of shift_right
• Using C-style operators like >> which are invalid in VHDL
• Using negative shift counts

3. Given the VHDL code:

signal data : std_logic_vector(7 downto 0) := "00011011";
signal result : std_logic_vector(7 downto 0);

result <= shift_left(data, 2);

What is the value of result after the shift?

medium

A. "01101100"

B. "11011000"

C. "00011000"

D. "01100000"

Solution

1. Step 1: Write the original bits and shift left by 2

   Original data: 00011011
   Shift left by 2 moves bits left 2 places: 01100000 (last two bits become zeros)

2. Step 2: Confirm the shifted bits and zero fill

   Bits shifted left: 0 0 0 1 1 0 1 1
   After shift left 2: 0 1 1 0 0 0 0 0

3. Final Answer:

   "01100000" -> Option D

4. Quick Check:

   shift_left("00011011", 2) = "01100000" [OK]

Hint: Shift left moves bits left, add zeros on right [OK]

Common Mistakes:

• Forgetting to add zeros on right
• Shifting bits right instead of left
• Miscounting bit positions

4. Consider this VHDL snippet:

signal data : std_logic_vector(7 downto 0) := "10101010";
signal result : std_logic_vector(7 downto 0);

result <= shift_right(data, 3);

But the output is unexpected. What is the likely error?

medium

A. Using shift_left instead of shift_right

B. Assigning to signal instead of variable

C. Using shift_right on std_logic_vector without numeric_std library

D. Incorrect bit width of result signal

Solution

1. Step 1: Understand shift_right requirements

   The shift_right function requires the numeric_std library for std_logic_vector operations.

2. Step 2: Identify missing library causing unexpected output

   If numeric_std is not included, shift_right may not work properly on std_logic_vector, causing wrong results.

3. Final Answer:

   Using shift_right on std_logic_vector without numeric_std library -> Option C

4. Quick Check:

   numeric_std needed for shift_right on std_logic_vector [OK]

Hint: Include numeric_std for shift_right on std_logic_vector [OK]

Common Mistakes:

• Forgetting to include numeric_std library
• Confusing shift_left and shift_right
• Assuming signals behave like variables

5. You want to multiply an 8-bit unsigned number num by 8 using shift operators in VHDL. Which expression correctly does this?

hard

A. result <= shift_left(num, 3);

B. result <= shift_right(num, 3);

C. result <= shift_left(num, 2);

D. result <= shift_right(num, 2);

Solution

1. Step 1: Understand multiplication by powers of two

   Multiplying by 8 is the same as multiplying by 2^3, which is shifting left by 3 bits.

2. Step 2: Choose the correct shift operator and count

   Use shift_left(num, 3) to multiply by 8 correctly.

3. Final Answer:

   result <= shift_left(num, 3); -> Option A

4. Quick Check:

   Multiply by 8 = shift_left by 3 [OK]

Hint: Multiply by 2^n with shift_left by n [OK]

Common Mistakes:

• Using shift_right instead of shift_left
• Shifting by wrong number of bits
• Confusing unsigned and signed types