Why does my code only run when I use printf?

Question

EDIT Changing my Main method after the end = clock(); call to:

    end = clock();
    unsigned long total_time = (end - start);
    u_llong total_iterations = (max - min);

    if ((u_llong)(total_time / CLOCKS_PER_SEC) > 0)
    {
        total_time = total_time / CLOCKS_PER_SEC;
        double ips = total_iterations / total_time;
        printf("Iterations per second: %f\n", ips);
        printf("Total time taken for %I64u iterations: %lu seconds.\n", total_iterations, total_time);
    }
    else
    {
        double ipms = total_iterations / total_time;
        printf("Iterations per millisecond: %f\n", ipms);
        printf("Total time taken for %I64u iterations: %lu ms.\n", total_iterations, total_time);
    }
    printf("---------------------\n");
    fflush(stdout);
    return 0;
    }

has done the trick for me..

Here is the question again:

I have a problem. When I compile this code using:gcc main.c -Wall -std=c99 -lcrypto I don't get any errors. However when I run the code in console it should output something like this:

$ a.exe
Starting 18446744073709551615 iterations now.
Starting at 11144000000
Done. Solution: caesar at 11144802215
Total time taken for 802215 iterations: 16 seconds
Iterations per second: 50138.000000
$

However that is not the case. Instead all I get is:

$ a.exe
Starting 18446744073709551615 iterations now.
Starting at 11144000000
$

The program just stops executing and terminates before it finishes. Now the bizarre thing: when I put in a printf("some random string"); inside my for- loop it works perfectly. I commented out the beforementioned printf(); so that you can see what I meant. I really don't understand why that is, where it comes from or how to fix it. why does my code only work when I use printf? I do not want to keep it because I would like to try and get this code to execute as fast as I can.

#include <stdio.h>
#include <time.h>
#include <openssl/sha.h>
#include <string.h>

typedef unsigned long long u_llong;

#ifndef PASSWORD
#define PASSWORD "52915A4731522B93613F74A52D26F6A62AC8C5BD" //caesar
#endif
const char *base62Table = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
const int base = 62;

void hexString(char *dest, unsigned char *bytes, int bytesLength)
{
    char lookup[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    for (int i = 0; i < bytesLength; i++)
    {
        dest[2 * i] = lookup[(bytes[i] >> 4) & 0xF];
        dest[2 * i + 1] = lookup[bytes[i] & 0xF];
    }
    dest[2 * bytesLength] = 0;
}

void genHash(char *str, unsigned char *dest)
{
    SHA1((unsigned char *)str, strlen(str), dest);
}

int check(char *str)
{
    unsigned char hash[SHA_DIGEST_LENGTH] = {0};
    char hex[41] = {0};
    genHash(str, hash);
    hexString((char *)hex, (unsigned char *)hash, sizeof(hash));
    hex[40] = '\0';
    return strcmp(PASSWORD, hex) == 0;
}

void to_base(u_llong num, char *out)
{
    const int base = 62;
    if (num == 0)
    {
        out[0] = '0';
        out[1] = '\0';
        return;
    }
    int i = 0;
    while (num != 0)
    {
        out[i++] = base62Table[(num % base)];
        num /= base;
    }
    out[i] = '\0';
    out = strrev(out);
}

void run(u_llong *min, u_llong *max, char *str)
{
    //Right solution should come at i = 11144802215
    for (u_llong i = *min; i < *max; i++)
    {
        to_base(i, str);
        //printf("I only work when using this\n");
        if (check(str))
        {
            printf("Done. Solution: %s at %I64u\n", str, i);
            *max = i;
            break;
        }
    }
}

int main(void)
{
    u_llong max = 0xFFFFFFFFFFFFFFFF, min = 11144000000; //start shortly before the right solution comes up
    clock_t start, end;
    printf("Starting %I64u iterations now.\nStarting at %I64u\n", max, min);
    fflush(stdout);
    const int length = 20;
    char str[length + 1];
    //Start executing the actual task
    start = clock();
    run(&min, &max, str);
    end = clock();
    //finished executing the task
    unsigned long total = (end - start) / CLOCKS_PER_SEC;
    u_llong total_iterations = (max - min);
    double ips = (max - min) / total;
    printf("Total time taken for %I64u iterations: %lu seconds \n", total_iterations, total);
    printf("Iterations per second: %f\n", ips);
    fflush(stdout);
    return 0;
}

---EDIT---

I am compiling and running on a Windows 10 OS using Mingw64. The format string %llu does not work in my GCC (it is "unknown"), so i use %I64u which works.

When I try to Run it using gdb (after adding -g flag to compiler) I get:

$ gdb a.exe
GNU gdb (GDB) 7.8
Copyright (C) 2014 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later http://gnu.org/licenses/gpl.html
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i686-w64-mingw32".
Type "show configuration" for configuration details.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from a.exe...done.
$

when I then use the bt command to "bt -- Print backtrace of all stack frames" it simply says:

No stack.

--- edit ---

So I added a Sleep(1); included from windows.h and now it does not crash on startup for some reason. Can it really be running "too" fast? I am so confused

Someone pointed out that end == start. This is not the case as the same crash happens even when I wrap it in

//...
end = clock();
if (end == start)
    {
        printf("End equals start");
    }
    else
    {
        unsigned long total = (end - start) / CLOCKS_PER_SEC;
        double ips = (max - min) / total;
        printf("Iterations per second: %f\n", ips);
        u_llong total_iterations = (max - min);
        printf("Total time taken for %I64u iterations: %lu seconds \n", total_iterations, total);
    }
    //...

Answer 1

unsigned long total = (end - start) / CLOCKS_PER_SEC;
double ips = (max - min) / total;

When you add an additional printf, the code happens to run for long enough so that total is not zero.

Without the printf, your code is fast enough that it executes faster then a second, so (end - start) < CLOCKS_PER_SEC. Because of that (end - start) / CLOCKS_PER_SEC is zero, total is equal to zero and when dividing by zero your program gets terminated when receiving an SIGFPE signal (arithmetic exception).

This is a perfect case to brush up your debugger skills, such case is easily detectable with a debugger.