stack dump while using malloc

Here is my program

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{ 
    char * pt[3];
    size_t size = sizeof(char);


    pt[0] = (char *) malloc(60 * size);
    pt[1] = (char *) malloc(60 * size);
    pt[2] = (char *) malloc(60 * size);

    pt[0] = "Earth";
    puts(pt[0]);

    puts("===================================\n");

    pt[1] = "University";
    puts(pt[1]);

    puts("===================================\n");

    pt[2] = "Things are very interesting!";
    puts(pt[2]);

    puts("===================================\n");

    for (int i = 0; i < 3; i++)
    {
        free(pt[i]);
    }
    

    return 0;
}

Now, program prints as expected. But there is some error at the end

cygwin_exception::open_stackdumpfile: Dumping stack trace to a.exe.stackdump

I tried to put some printf statements and I found that free statement is creating some error. What could be the problem ?

You're not freeing the same pointers you allocated, because a statement like pt[0] = "Earth"; is overwriting the address in pt[0] with the address of the hard-coded string "Earth".

So by the time that free runs in your code, it tries to deallocate the wrong memory address.

At that point, either free was coded to check for this possibility and it deliberately crashed the program instead of doing bad things, or free tried to trustingly do things that it wasn't supposed to based on the address you gave it, and got killed by modern safety features of the OS (for example, when a program runs, modern operating systems will load hard-coded strings into a memory page marked read-only, so the program gets a fatal-by-default signal if it tries to write there).

Why would free do stuff it wasn't supposed to do when given a bad address? Because one way that memory allocators have been traditionally written is to allocate slightly larger chunks then you asked for and store metadata for that allocation at the front of that space, and/or to write metadata needed for reusing that memory into the space once you've freed it. In allocators like that, every free leads to some memory being overwritten near the address you gave it. This kind of design has led to many bugs and exploitable security vulnerabilities in code, but last I checked it persists in some C implementations.

Now onto your bigger-picture goal:

You were seemingly expecting = to copy the characters from one location to the other. This can make sense when coming from higher-level languages, but C doesn't have such syntactic sugar. Instead, in C, = on a memory address ("pointer") copies the memory address.

It's also probably not obvious, but in C, a string literal expression mostly works like a pointer - the type of the expression "Earth" is actually char *.

Anyway, as others have pointer out, you would use a function like strcpy to copy the characters from "Earth" into the newly-allocated storage. You could also copy the characters yourself with a loop, but this isn't recommended in most cases because the standard library implementation: says what you mean in a way that C devs can immediately understand; might be optimized to perform better than a naive byte-by-byte loop, and; might be understood by your compiler's optimizer passes.

Since constant string store in program data segment read-only arena and you can't just free it!!
use strcpy to copy str to your allocated memory instead

Understanding application binary segement is really important
in c, have these segments :

Stack
Heap
BSS (Uninitialized Data Segment)
Data ( has initialized read-only and initialized read-write area)
Code (contains executable instructions)

Most likely, the program is attempting to release memory that has already been released or memory that was not dynamically allocated using the malloc function . To resolve this problem, use a method like strcpy() to copy the contents of the string literals into the memory allotted by malloc() .