Runtime Namespace Reference

Classes
struct	Exception
struct	FunctionInstance
struct	GCGlobals
struct	GCObject
struct	GlobalInstance
struct	ImportBindings
struct	IntrinsicResolver
struct	LazyResolver
struct	LinkResult
struct	MemoryInstance
struct	ModuleExportResolver
struct	ModuleInstance
struct	NullResolver
struct	ObjectInstance
struct	Resolver
struct	Result
struct	TableInstance
struct	UntaggedValue
struct	Value

Functions
RUNTIME_API LinkResult	linkModule (const IR::Module &module, Resolver &resolver)
RUNTIME_API void	init ()
const char *	describeExceptionCause (Exception::Cause cause)
RUNTIME_API void	causeException (Exception::Cause cause)
RUNTIME_API bool	isA (ObjectInstance *object, const IR::ObjectType &type)
FunctionInstance *	asFunction (ObjectInstance *object)
TableInstance *	asTable (ObjectInstance *object)
MemoryInstance *	asMemory (ObjectInstance *object)
GlobalInstance *	asGlobal (ObjectInstance *object)
ModuleInstance *	asModule (ObjectInstance *object)
template<typename Instance >
Instance *	as (ObjectInstance *object)
template<>
FunctionInstance *	as< FunctionInstance > (ObjectInstance *object)
template<>
TableInstance *	as< TableInstance > (ObjectInstance *object)
template<>
MemoryInstance *	as< MemoryInstance > (ObjectInstance *object)
template<>
GlobalInstance *	as< GlobalInstance > (ObjectInstance *object)
template<>
ModuleInstance *	as< ModuleInstance > (ObjectInstance *object)
ObjectInstance *	asObject (FunctionInstance *function)
ObjectInstance *	asObject (TableInstance *table)
ObjectInstance *	asObject (MemoryInstance *memory)
ObjectInstance *	asObject (GlobalInstance *global)
ObjectInstance *	asObject (ModuleInstance *module)
FunctionInstance *	asFunctionNullable (ObjectInstance *object)
TableInstance *	asTableNullable (ObjectInstance *object)
MemoryInstance *	asMemoryNullable (ObjectInstance *object)
GlobalInstance *	asGlobalNullable (ObjectInstance *object)
ModuleInstance *	asModuleNullable (ObjectInstance *object)
RUNTIME_API void	freeUnreferencedObjects (std::vector< ObjectInstance * > &&rootObjectReferences)
RUNTIME_API Result	invokeFunction (FunctionInstance *function, const std::vector< Value > &parameters)
RUNTIME_API const IR::FunctionType *	getFunctionType (FunctionInstance *function)
RUNTIME_API TableInstance *	createTable (IR::TableType type)
RUNTIME_API ObjectInstance *	getTableElement (TableInstance *table, Uptr index)
RUNTIME_API ObjectInstance *	setTableElement (TableInstance *table, Uptr index, ObjectInstance *newValue)
RUNTIME_API Uptr	getTableNumElements (TableInstance *table)
RUNTIME_API Uptr	getTableMaxElements (TableInstance *table)
RUNTIME_API Iptr	growTable (TableInstance *table, Uptr numElements)
RUNTIME_API Iptr	shrinkTable (TableInstance *table, Uptr numElements)
RUNTIME_API MemoryInstance *	createMemory (IR::MemoryType type)
RUNTIME_API U8 *	getMemoryBaseAddress (MemoryInstance *memory)
RUNTIME_API Uptr	getMemoryNumPages (MemoryInstance *memory)
RUNTIME_API Uptr	getMemoryMaxPages (MemoryInstance *memory)
RUNTIME_API Iptr	growMemory (MemoryInstance *memory, Uptr numPages)
RUNTIME_API Iptr	shrinkMemory (MemoryInstance *memory, Uptr numPages)
RUNTIME_API U8 *	getValidatedMemoryOffsetRange (MemoryInstance *memory, Uptr offset, Uptr numBytes)
template<typename Value >
Value &	memoryRef (MemoryInstance *memory, U32 offset)
template<typename Value >
Value *	memoryArrayPtr (MemoryInstance *memory, U32 offset, U32 numElements)
RUNTIME_API GlobalInstance *	createGlobal (IR::GlobalType type, Value initialValue)
RUNTIME_API Value	getGlobalValue (GlobalInstance *global)
RUNTIME_API Value	setGlobalValue (GlobalInstance *global, Value newValue)
RUNTIME_API ModuleInstance *	instantiateModule (const IR::Module &module, ImportBindings &&imports)
RUNTIME_API MemoryInstance *	getDefaultMemory (ModuleInstance *moduleInstance)
RUNTIME_API uint64_t	getDefaultMemorySize (ModuleInstance *moduleInstance)
RUNTIME_API TableInstance *	getDefaultTable (ModuleInstance *moduleInstance)
RUNTIME_API void	runInstanceStartFunc (ModuleInstance *moduleInstance)
RUNTIME_API void	resetGlobalInstances (ModuleInstance *moduleInstance)
RUNTIME_API void	resetMemory (MemoryInstance *memory, IR::MemoryType &newMemoryType)
RUNTIME_API ObjectInstance *	getInstanceExport (ModuleInstance *moduleInstance, const std::string &name)
bool	areBitsEqual (IR::ResultType type, UntaggedValue a, UntaggedValue b)
bool	areBitsEqual (const Value &a, const Value &b)
bool	areBitsEqual (const Result &a, const Result &b)
bool	areBitsEqual (const Result &a, const Value &b)
bool	areBitsEqual (const Value &a, const Result &b)
const FunctionType *	resolveImportType (const IR::Module &module, IndexedFunctionType type)
TableType	resolveImportType (const IR::Module &module, TableType type)
MemoryType	resolveImportType (const IR::Module &module, MemoryType type)
GlobalType	resolveImportType (const IR::Module &module, GlobalType type)
template<typename Instance , typename Type >
void	linkImport (const IR::Module &module, const Import< Type > &import, Resolver &resolver, LinkResult &linkResult, std::vector< Instance * > &resolvedImports)
void	getThreadGCRoots (std::vector< ObjectInstance * > &outGCRoots)

