ARM32 Architecture: Bus Error When Converting Vector of Packed Structures to JSON

[sbhutch]

Description

Converting a vector of packed structures to JSON produces a bus error on arm32v7 architectures.

Reproduction steps

A minimal code example is provided below, this program features a packed structure that is not 4-byte-aligned. The program creates a vector of packed structures and attempts to convert to json via a user defined conversion function. The program was cross-compiled for a 32-bit arm system. Executing the program on said system produces a bus error during the conversion process.

Expected vs. actual results

The program should convert the vector of packed structures to JSON and print the result. A bus error occurs during the process.

Minimal code example

#include <nlohmann/json.hpp>

#include <iostream>
#include <vector>

#pragma pack(push, 1)
struct Foo {
    double bar1;
    char bar2;
};
#pragma pack(pop)

void to_json(nlohmann::json& json, const Foo& foo)
{
    json = {
        { "bar1", foo.bar1 },
        { "bar2", foo.bar2 },
    };
}

int main()
{
    std::vector<Foo> foos {
        { 1.0, 1 },
        { 2.0, 2 },
    };

    nlohmann::json json = foos;

    std::cout << json << "\n";
}

Error messages

$ ./json_test 
Bus error

Compiler and operating system

Cross compiled via arm-linux-gnueabihf-g++ for arm32v7 architecture, all systems running Ubuntu 24.04.

Library version

3.11.3

Validation

• The bug also occurs if the latest version from the develop branch is used.
• I can successfully compile and run the unit tests.

[sbhutch]

I have tested an equivalent program using boost::json and confirmed that no bus error occurs:

#include <boost/json.hpp>

#include <iostream>
#include <vector>

#pragma pack(push, 1)
struct Foo {
    double bar1;
    char bar2;
};
#pragma pack(pop)

void tag_invoke(const boost::json::value_from_tag&, boost::json::value& json, const Foo& foo)
{
    json = {
        { "bar1", foo.bar1 },
        { "bar2", foo.bar2 },
    };
}

int main(int, char**)
{
    std::vector<Foo> foos {
        { 1.0, 1 },
        { 2.0, 2 },
    };

    auto json = boost::json::value_from(foos);

    std::cout << json << "\n";
};

[gregmarr]

Which of these two lines causes the error? Can you get a stack trace?

    nlohmann::json json = foos;

    std::cout << json << "\n";

[sbhutch]

I have attached the gdb output showing the bus error and stack trace, I have used the exact minimal program posted above, so the line numbers should match. The stack trace references the minimal program twice. Once at the following line:

nlohmann::json json = foos;

and again at the closing brace of the to_json function.

stacktrace.txt

[sbhutch]

Instructions to replicate the build process, in case it is useful:

.
├── CMakeLists.txt
├── src
│   └── main.cpp
└── toolchain.cmake

CMakeLists.txt:

cmake_minimum_required(VERSION 3.10.0)
project(json_test)

include(FetchContent)

FetchContent_Declare(
    nlohmann_json
    GIT_REPOSITORY "https://github.com/nlohmann/json.git"
    GIT_TAG v3.11.3
)

FetchContent_MakeAvailable(nlohmann_json)

add_executable(
    json_test
    src/main.cpp
)

target_link_libraries(
    json_test
    PRIVATE
    nlohmann_json::nlohmann_json
)

toolchain.cmake :

set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

Build commands:

mkdir build && cd build
cmake .. -DCMAKE_TOOLCHAIN_FILE=../toolchain.cmake -DCMAKE_BUILD_TYPE=Debug
make

Compiler installed on Ubuntu 24.04:

apt install g++-arm-linux-gnueabihf

[gregmarr]

It is most likely a bus error caused by an unaligned memory access.

Here is the bottom of the call stack:

#0  nlohmann::detail::to_json_fn::operator()<json, double const&>()
#1  nlohmann::adl_serializer<double, void>::to_json<json, double const&>()
#2  json::json<>(...)                                                                                                 
#3  nlohmann::detail::json_ref<json>::json_ref<double const&, 0>(...)
#4  to_json(json, foo)

