#include <cstring>
#include <cstdint>
#include <iostream>

template<typename IntegerT>
void memset_impl(IntegerT* ptr, IntegerT value, std::size_t num)
{
    for(IntegerT* end = ptr + num; ptr != end; ++ptr)
        *ptr = value;
}

void my_memset(void* ptr, std::uint8_t value, std::size_t num)
{
    std::uint8_t* data = static_cast<std::uint8_t*>(ptr);

    if(num <= sizeof(std::uint64_t) * 2)
    {
        memset_impl<std::uint8_t>(data, value, num);
    }
    else
    {
        std::size_t rest = num % sizeof(std::uint64_t);
        if(rest)
        {
            memset_impl<std::uint8_t>(data, value, rest);
            num -= rest;
            data += rest;
        }

        std::uint64_t pattern;
        auto pattern_ptr = reinterpret_cast<std::uint8_t*>(&pattern);
        memset_impl<std::uint8_t>(pattern_ptr, value, sizeof(pattern));

        auto new_ptr = reinterpret_cast<std::uint64_t*>(data);
        memset_impl<std::uint64_t>(new_ptr, pattern,
            num / sizeof(std::uint64_t));
    }
}

int main()
{
    char* huge = new char[50];
    my_memset(huge, '*', 49);
    huge[49] = 0;
    std::cout << huge;
}

Der GCC macht mit O0, O1, O2 keine Probleme, bei O3 kracht es aber. Mit Debug-Ausgaben in memset_impl nichtmal dann.
Bin gerade hundemüde, warscheinlich ist es etwas Triviales, aber wo erzeuge ich UB?

Debuggen hat mir nicht wirklich etwas gebracht. Fliegt bei einem

movdqa %xmm0,(%rcx)

in die Luf, dh. wenn der Compiler eigenständig XMM verwendet.

Danke & Grüße,
Ethon

wo erzeuge ich UB?

Hier:

auto new_ptr = reinterpret_cast<std::uint64_t*>(data);

Durch das data += rest; ist praktisch garantiert, dass data nicht richtig ausgerichtet ist. (Auch ohne das data+=rest müsste die Funktion selbst für die korrekte Ausrichtung sorgen, um allgemein einsetzbar zu sein).

auto new_ptr = reinterpret_cast<std::uint64_t*>(data);

Aber ansonsten so, wie camper es beschreibt.

(Auch ohne das data+=rest müsste die Funktion selbst für die korrekte Ausrichtung sorgen, um allgemein einsetzbar zu sein).

Das heißt wohl dass es nicht genügt rest einfach danach zu schreiben?
Was wäre denn korrekt? Mit alignof eine "Basis" für uint64 finden, Bytes bis zu dieser Basis schreiben, möglichst viele uint64s schreiben und dann den Rest wieder byteweise?