Function Documentation

areBitsEqual() [1/5]

bool Runtime::areBitsEqual ( const Result & a, const Result & b )

inline

Definition at line 127 of file TaggedValue.h.

{ return a.type == b.type && areBitsEqual(a.type,a,b); }

Here is the call graph for this function:

areBitsEqual() [2/5]

bool Runtime::areBitsEqual ( const Result & a, const Value & b )

inline

Definition at line 128 of file TaggedValue.h.

{ return a.type == asResultType(b.type) && areBitsEqual(a.type,a,b); }

Here is the call graph for this function:

areBitsEqual() [3/5]

bool Runtime::areBitsEqual ( const Value & a, const Result & b )

inline

Definition at line 129 of file TaggedValue.h.

{ return asResultType(a.type) == b.type && areBitsEqual(b.type,a,b); }

Here is the call graph for this function:

areBitsEqual() [4/5]

bool Runtime::areBitsEqual ( const Value & a, const Value & b )

inline

Definition at line 126 of file TaggedValue.h.

{ return a.type == b.type && areBitsEqual(asResultType(a.type),a,b); }

Here is the call graph for this function:

areBitsEqual() [5/5]

bool Runtime::areBitsEqual ( IR::ResultType type, UntaggedValue a, UntaggedValue b )

inline

Definition at line 109 of file TaggedValue.h.

    {
        switch(type)
        {
        case IR::ResultType::i32:
        case IR::ResultType::f32: return a.i32 == b.i32;
        case IR::ResultType::i64:
        case IR::ResultType::f64: return a.i64 == b.i64;
        #if ENABLE_SIMD_PROTOTYPE
        case IR::ResultType::v128: return a.v128.u64[0] == b.v128.u64[0] && a.v128.u64[1] == b.v128.u64[1];
        #endif
        case IR::ResultType::none: return true;
        default: Errors::unreachable();
        };
    }

Here is the call graph for this function:

Here is the caller graph for this function:

as()

template<typename Instance >

Instance * Runtime::as

(

ObjectInstance *

object

)

Here is the caller graph for this function:

as< FunctionInstance >()

template<>

FunctionInstance * Runtime::as< FunctionInstance > ( ObjectInstance * object )

inline

Definition at line 97 of file Runtime.h.

{ return asFunction(object); }

Here is the call graph for this function:

as< GlobalInstance >()

template<>

GlobalInstance * Runtime::as< GlobalInstance > ( ObjectInstance * object )

inline

Definition at line 100 of file Runtime.h.

