Struct operations in Javascript through Emscripten

Question

I am having quite a lot of problems with emscripten inter-operating between C and Javascript.

More specifically, I am having trouble accessing a struct created in C in javascript, given that the pointer to the struct is passed into javascript as an external library.

Take a look at the following code:

C:

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

struct test_st;

extern void read_struct(struct test_st *mys, int siz);

struct test_st{
    uint32_t my_number;
    uint8_t my_char_array[32];
};

int main(){
    struct test_st *teststr = malloc(sizeof(struct test_st));
    teststr->my_number = 500;
    for(int i = 0; i < 32; i++){
        teststr->my_char_array[i] = 120 + i;
    }
    for(int i = 0; i < 32; i++){
        printf("%d\n",teststr->my_char_array[i]);
    }
    read_struct(teststr,sizeof(teststr));
    return 0;
}

Javascript:

mergeInto(LibraryManager.library,
    {
        read_struct: function(mys,siz){
            var read_ptr = 0;
            console.log("my_number: " + getValue(mys + read_ptr, 'i32'));
            read_ptr += 4;
            for(var i = 0; i < 32; i++){
                console.log("my_char[" + i + "]: " + getValue(mys + read_ptr, 'i8'));
                read_ptr += 1;
            };
        },
    });

This is then compiled using emcc cfile.c --js-library jsfile.js.

The issue here is that you can't really read structs in javascript, you have to get memory from the respective addresses according to the size of the struct field (so read 4 bytes from the uint32_t and 1 byte from the uint8_t). Ok, that wouldn't be an issue, except you also have to state the LLVM IR type for getValue to work, and it doesn't include unsigned types, so in the case of the array, it will get to 127 and overflow to -128, when the intended behaviour is to keep going up, since the variable is unsigned.

I looked everywhere for an answer but apparently this specific intended behaviour is not common. Changing the struct wouldn't be possible in the program I'm applying this to (not the sample one above).

Answer 1

One way is to use the HEAP* typed arrays exposed by Emscripten, which do have unsigned views:

mergeInto(LibraryManager.library, {
  read_struct: function(myStructPointer, size) {
    // Assumes the struct starts on a 4-byte boundary
    var myNumber = HEAPU32[myStructPointer/4];
    console.log(myNumber);
    // Assumes my_char_array is immediately after my_number with no padding
    var myCharArray = HEAPU8.subarray(myStructPointer+4, myStructPointer+4+32);
    console.log(myCharArray);
  }
});

This works in my test, running Emscripten 1.29.0-64bit, but as noted it makes assumptions about alignment/padding. The cases I tested seemed to show that a struct seemed to always start on a 4 byte boundary, and that 32 bit unsigned integers inside a struct were also always aligned on a 4 byte boundary, and so accessible by HEAPU32.

However, it's beyond my knowledge to know if you can depend on this behaviour in Emscripten. It's my understanding that you can't in usual C/C++ world.