So the issue looks to be accessing the double from the packed structure inside the initializer list. You could try changing the code from this:

    json = {
        { "bar1", foo.bar1 },
        { "bar2", foo.bar2 },
    };

to this:

    json["bar1"] = foo.bar1;
    Json["bar2"] = foo.bar2;

and this is better from a performance standpoint anyway.

[sbhutch]

I agree that the bus error is most likely caused by unaligned memory access, but I believe it has something to do with the way that json manages its own memory internally. The reason i suspect this:

• No error when initialising the packed structures
• No error when reading from or writing to the packed structure members
• No error when using boost::json to perform the same action
• No error when using nlohmann::json to convert a single structure (only a vector)

While inspecting the stack trace, I notice there are some interesting memory management techniques being used. For example (17):

template<typename T, typename... Args>
JSON_HEDLEY_RETURNS_NON_NULL
static T* create(Args&& ... args)
{
    AllocatorType<T> alloc;
    using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;

    auto deleter = [&](T * obj)
    {
        AllocatorTraits::deallocate(alloc, obj, 1);
    };
    std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
    AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
    JSON_ASSERT(obj != nullptr);
    return obj.release();
}

I can also confirm that the bus error still persists with the alternative conversion logic that you suggested.

[gregmarr]

I can also confirm that the bus error still persists with the alternative conversion logic that you suggested.

Has the stack trace changed? There should be a different bus error location now, since the last 4 stack frames should have changed.

[sbhutch]

Good point, this is the updated program and stacktrace:

#include <nlohmann/json.hpp>

#include <iostream>
#include <vector>

#pragma pack(push, 1)
struct Foo {
    double bar1;
    char bar2;
};
#pragma pack(pop)

void to_json(nlohmann::json& json, const Foo& foo)
{
    json["bar1"] = foo.bar1;
    json["bar2"] = foo.bar2;
}

int main()
{
    std::vector<Foo> foos {
        { 1.0, 1 },
        { 2.0, 2 },
    };

    nlohmann::json json = foos;

    std::cout << json << "\n";
}

Entries 0 and 1 are identical in each stack trace, changing from 2 onward.

stacktrace.txt

[gregmarr]

Do either of these changes alter the behavior?

void to_json(nlohmann::json& json, const Foo& foo)
{
    double bar1 = foo.bar1;
    json["bar1"] = bar1;
    json["bar2"] = foo.bar2;
}

void to_json(nlohmann::json& json, const Foo& foo)
{
    json["bar1"] = double(foo.bar1);
    json["bar2"] = foo.bar2;
}

[t-b]

I've ran the tests on my M1 MacOSX (Darwin Thomass-Mac-Studio.local 24.3.0 Darwin Kernel Version 24.3.0: Thu Jan 2 20:24:16 PST 2025; root:xnu-11215.81.4~3/RELEASE_ARM64_T6000 arm64) and they all pass. So this must be something specific to that arch.

[sbhutch]

@gregmarr Both of the changes that you suggested work (no bus error).

[sbhutch]

@t-b I believe the issue is specific to the 32-bit arm architecture.

For what it is worth, I found that you can emulate the target architecture using multi-platform docker containers.

Instructions tested on Ubuntu 24.04:

# Start docker container using arm architecture emulation
# mount source code directory
docker run -it --rm \
    -v path/to/source:/root \
    --platform linux/arm/v7 \
    arm32v7/ubuntu:24.04

# Install build tools
apt update
apt install -y build-essential cmake git

# Build and run
cd root
mkdir build && cd build
cmake .. && make
./json_test

This will produce the bus error.

[gregmarr]

@gregmarr Both of the changes that you suggested work (no bus error).

That's good. I think it has to do with the functions taking a double & instead of a double, and the compiler thus not realizing that it was accessing an unaligned member. Without that information, it couldn't do the extra work needed to read from the structure safely.

[sbhutch]

I am happy to use this as a solution for my project. Do you think it is worth making any changes to this library to support this use case, or is it too much of an edge case?