{ return asGlobal(object); }

Here is the call graph for this function:

as< MemoryInstance >()

template<>

MemoryInstance * Runtime::as< MemoryInstance > ( ObjectInstance * object )

inline

Definition at line 99 of file Runtime.h.

{ return asMemory(object); }

Here is the call graph for this function:

as< ModuleInstance >()

template<>

ModuleInstance * Runtime::as< ModuleInstance > ( ObjectInstance * object )

inline

Definition at line 101 of file Runtime.h.

{ return asModule(object); }

Here is the call graph for this function:

as< TableInstance >()

template<>

TableInstance * Runtime::as< TableInstance > ( ObjectInstance * object )

inline

Definition at line 98 of file Runtime.h.

{ return asTable(object); }

Here is the call graph for this function:

asFunction()

FunctionInstance * Runtime::asFunction ( ObjectInstance * object )

inline

Definition at line 90 of file Runtime.h.

{ WAVM_ASSERT_THROW(object && object->kind == IR::ObjectKind::function); return (FunctionInstance*)object; }

Here is the caller graph for this function:

asFunctionNullable()

FunctionInstance * Runtime::asFunctionNullable ( ObjectInstance * object )

inline

Definition at line 110 of file Runtime.h.

{ return object && object->kind == IR::ObjectKind::function ? (FunctionInstance*)object : nullptr; }

asGlobal()

GlobalInstance * Runtime::asGlobal ( ObjectInstance * object )

inline

Definition at line 93 of file Runtime.h.

{ WAVM_ASSERT_THROW(object && object->kind == IR::ObjectKind::global); return (GlobalInstance*)object; }

Here is the caller graph for this function:

asGlobalNullable()

GlobalInstance * Runtime::asGlobalNullable ( ObjectInstance * object )

inline

Definition at line 113 of file Runtime.h.

{ return object && object->kind == IR::ObjectKind::global ? (GlobalInstance*)object : nullptr; }

asMemory()

MemoryInstance * Runtime::asMemory ( ObjectInstance * object )

inline

Definition at line 92 of file Runtime.h.

{ WAVM_ASSERT_THROW(object && object->kind == IR::ObjectKind::memory); return (MemoryInstance*)object; }

Here is the caller graph for this function:

asMemoryNullable()

MemoryInstance * Runtime::asMemoryNullable ( ObjectInstance * object )

inline

Definition at line 112 of file Runtime.h.

{ return object && object->kind == IR::ObjectKind::memory ? (MemoryInstance*)object : nullptr; }

asModule()

ModuleInstance * Runtime::asModule ( ObjectInstance * object )

inline

Definition at line 94 of file Runtime.h.

{ WAVM_ASSERT_THROW(object && object->kind == IR::ObjectKind::module); return (ModuleInstance*)object; }

Here is the caller graph for this function:

asModuleNullable()

ModuleInstance * Runtime::asModuleNullable ( ObjectInstance * object )

inline

Definition at line 114 of file Runtime.h.

{ return object && object->kind == IR::ObjectKind::module ? (ModuleInstance*)object : nullptr; }

asObject() [1/5]

ObjectInstance * Runtime::asObject ( FunctionInstance * function )

inline

Definition at line 103 of file Runtime.h.

{ return (ObjectInstance*)function; }

asObject() [2/5]

ObjectInstance * Runtime::asObject ( GlobalInstance * global )

inline

Definition at line 106 of file Runtime.h.

{ return (ObjectInstance*)global; }

asObject() [3/5]

ObjectInstance * Runtime::asObject ( MemoryInstance * memory )

inline

Definition at line 105 of file Runtime.h.

{ return (ObjectInstance*)memory; }

asObject() [4/5]

ObjectInstance * Runtime::asObject ( ModuleInstance * module )

inline

Definition at line 107 of file Runtime.h.

{ return (ObjectInstance*)module; }

asObject() [5/5]

ObjectInstance * Runtime::asObject ( TableInstance * table )

inline

Definition at line 104 of file Runtime.h.

{ return (ObjectInstance*)table; }

asTable()

TableInstance * Runtime::asTable ( ObjectInstance * object )

inline

Definition at line 91 of file Runtime.h.

{ WAVM_ASSERT_THROW(object && object->kind == IR::ObjectKind::table); return (TableInstance*)object; }

Here is the caller graph for this function:

asTableNullable()

