Q:

What are the differences between constant expressions and nonmodifiable lvalues?

From C in a Nutshell:

Constant expressions
The  compiler  recognizes  constant  expressions  in  source  code
and  replaces  them with their values. The resulting constant value
must be representable in the expression’s type. You may use a constant
expression wherever a simple constant is permitted.
Operators in
constant expressions are subject to the same rules as in other
expressions. Because constant expressions are evaluated at translation
time, though, they cannot contain function calls or operations that
modify variables, such as assignments.

What are constant expressions? It doesn't define constant expressions

What are the differences between constant expressions and non-modifiable lvalues (e.g. array names, lvalues which have been declared with const)

Are constant expressions always non-lvalues?

Are non-modifiable lvalues constant expressions?

A:

What are constant expressions?

§6.6- Constant Expression:  

A constant expression can be evaluated during translation rather than runtime, and accordingly may be used in any place that a constant may be.  

One of the constraint on the constant expression is  

Constant expressions shall not contain assignment, increment, decrement, function-call, or comma operators, except when they are contained within a subexpression that is not evaluated115).  

What are the differences between constant expressions and nonmodifiable lvalues?

Non modifiable lvalues are not constant expressions. Non-modifiable values are lvalues that can't be used to modify an object.  
int const i = 5;

i is referring to a const object but it is an lvalue, a special kind of lvalue called non-modifiable lvalue. 
Wherever standard says about "lvalue", it actually means "modifiable lvalue" (you won't find this in standard but for the sake of clarity)  
Now let me explain it a bit more. 
int x = 5;
int const *p;

x is a non const object and it is a modifiable lvalue. p is a pointer to a const int object.   
p = &x;  // This will raise a warning though and hazardous to do.

Above assignment uses a qualification conversion to convert a value of type pointer to int into a value of type pointer to const int.
*p and x are two different expression referring to the same object. This abject can be modified using x 
--x;  

but this can't be done using *p as it is a non-modifiable lvalues.   
--(*p); // Error

One more difference between a constant expression and a non-modifiable lvalue is   
int const x = 5;
int *p;
/* Assigning address of a non-modifiable object */
p = &x      // Correct
/* Assigning address of a constant expression */
p = &5      // Wrong  

Are constant expressions always non-lvalues? 

Yes, constant expressions are always non-lvalues, i.e rvalues.

Are nonmodifiable lvalues constant expressions? 

No.

A:

Constant expressions are defined in C11 6.6:

Description
2. A constant expression can be evaluated during translation rather than runtime, and accordingly may be used in any place that a constant may be. 
Constraints
3 Constant expressions shall not contain assignment, increment, decrement, function-call, or comma operators, except when they are contained within a subexpression that is not evaluated.115)
4 Each constant expression shall evaluate to a constant that is in the range of representable values for its type.

There are several types of constant expressions which might be allowed in a place. There are constant expressions that evaluate to

an arithmetic constant expression,

a special case of this is integer constant expression, which is allowed for example as the size of a (statically allocated) array, or a bitfield width.

a null pointer constant,
an address constant, or
an address constant for a complete object type plus or minus an integer constant expression. 

lvalues or locator values (potentially) designate objects. You can take the address of an lvalue. The difference between a modifiable and non-modifiable lvalue is that the latter cannot be used as the left-hand side of an assignment. Or, C11 6.3.2.1p1:

A modifiable lvalue is an lvalue that does not have array type, does not have an incomplete type, does not have a const- qualified type, and if it is a structure or union, does not have any member (including, recursively, any member or element of all contained aggregates or unions) with a const- qualified type.

A non-modifiable lvalue is an lvalue that is not modifiable.
Constant expressions are just... values. They do not reside in memory - there  is no address for number 42 - &42 is meaningless.
constant expressions are thus always non-lvalues. They do not designate objects. You cannot take the address of 6 * 9.
no, but... lvalues of array types implicitly decay into pointers-to-arrays, and these are address constants. However as they're thusly converted they stop being lvalues.

