I was curious about these things:
It would be really helpful if you can cite any sources. I've looked at the IEEE-754 document, but was not able to find any specific statements regarding implementation.
Edit: Assume the IEEE-754 specification
Does the C language always store the floating-point numbers in the normalized form?
"It depends." As we'll see, it's more the hardware than the C language that determines this.
If the implementation uses something other than IEEE-754, there's not much we can say.
If the implementation does use IEEE-754, then all numbers are always stored normalized except the ones that aren't, namely the subnormals.
Does this also hold true for the results obtained after some arithmetic (addition, multiplication)?
Yes. (More on this below.)
Is it dependent on the language or the hardware - FPU?
It is typically dependent on the hardware. Most of the time, assuming the target processor supports floating-point at all, a C program is compiled straight to native floating-point instructions, without any language- or compiler-imposed extra processing. (This is by contrast to, for example, Java, which does have a language-imposed floating-point definition, which is implemented in part by the JVM.)
The C standard does have an optional section, "Annex F", which specifies a bunch of specific floating-point behavior, conformant with IEEE-754.
Now, if the C implementation adopts Annex F and is conformant with IEEE-754 (typically because the underlying hardware is, too), the answers to your first two questions become even easier. In IEEE-754 binary arithmetic, with one exception, there are no ambiguities of representation. Every number that can be represented in normalized form has exactly one normalized representation. Every number that cannot be represented in normalized form, but that can be represented as a subnormal, has exactly one subnormal representation. These constraints apply to every IEEE-754 floating-point number, including (naturally enough) the results of other operations.
(The exception, as Eric and Chux have reminded me in a comment, is zero, which IEEE-754 has two of, positive and negative.)
So the answer to "Is the result always normalized?" is "No" (because IEEE-754 most definitely has those subnormals, and of course zero), but if the question is "Does every number have a unique representation?", the answer is mostly "Yes." (Except, again, for zero. Or if you're one of the rare few who is doing something with the IEEE-754-2008 decimal formats, which are much less unique.) See also How to distinguish between 1 and zero floating-point values?
The last question, I suppose, is "How many C implementations adopt Annex F?", or, stated another way, "How many processors comply with IEEE-754?" For the CPU's on general-purpose computers (mainframes and personal computers), as far as I know the answer these days is "All of them". GPU's, on the other hand, are deliberately not quite compatible with IEEE-754 (because they can be even more insanely efficient that way). Microprocessors, for "embedded" work, I'm not so sure about. (Often they don't have viable floating-point at all.)