TableInstance * Runtime::asTableNullable ( ObjectInstance * object )

inline

Definition at line 111 of file Runtime.h.

{ return object && object->kind == IR::ObjectKind::table ? (TableInstance*)object : nullptr; }

causeException()

RUNTIME_API void Runtime::causeException

(

Exception::Cause

cause

)

createGlobal()

RUNTIME_API GlobalInstance * Runtime::createGlobal	(	IR::GlobalType	type,
		Value	initialValue )

createMemory()

RUNTIME_API MemoryInstance * Runtime::createMemory

(

IR::MemoryType

type

)

createTable()

RUNTIME_API TableInstance * Runtime::createTable

(

IR::TableType

type

)

describeExceptionCause()

const char * Runtime::describeExceptionCause ( Exception::Cause cause )

inline

Definition at line 45 of file Runtime.h.

    {
        switch(cause)
        {
        case Exception::Cause::accessViolation: return "access violation";
        case Exception::Cause::stackOverflow: return "stack overflow";
        case Exception::Cause::integerDivideByZeroOrIntegerOverflow: return "integer divide by zero or signed integer overflow";
        case Exception::Cause::invalidFloatOperation: return "invalid floating point operation";
        case Exception::Cause::invokeSignatureMismatch: return "invoke signature mismatch";
        case Exception::Cause::reachedUnreachable: return "reached unreachable code";
        case Exception::Cause::indirectCallSignatureMismatch: return "call_indirect to function with wrong signature";
        case Exception::Cause::undefinedTableElement: return "undefined function table element";
        case Exception::Cause::calledAbort: return "called abort";
        case Exception::Cause::calledUnimplementedIntrinsic: return "called unimplemented intrinsic";
        case Exception::Cause::outOfMemory: return "out of memory";
        case Exception::Cause::invalidSegmentOffset: return "invalid segment offset";
        case Exception::Cause::misalignedAtomicMemoryAccess: return "misaligned atomic memory access";
        default: return "unknown";
        }
    }

freeUnreferencedObjects()

void Runtime::freeUnreferencedObjects

(

std::vector< ObjectInstance * > &&

rootObjectReferences

)

Definition at line 38 of file ObjectGC.cpp.

    {
        std::set<ObjectInstance*> referencedObjects;
        std::vector<ObjectInstance*> pendingScanObjects;
 
        // Initialize the referencedObjects set from the rootObjectReferences and intrinsic objects.
        for(auto object : rootObjectReferences)
        {
            if(object && !referencedObjects.count(object))
            {
                referencedObjects.insert(object);
                pendingScanObjects.push_back(object);
            }
        }
 
        const std::vector<ObjectInstance*> intrinsicObjects = Intrinsics::getAllIntrinsicObjects();
        for(auto object : intrinsicObjects)
        {
            if(object && !referencedObjects.count(object))
            {
                referencedObjects.insert(object);
                pendingScanObjects.push_back(object);
            }
        }
 
        // Scan the objects added to the referenced set so far: gather their child references and recurse.
        while(pendingScanObjects.size())
        {
            ObjectInstance* scanObject = pendingScanObjects.back();
            pendingScanObjects.pop_back();
 
            // Gather the child references for this object based on its kind.
            std::vector<ObjectInstance*> childReferences;
            switch(scanObject->kind)
            {
            case ObjectKind::function:
            {
                FunctionInstance* function = asFunction(scanObject);
                childReferences.push_back(function->moduleInstance);
                break;
            }
            case ObjectKind::module:
            {
                ModuleInstance* moduleInstance = asModule(scanObject);
                childReferences.insert(childReferences.begin(),moduleInstance->functionDefs.begin(),moduleInstance->functionDefs.end());
                childReferences.insert(childReferences.begin(),moduleInstance->functions.begin(),moduleInstance->functions.end());
                childReferences.insert(childReferences.begin(),moduleInstance->tables.begin(),moduleInstance->tables.end());
                childReferences.insert(childReferences.begin(),moduleInstance->memories.begin(),moduleInstance->memories.end());
                childReferences.insert(childReferences.begin(),moduleInstance->globals.begin(),moduleInstance->globals.end());
                childReferences.push_back(moduleInstance->defaultMemory);
                childReferences.push_back(moduleInstance->defaultTable);
                break;
            }
            case ObjectKind::table:
            {
                TableInstance* table = asTable(scanObject);
                childReferences.insert(childReferences.end(),table->elements.begin(),table->elements.end());
                break;
            }
            case ObjectKind::memory:
            case ObjectKind::global: break;
            default: Errors::unreachable();
            };
 
            // Add the object's child references to the referenced set, and enqueue them for scanning.
            for(auto reference : childReferences)
            {
                if(reference && !referencedObjects.count(reference))
                {
                    referencedObjects.insert(reference);
                    pendingScanObjects.push_back(reference);
                }
            }
        };
 
        // Iterate over all objects, and delete objects that weren't referenced directly or indirectly by the root set.
        GCGlobals& gcGlobals = GCGlobals::get();
        auto objectIt = gcGlobals.allObjects.begin();
        while(objectIt != gcGlobals.allObjects.end())
        {
            if(referencedObjects.count(*objectIt)) { ++objectIt; }
            else
            {
                ObjectInstance* object = *objectIt;
                objectIt = gcGlobals.allObjects.erase(objectIt);
                delete object;
            }
        }
    }

