Numeric literal constant in VHDL treatment

Question

I was wondering if there's a special way to treat numeric literal constant in way similar to C language... i.e. in C we can do something like:

1LL //signed long long
1ULL //unsigned long long

etc

is there something similar in VHDL that I'm not aware of?

Answer 1

In VHDL, the constant declaration requires that the type is specified. The length is usually baked in to the type. For example

constant my_constant : unsigned(63 downto 0):= X"0000000000000001";

Whenever a signal is driven by a numeric constant, it's necessary to match the constant length with the signal length.

For example:

signal my_signal : unsigned(63 downto 0);
....
my_signal <= X"0000000000000001";

Since VHDL is strongly typed, if the literal length does not match the signal declaration, it will produce an error.

As jeff mentioned, it's also possible to use to_unsigned, as follows:

my_signal <= x + y + to_unsigned(1,my_signal'length);

Answer 2

All integer literals are signed 32-bit integers. So as of now VHDL has only one integer type, so no prefix or suffix is needed to distinguish the literals.

Of cause you can declare subtypes of integer:

subtype T_INT_8  is INTEGER range -128 to 127;
subtype T_UINT_8 is INTEGER range 0 to 255;

There is a discussion if VHDL should be extended to support 64-bit integers (and literals) or even bigger.

Discussions on the "P1076 Working Group" twiki:

• Long Integers
• Arbitrary Integers
• Extended Integers

Answer 3

An object with a type of signed or unsigned from IEEE packages numeric_bit and numeric_std is an array type comprised of sequentially ordered elements of an enumerated type.

An object of an array type with an enumerated element type can have a value provided by string literal, provided the string only contains character values of literals comprising the enumeration types element values.

In addition to string literals there are bit string literals which in -2008 with the addition of a length prefix integer value can trim or extend a string literal value derived from evaluating a based literal.

Additionally in -2008 there are signed and unsigned prefixes for base specifiers B, O and X, and an additional base specifier D.

Using -2008 syntax you might express 1ULL as 64X"1" and 1LL as 64SX"1" for a long comprised of a 32 bit value. There are aother based literal representations.

The applicable section of the -2008 standard 15.8 Bit string literals is worth reading as may be other references.