I do have the following struct:

struct Vec(T) {
private:
  T* _ptr = null; // The pointer to the data
  u64 _cap = 0;   // Total amount of elements (not bytes) we can store

public:
  /* Create a vector by just allocating memory for it. The null terminator is not set for
     strings as, the vector is considered empty and we should  first push something to it
     in order to use it! */
  this(i64 size) {
    this._len = 0;
    this._cap = size;

    static if (is(T == char)) { size += 1; } // Additional space for the null terminator
    this._ptr = cast(T*)malloc(size);
  }
}

That's some minimal code that I do have just to showcase it. So, some times, this work will works, some others, it will give me the following error:

Fatal glibc error: malloc.c:2594 (sysmalloc): assertion failed: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)

The problem seems to happen when the pointer that is returned from malloc is assigned to the _ptr field. If I just assign it to a variable and don't assign anything to _ptr, it will work!

Is there any possible that there is a compiler bug? I do use ldc2 and betterC!

I do have the following struct:

struct Vec(T) {
private:
  T* _ptr = null; // The pointer to the data
  u64 _cap = 0;   // Total amount of elements (not bytes) we can store

public:
  /* Create a vector by just allocating memory for it. The null terminator is not set for
     strings as, the vector is considered empty and we should  first push something to it
     in order to use it! */
  this(i64 size) {
    this._len = 0;
    this._cap = size;

    static if (is(T == char)) { size += 1; } // Additional space for the null terminator
    this._ptr = cast(T*)malloc(size);
  }
}

That's some minimal code that I do have just to showcase it. So, some times, this work will works, some others, it will give me the following error:

Fatal glibc error: malloc.c:2594 (sysmalloc): assertion failed: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)

The problem seems to happen when the pointer that is returned from malloc is assigned to the _ptr field. If I just assign it to a variable and don't assign anything to _ptr, it will work!

Is there any possible that there is a compiler bug? I do use ldc2 and betterC!

Hard to tell from that code but it is quite unlikely there is a compiler bug in such simple use case.

I assume you already tried debugging your program, right?

So how about to diagnose a bit more, what if you enforce check before malloc that size>0,

and second - from that example it is unclear how you are using that struct, so maybe add else statement static assert to see if it is misused somewhere else in your codebase?

Also this example doesn't have len field, depending on how you use with regard to cap this could be a source of problems too.

Hello, not completely unrelated to your problem, I have also done something like that, and when you're in D, don't use simply a pointer and length like that, use the slice operator.

See references:

https://tour.dlang.org/tour/en/basics/slices
https://dlang.org/spec/operatoroverloading.html#array-ops

For example, you can make your pointer a lot safer by doing:

size_t length = 5;
int* pointer = cast(int*)malloc(int.sizeof * length); //Don't
int[] mallocArray = (cast(int*)malloc(int.sizeof * length))[0..length]; //Do

On the second way, you'll get bound checks, thus, making it safer. Also, no need to keep track of your length separately anymore.

This is good practice in D language and you'll find yourself using this instead in the future.

And yes, this works in betterC, it is a simple runtime check, completely @nogc @safe nothrow and every other kind of thing you would want.

That's interesting, I wasn't able to find something else! The bug happens when I run the testing suit and well... the tests before pass so I cannot find anything that goes wrong except for the fact that I do not free the memory that is allocated (on purpose).

I do have the following struct:

struct Vec(T) {
private:
  T* _ptr = null; // The pointer to the data
  u64 _cap = 0;   // Total amount of elements (not bytes) we can store

public:
  /* Create a vector by just allocating memory for it. The null terminator is not set for
     strings as, the vector is considered empty and we should  first push something to it
     in order to use it! */
  this(i64 size) {
    this._len = 0;
    this._cap = size;

    static if (is(T == char)) { size += 1; } // Additional space for the null terminator
    this._ptr = cast(T*)malloc(size);
  }
}

That's some minimal code that I do have just to showcase it. So, some times, this work will works, some others, it will give me the following error:

Fatal glibc error: malloc.c:2594 (sysmalloc): assertion failed: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)

The problem seems to happen when the pointer that is returned from malloc is assigned to the _ptr field. If I just assign it to a variable and don't assign anything to _ptr, it will work!

Is there any possible that there is a compiler bug? I do use ldc2 and betterC!

You run with -unittest compiler flag? Well, that does nothing for me with betterc (without it is ok).

I did stupid and unsafe things like malloc(0) and writing out of bounds but still no crash, it works fine.

I guess it depends on your libc, tested this on ubuntu 23.04 with gcc12 install and ldc 1.32.2

import core.stdc.stdlib;
import core.stdc.stdio;

alias u64 = ulong;
alias i64 = long;

struct Vec(T) {
private:
  T* _ptr = null; // The pointer to the data
  u64 _cap = 0;   // Total amount of elements (not bytes) we can store
  u64 _len = 0;

public:
  /* Create a vector by just allocating memory for it. The null terminator is not set for
     strings as, the vector is considered empty and we should  first push something to it
     in order to use it! */
  this(i64 size) {
    this._len = 0;
    this._cap = size;

    static if (is(T == char)) { size += 1; } // Additional space for the null terminator
    this._ptr = cast(T*)malloc(size);
  }

  ref T opIndex(size_t idx) { return _ptr[idx]; }
}

extern(C)
void main()
//unittest
{
    enum el = 3;
    auto vec = Vec!char(10);
    assert(vec._ptr);
    vec[el] = 'h';
    assert(vec[el] == 'h');
    printf("ptr = %p\n", vec._ptr);
    printf("vec ptr = %p\n", &vec[el]);
    printf("vec local = %p\n", &vec);
    printf("vec[%d] = %c\n", el, vec[el]);
    foreach (i; 0..vec._cap) {
      printf("-");
    }
    printf("\n");
    foreach (i; 0..vec._cap) {
      printf("%d", vec[i]);
    }
    printf("\n");
    printf("run ok\n");
}

ldc2 -betterC -run membug.d

output

ptr = 0x55cb701de2a0
vec ptr = 0x55cb701de2a3
vec local = 0x7fffa1542258
vec[3] = h
----------
000104000000
run ok

In case you didn't know, all you need to get unittests working in -betterC is:

			foreach (module_; allModules) {
				foreach (unitTest; __traits(getUnitTests, module_)) {
					unitTest();
				}
			}

You'd need to provide allModules somehow, like dub does.

https://github.com/dlang/dub/blob/2ea883833adf085095b07a7dba8250fb3db79a71/source/dub/project.d#L1937