Create a separate type vector

The new type vector uses bytes for generic types.

Signed-off-by: Zoltan Herczeg [email protected]

Author: zherczeg

src/api/wasm.cpp

@@ -505,7 +505,7 @@ static void FromWalrusValueTypes(const TypeVector& types, wasm_valtype_vec_t* ou
 {
     wasm_valtype_vec_new_uninitialized(out, types.size());
     for (size_t i = 0; i < types.size(); i++) {
-        out->data[i] = wasm_valtype_new(FromWalrusValueType(types[i]));
+        out->data[i] = wasm_valtype_new(FromWalrusValueType(types.types()[i]));
     }
 }
 
@@ -903,16 +903,14 @@ own wasm_module_t* wasm_module_deserialize(wasm_store_t*, const wasm_byte_vec_t*
 // Function Instances
 static FunctionType* ToWalrusFunctionType(const wasm_functype_t* ft)
 {
-    TypeVector* params = new TypeVector();
-    TypeVector* results = new TypeVector();
-    params->reserve(ft->params.size);
-    results->reserve(ft->results.size);
+    TypeVector* params = new TypeVector(ft->params.size, 0);
+    TypeVector* results = new TypeVector(ft->results.size, 0);
 
     for (uint32_t i = 0; i < ft->params.size; i++) {
-        params->push_back(ft->params.data[i]->type);
+        params->setType(i, ft->params.data[i]->type);
     }
     for (uint32_t i = 0; i < ft->results.size; i++) {
-        results->push_back(ft->results.data[i]->type);
+        results->setType(i, ft->results.data[i]->type);
     }
 
     return new FunctionType(params, results);

src/interpreter/Interpreter.cpp

@@ -2223,7 +2223,7 @@ ByteCodeStackOffset* Interpreter::interpret(ExecutionState& state,
         userExceptionData.resizeWithUninitializedValues(sz);
 
         uint8_t* ptr = userExceptionData.data();
-        auto& param = tag->functionType()->param();
+        auto& param = tag->functionType()->param().types();
         for (size_t i = 0; i < param.size(); i++) {
             auto sz = valueStackAllocatedSize(param[i]);
             memcpy(ptr, bp + code->dataOffsets()[i], sz);

src/jit/Analysis.cpp

@@ -97,7 +97,7 @@ void DependencyGenContext::update(size_t dependencyStart, size_t id, size_t excl
            && (dependencyStart % size) == 0
            && maxDistance[dependencyStart / size] <= id);
 
-    for (auto it : param) {
+    for (auto it : param.types()) {
         if (variableList != nullptr) {
             // Construct new variables.
             VariableRef ref = variableList->variables.size();
@@ -520,7 +520,7 @@ void JITCompiler::buildVariables(uint32_t requiredStackSize)
 
         size_t id = instr->id();
 
-        for (auto it : functionType->result()) {
+        for (auto it : functionType->result().types()) {
             VariableRef ref = VARIABLE_SET(m_variableList->variables.size(), DependencyGenContext::Variable);
             uint32_t typeInfo = Instruction::valueTypeToOperandType(it);
 
@@ -700,7 +700,7 @@ void JITCompiler::buildVariables(uint32_t requiredStackSize)
             } else {
                 switch (instr->opcode()) {
                 case ByteCode::StructNewOpcode: {
-                    for (auto it : reinterpret_cast<StructNew*>(instr->byteCode())->typeInfo()->fields()) {
+                    for (auto it : reinterpret_cast<StructNew*>(instr->byteCode())->typeInfo()->fields().types()) {
                         VariableList::Variable& variable = m_variableList->variables[*param++];
                         variable.info |= Instruction::valueTypeToOperandType(Value::unpackType(it.type()));
                     }
@@ -790,7 +790,7 @@ void JITCompiler::buildVariables(uint32_t requiredStackSize)
                     }
                     }
 
-                    for (auto it : *types) {
+                    for (auto it : types->types()) {
                         VariableList::Variable& variable = m_variableList->variables[*param++];
                         variable.info |= Instruction::valueTypeToOperandType(it);
                     }

src/jit/Backend.cpp

@@ -703,7 +703,7 @@ static void emitImmediate(sljit_compiler* compiler, Instruction* instr)
 
 static ByteCodeStackOffset* emitStoreOntoStack(sljit_compiler* compiler, Operand* param, ByteCodeStackOffset* stackOffset, const TypeVector& types, bool isWordOffsets)
 {
-    for (auto it : types) {
+    for (auto it : types.types()) {
         Operand dst = VARIABLE_SET(STACK_OFFSET(*stackOffset), Instruction::Offset);
 
         switch (VARIABLE_TYPE(*param)) {

src/jit/ByteCodeParser.cpp

@@ -93,7 +93,7 @@ static void buildCatchInfo(JITCompiler* compiler, ModuleFunction* function, std:
 
 static bool isFloatGlobal(uint32_t globalIndex, Module* module)
 {
-    Value::Type type = module->globalType(globalIndex)->type();
+    Value::Type type = module->globalType(globalIndex)->type().type();
 
     return type == Value::F32 || type == Value::F64;
 }
@@ -1146,7 +1146,7 @@ static void compileFunction(JITCompiler* compiler)
             Operand* operand = instr->operands();
             instr->addInfo(Instruction::kIsCallback | Instruction::kFreeUnusedEarly);
 
-            for (auto it : functionType->param()) {
+            for (auto it : functionType->param().types()) {
                 *operand++ = STACK_OFFSET(*stackOffset);
                 stackOffset += (valueSize(it) + (sizeof(size_t) - 1)) / sizeof(size_t);
             }
@@ -1157,7 +1157,7 @@ static void compileFunction(JITCompiler* compiler)
                 *operand++ = STACK_OFFSET(reinterpret_cast<CallRef*>(byteCode)->calleeOffset());
             }
 
-            for (auto it : functionType->result()) {
+            for (auto it : functionType->result().types()) {
                 *operand++ = STACK_OFFSET(*stackOffset);
                 stackOffset += (valueSize(it) + (sizeof(size_t) - 1)) / sizeof(size_t);
             }
@@ -2066,7 +2066,7 @@ static void compileFunction(JITCompiler* compiler)
             Operand* param = instr->params();
             ByteCodeStackOffset* offsets = reinterpret_cast<End*>(byteCode)->resultOffsets();
 
-            for (auto it : result) {
+            for (auto it : result.types()) {
                 *param++ = STACK_OFFSET(*offsets);
                 offsets += (valueSize(it) + (sizeof(size_t) - 1)) / sizeof(size_t);
             }

src/jit/CallInl.h

@@ -182,7 +182,7 @@ static void emitCall(sljit_compiler* compiler, Instruction* instr)
 
     sljit_jump* jump = sljit_emit_cmp(compiler, SLJIT_NOT_EQUAL, SLJIT_R0, 0, SLJIT_IMM, ExecutionContext::NoError);
 
-    for (auto it : functionType->result()) {
+    for (auto it : functionType->result().types()) {
         ASSERT(VARIABLE_TYPE(*operand) != Instruction::ConstPtr);
 
         if (VARIABLE_TYPE(*operand) == Instruction::Register) {

src/jit/GarbageCollectorInl.h

@@ -1022,7 +1022,7 @@ static void emitGCStructNew(sljit_compiler* compiler, Instruction* instr)
     ByteCodeStackOffset* stackOffset = structNew->dataOffsets();
     Operand* param = instr->params();
 
-    for (auto it : structNew->typeInfo()->fields()) {
+    for (auto it : structNew->typeInfo()->fields().types()) {
         emitGCStore(compiler, *stackOffset++, param++, it.type());
     }
 

src/jit/TryCatchInl.h

@@ -232,7 +232,7 @@ static void throwWithArgs(Throw* throwTag, uint8_t* bp, ExecutionContext* contex
     userExceptionData.resizeWithUninitializedValues(sz);
 
     uint8_t* ptr = userExceptionData.data();
-    auto& param = tag->functionType()->param();
+    auto& param = tag->functionType()->param().types();
     for (size_t i = 0; i < param.size(); i++) {
         auto sz = valueStackAllocatedSize(param[i]);
         memcpy(ptr, bp + throwTag->dataOffsets()[i], sz);