Here is the call graph for this function:

getDefaultMemory()

RUNTIME_API MemoryInstance * Runtime::getDefaultMemory

(

ModuleInstance *

moduleInstance

)

getDefaultMemorySize()

RUNTIME_API uint64_t Runtime::getDefaultMemorySize

(

ModuleInstance *

moduleInstance

)

getDefaultTable()

RUNTIME_API TableInstance * Runtime::getDefaultTable

(

ModuleInstance *

moduleInstance

)

getFunctionType()

RUNTIME_API const IR::FunctionType * Runtime::getFunctionType

(

FunctionInstance *

function

)

getGlobalValue()

RUNTIME_API Value Runtime::getGlobalValue

(

GlobalInstance *

global

)

getInstanceExport()

RUNTIME_API ObjectInstance * Runtime::getInstanceExport	(	ModuleInstance *	moduleInstance,
		const std::string &	name )

getMemoryBaseAddress()

RUNTIME_API U8 * Runtime::getMemoryBaseAddress

(

MemoryInstance *

memory

)

getMemoryMaxPages()

RUNTIME_API Uptr Runtime::getMemoryMaxPages

(

MemoryInstance *

memory

)

getMemoryNumPages()

RUNTIME_API Uptr Runtime::getMemoryNumPages

(

MemoryInstance *

memory

)

getTableElement()

RUNTIME_API ObjectInstance * Runtime::getTableElement	(	TableInstance *	table,
		Uptr	index )

getTableMaxElements()

RUNTIME_API Uptr Runtime::getTableMaxElements

(

TableInstance *

table

)

getTableNumElements()

RUNTIME_API Uptr Runtime::getTableNumElements

(

TableInstance *

table

)

getThreadGCRoots()

void Runtime::getThreadGCRoots

(

std::vector< ObjectInstance * > &

outGCRoots

)

getValidatedMemoryOffsetRange()

RUNTIME_API U8 * Runtime::getValidatedMemoryOffsetRange	(	MemoryInstance *	memory,
		Uptr	offset,
		Uptr	numBytes )

Here is the caller graph for this function:

growMemory()

RUNTIME_API Iptr Runtime::growMemory	(	MemoryInstance *	memory,
		Uptr	numPages )

growTable()

RUNTIME_API Iptr Runtime::growTable	(	TableInstance *	table,
		Uptr	numElements )

init()

RUNTIME_API void Runtime::init

(

)

instantiateModule()

RUNTIME_API ModuleInstance * Runtime::instantiateModule	(	const IR::Module &	module,
		ImportBindings &&	imports )

invokeFunction()

RUNTIME_API Result Runtime::invokeFunction	(	FunctionInstance *	function,
		const std::vector< Value > &	parameters )

isA()

bool Runtime::isA	(	ObjectInstance *	object,
		const IR::ObjectType &	type )

