Counting occurrences of values in C Array (Shannon Entropy)

Firstly, you know the size of the number of buckets you want to use here, so there is no reason to use dynamic allocation (specifically, double *probabilityOfX = calloc(sizeof(double), 256);). This could simply be:

double probabilityOfX[256];
memset(&probabilityOfX, 0.0, 256);

You don't need to free this memory at the end then, either, reducing the possibility for memory leaks.

Of course, this is fine for small values (like what can fit in a uint8_t), however, using a uint32_t (or larger), this will pre-allocate a large array which could potentially be very sparse. In this case, what you actually want is a dictionary data structure (like a hashmap). Since C doesn't have anything like this inbuilt, I'm going to switch over to C++ so we can use std::unordered_map and some other nice things like std::vector (instead of raw uintx_t pointers):

double entropyOfDistribution(const std::vector<uint32_t>& vec)
{
    std::unordered_map<uint32_t, unsigned> counts;

    // Store the number of counts
    for(uint32_t value : vec) {
        ++counts[value];
    }

    double sum = 0.0;
    // Note the cast as otherwise we'll be doing integer
    // division and hence rounding to an int -
    // thanks @syb0rg for pointing that out.
    const double num_samples = static_cast<double>(vec.size());

    for(auto it = counts.begin(); it != counts.end(); ++it) {
        double probability = it->second / num_samples;
        sum += probability * log2(probability);
    }

    return -1.0 * sum;
}

@Yuushi has already given a pretty good suggestions, but if I were doing this in C++, I'd do it just a bit differently.

Let's start by reviewing your code:

    //Counting number of occurrences of a number (using "buckets")
    double *probabilityOfX = calloc(sizeof(double), 256);

Although it's rarely likely to be a problem, I don't believe that the contents of an array allocated with calloc is guaranteed to contain 0.0 when viewed as doubles (but it will in most typical implementations, so you may not care).

    //Calculating the probabilities
    for (int i = 0; i < 256; i++)
        probabilityOfX[x[i]] /= length;

This (I'm fairly sure) is a bug. I'm pretty sure what was intended was:

    //Calculating the probabilities
    for (int i = 0; i < 256; i++)
        probabilityOfX[i] /= length;

As it was, it attempted to use 256 characters of the input string, even if the input string was much shorter than that. It could also fail to adjust the probabilities in the counts correctly if the string was longer than 256, but the string contained any characters that didn't occur in the first 256 characters.

As to how I'd do things: I think I'd at least consider implementing it as a (relatively) generic algorithm that could take (for example) any sequence-type container as its input. I'd implement it internally using std::accumulate to do the majority of the work:

template <class Vector>
double entropy(Vector const &v) {
    typedef typename Vector::value_type v_t;
    std::map<v_t, size_t> counts;

    for (auto && c : v)
        ++counts[c];

    return -std::accumulate(counts.begin(), counts.end(), 0.0,
        [=](double a, std::pair<v_t, size_t> const &t) { 
            double x = t.second / static_cast<double>(v.size()); 
            return a + x * log2(x); 
        });
}

In this case, using accumulate doesn't really make the code drastically shorter, but it does (IMO) give a little clearer picture of what you're trying to do that using a generic for loop to sum the probabilities.