Operators are means for constructing expressions.
adding_operator ::= + | - | &
logical_operator ::= and | or | nand | nor | xor | xnor
miscellaneous_operator ::= ** | abs | not
multiplying_operator ::= * | / | mod | rem
relational_operator ::= = | /= | < | <= | > | >=
shift_operator ::= sll | srl | sla | sra | rol | ror
VHDL has a wide set of different operators, which can be divided into groups of the same precedence level (priority). The table below lists operators grouped according to priority level, highest priority first.
Table 1. Operator priority
miscellaneous operators |
** | abs | not |
multiplying operators |
* | / | mod | rem |
sign operators |
+ | - |
adding operators |
+ | - | & |
shift operators |
sll | srl | sla | sra | rol | ror |
relational operators |
= | /= | < | <= | > | >= |
logical operators |
and | or | nand| nor | xor | xnor |
The expressions are evaluated form left to right, operations with
higher precedence are evaluated first. If the order should be
different from the one resulting from this rule, parentheses can be
used (Example 1).
The operands, connected with each other by an operator, are evaluated before the operation described by that operator is carried out. For some operators the right operand is evaluated only when the left operand has a certain value assigned to it. The logical operators such as and, or, nand, nor defined for the BIT and BOOLEAN operands belong to those operators.
The operators for the predefined types are defined in the STANDARD package in the STD library. These operators are functions, which always return the same value when they are called with the same values of the actual parameters. These functions are called the pure function (see function for details).
The logical operators and, or, nand, nor, xor, xnor and not are defined for BIT and BOOLEAN types, as well as for one-dimensional arrays containing the elements of BIT and BOOLEAN. All these operators have the lowest priority, except for the operator not, which has the highest priority. The results of the logical operators for the predefined types are presented in the tables 2 through 8. The BIT type is represented by the values '0' and '1', while the Boolean type by True and False.
Table 2. Operator not
A |
not A |
||
True |
'1' |
False |
'0' |
False |
'0' |
True |
'1' |
Table 3. Operator and
A |
B |
A and B |
|||
True |
'1' |
True |
'1' |
True |
'1' |
True |
'1' |
False |
'0' |
False |
'0' |
False |
'0' |
True |
'1' |
False |
'0' |
False |
'0' |
False |
'0' |
False |
'0' |
Table 4. Operator or
A |
B |
A or B |
|||
True |
'1' |
True |
'1' |
True |
'1' |
True |
'1' |
False |
'0' |
True |
'1' |
False |
'0' |
True |
'1' |
True |
'1' |
False |
'0' |
False |
'0' |
False |
'0' |
Table 5. Operator xor
A |
B |
A xor B |
|||
True |
'1' |
True |
'1' |
False |
'0' |
True |
'1' |
False |
'0' |
True |
'1' |
False |
'0' |
True |
'1' |
True |
'1' |
False |
'0' |
False |
'0' |
False |
'0' |
Table 6. Operator nand
A |
B |
A nand B |
|||
True |
'1' |
True |
'1' |
False |
'0' |
True |
'1' |
False |
'0' |
True |
'1' |
False |
'0' |
True |
'1' |
True |
'1' |
False |
'0' |
False |
'0' |
True |
'1' |
Table 7. Operator nor
A |
B |
A nor B |
|||
True |
'1' |
True |
'1' |
False |
'0' |
True |
'1' |
False |
'0' |
False |
''0' |
False |
'0' |
True |
'1' |
False |
'0' |
False |
'0' |
False |
'0' |
True |
'1' |
Table 8. Operator xnor
A |
B |
A xnor B |
|||
True |
'1' |
True |
'1' |
True |
'1' |
True |
'1' |
False |
'0' |
False |
''0' |
False |
'0' |
True |
'1' |
False |
'0' |
False |
'0' |
False |
'0' |
True |
'1' |
The relational operators allow checking relation between operands, i.e. to state whether they are equal, not equal or are ordered in a way defined by operator (Table 9). Both operands must be of the same type, and the result received is always of the Boolean type.
Table 9. Relational operations
= |
Equality |
/= |
Inequality |
< |
Ordering „less than” |
<= |
Ordering „less than or equal” |
> |
Ordering „greater than” |
>= |
Ordering „greater than or equal” |
The equality operator returns the value TRUE only when both operands have the same values, and FALSE when the values are different. The inequality operator returns the value TRUE when the operators are different and FALSE when they are equal. There are certain rules that are used to compare operands depending on their type: in case of the scalar type, the operand values are equal only when the values are the same. Two values of the composite type are equal only when each value of the left operand corresponds to the value of the right operand and vice versa. In the record the corresponding elements have identical identifiers, and in the array the corresponding elements are those which appear at the same positions of arrays. In particular two null arrays of the same type are always equal.
The operators: <, <=, >, and >= return the TRUE logical value only when the condition in the given relation is met, otherwise the FALSE value is returned (Example 4).
The shift operators are defined for the one-dimensional array with the elements of the type BIT or BOOLEAN. For the shift operator an array is the left operand L and integer is the right operand R. The right operand represents the number of positions the left operand should be shifted. As the result of shifting, the value of the same type as the left operand is returned. Table 10 below shows predefined shift operators.
Table 10. Shift operators
sll |
Shift left logical |
srl |
Shift right logical |
sla |
Shift left arithmetic |
sra |
Shift right arithmetic |
rol |
Rotate left logical |
ror |
Rotate right logical |
The operator srl returns the value of the left operand L after it has been shifted to right R times. In case when R is equal to 0 or L is the null array, the left operand L is returned. The single shifting operation replaces the operand L with the concatenation of the leftmost L'Length -1 elements of L and a single value T'Left, where T is the element type of L. If R is a negative number then the value of expression L sll -R is returned, otherwise the single shift operation is repeated R number of times.
The operator sla returns the value of the left operand L after it has been shifted to the left R number of times. In case when R is equal to 0 or L is the null array the left operand L is returned. The single shift operation replaces L with concatenation of the rightmost L'Length -1 elements of L and a single value L'Right. If R is a negative number, the value of the expression L sra -R is returned, otherwise the single shift operation is repeated R number of times.
The operator sra returns the value of the left operand L after it has been shifted to the right R number of times. In case when R is equal to 0 or L is the null array, the left operand L is returned. The single shift operation replaces L with a value, which is the result of concatenation whose left argument is the leftmost L'Length -1 elements of L and whose right argument is L'Left. If R is a negative number, the value of the expression L sla -R is returned, otherwise the single shift operation is repeated R number of times.
The operator rol returns the value of the L left operand after it has been rotated to the left R times. In case when R is equal to 0 or L is the null array the left operand L is returned. The single shift operation replaces L with a value which is the result of concatenation of the rightmost L'Length -1 elements of L and a single value L'Left. If R > 1 the sing.le shift operation is repeated R times. If R > 1 is a negative number, the expression L ror -R is returned.
The operator ror returns the value of the L left operand after it has been rotated to the right R number of times. In case when R is equal to 0 or L is the null array, the left operand L is returned. The single shift operation replaces L with a value which is the result of concatenation whose left argument is the leftmost L'Length -1 elements of L and whose right argument is L'Right. If R > 1 the single shift operation is repeated R times. If R is a negative number, the expression L rol -R is returned.
Adding operators consist of addition, subtraction and concatenation. The adding operators are shown in the Table 11 below.
Table 11. Adding operators
+ |
Addition |
- |
Subtraction |
& |
Concatenation |
The adding and subtraction operators perform mathematical operations, and their operands can be of any numeric type.
The concatenation (&) operator is defined for elements of one-dimensional arrays. In the concatenation, the following situations can take place:
When both operands are one-dimensional arrays of the same type, the concatenation connects the two arrays into one. The new array contains the elements from both arrays. The direction of the new array is the same as the direction in the array of the left operand, but if the left operand is the null array then it is the same as the direction of the right operand. In case when both operands are null arrays, the direction of the right operand is assumed (Example 6).
When one of the operands is a one-dimensional array and the second operand is a scalar of the same type as the elements of that array, then the result of the concatenation is the same as in the first point. However, in this case the second operand is treated as a one-dimensional array which contains only one element (Example 6).
In case when both operands are of the same scalar type, then the result of concatenation is one-dimensional array with elements of the same types as the operands (Example 6).
Sign operators are unary operators, i.e. have only one, right operand, which must be of a numeric type. The result of the expression evaluation is of the same type as the operand. There are two sign operators (Table 12).
Table 12. Sign operators
+ |
Identity |
- |
Negation |
The multiplication and division operators are predefined for all integers, floating point numbers. Under certain conditions, they may be used for operations on physical type objects as well. The mod and rem operators, on the other hand, are defined only for the integers. When mod and rem operators are used, then both the operands and the result are of the same integer type. The multiplying operators are shown in the Table 13.
Table 13. Multiplying operators
* |
Multiplication |
/ |
Division |
mod |
Modulus |
rem |
Remainder |
The two miscellaneous operators are shown in the Table 14.
Table 14. Miscellaneous operators
** |
Exponentiation |
abs |
Absolute value |
The abs operator has only one operand. It allows defining the operand's absolute value. The result is of the same type as the operand.
The exponentiation operator has two operands. This operator is defined for any integer or floating point number. The right operand (exponent) must be of integer type. When the exponent is the positive integer, then the left operand is repeatedly multiplied by itself. When the exponent is the negative number, then the result is a reverse of exponentiation with the exponent equal to the absolute value of the right operand (Example 9). If the exponent is equal to 0 the result will be 1.
Example 1
v := a + y * x;
The multiplication y*x is carried out first, then a is added to the
result of multiplication. This is because the multiplication operator
has higher level of priority than the adding operator.
Example 2
variable We1, We2, We3, Wy :
BIT := '1';
Wy := We1 and We2 xnor
We1 nor We3;
For the initial value of the variables We1, We2, We3 equal to '1',
the result is assigned to the variable Wy and is equal to '0'.
Example 3
variable Zm1: REAL := 100.0;
variable Zm2 : BIT_VECTOR(7 downto
0) := ('0','0','0','0','0','0','0','0');
variable Zm3, Zm4 :
BIT_VECTOR(1 to 0);
Zm1 /= 342.54 -- True
Zm1 = 100.0 -- True
Zm2 /= ('1', '0', '0', '0', '0', '0', '0', '0') -- True
Zm3 = Zm4 -- True
Example 4
Zm1 > 42.54 -- True
Zm1 >= 100.0 -- True
Zm2 < ('1', '0', '0', '0', '0', '0', '0', '0') -- True
Zm3 <= Zm2 -- True
Example 5
variable Zm5 : BIT_VECTOR(3 downto
0) := ('1','0','1','1');
Zm5 sll 1 -- ('0', '1', '1', '0')
Zm5 sll 3 -- ('1', '0', '0', '0')
Zm5 sll -3 -- Zm5 srl 3
Zm5 srl 1 -- ('0', '1', '0', '1')
Zm5 srl 3 -- ('0', '0', '0', '1')
Zm5 srl -3 -- Zm5 sll 3
Zm5 sla 1 -- ('0', '1', '1', '1')
Zm5 sla 3 -- ('1', '1', '1', '1')
Zm5 sla -3 -- Zm5 sra 3
Zm5 sra 1 -- ('1', '1', '0', '1')
Zm5 sra 3 -- ('1', '1', '1', '1')
Zm5 sra -3 -- Zm5 sla 3
Zm5 rol 1 -- ('0', '1', '1', '1')
Zm5 rol 3 -- ('1', '1', '0', '1')
Zm5 rol -3 -- Zm5 ror 3
Zm5 ror 1 -- ('1', '1', '0', '1')
Zm5 ror 3 -- ('0', '1', '1', '1')
Zm5 ror -3 -- Zm5 rol 3
Example 6
constant B1: BIT_VECTOR :=
"0000"; -- four element array
constant B2: BIT_VECTOR :=
"1111"; -- four element array
constant B3: BIT_VECTOR :=
B1 & B2; -- eight element array, ascending
-- direction, value "00001111"
subtype BIT_VECTOR_TAB is
BIT_VECTOR (1 downto 0);
constant B4: BIT_VECTOR_TAB
:= "01";
constant B5: BIT_VECTOR:= B4
& B2; -- six element array, descending
-- direction, value "011111"
constant B6 : BIT := '0' ;
constant B7 : BIT_VECTOR :=
B2 & B6;-- five element array, ascending
-- direction, value "11110"
constant B8: BIT := '1';
constant B9: BIT_VECTOR :=
B6 & B8; -- two element array, ascending
-- direction value "01"
Example 7
z := x * ( -y) -- A legal expression
z := x / (not y) -- A legal expression
The same expressions without parentheses would be illegal.
Example 7
variable A,B :Integer;
variable C : Real;
C:= 12.34 * ( 234.4 / 43.89 );
A:= B mod 2;
Example 8
2 ** 8 = 256
3.8 ** 3 = 54.872
4 ** (-2) = 1 / (4**2) = 0.0625
All predefined operators for standard types are declared in the package STANDARD.
The operator not is classified as a miscellaneous operator only for the purpose of defining precedence. Otherwise, it is classified as a logical operator.