etl::string_view odd length/size behaviour

[StaticReentrant]

I have noticed some odd behaviour with etl::string_view and the stored length of a string. Compiler is MSVC 2019 (windows simulator build of an embedded device)

#include <etl/string_view.h>
#include <cstdio>

// global string_view declaration
etl::string_view aGlobalStringView{"a_string_to_view"};

int main()
{
    // local string view declaration
    etl::string_view aLocalStringView{"a_string_to_view"};

    // these two print different lengths, global is much larger!
    printf("Global String View Length is %d\n", aGlobalStringView.length());
    printf("Local String View Length is %d\n", aLocalStringView.length());

    return 0;
}

I do not observe this behaviour with std::string_view, which outputs the same length for both. Any idea why this discrepancy should exist?

[jwellbelove]

Mmm, that's odd. I'll take a look.

[StaticReentrant]

After further investigation it looks like it could be an MSVC bug as hinted at by the following discussion: https://stackoverflow.com/questions/76546125/msvc-length-of-string-literal-appears-wrong-in-constexpr-context

I will investigate this angle, I don't think it's an issue with etl::string_view itself and it seems to work fine on clang & gcc

[jwellbelove]

If I try you example with VS2022 on Windows, and Clang 15/GCC 11 on Linux I get

Global String View Length is 16
Local String View Length is 16

What compiler are you running and on what platform?

[StaticReentrant]

Visual Studio 2019 & 2022 with the latest patched compiler versions on both. Issue is only perfectly reproducible in debug mode ("/Od") with String Pooling disabled ("/GF-") and x64 code generation (x86 works fine). I have now reproduced this with a very simplified "MyStringView" class that approximates the ETL string_view with the use of constexpr

#include <cstdio>

class MyStringView
{
public:
    constexpr MyStringView(const char* z_cstring) : mbegin(z_cstring), mend(z_cstring + calc_length(z_cstring)) {}

    constexpr size_t calc_length(const char* z_cstring)
    {
        size_t count = 0;

        if (z_cstring != nullptr)
        {
            while (*z_cstring != '\0')
            {
                count++;
                z_cstring++;
            }
        }

        return count;
    }

    constexpr size_t length() const
    {
        return static_cast<size_t>(mend - mbegin);
    }

private:
    const char* mbegin;
    const char* mend;
};

MyStringView aGlobalStringToView{ "a_string_to_view" };

int main()
{
    MyStringView aLocalStringToView{ "a_string_to_view" };
    
    printf("Length of global constant string = %zd\n", aGlobalStringToView.length());
    printf("Length of local constant string = %zd\n", aLocalStringToView.length());

    return 0;
}

Result is now

Global String View Length is 40
Local String View Length is 16