Definition at line 15 of file Linker.cpp.

    {
        if(type.kind != object->kind) { return false; }
 
        switch(type.kind)
        {
        case ObjectKind::function: return asFunctionType(type) == asFunction(object)->type;
        case ObjectKind::global: return asGlobalType(type) == asGlobal(object)->type;
        case ObjectKind::table: return isSubset(asTableType(type),asTable(object)->type);
        case ObjectKind::memory: return isSubset(asMemoryType(type),asMemory(object)->type);
        default: Errors::unreachable();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

linkImport()

template<typename Instance , typename Type >

void Runtime::linkImport	(	const IR::Module &	module,
		const Import< Type > &	import,
		Resolver &	resolver,
		LinkResult &	linkResult,
		std::vector< Instance * > &	resolvedImports )

Definition at line 47 of file Linker.cpp.

    {
        // Ask the resolver for a value for this import.
        ObjectInstance* importValue;
        if(resolver.resolve(import.moduleName,import.exportName,resolveImportType(module,import.type),importValue))
        {
            // Sanity check that the resolver returned an object of the right type.
            WAVM_ASSERT_THROW(isA(importValue,resolveImportType(module,import.type)));
            resolvedImports.push_back(as<Instance>(importValue));
        }
        else { linkResult.missingImports.push_back({import.moduleName,import.exportName,resolveImportType(module,import.type)}); }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

linkModule()

LinkResult Runtime::linkModule	(	const IR::Module &	module,
		Resolver &	resolver )

Definition at line 60 of file Linker.cpp.

    {
        LinkResult linkResult;
        for(const auto& import : module.functions.imports)
        {
            linkImport(module,import,resolver,linkResult,linkResult.resolvedImports.functions);
        }
        for(const auto& import : module.tables.imports)
        {
            linkImport(module,import,resolver,linkResult,linkResult.resolvedImports.tables);
        }
        for(const auto& import : module.memories.imports)
        {
            linkImport(module,import,resolver,linkResult,linkResult.resolvedImports.memories);
        }
        for(const auto& import : module.globals.imports)
        {
            linkImport(module,import,resolver,linkResult,linkResult.resolvedImports.globals);
        }
 
        linkResult.success = linkResult.missingImports.size() == 0;
        return linkResult;
    }

Here is the call graph for this function:

memoryArrayPtr()

template<typename Value >

Value * Runtime::memoryArrayPtr	(	MemoryInstance *	memory,
		U32	offset,
		U32	numElements )

Definition at line 177 of file Runtime.h.

    { return (Value*)getValidatedMemoryOffsetRange(memory,offset,numElements * sizeof(Value)); }

Here is the call graph for this function:

memoryRef()

template<typename Value >

Value & Runtime::memoryRef	(	MemoryInstance *	memory,
		U32	offset )

Definition at line 173 of file Runtime.h.

    { return *(Value*)getValidatedMemoryOffsetRange(memory,offset,sizeof(Value)); }

Here is the call graph for this function:

resetGlobalInstances()

RUNTIME_API void Runtime::resetGlobalInstances

(

ModuleInstance *

moduleInstance

)

resetMemory()

RUNTIME_API void Runtime::resetMemory	(	MemoryInstance *	memory,
		IR::MemoryType &	newMemoryType )

resolveImportType() [1/4]

GlobalType Runtime::resolveImportType	(	const IR::Module &	module,
		GlobalType	type )

Definition at line 44 of file Linker.cpp.

{ return type; }

resolveImportType() [2/4]

const FunctionType * Runtime::resolveImportType	(	const IR::Module &	module,
		IndexedFunctionType	type )

Definition at line 38 of file Linker.cpp.

    {
        return module.types[type.index];
    }

Here is the caller graph for this function:

resolveImportType() [3/4]

MemoryType Runtime::resolveImportType	(	const IR::Module &	module,
		MemoryType	type )

Definition at line 43 of file Linker.cpp.

{ return type; }

resolveImportType() [4/4]

TableType Runtime::resolveImportType	(	const IR::Module &	module,
		TableType	type )

Definition at line 42 of file Linker.cpp.

{ return type; }

runInstanceStartFunc()

RUNTIME_API void Runtime::runInstanceStartFunc

(

ModuleInstance *

moduleInstance

)

setGlobalValue()

RUNTIME_API Value Runtime::setGlobalValue	(	GlobalInstance *	global,
		Value	newValue )

setTableElement()

RUNTIME_API ObjectInstance * Runtime::setTableElement	(	TableInstance *	table,
		Uptr	index,
		ObjectInstance *	newValue )

shrinkMemory()

RUNTIME_API Iptr Runtime::shrinkMemory	(	MemoryInstance *	memory,
		Uptr	numPages )

shrinkTable()

RUNTIME_API Iptr Runtime::shrinkTable	(	TableInstance *	table,
		Uptr	numElements )