From 528917224f862f11b8449f31ca725f776f46f272 Mon Sep 17 00:00:00 2001 From: Matthew A Johnson Date: Thu, 6 Jun 2024 00:50:49 +0100 Subject: [PATCH] Adding the cheriot tests to the test suite. Signed-off-by: Matthew A Johnson --- CMakeLists.txt | 1 + include/rego/rego.hh | 4 +- src/internal.cc | 10 + src/interpreter.cc | 4 +- src/reader.cc | 7 - src/rego_c.cc | 4 +- src/unify.hh | 2 +- src/unify/symbols.cc | 13 +- tests/CMakeLists.txt | 5 +- tests/cheriot/builtins.cpp | 181 + tests/cheriot/cheriot.yaml | 41 + tests/cheriot/compartment.rego | 138 + tests/cheriot/rtos.rego | 40 + tests/cheriot/sail.yaml | 41 + tests/cheriot/test-suite.json | 5195 ++++++++++++++++++++++++++++ tests/main.cc | 2 +- tests/{test_case.h => rego_test.h} | 3 +- tests/test_case.cc | 73 +- 18 files changed, 5733 insertions(+), 31 deletions(-) create mode 100644 tests/cheriot/builtins.cpp create mode 100644 tests/cheriot/cheriot.yaml create mode 100644 tests/cheriot/compartment.rego create mode 100644 tests/cheriot/rtos.rego create mode 100644 tests/cheriot/sail.yaml create mode 100644 tests/cheriot/test-suite.json rename tests/{test_case.h => rego_test.h} (96%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 84d4fe50..5099c2fb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -233,6 +233,7 @@ if (REGOCPP_BUILD_TESTS) install(TARGETS rego_test rego_test_c_api RUNTIME) install(FILES tests/regocpp.yaml tests/bigint.yaml tests/bugs.yaml DESTINATION tests) install(DIRECTORY tests/aci DESTINATION tests) + install(DIRECTORY tests/cheriot DESTINATION tests) endif() export(EXPORT ${PROJECT_NAME}_Targets diff --git a/include/rego/rego.hh b/include/rego/rego.hh index 1b5f0104..a912bf4f 100644 --- a/include/rego/rego.hh +++ b/include/rego/rego.hh @@ -168,7 +168,7 @@ namespace rego | (Ref <<= RefHead * RefArgSeq) | (RefHead <<= Var | Array | Object | Set | ArrayCompr | ObjectCompr | SetCompr | ExprCall) | (RefArgSeq <<= (RefArgDot | RefArgBrack)++) - | (RefArgBrack <<= ExprInfix | Scalar | Var | Array | Object | Set | Placeholder) + | (RefArgBrack <<= Expr | Placeholder) | (RefArgDot <<= Var) | (Scalar <<= String | Int | Float | True | False | Null) | (String <<= JSONString | RawString) @@ -945,7 +945,7 @@ namespace rego * This object can be used to register custom built-ins created using * BuiltInDef::create. */ - BuiltIns builtins() const; + BuiltInsDef& builtins() const; private: friend const char* ::regoGetError(regoInterpreter* rego); diff --git a/src/internal.cc b/src/internal.cc index cf108f23..8819499b 100644 --- a/src/internal.cc +++ b/src/internal.cc @@ -263,6 +263,16 @@ namespace rego else { Node index = arg->front(); + if(index == Expr) + { + index = index->front(); + } + + if (index == Term) + { + index = index->front(); + } + if (index->type() == Scalar) { index = index->front(); diff --git a/src/interpreter.cc b/src/interpreter.cc index 54c34b9d..c5649cf6 100644 --- a/src/interpreter.cc +++ b/src/interpreter.cc @@ -354,8 +354,8 @@ namespace rego return m_reader.wf_check_enabled(); } - BuiltIns Interpreter::builtins() const + BuiltInsDef& Interpreter::builtins() const { - return m_builtins; + return *m_builtins; } } diff --git a/src/reader.cc b/src/reader.cc index 72f619c6..296d8f0a 100644 --- a/src/reader.cc +++ b/src/reader.cc @@ -1452,13 +1452,6 @@ namespace In(VarSeq) * (T(Term) << T(Var)[Var]) >> [](Match& _) { return _(Var); }, - In(RefArgBrack) * - (T(Expr) << (T(Term) << T(Scalar, Var, Object, Array, Set)[Idx])) >> - [](Match& _) { return _(Idx); }, - - In(RefArgBrack) * (T(Expr) << T(ExprInfix)[ExprInfix]) >> - [](Match& _) { return _(ExprInfix); }, - In(RuleHead) * (T(RuleHeadComp) << End) >> [](Match&) { return RuleHeadComp diff --git a/src/rego_c.cc b/src/rego_c.cc index 9de94283..b521b843 100644 --- a/src/rego_c.cc +++ b/src/rego_c.cc @@ -248,7 +248,7 @@ extern "C" void regoSetStrictBuiltInErrors(regoInterpreter* rego, regoBoolean enabled) { logging::Debug() << "regoSetStrictBuiltInErrors: " << enabled; - reinterpret_cast(rego)->builtins()->strict_errors( + reinterpret_cast(rego)->builtins().strict_errors( enabled); } @@ -257,7 +257,7 @@ extern "C" logging::Debug() << "regoGetStrictBuiltInErrors"; return reinterpret_cast(rego) ->builtins() - ->strict_errors(); + .strict_errors(); } // Output functions diff --git a/src/unify.hh b/src/unify.hh index ca718e0e..8846f5d0 100644 --- a/src/unify.hh +++ b/src/unify.hh @@ -144,7 +144,7 @@ namespace rego | (SetCompr <<= Expr * (Body >>= NestedBody)) | (RefTerm <<= Ref | Var) | (NumTerm <<= Int | Float) - | (RefArgBrack <<= RefTerm | Scalar | Object | Array | Set | Expr) + | (RefArgBrack <<= RefTerm | NumTerm | Scalar | Object | Array | Set | Expr) | (Expr <<= wf_symbols_exprs) | (NestedBody <<= Key * (Val >>= UnifyBody)) ; diff --git a/src/unify/symbols.cc b/src/unify/symbols.cc index ef83512e..f91d2cb4 100644 --- a/src/unify/symbols.cc +++ b/src/unify/symbols.cc @@ -436,16 +436,23 @@ namespace rego return NumTerm << _(Val); }, - In(RefArgBrack) * T(Var)[Var] >> + In(RefArgBrack) * (T(Expr) << T(RefTerm, NumTerm)[Term]) >> [](Match& _) { + ACTION(); + return _(Term); + }, + + In(RefArgBrack) * T(Var)[Var] >> + [](Match& _){ ACTION(); return RefTerm << _(Var); }, - In(RefArgBrack) * T(ExprInfix)[ExprInfix] >> + In(RefArgBrack) * + (T(Expr) << (T(Term) << T(Scalar, Object, Array, Set)[Term])) >> [](Match& _) { ACTION(); - return Expr << _(ExprInfix); + return _(Term); }, In(UnifyBody) * diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index aed403fa..2c05d126 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,4 +1,4 @@ -add_executable(rego_test main.cc test_case.cc) +add_executable(rego_test main.cc test_case.cc cheriot/builtins.cpp) target_link_libraries(rego_test PRIVATE regocpp::rego) @@ -16,6 +16,7 @@ endif() add_test(NAME rego_test_regocpp COMMAND rego_test regocpp.yaml -wf WORKING_DIRECTORY $) add_test(NAME rego_test_bugs COMMAND rego_test bugs.yaml -wf WORKING_DIRECTORY $) add_test(NAME rego_test_aci COMMAND rego_test aci/aci.yaml WORKING_DIRECTORY $) +add_test(NAME rego_test_cheriot COMMAND rego_test cheriot/cheriot.yaml -wf WORKING_DIRECTORY $) add_test(NAME rego_test_c_api COMMAND rego_test_c_api WORKING_DIRECTORY $) set_tests_properties(rego_test_aci PROPERTIES TIMEOUT 300) @@ -25,6 +26,8 @@ add_custom_command(TARGET rego_test POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/bugs.yaml $/bugs.yaml) add_custom_command(TARGET rego_test POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/aci $/aci) +add_custom_command(TARGET rego_test POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/cheriot $/cheriot) if(REGOCPP_OPA_TESTS) set( OPA_TEST_DIRS diff --git a/tests/cheriot/builtins.cpp b/tests/cheriot/builtins.cpp new file mode 100644 index 00000000..369218fe --- /dev/null +++ b/tests/cheriot/builtins.cpp @@ -0,0 +1,181 @@ +#include "../rego_test.h" + +#include +#include + +namespace +{ + using namespace rego; + + /** + * Built-in function exposed to Rego for demangling the symbol names in + * export entries. Takes two arguments, the compartment name and the + * mangled symbol name. + */ + Node demangle_export(const Nodes& args) + { + Node exportName = unwrap_arg(args, UnwrapOpt(1).types({JSONString})); + if (exportName->type() == Error) + { + return scalar(false); + } + Node compartmentName = unwrap_arg(args, UnwrapOpt(0).types({JSONString})); + if (compartmentName->type() == Error) + { + return scalar(false); + } + auto string = get_string(exportName); + auto compartmentNameString = get_string(compartmentName); + const std::string_view LibraryExportPrefix = "__library_export_libcalls"; + const std::string_view ExportPrefix = "__export_"; + if (string.starts_with(LibraryExportPrefix)) + { + string = string.substr(LibraryExportPrefix.size()); + } + else + { + if (!string.starts_with(ExportPrefix)) + { + return scalar(false); + } + string = string.substr(ExportPrefix.size()); + if (!string.starts_with(compartmentNameString)) + { + return scalar(false); + } + string = string.substr(compartmentNameString.size()); + } + if (!string.starts_with("_")) + { + return scalar(false); + } + string = string.substr(1); + // The way that rego-cpp exposes snmalloc can cause the realloc here to + // crash. Try to allocate a buffer that's large enough that we don't + // care. + size_t bufferSize = strlen(string.c_str()) * 8; + char* buffer = static_cast(malloc(bufferSize)); + int error; + buffer = abi::__cxa_demangle(string.c_str(), buffer, &bufferSize, &error); + if (error != 0) + { + free(buffer); + return scalar(false); + } + std::string demangled(buffer); + free(buffer); + return scalar(std::move(demangled)); + } + + /** + * Helper that decodes the hex strings emitted for static sealed objects. + * These are written as sequences of bytes, with a space between each four + * bytes. + * + * Takes a node that must have been unwrapped to a JSONString. + */ + std::vector decode_hex_node(const Node& node) + { + if (node->type() == Error) + { + return {}; + } + auto hexString = get_string(node); + std::vector result; + while (hexString.size() >= 8) + { + for (size_t i = 0; i < 8; i += 2) + { + uint8_t byte; + auto [p, ec] = std::from_chars( + hexString.data() + i, hexString.data() + i + 2, byte, 16); + if (ec != std::errc{}) + { + return {}; + } + result.push_back(byte); + } + hexString = hexString.substr(8); + if (hexString.size() > 0 && hexString[0] == ' ') + { + hexString = hexString.substr(1); + } + } + return result; + } + + /** + * Built-in function exposed to Rego for decoding a hex string into an + * integer. + * + * Takes three arguments: + * 1. The hex string to decode + * 2. The offset in the string to start decoding + * 3. The number of bytes to decode + * + * The third argument must be 1, 2, 3, or 4 bytes (3 does not make sense, + * but it's easier to allow it than exclude it). This corresponds to + * uint8_t, uint16_t, and uint32_t in the source. + */ + Node decode_integer(const Nodes& args) + { + auto bytes = + decode_hex_node(unwrap_arg(args, UnwrapOpt(0).types({JSONString}))); + auto offsetNode = unwrap_arg(args, UnwrapOpt(1).types({Int})); + auto lengthNode = unwrap_arg(args, UnwrapOpt(2).types({Int})); + if ((offsetNode->type() == Error) || (lengthNode->type() == Error)) + { + return scalar(false); + } + size_t offset = get_int(offsetNode).to_int(); + size_t length = get_int(lengthNode).to_int(); + uint32_t result = 0; + size_t end = offset + length; + if ((length > 4) || (end > bytes.size())) + { + return scalar(false); + } + for (size_t i = 0; i < length; i++) + { + result |= (bytes[offset + i] << (i * 8)); + } + return scalar(BigInt{int64_t(result)}); + } + + /** + * Built-in function exposed to Rego for decoding a hex string containing a + * C string into a Rego string. This takes two arguments, the hex string + * and the offset where the C string starts. + */ + Node decode_c_string(const Nodes& args) + { + auto bytes = + decode_hex_node(unwrap_arg(args, UnwrapOpt(0).types({JSONString}))); + auto offsetNode = unwrap_arg(args, UnwrapOpt(1).types({Int})); + size_t offset = get_int(offsetNode).to_int(); + std::string result; + if (offset >= bytes.size()) + { + return scalar(false); + } + for (auto it = bytes.begin() + offset; (it != bytes.end()) && (*it != '\0'); + it++) + { + result.push_back(*it); + } + return scalar(std::move(result)); + } +} + +namespace rego_test +{ + std::vector cheriot_builtins() + { + return { + BuiltInDef::create(Location("export_entry_demangle"), 2, demangle_export), + BuiltInDef::create( + Location("integer_from_hex_string"), 3, decode_integer), + BuiltInDef::create( + Location("string_from_hex_string"), 2, decode_c_string)}; + } +} \ No newline at end of file diff --git a/tests/cheriot/cheriot.yaml b/tests/cheriot/cheriot.yaml new file mode 100644 index 00000000..19641085 --- /dev/null +++ b/tests/cheriot/cheriot.yaml @@ -0,0 +1,41 @@ +cases: +- note: Check that we can demangle a library export correctly + modules: + - compartment.rego + data: sail.yaml + input: test-suite.json + query: data.compartment.compartment_call_allow_list("allocator_test", `test_allocator\(\)`, {"test_runner"}) = x + want_result: + - x : true +- note: Check that we can demangle a compartment export correctly + modules: + - compartment.rego + data: sail.yaml + input: test-suite.json + query: export_entry_demangle("alloc", input.compartments.allocator.exports[6].export_symbol) = x + want_result: + - x: heap_free(SObjStruct*, void*) +- note: Check that we can demangle a library export correctly + modules: + - compartment.rego + data: sail.yaml + input: test-suite.json + query: export_entry_demangle("token_library", input.compartments.token_library.exports[0].export_symbol) = x + want_result: + - x: token_obj_unseal(SKeyStruct*, SObjStruct*) +- note: Check that we can demangle a library export correctly + modules: + - compartment.rego + data: sail.yaml + input: test-suite.json + query: data.compartment.mmio_allow_list("clint", {"scheduler"}) = x + want_result: + - x: true +- note: Check that we can demangle a library export correctly. + modules: + - rtos.rego + data: sail.yaml + input: test-suite.json + query: sum([ data.rtos.decode_allocator_capability(c).quota | c = input.compartments[_].imports[_] ; data.rtos.is_allocator_capability(c) ]) = x + want_result: + - x: 1070080 diff --git a/tests/cheriot/compartment.rego b/tests/cheriot/compartment.rego new file mode 100644 index 00000000..6fef3fa3 --- /dev/null +++ b/tests/cheriot/compartment.rego @@ -0,0 +1,138 @@ +package compartment + +compartment_contains_export(compartment, export) { + compartment.exports[_] == export +} + +compartment_includes_file(compartment, filename) { + compartment.code.inputs[_].file == filename +} + +compartment_includes_file(compartment, filename) { + compartment.data.inputs[_].file == filename +} + +export_matches_import(export, importEntry) { + export.export_symbol = importEntry.export_symbol +} + + +export_for_import(importEntry) = entry { + some possibleEntries + some allExports + allExports = {export | input.compartments[_].exports[_] = export} + possibleEntries = [{"compartment": compartment, "entry": entry} | entry = input.compartments[compartment].exports[_]; export_matches_import(entry, importEntry)] + count(possibleEntries) == 1 + compartment_includes_file(input.compartments[possibleEntries[0].compartment], importEntry.provided_by) + entry := possibleEntries[0].entry +} + +import_is_library_call(a) { a.kind = "LibraryFunction" } +import_is_MMIO(a) { a.kind = "MMIO" } +import_is_compartment_call(a) { + a.kind = "CompartmentExport" + a.function +} + +import_is_call { + import_is_library_call(importEntry) +} + +import_is_call { + import_is_compartment_call(importEntry) +} + +mmio_imports_for_compartment(compartment) = entry { + entry := [e | e = compartment.imports[_]; import_is_MMIO(e)] +} + +mmio_is_device(importEntry, device) { + importEntry.start = device.start + importEntry.length = device.length +} + +device_for_mmio_import(importEntry) = device { + import_is_MMIO(importEntry) + some devices + devices = [{ i:d } | d = data.board.devices[i]; mmio_is_device(importEntry, d)] + count(devices) == 1 + device := devices[0] +} + +compartment_imports_device(compartment, device) { + count([d | d = mmio_imports_for_compartment(compartment)[_] ; mmio_is_device(d, device)]) > 0 +} + +compartments_with_mmio_import(device) = compartments { + compartments = [i | c = input.compartments[i]; compartment_imports_device(c, device)] +} + +compartment_export_matching_symbol(compartmentName, symbol) = export { + some compartment + compartment = input.compartments[compartmentName] + some exports + exports = [e | e = compartment.exports[_]; re_match(symbol, export_entry_demangle(compartmentName, e.export_symbol))] + count(exports) == 1 + export := exports[0] +} + +compartments_calling_export(export) = compartments { + compartments = [c | i = input.compartments[c].imports[_]; export_matches_import(i, export)] +} + +compartments_calling_export_matching(compartmentName, export) = compartments { + compartments = compartments_calling_export(compartment_export_matching_symbol(compartmentName, export)) +} + +# Helper that builds a map from symbol names to compartments. This is +# to avoid some O(n^2) lookups. Or would, if rego-cpp didn't recompute +# this every evaluation. +#entry_point_map := { entry.export_symbol : compartment | entry = input.compartments[compartment].exports[_] ; entry.kind = "Function"} + +compartment_exports_function(callee, importEntry) { + #entry_point_map[importEntry.export_symbol] == callee + some possibleEntries + possibleEntries = [entry | entry = input.compartments[callee].exports[_]; export_matches_import(entry, importEntry)] + count(possibleEntries) == 1 + compartment_includes_file(input.compartments[callee], importEntry.provided_by) +} + +# Helper to work around rego-cpp#117 +check_export(exports, importEntry, compartment) { + exports[importEntry.export_symbol] == compartment +} + +compartments_calling(callee) = compartments { + # Create a reverse map that maps from exported symbols to + # compartments. This avoids some O(n^2) lookups. It would be nice + # to cache this globally but rego-cpp doesn't support that yet. + # This reduces the time for this query on the test suite from over + # 6s to under 0.5s for me. + some entry_point_map + entry_point_map = { entry.export_symbol : compartment | entry = input.compartments[compartment].exports[_] ; entry.kind = "Function"} + compartments = {c | i = input.compartments[c].imports[_]; check_export(entry_point_map, i, callee)} +} + + +# Helper for allow lists. Functions cannot return sets, so this +# accepts an array of compartment names that match some property and +# evaluates to true if and only if each one is also present in the allow +# list. +allow_list(testArray, allowList) { + some compartments + compartments = {c | c:=testArray[_]} + compartments & allowList == compartments +} + +mmio_allow_list(mmioName, allowList) { + allow_list(compartments_with_mmio_import(data.board.devices[mmioName]), allowList) +} + +compartment_call_allow_list(compartmentName, exportPattern, allowList) { + allow_list(compartments_calling_export_matching(compartmentName, exportPattern), allowList) +} + +compartment_allow_list(compartmentName, allowList) { + allow_list(compartments_calling(compartmentName), allowList) +} + diff --git a/tests/cheriot/rtos.rego b/tests/cheriot/rtos.rego new file mode 100644 index 00000000..d3c608ae --- /dev/null +++ b/tests/cheriot/rtos.rego @@ -0,0 +1,40 @@ +package rtos + +import future.keywords + +is_allocator_capability(capability) { + capability.kind == "SealedObject" + capability.sealing_type.compartment == "alloc" + capability.sealing_type.key == "MallocKey" +} + +decode_allocator_capability(capability) = decoded { + is_allocator_capability(capability) + some quota + quota = integer_from_hex_string(capability.contents, 0, 4) + # Remaining words are all zero + integer_from_hex_string(capability.contents, 4, 4) == 0 + integer_from_hex_string(capability.contents, 8, 4) == 0 + integer_from_hex_string(capability.contents, 12, 4) == 0 + integer_from_hex_string(capability.contents, 16, 4) == 0 + integer_from_hex_string(capability.contents, 20, 4) == 0 + decoded := { "quota": quota } +} + +all_sealed_allocator_capabilities_are_valid { + some allocatorCapabilities + allocatorCapabilities = [ c | c = input.compartments[_].imports[_] ; is_allocator_capability(c) ] + every c in allocatorCapabilities { + decode_allocator_capability(c) + } +} + + +valid { + all_sealed_allocator_capabilities_are_valid + # Only the allocator may access the revoker. + data.compartment.mmio_allow_list("revoker", {"allocator"}) + # Only the scheduler may access the interrupt controllers. + data.compartment.mmio_allow_list("clint", {"scheduler"}) + data.compartment.mmio_allow_list("plic", {"scheduler"}) +} \ No newline at end of file diff --git a/tests/cheriot/sail.yaml b/tests/cheriot/sail.yaml new file mode 100644 index 00000000..08afcd59 --- /dev/null +++ b/tests/cheriot/sail.yaml @@ -0,0 +1,41 @@ +board: + { + "devices": { + "clint": { + "start": 0x2000000, + "length": 0x10000 + }, + "uart": { + "start": 0x10000000, + "end": 0x10000100 + }, + "shadow" : { + "start" : 0x83000000, + "end" : 0x83001000 + } + }, + "instruction_memory": { + "start": 0x80000000, + "end": 0x80040000 + }, + "heap": { + "end": 0x80040000 + }, + "interrupts": [ + { + "name": "FakeInterrupt", + "number": 4, + "priority": 2 + } + ], + "defines" : "SAIL", + "driver_includes" : [ + "../include/platform/generic-riscv" + ], + "timer_hz" : 2000, + "tickrate_hz" : 10, + "revoker" : "software", + "stack_high_water_mark" : true, + "simulator" : "cheriot_sim", + "simulation": true + } \ No newline at end of file diff --git a/tests/cheriot/test-suite.json b/tests/cheriot/test-suite.json new file mode 100644 index 00000000..b9bde4c4 --- /dev/null +++ b/tests/cheriot/test-suite.json @@ -0,0 +1,5195 @@ +{ + "compartments": { + "allocator": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "section_name": ".text", + "sha256": "524222b315c14e892c064f464289f1d6d2113332323c3ee48e010871d39e5d32", + "size": 15740 + }, + { + "file": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "section_name": ".rodata", + "sha256": "40848ee436ba2090c78c9fe8ba5db9ddd0506a4363497bc10bc6965d776d9b46", + "size": 4754 + } + ], + "name": "allocator_code", + "output": { + "sha256": "2893ce4cf2cb2eb10f3d67a325dbf428a641c978f30a4cb934ecdfa2882b4cdf" + } + }, + "exports": [ + { + "export_symbol": "__export.sealing_type.alloc.MallocKey", + "exported": true, + "kind": "SealingKey" + }, + { + "export_symbol": "__export_alloc__Z20heap_quota_remainingP10SObjStruct", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 208 + }, + { + "export_symbol": "__export_alloc__Z21heap_quarantine_emptyv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 494 + }, + { + "export_symbol": "__export_alloc__Z13heap_allocateP7TimeoutP10SObjStructj", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 694 + }, + { + "export_symbol": "__export_alloc__Z10heap_claimP10SObjStructPv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1250 + }, + { + "export_symbol": "__export_alloc__Z13heap_can_freeP10SObjStructPv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 2200 + }, + { + "export_symbol": "__export_alloc__Z9heap_freeP10SObjStructPv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 2410 + }, + { + "export_symbol": "__export_alloc__Z13heap_free_allP10SObjStruct", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 2572 + }, + { + "export_symbol": "__export_alloc__Z19heap_allocate_arrayP7TimeoutP10SObjStructjj", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 3310 + }, + { + "export_symbol": "__export_alloc__Z13token_key_newv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 3482 + }, + { + "export_symbol": "__export_alloc__Z27token_sealed_unsealed_allocP7TimeoutP10SObjStructP10SKeyStructjPPv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 5, + "start_offset": 3742 + }, + { + "export_symbol": "__export_alloc__Z18token_sealed_allocP7TimeoutP10SObjStructP10SKeyStructj", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 4342 + }, + { + "export_symbol": "__export_alloc__Z17token_obj_destroyP10SObjStructP10SKeyStructS0_", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 4456 + }, + { + "export_symbol": "__export_alloc__Z14heap_availablev", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 4626 + } + ], + "imports": [ + { + "export_symbol": "__export.sealing_type.alloc.MallocKey", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "kind": "MMIO", + "length": 148960, + "permits_load": true, + "permits_load_mutable": true, + "permits_load_store_capabilities": true, + "permits_store": true, + "start": 2147596832 + }, + { + "kind": "MMIO", + "length": 48, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": true, + "permits_store": true, + "start": 2147595576 + }, + { + "kind": "MMIO", + "length": 4, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 2147595624 + }, + { + "kind": "MMIO", + "length": 4096, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 2197815296 + }, + { + "export_symbol": "__library_export_libcalls__Z15flaglock_unlockP13FlagLockState", + "function": "flaglock_unlock(FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls__Z21check_timeout_pointerPK7Timeout", + "function": "check_timeout_pointer(Timeout const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls__Z3clzj", + "function": "clz(unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/crt.library" + }, + { + "export_symbol": "__library_export_libcalls__Z3ctzj", + "function": "ctz(unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/crt.library" + }, + { + "export_symbol": "__library_export_libcalls__Z16flaglock_trylockP7TimeoutP13FlagLockState", + "function": "flaglock_trylock(Timeout*, FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z36flaglock_priority_inheriting_trylockP7TimeoutP13FlagLockState", + "function": "flaglock_priority_inheriting_trylock(Timeout*, FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "function": "token_obj_unseal(SKeyStruct*, SObjStruct*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cheriot.token_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z13check_pointerPKvjjb", + "function": "check_pointer(void const*, unsigned int, unsigned int, bool)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z12thread_sleepP7Timeout", + "function": "thread_sleep(Timeout*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "software_revoker", + "export_symbol": "__export_software_revoker__Z17revoker_epoch_getv", + "function": "revoker_epoch_get()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.software_revoker.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z13thread_id_getv", + "function": "thread_id_get()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "software_revoker", + "export_symbol": "__export_software_revoker__Z12revoker_tickv", + "function": "revoker_tick()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.software_revoker.compartment" + } + ] + }, + "allocator_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/allocator_test.compartment", + "section_name": ".text", + "sha256": "634269afc59a22d449bdecb5c0b63dac9b1c1b81966b4a5904520b63bd4b35b9", + "size": 8028 + }, + { + "file": "build/cheriot/cheriot/release/allocator_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/allocator_test.compartment", + "section_name": ".rodata", + "sha256": "611de35657c82a5cf2e097b477f4a71a2ac83964abb1f8a6862c433af5bfdd9e", + "size": 3360 + } + ], + "name": ".allocator_test_code", + "output": { + "sha256": "c6a5eb0c8569f473bddaa70556a32b97a5da04cb9b00de3cb3393159cd3eb09b" + } + }, + "exports": [ + { + "export_symbol": "__export.sealing_type.allocator_test.sealingTest", + "exported": true, + "kind": "SealingKey" + }, + { + "export_symbol": "__export_allocator_test__Z14test_allocatorv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 376 + }, + { + "export_symbol": "__export_allocator_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_112test_hazardsEvE3$_1EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 5856 + }, + { + "export_symbol": "__export_allocator_test__ZN11thread_pool6detail22wrap_callback_functionIZN12_GLOBAL__N_123test_blocking_allocatorEvE3$_0EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 7482 + } + ], + "imports": [ + { + "contents": "00040000 00000000 00000000 00000000 00000000 00000000", + "kind": "SealedObject", + "sealing_type": { + "compartment": "alloc", + "key": "MallocKey", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "symbol": "__export.sealing_type.alloc.MallocKey" + } + }, + { + "contents": "00001000 00000000 00000000 00000000 00000000 00000000", + "kind": "SealedObject", + "sealing_type": { + "compartment": "alloc", + "key": "MallocKey", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "symbol": "__export.sealing_type.alloc.MallocKey" + } + }, + { + "export_symbol": "__export.sealing_type.allocator_test.sealingTest", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/allocator_test.compartment" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "thread_pool", + "export_symbol": "__export_thread_pool__Z17thread_pool_asyncPU10chericcallFvPvES_", + "function": "thread_pool_async(void (void*) chericcall*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13heap_free_allP10SObjStruct", + "function": "heap_free_all(SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "allocator_test", + "export_symbol": "__export_allocator_test__ZN11thread_pool6detail22wrap_callback_functionIZN12_GLOBAL__N_123test_blocking_allocatorEvE3$_0EEvPv", + "function": "void thread_pool::detail::wrap_callback_function<(anonymous namespace)::test_blocking_allocator()::$_0>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/allocator_test.compartment" + }, + { + "compartment_name": "allocator_test", + "export_symbol": "__export_allocator_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_112test_hazardsEvE3$_1EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda<(anonymous namespace)::test_hazards()::$_1>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/allocator_test.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z17token_obj_destroyP10SObjStructP10SKeyStructS0_", + "function": "token_obj_destroy(SObjStruct*, SKeyStruct*, SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_acquire", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z10heap_claimP10SObjStructPv", + "function": "heap_claim(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z9heap_freeP10SObjStructPv", + "function": "heap_free(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13token_key_newv", + "function": "token_key_new()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "function": "token_obj_unseal(SKeyStruct*, SObjStruct*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cheriot.token_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z27token_sealed_unsealed_allocP7TimeoutP10SObjStructP10SKeyStructjPPv", + "function": "token_sealed_unsealed_alloc(Timeout*, SObjStruct*, SKeyStruct*, unsigned int, void**)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13heap_allocateP7TimeoutP10SObjStructj", + "function": "heap_allocate(Timeout*, SObjStruct*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z12thread_sleepP7Timeout", + "function": "thread_sleep(Timeout*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z6memsetPvij", + "function": "memset(void*, int, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/freestanding.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z15heap_claim_fastP7TimeoutPKvS2_", + "function": "heap_claim_fast(Timeout*, void const*, void const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z20heap_quota_remainingP10SObjStruct", + "function": "heap_quota_remaining(SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_release", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + }, + { + "export_symbol": "__library_export_libcalls__Z6memcpyPvPKvj", + "function": "memcpy(void*, void const*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/freestanding.library" + } + ] + }, + "atomic1": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/atomic1.library", + "section_name": ".text", + "sha256": "d113e1e9108436d945130af4ae56e31f4ee97ffaaa00052f90ae03992e694c42", + "size": 124 + } + ], + "name": ".atomic1_code", + "output": { + "sha256": "e07fe5bdaf0f2dd9f9f5185ed89c01e2fb54f27575388c51785bae59007fbbbe" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls___atomic_load_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 8 + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 14 + }, + { + "export_symbol": "__library_export_libcalls___atomic_exchange_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 20 + }, + { + "export_symbol": "__library_export_libcalls___atomic_compare_exchange_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 32 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_add_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 60 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_sub_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 74 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_and_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 90 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_or_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 104 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_xor_1", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 118 + } + ] + }, + "atomic2": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/atomic2.library", + "section_name": ".text", + "sha256": "0ddb04adefb93f257ed0d14735cf548f0cdd8d8fef3738f5215e71adffe2711a", + "size": 124 + } + ], + "name": ".atomic2_code", + "output": { + "sha256": "1436cc421e1fa39922bfdf41b59321b12e3f067757fc067fac2e822b5a1ff80e" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls___atomic_load_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 8 + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 14 + }, + { + "export_symbol": "__library_export_libcalls___atomic_exchange_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 20 + }, + { + "export_symbol": "__library_export_libcalls___atomic_compare_exchange_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 32 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_add_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 60 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_sub_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 74 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_and_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 90 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_or_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 104 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_xor_2", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 118 + } + ] + }, + "atomic4": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/atomic4.library", + "section_name": ".text", + "sha256": "3d529c937a16b08f435b021550264502018d46d7368150db7ed39a45421bb371", + "size": 88 + } + ], + "name": ".atomic4_code", + "output": { + "sha256": "def9b37b3801c7f72fc691d80ecad06d468a1ec4e72a5a7c69a07899ebfe5b12" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 8 + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 12 + }, + { + "export_symbol": "__library_export_libcalls___atomic_exchange_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 16 + }, + { + "export_symbol": "__library_export_libcalls___atomic_compare_exchange_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 24 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_add_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 44 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_sub_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 54 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_and_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 66 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_or_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 76 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_xor_4", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 86 + } + ] + }, + "atomic8": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/atomic8.library", + "section_name": ".text", + "sha256": "afe385d71e93fb3e0830ae302bb0547bedbc4a26542ff3625b5826ac6252d1ce", + "size": 178 + } + ], + "name": ".atomic8_code", + "output": { + "sha256": "444f295cb502c0b3cd630ceccab4be402f99dd51dd52b0cf3dd55999c458cf78" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls___atomic_load_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 8 + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 16 + }, + { + "export_symbol": "__library_export_libcalls___atomic_exchange_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 22 + }, + { + "export_symbol": "__library_export_libcalls___atomic_compare_exchange_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 36 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_add_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 80 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_sub_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 104 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_and_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 132 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_or_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 150 + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_xor_8", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 168 + } + ] + }, + "ccompile_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/ccompile_test.compartment", + "section_name": ".text", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/ccompile_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + } + ], + "name": ".ccompile_test_code", + "output": { + "sha256": "af5570f5a1810b7af78caf4bc70a660f0df51e42baf91d4de5b2328de0e83dfc" + } + } + }, + "check_pointer_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/check_pointer_test.compartment", + "section_name": ".text", + "sha256": "07c871ae9b72089839c9d947d3c6935447e6ead81f2dd00e40c570f4b239c02a", + "size": 1448 + }, + { + "file": "build/cheriot/cheriot/release/check_pointer_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/check_pointer_test.compartment", + "section_name": ".rodata", + "sha256": "68648f9ba9dcd0d2e177c4ede4d9a5063c1050028368df0e97fef4dfb930009a", + "size": 1752 + } + ], + "name": ".check_pointer_test_code", + "output": { + "sha256": "8167fb35351305a03d6cedb3d1ab20c1c9d223f7195b7e0bfced4d962285a30c" + } + }, + "exports": [ + { + "export_symbol": "__export_check_pointer_test__Z18test_check_pointerv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 1376 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls__Z13check_pointerPKvjjb", + "function": "check_pointer(void const*, unsigned int, unsigned int, bool)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + } + ] + }, + "compartment_calls_inner": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/compartment_calls_inner.compartment", + "section_name": ".text", + "sha256": "f33eba7af7d764d6c10fd051d36a742de6ddc518351d956c0b463e62ffb1d7d1", + "size": 1224 + }, + { + "file": "build/cheriot/cheriot/release/compartment_calls_inner.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/compartment_calls_inner.compartment", + "section_name": ".rodata", + "sha256": "95085f27b44d261690e723c0ce7eee313873fb2fb0444178001ed3351675a9d6", + "size": 283 + } + ], + "name": ".compartment_calls_inner_code", + "output": { + "sha256": "f4f2ea45a13f9e3f5122a5139143d536bc1bd1b6db54e054b7c84c1e0d971466" + } + }, + "exports": [ + { + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneri", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 24 + }, + { + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_innerii", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 146 + }, + { + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKi", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 264 + }, + { + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKii", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 394 + }, + { + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKiiS0_", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 5, + "start_offset": 534 + }, + { + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKiiS0_i", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 6, + "start_offset": 686 + }, + { + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKiiS0_ii", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 7, + "start_offset": 848 + }, + { + "export_symbol": "__export_compartment_calls_inner__Z27test_incorrect_export_tablePU10chericcallFvvEPb", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1094 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + } + ] + }, + "compartment_calls_inner_with_handler": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/compartment_calls_inner_with_handler.compartment", + "section_name": ".text", + "sha256": "7dc33dc45d9d0b7c7fa2326db64da8280a14e1be92cbc25a081a1fd34ad05017", + "size": 180 + }, + { + "file": "build/cheriot/cheriot/release/compartment_calls_inner_with_handler.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/compartment_calls_inner_with_handler.compartment", + "section_name": ".rodata", + "sha256": "c8077ca2d69fae57a03e626f7d28c19b2d3b82521a1864911f1eb4a630e31262", + "size": 251 + } + ], + "name": ".compartment_calls_inner_with_handler_code", + "output": { + "sha256": "31060f0b4796c640266ba17640ae24878009529f240856ea3d0594b365072864" + } + }, + "exports": [ + { + "export_symbol": "__export_compartment_calls_inner_with_handler__Z40test_incorrect_export_table_with_handlerPU10chericcallFvvE", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 28 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + } + ] + }, + "compartment_calls_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/compartment_calls_test.compartment", + "section_name": ".text", + "sha256": "4ca39429c6aa5845b0bb821311682aad98cb014be582a52592354685c3f8cdcf", + "size": 1224 + }, + { + "file": "build/cheriot/cheriot/release/compartment_calls_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/compartment_calls_test.compartment", + "section_name": ".rodata", + "sha256": "900785b6ead81d008d49639ea792a1f9590ee4f60dc2bbb948b38acd806316db", + "size": 661 + } + ], + "name": ".compartment_calls_test_code", + "output": { + "sha256": "43b97a3120941d1deabaae5bbdfd83364c725b8265beeabb44f79639d31806b8" + } + }, + "exports": [ + { + "export_symbol": "__export_compartment_calls_test__Z21test_compartment_callv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 644 + } + ], + "imports": [ + { + "compartment_name": "compartment_calls_inner_with_handler", + "export_symbol": "__export_compartment_calls_inner_with_handler__Z40test_incorrect_export_table_with_handlerPU10chericcallFvvE", + "function": "test_incorrect_export_table_with_handler(void () chericcall*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner_with_handler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z22switcher_recover_stackv", + "function": "switcher_recover_stack()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "compartment_name": "compartment_calls_inner", + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKii", + "function": "compartment_call_inner(int, int, int const*, int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner.compartment" + }, + { + "compartment_name": "compartment_calls_inner", + "export_symbol": "__export_compartment_calls_inner__Z27test_incorrect_export_tablePU10chericcallFvvEPb", + "function": "test_incorrect_export_table(void () chericcall*, bool*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner.compartment" + }, + { + "compartment_name": "compartment_calls_inner", + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKiiS0_i", + "function": "compartment_call_inner(int, int, int const*, int, int const*, int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner.compartment" + }, + { + "compartment_name": "compartment_calls_inner", + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKiiS0_ii", + "function": "compartment_call_inner(int, int, int const*, int, int const*, int, int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z23trusted_stack_has_spacei", + "function": "trusted_stack_has_space(int)", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "compartment_name": "compartment_calls_inner", + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_innerii", + "function": "compartment_call_inner(int, int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "compartment_calls_inner", + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKi", + "function": "compartment_call_inner(int, int, int const*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "compartment_calls_inner", + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneri", + "function": "compartment_call_inner(int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner.compartment" + }, + { + "compartment_name": "compartment_calls_inner", + "export_symbol": "__export_compartment_calls_inner__Z22compartment_call_inneriiPKiiS0_", + "function": "compartment_call_inner(int, int, int const*, int, int const*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_inner.compartment" + } + ] + }, + "compartment_helpers": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/compartment_helpers.library", + "section_name": ".text", + "sha256": "c587a45218c189472d6988d452dee7765fa0cecfbaaef3230f978277a45eb331", + "size": 572 + } + ], + "name": ".compartment_helpers_code", + "output": { + "sha256": "9cb6c1946de7d863a680e9aeaeddfaec9f1126934fbff4dfdbc8c822821e7868" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z15heap_claim_fastP7TimeoutPKvS2_", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 40 + }, + { + "export_symbol": "__library_export_libcalls__Z13check_pointerPKvjjb", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 4, + "start_offset": 390 + }, + { + "export_symbol": "__library_export_libcalls__Z21check_timeout_pointerPK7Timeout", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 510 + } + ], + "imports": [ + { + "kind": "MMIO", + "length": 4, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": false, + "start": 2147595624 + }, + { + "export_symbol": "__library_export_libcalls__Z28switcher_thread_hazard_slotsv", + "function": "switcher_thread_hazard_slots()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + } + ] + }, + "compartment_switcher": { + "code": { + "inputs": [ + { + "file": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o", + "section_name": ".text", + "sha256": "227448ee769453aa0c96b2751fc6c2b53df1df6a47bcbe64518e303c4054ff2a", + "size": 1382 + } + ], + "name": "compartment_switcher_code", + "output": { + "sha256": "ce8d8c5a4492f3164605676ec9e00bad8a9380a58419a45af2290ecad8bac8ec" + } + }, + "exports": [ + { + "export_symbol": "__export_switcher__Z26compartment_switcher_entryz", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 32 + }, + { + "export_symbol": "__library_export_libcalls__Z23trusted_stack_has_spacei", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 1196 + }, + { + "export_symbol": "__library_export_libcalls__Z22switcher_recover_stackv", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 1224 + }, + { + "export_symbol": "__library_export_libcalls__Z25switcher_interrupt_threadPv", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 1240 + }, + { + "export_symbol": "__library_export_libcalls__Z23switcher_current_threadv", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 1336 + }, + { + "export_symbol": "__library_export_libcalls__Z28switcher_thread_hazard_slotsv", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 1364 + }, + { + "export_symbol": "__library_export_libcalls__Z13thread_id_getv", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 1372 + } + ] + }, + "crash_recovery_inner": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/crash_recovery_inner.compartment", + "section_name": ".text", + "sha256": "407821351c005df871590a272a4bb462e789a41cef785408e6323e143a55e50c", + "size": 888 + }, + { + "file": "build/cheriot/cheriot/release/crash_recovery_inner.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/crash_recovery_inner.compartment", + "section_name": ".rodata", + "sha256": "0509c2fd089051e67bda79da45ee6a411501017f664240a139bbfb66a89b6034", + "size": 456 + } + ], + "name": ".crash_recovery_inner_code", + "output": { + "sha256": "945583ac16720c78beee6a6f2db5d6c6d322f5b1da03bbefd65a68f5ea31826d" + } + }, + "exports": [ + { + "export_symbol": "__export_crash_recovery_inner__Z25test_crash_recovery_inneri", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 394 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z6memcpyPvPKvj", + "function": "memcpy(void*, void const*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/freestanding.library" + } + ] + }, + "crash_recovery_outer": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/crash_recovery_outer.compartment", + "section_name": ".text", + "sha256": "f2b38f13ff06b292964b6821f4ce4cbae0462422a7052e9447d313e0e6ad80a6", + "size": 424 + }, + { + "file": "build/cheriot/cheriot/release/crash_recovery_outer.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/crash_recovery_outer.compartment", + "section_name": ".rodata", + "sha256": "13e5d59bbb3fea514527a94397b97476234362e95b4490a0c9511d9b0616c67d", + "size": 376 + } + ], + "name": ".crash_recovery_outer_code", + "output": { + "sha256": "9ea274eceb87e2aabf0b3e4faad949cf576ecab81703feab9b34c269659e1439" + } + }, + "exports": [ + { + "export_symbol": "__export_crash_recovery_outer__Z25test_crash_recovery_outeri", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 32 + } + ], + "imports": [ + { + "compartment_name": "crash_recovery_inner", + "export_symbol": "__export_crash_recovery_inner__Z25test_crash_recovery_inneri", + "function": "test_crash_recovery_inner(int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/crash_recovery_inner.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + } + ] + }, + "crash_recovery_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/crash_recovery_test.compartment", + "section_name": ".text", + "sha256": "fbd8c8fc49cf064037db99e3b7f86e7e647fd9fe8b49ffc9be9828ab6190760a", + "size": 1062 + }, + { + "file": "build/cheriot/cheriot/release/crash_recovery_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/crash_recovery_test.compartment", + "section_name": ".rodata", + "sha256": "3bbfc672e43b8c1f1bc152fbff7548b8ab98a0f205fc95aca3af31378dfee10d", + "size": 882 + } + ], + "name": ".crash_recovery_test_code", + "output": { + "sha256": "35e1f32f4a242ca10038b1527608190f33095f4bd77b3cda78425e2408aa6b32" + } + }, + "exports": [ + { + "export_symbol": "__export_crash_recovery_test__Z19test_crash_recoveryv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 366 + } + ], + "imports": [ + { + "compartment_name": "crash_recovery_inner", + "export_symbol": "__export_crash_recovery_inner__Z25test_crash_recovery_inneri", + "function": "test_crash_recovery_inner(int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/crash_recovery_inner.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "crash_recovery_outer", + "export_symbol": "__export_crash_recovery_outer__Z25test_crash_recovery_outeri", + "function": "test_crash_recovery_outer(int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/crash_recovery_outer.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + } + ] + }, + "crt": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/crt.library", + "section_name": ".text", + "sha256": "d2930725969be36d2e115337549238406a51bd9725b1b50277d5ebf3212444e9", + "size": 1594 + } + ], + "name": ".crt_code", + "output": { + "sha256": "e23f090f8db2360a118790c4810915236cb655465ed2e4df64ac1672b43c5685" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z3clzj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 24 + }, + { + "export_symbol": "__library_export_libcalls__Z3ctzj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 124 + }, + { + "export_symbol": "__library_export_libcalls___absvdi2", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 148 + }, + { + "export_symbol": "__library_export_libcalls___ashldi3", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 172 + }, + { + "export_symbol": "__library_export_libcalls___ashrdi3", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 220 + }, + { + "export_symbol": "__library_export_libcalls___clzsi2", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 268 + }, + { + "export_symbol": "__library_export_libcalls___clzdi2", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 340 + }, + { + "export_symbol": "__library_export_libcalls___ctzsi2", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 514 + }, + { + "export_symbol": "__library_export_libcalls___ctzdi2", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 588 + }, + { + "export_symbol": "__library_export_libcalls___divmoddi4", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 5, + "start_offset": 764 + }, + { + "export_symbol": "__library_export_libcalls___divdi3", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 4, + "start_offset": 1118 + }, + { + "export_symbol": "__library_export_libcalls___ffsdi2", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1212 + }, + { + "export_symbol": "__library_export_libcalls___lshrdi3", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 1236 + }, + { + "export_symbol": "__library_export_libcalls___moddi3", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 4, + "start_offset": 1284 + }, + { + "export_symbol": "__library_export_libcalls___popcountsi2", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 1380 + }, + { + "export_symbol": "__library_export_libcalls___popcountdi2", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1448 + }, + { + "export_symbol": "__library_export_libcalls___udivdi3", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 4, + "start_offset": 1578 + }, + { + "export_symbol": "__library_export_libcalls___umoddi3", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 4, + "start_offset": 1594 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls___lshrdi3", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/crt.library" + }, + { + "export_symbol": "__library_export_libcalls___ashldi3", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/crt.library" + } + ] + }, + "cxxrt": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/cxxrt.library", + "section_name": ".text", + "sha256": "f3b037b40ffdbc7436d2c17cd59b0a380bb573984c51a1a4b391073ac23a3817", + "size": 180 + } + ], + "name": ".cxxrt_code", + "output": { + "sha256": "fa15d6bfd1d30e6b527795984043521698d45190bd1b61b5ae41a6ee35515088" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls___cxa_guard_acquire", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 24 + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_release", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 128 + }, + { + "export_symbol": "__library_export_libcalls___cxa_atexit", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 200 + } + ], + "imports": [ + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + } + ] + }, + "debug": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/debug.library", + "section_name": ".text", + "sha256": "3b91ab77012b5daaf8c5b781068c7ce81a3481fbf0c1432020332eecc148c2c2", + "size": 1878 + }, + { + "file": "build/cheriot/cheriot/release/debug.library", + "section_name": ".rodata", + "sha256": "b4724e80548210ba1e6536dfc9d3244f4552004fb5e20f1b1a8d0e08c04a6de7", + "size": 224 + } + ], + "name": ".debug_code", + "output": { + "sha256": "bfe9de8cde56f3e37fc8e34100fa2be04582e89f5db8d81fea885c7694823939" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 32 + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 6, + "start_offset": 810 + } + ], + "imports": [ + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 268435456 + }, + { + "export_symbol": "__library_export_libcalls___divdi3", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/crt.library" + }, + { + "export_symbol": "__library_export_libcalls__Z6memcpyPvPKvj", + "function": "memcpy(void*, void const*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/freestanding.library" + } + ] + }, + "event_group": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/event_group.library", + "section_name": ".text", + "sha256": "7445f930122bb995c36b5b7108c4be491d0603d940cb5f5749c005ca4a5ed428", + "size": 1092 + } + ], + "name": ".event_group_code", + "output": { + "sha256": "f72d2a6035d737b6bf7c144653e01cb73df068ec39113e710beee2a31ea982e0" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z17eventgroup_createP7TimeoutP10SObjStructPP10EventGroup", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 88 + }, + { + "export_symbol": "__library_export_libcalls__Z15eventgroup_waitP7TimeoutP10EventGroupPjjbb", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 6, + "start_offset": 194 + }, + { + "export_symbol": "__library_export_libcalls__Z16eventgroup_clearP7TimeoutP10EventGroupPjj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 4, + "start_offset": 566 + }, + { + "export_symbol": "__library_export_libcalls__Z14eventgroup_setP7TimeoutP10EventGroupPjj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 4, + "start_offset": 656 + }, + { + "export_symbol": "__library_export_libcalls__Z14eventgroup_getP10EventGroupPj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 988 + }, + { + "export_symbol": "__library_export_libcalls__Z18eventgroup_destroyP10SObjStructP10EventGroup", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 996 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls__Z15flaglock_unlockP13FlagLockState", + "function": "flaglock_unlock(FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z9heap_freeP10SObjStructPv", + "function": "heap_free(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16flaglock_trylockP7TimeoutP13FlagLockState", + "function": "flaglock_trylock(Timeout*, FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13heap_allocateP7TimeoutP10SObjStructj", + "function": "heap_allocate(Timeout*, SObjStruct*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z13thread_id_getv", + "function": "thread_id_get()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z12thread_countv", + "function": "thread_count()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + } + ] + }, + "eventgroup_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/eventgroup_test.compartment", + "section_name": ".text", + "sha256": "256d171c0a2b1233ca6f80eb56bd7f3224d109507b77f681738a023a935d2b83", + "size": 1648 + }, + { + "file": "build/cheriot/cheriot/release/eventgroup_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/eventgroup_test.compartment", + "section_name": ".rodata", + "sha256": "3ea1f4ab79cace544cab098445ee6d8282aab8998f97f38069a565863cd1a62a", + "size": 641 + } + ], + "name": ".eventgroup_test_code", + "output": { + "sha256": "2a56feae9234711036ec5235b998e6bf40372721a65ca27327c5844c4f022fd7" + } + }, + "exports": [ + { + "export_symbol": "__export_eventgroup_test__Z15test_eventgroupv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 184 + }, + { + "export_symbol": "__export_eventgroup_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ15test_eventgroupvE3$_0EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 1602 + } + ], + "imports": [ + { + "contents": "00100000 00000000 00000000 00000000 00000000 00000000", + "kind": "SealedObject", + "sealing_type": { + "compartment": "alloc", + "key": "MallocKey", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "symbol": "__export.sealing_type.alloc.MallocKey" + } + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "compartment_name": "thread_pool", + "export_symbol": "__export_thread_pool__Z17thread_pool_asyncPU10chericcallFvPvES_", + "function": "thread_pool_async(void (void*) chericcall*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z17token_obj_destroyP10SObjStructP10SKeyStructS0_", + "function": "token_obj_destroy(SObjStruct*, SKeyStruct*, SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_acquire", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + }, + { + "compartment_name": "eventgroup_test", + "export_symbol": "__export_eventgroup_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ15test_eventgroupvE3$_0EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/eventgroup_test.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z14eventgroup_setP7TimeoutP10EventGroupPjj", + "function": "eventgroup_set(Timeout*, EventGroup*, unsigned int*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/event_group.library" + }, + { + "export_symbol": "__library_export_libcalls__Z15eventgroup_waitP7TimeoutP10EventGroupPjjbb", + "function": "eventgroup_wait(Timeout*, EventGroup*, unsigned int*, unsigned int, bool, bool)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/event_group.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13token_key_newv", + "function": "token_key_new()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "function": "token_obj_unseal(SKeyStruct*, SObjStruct*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cheriot.token_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z27token_sealed_unsealed_allocP7TimeoutP10SObjStructP10SKeyStructjPPv", + "function": "token_sealed_unsealed_alloc(Timeout*, SObjStruct*, SKeyStruct*, unsigned int, void**)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_sub_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16eventgroup_clearP7TimeoutP10EventGroupPjj", + "function": "eventgroup_clear(Timeout*, EventGroup*, unsigned int*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/event_group.library" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z17eventgroup_createP7TimeoutP10SObjStructPP10EventGroup", + "function": "eventgroup_create(Timeout*, SObjStruct*, EventGroup**)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/event_group.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z13thread_id_getv", + "function": "thread_id_get()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls__Z14eventgroup_getP10EventGroupPj", + "function": "eventgroup_get(EventGroup*, unsigned int*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/event_group.library" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_release", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + } + ] + }, + "freestanding": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/freestanding.library", + "section_name": ".text", + "sha256": "51ed150f6aa2010675491bd6d316993d87ac5ed674a80833a4c73f60612a17d4", + "size": 508 + } + ], + "name": ".freestanding_code", + "output": { + "sha256": "aa175d21601b2a5511177a2213d8e93c3fde84f25fa404a241526b3c647e050d" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z6memcmpPKvS0_j", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 8 + }, + { + "export_symbol": "__library_export_libcalls__Z6memcpyPvPKvj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 44 + }, + { + "export_symbol": "__library_export_libcalls__Z7memmovePvPKvj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 350 + }, + { + "export_symbol": "__library_export_libcalls__Z6memsetPvij", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 374 + }, + { + "export_symbol": "__library_export_libcalls__Z14explicit_bzeroPvj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 500 + } + ] + }, + "futex_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/futex_test.compartment", + "section_name": ".text", + "sha256": "3d72cc7d02c500adf3a07d775e85290413fd9566cabbfed05c1d4e07b618d6d5", + "size": 2750 + }, + { + "file": "build/cheriot/cheriot/release/futex_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/futex_test.compartment", + "section_name": ".rodata", + "sha256": "10bfdd78e58af93624a1c0baf8f2648bd2b50202c14edd4a584a09247c879dd3", + "size": 1843 + } + ], + "name": ".futex_test_code", + "output": { + "sha256": "87609030ec32f93dec615e83637986c7ead30c7a7b509c111531fe904eb6fe67" + } + }, + "exports": [ + { + "export_symbol": "__export_futex_test__Z10test_futexv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 120 + }, + { + "export_symbol": "__export_futex_test__ZN11thread_pool6detail22wrap_callback_functionIZ10test_futexvE3$_0EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 2064 + }, + { + "export_symbol": "__export_futex_test__ZN11thread_pool6detail22wrap_callback_functionIZ10test_futexvE3$_1EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 2508 + } + ], + "imports": [ + { + "contents": "04000101", + "kind": "SealedObject", + "sealing_type": { + "compartment": "sched", + "key": "InterruptKey", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment", + "symbol": "__export.sealing_type.sched.InterruptKey" + } + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "thread_pool", + "export_symbol": "__export_thread_pool__Z17thread_pool_asyncPU10chericcallFvPvES_", + "function": "thread_pool_async(void (void*) chericcall*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool.compartment" + }, + { + "compartment_name": "futex_test", + "export_symbol": "__export_futex_test__ZN11thread_pool6detail22wrap_callback_functionIZ10test_futexvE3$_0EEvPv", + "function": "void thread_pool::detail::wrap_callback_function(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/futex_test.compartment" + }, + { + "compartment_name": "futex_test", + "export_symbol": "__export_futex_test__ZN11thread_pool6detail22wrap_callback_functionIZ10test_futexvE3$_1EEvPv", + "function": "void thread_pool::detail::wrap_callback_function(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/futex_test.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z12thread_sleepP7Timeout", + "function": "thread_sleep(Timeout*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z13thread_id_getv", + "function": "thread_id_get()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z18interrupt_completeP10SObjStruct", + "function": "interrupt_complete(SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z19interrupt_futex_getP10SObjStruct", + "function": "interrupt_futex_get(SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + } + ] + }, + "locks": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/locks.library", + "section_name": ".text", + "sha256": "cf9a8b54480dc368f7e978f05af4783314da489e866645a59803ebe48d7ffa90", + "size": 1100 + } + ], + "name": ".locks_code", + "output": { + "sha256": "57bb2d707b8fd6c947f27533710582b06aba3771187103989dc887bc5dc87f36" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z16flaglock_trylockP7TimeoutP13FlagLockState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 72 + }, + { + "export_symbol": "__library_export_libcalls__Z36flaglock_priority_inheriting_trylockP7TimeoutP13FlagLockState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 266 + }, + { + "export_symbol": "__library_export_libcalls__Z15flaglock_unlockP13FlagLockState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 314 + }, + { + "export_symbol": "__library_export_libcalls__Z32flaglock_upgrade_for_destructionP13FlagLockState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 406 + }, + { + "export_symbol": "__library_export_libcalls__Z15ticketlock_lockP15TicketLockState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 540 + }, + { + "export_symbol": "__library_export_libcalls__Z17ticketlock_unlockP15TicketLockState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 648 + }, + { + "export_symbol": "__library_export_libcalls__Z22recursivemutex_trylockP7TimeoutP19RecursiveMutexState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 730 + }, + { + "export_symbol": "__library_export_libcalls__Z21recursivemutex_unlockP19RecursiveMutexState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 828 + }, + { + "export_symbol": "__library_export_libcalls__Z13semaphore_getP7TimeoutP22CountingSemaphoreState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 860 + }, + { + "export_symbol": "__library_export_libcalls__Z13semaphore_putP22CountingSemaphoreState", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 1034 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls___atomic_exchange_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_or_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_compare_exchange_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_add_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z13thread_id_getv", + "function": "thread_id_get()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + } + ] + }, + "locks_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/locks_test.compartment", + "section_name": ".text", + "sha256": "8a6506b58a910941754ff95899ad2159b46745d3ce48995527bacef15918b492", + "size": 6334 + }, + { + "file": "build/cheriot/cheriot/release/locks_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/locks_test.compartment", + "section_name": ".rodata", + "sha256": "1588ea9a3dccfd7cb8e80cf8da77c16288f8fa76a8c914659991570099f99306", + "size": 2275 + } + ], + "name": ".locks_test_code", + "output": { + "sha256": "345219ce1a10146b949dd21f25520c198931ecd9b7a8f40e3a436e27db49a307" + } + }, + "exports": [ + { + "export_symbol": "__export_locks_test__Z10test_locksv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 280 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_125test_ticket_lock_orderingEvE3$_1EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 3784 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_125test_ticket_lock_orderingEvE3$_2EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 4118 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_125test_ticket_lock_overflowEvE3$_3EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 4460 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_125test_ticket_lock_overflowEvE3$_4EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 4706 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail22wrap_callback_functionIZN12_GLOBAL__N_120test_recursive_mutexEvE3$_0EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 4918 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_19test_lockI15FlagLockGenericILb0EEEEvRT_EUlvE_EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 5382 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_19test_lockI15FlagLockGenericILb1EEEEvRT_EUlvE_EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 5682 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_19test_lockI10TicketLockEEvRT_EUlvE_EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 5912 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_126test_destruct_lock_wake_upI15FlagLockGenericILb0EEEEvRT_EUlvE_EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 6152 + }, + { + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_126test_destruct_lock_wake_upI15FlagLockGenericILb1EEEEvRT_EUlvE_EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 6436 + } + ], + "imports": [ + { + "contents": "00100000 00000000 00000000 00000000 00000000 00000000", + "kind": "SealedObject", + "sealing_type": { + "compartment": "alloc", + "key": "MallocKey", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "symbol": "__export.sealing_type.alloc.MallocKey" + } + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "export_symbol": "__library_export_libcalls__Z15flaglock_unlockP13FlagLockState", + "function": "flaglock_unlock(FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "thread_pool", + "export_symbol": "__export_thread_pool__Z17thread_pool_asyncPU10chericcallFvPvES_", + "function": "thread_pool_async(void (void*) chericcall*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_19test_lockI15FlagLockGenericILb1EEEEvRT_EUlvE_EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda >(FlagLockGeneric&)::'lambda'()>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_125test_ticket_lock_orderingEvE3$_1EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda<(anonymous namespace)::test_ticket_lock_ordering()::$_1>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_125test_ticket_lock_orderingEvE3$_2EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda<(anonymous namespace)::test_ticket_lock_ordering()::$_2>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_19test_lockI15FlagLockGenericILb0EEEEvRT_EUlvE_EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda >(FlagLockGeneric&)::'lambda'()>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_125test_ticket_lock_overflowEvE3$_4EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda<(anonymous namespace)::test_ticket_lock_overflow()::$_4>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_125test_ticket_lock_overflowEvE3$_3EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda<(anonymous namespace)::test_ticket_lock_overflow()::$_3>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_19test_lockI10TicketLockEEvRT_EUlvE_EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda(TicketLock&)::'lambda'()>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_126test_destruct_lock_wake_upI15FlagLockGenericILb1EEEEvRT_EUlvE_EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda >(FlagLockGeneric&)::'lambda'()>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail20wrap_callback_lambdaIZN12_GLOBAL__N_126test_destruct_lock_wake_upI15FlagLockGenericILb0EEEEvRT_EUlvE_EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda >(FlagLockGeneric&)::'lambda'()>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__ZN11thread_pool6detail22wrap_callback_functionIZN12_GLOBAL__N_120test_recursive_mutexEvE3$_0EEvPv", + "function": "void thread_pool::detail::wrap_callback_function<(anonymous namespace)::test_recursive_mutex()::$_0>(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z17token_obj_destroyP10SObjStructP10SKeyStructS0_", + "function": "token_obj_destroy(SObjStruct*, SKeyStruct*, SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_acquire", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "export_symbol": "__library_export_libcalls__Z15ticketlock_lockP15TicketLockState", + "function": "ticketlock_lock(TicketLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z21recursivemutex_unlockP19RecursiveMutexState", + "function": "recursivemutex_unlock(RecursiveMutexState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13token_key_newv", + "function": "token_key_new()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16flaglock_trylockP7TimeoutP13FlagLockState", + "function": "flaglock_trylock(Timeout*, FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z36flaglock_priority_inheriting_trylockP7TimeoutP13FlagLockState", + "function": "flaglock_priority_inheriting_trylock(Timeout*, FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z27token_sealed_unsealed_allocP7TimeoutP10SObjStructP10SKeyStructjPPv", + "function": "token_sealed_unsealed_alloc(Timeout*, SObjStruct*, SKeyStruct*, unsigned int, void**)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_add_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "function": "token_obj_unseal(SKeyStruct*, SObjStruct*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cheriot.token_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z22recursivemutex_trylockP7TimeoutP19RecursiveMutexState", + "function": "recursivemutex_trylock(Timeout*, RecursiveMutexState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z17ticketlock_unlockP15TicketLockState", + "function": "ticketlock_unlock(TicketLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z12thread_sleepP7Timeout", + "function": "thread_sleep(Timeout*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z32flaglock_upgrade_for_destructionP13FlagLockState", + "function": "flaglock_upgrade_for_destruction(FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_release", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + } + ] + }, + "message_queue": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/message_queue.compartment", + "section_name": ".text", + "sha256": "d436028a31d5cbec4edb0666a2137e9cffcd4f74fe21f79da5a16229a5a3ba7f", + "size": 1192 + }, + { + "file": "build/cheriot/cheriot/release/message_queue.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + } + ], + "name": ".message_queue_code", + "output": { + "sha256": "498df9da872018c5a78ce80559f5df838fddcb787d9dd7b103f91c99d7984fd7" + } + }, + "exports": [ + { + "export_symbol": "__export.sealing_type.message_queue.SendHandle", + "exported": true, + "kind": "SealingKey" + }, + { + "export_symbol": "__export.sealing_type.message_queue.ReceiveHandle", + "exported": true, + "kind": "SealingKey" + }, + { + "export_symbol": "__export_message_queue__Z19queue_create_sealedP7TimeoutP10SObjStructPS2_S3_jj", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 6, + "start_offset": 168 + }, + { + "export_symbol": "__export_message_queue__Z20queue_destroy_sealedP7TimeoutP10SObjStructS2_", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 746 + }, + { + "export_symbol": "__export_message_queue__Z17queue_send_sealedP7TimeoutP10SObjStructPKv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 962 + }, + { + "export_symbol": "__export_message_queue__Z20queue_receive_sealedP7TimeoutP10SObjStructPv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 3, + "start_offset": 1052 + }, + { + "export_symbol": "__export_message_queue__Z37multiwaiter_queue_receive_init_sealedP17EventWaiterSourceP10SObjStruct", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1142 + }, + { + "export_symbol": "__export_message_queue__Z34multiwaiter_queue_send_init_sealedP17EventWaiterSourceP10SObjStruct", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1206 + }, + { + "export_symbol": "__export_message_queue__Z28queue_items_remaining_sealedP10SObjStructPj", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1270 + } + ], + "imports": [ + { + "export_symbol": "__export.sealing_type.message_queue.SendHandle", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/message_queue.compartment" + }, + { + "export_symbol": "__export.sealing_type.message_queue.ReceiveHandle", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/message_queue.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z12queue_createP7TimeoutP10SObjStructP11QueueHandlePPvjj", + "function": "queue_create(Timeout*, SObjStruct*, QueueHandle*, void**, unsigned int, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z15flaglock_unlockP13FlagLockState", + "function": "flaglock_unlock(FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z17token_obj_destroyP10SObjStructP10SKeyStructS0_", + "function": "token_obj_destroy(SObjStruct*, SKeyStruct*, SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z21check_timeout_pointerPK7Timeout", + "function": "check_timeout_pointer(Timeout const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls__Z10queue_sendP7TimeoutP11QueueHandlePKv", + "function": "queue_send(Timeout*, QueueHandle*, void const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z10heap_claimP10SObjStructPv", + "function": "heap_claim(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z30multiwaiter_queue_receive_initP17EventWaiterSourceP11QueueHandle", + "function": "multiwaiter_queue_receive_init(EventWaiterSource*, QueueHandle*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z22queue_make_send_handle11QueueHandle", + "function": "queue_make_send_handle(QueueHandle)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z9heap_freeP10SObjStructPv", + "function": "heap_free(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z13queue_receiveP7TimeoutP11QueueHandlePv", + "function": "queue_receive(Timeout*, QueueHandle*, void*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z21queue_items_remainingP11QueueHandlePj", + "function": "queue_items_remaining(QueueHandle*, unsigned int*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "function": "token_obj_unseal(SKeyStruct*, SObjStruct*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cheriot.token_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z27token_sealed_unsealed_allocP7TimeoutP10SObjStructP10SKeyStructjPPv", + "function": "token_sealed_unsealed_alloc(Timeout*, SObjStruct*, SKeyStruct*, unsigned int, void**)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z13check_pointerPKvjjb", + "function": "check_pointer(void const*, unsigned int, unsigned int, bool)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls__Z36flaglock_priority_inheriting_trylockP7TimeoutP13FlagLockState", + "function": "flaglock_priority_inheriting_trylock(Timeout*, FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z27multiwaiter_queue_send_initP17EventWaiterSourceP11QueueHandle", + "function": "multiwaiter_queue_send_init(EventWaiterSource*, QueueHandle*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z15heap_claim_fastP7TimeoutPKvS2_", + "function": "heap_claim_fast(Timeout*, void const*, void const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls__Z25queue_make_receive_handle11QueueHandle", + "function": "queue_make_receive_handle(QueueHandle)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + } + ] + }, + "message_queue_library": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/message_queue_library.library", + "section_name": ".text", + "sha256": "92901922a2579a88c835d8898711e81a3dacf57efc89338db72d6825fcae2ea6", + "size": 1618 + } + ], + "name": ".message_queue_library_code", + "output": { + "sha256": "45d32d80d3c9ac0b54323ee09b4ec425fa8d92730dab786ade8bbdac3a7e4713" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z25queue_make_receive_handle11QueueHandle", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 80 + }, + { + "export_symbol": "__library_export_libcalls__Z22queue_make_send_handle11QueueHandle", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 120 + }, + { + "export_symbol": "__library_export_libcalls__Z12queue_createP7TimeoutP10SObjStructP11QueueHandlePPvjj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 6, + "start_offset": 160 + }, + { + "export_symbol": "__library_export_libcalls__Z10queue_sendP7TimeoutP11QueueHandlePKv", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 320 + }, + { + "export_symbol": "__library_export_libcalls__Z13queue_receiveP7TimeoutP11QueueHandlePv", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 1118 + }, + { + "export_symbol": "__library_export_libcalls__Z21queue_items_remainingP11QueueHandlePj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1500 + }, + { + "export_symbol": "__library_export_libcalls__Z27multiwaiter_queue_send_initP17EventWaiterSourceP11QueueHandle", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1562 + }, + { + "export_symbol": "__library_export_libcalls__Z30multiwaiter_queue_receive_initP17EventWaiterSourceP11QueueHandle", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1638 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls___atomic_exchange_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls__Z13check_pointerPKvjjb", + "function": "check_pointer(void const*, unsigned int, unsigned int, bool)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_compare_exchange_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13heap_allocateP7TimeoutP10SObjStructj", + "function": "heap_allocate(Timeout*, SObjStruct*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z15heap_claim_fastP7TimeoutPKvS2_", + "function": "heap_claim_fast(Timeout*, void const*, void const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls__Z6memcpyPvPKvj", + "function": "memcpy(void*, void const*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/freestanding.library" + } + ] + }, + "mmio_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/mmio_test.compartment", + "section_name": ".text", + "sha256": "ceb5d7ba1afcd24660e91fe46b4bf70d8a3e625a7ba55992d4bba057be001c81", + "size": 1156 + }, + { + "file": "build/cheriot/cheriot/release/mmio_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/mmio_test.compartment", + "section_name": ".rodata", + "sha256": "2b0b5582a69d4625527eda14cda264046633962c60db5bef6d359c2af742bd4c", + "size": 108 + } + ], + "name": ".mmio_test_code", + "output": { + "sha256": "bc7eb6f2c43ea20ee79eab416dbebc013964e5b4b4ebcb120267a951ffd67452" + } + }, + "exports": [ + { + "export_symbol": "__export_mmio_test__Z9test_mmiov", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 204 + } + ], + "imports": [ + { + "kind": "MMIO", + "length": 256, + "permits_load": false, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": false, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": false, + "permits_load_mutable": false, + "permits_load_store_capabilities": true, + "permits_store": false, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": false, + "permits_load_mutable": true, + "permits_load_store_capabilities": false, + "permits_store": false, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": false, + "permits_load_mutable": true, + "permits_load_store_capabilities": true, + "permits_store": false, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": false, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": false, + "permits_load_mutable": false, + "permits_load_store_capabilities": true, + "permits_store": true, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": false, + "permits_load_mutable": true, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": false, + "permits_load_mutable": true, + "permits_load_store_capabilities": true, + "permits_store": true, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": false, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": true, + "permits_store": false, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": true, + "permits_load_store_capabilities": false, + "permits_store": false, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": true, + "permits_load_store_capabilities": true, + "permits_store": false, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": true, + "permits_store": true, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": true, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": true, + "permits_load_store_capabilities": true, + "permits_store": true, + "start": 268435456 + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z6memcpyPvPKvj", + "function": "memcpy(void*, void const*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/freestanding.library" + } + ] + }, + "multiwaiter_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/multiwaiter_test.compartment", + "section_name": ".text", + "sha256": "a04bff8b3e7c3b5141b7cc386fe3af7caf816c83d787f256c0734727631e9b43", + "size": 3252 + }, + { + "file": "build/cheriot/cheriot/release/multiwaiter_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/multiwaiter_test.compartment", + "section_name": ".rodata", + "sha256": "83540fde286cf043d6456782ef0c1e4cd2deed9dc6dd9c006ff8666e0bdef1da", + "size": 1025 + } + ], + "name": ".multiwaiter_test_code", + "output": { + "sha256": "8c88ea4b7d809215d25ec112145a9492fb63ae0e90c96ac45ee83acc944146e4" + } + }, + "exports": [ + { + "export_symbol": "__export_multiwaiter_test__Z16test_multiwaiterv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 208 + }, + { + "export_symbol": "__export_multiwaiter_test__ZN11thread_pool6detail20wrap_callback_lambdaIZZ16test_multiwaitervENK3$_0clEPjjEUlvE_EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 2362 + }, + { + "export_symbol": "__export_multiwaiter_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ16test_multiwaitervE3$_1EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 2938 + }, + { + "export_symbol": "__export_multiwaiter_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ16test_multiwaitervE3$_2EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 3274 + } + ], + "imports": [ + { + "contents": "00100000 00000000 00000000 00000000 00000000 00000000", + "kind": "SealedObject", + "sealing_type": { + "compartment": "alloc", + "key": "MallocKey", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "symbol": "__export.sealing_type.alloc.MallocKey" + } + }, + { + "export_symbol": "__library_export_libcalls__Z12queue_createP7TimeoutP10SObjStructP11QueueHandlePPvjj", + "function": "queue_create(Timeout*, SObjStruct*, QueueHandle*, void**, unsigned int, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "compartment_name": "thread_pool", + "export_symbol": "__export_thread_pool__Z17thread_pool_asyncPU10chericcallFvPvES_", + "function": "thread_pool_async(void (void*) chericcall*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z17token_obj_destroyP10SObjStructP10SKeyStructS0_", + "function": "token_obj_destroy(SObjStruct*, SKeyStruct*, SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_acquire", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + }, + { + "export_symbol": "__library_export_libcalls__Z10queue_sendP7TimeoutP11QueueHandlePKv", + "function": "queue_send(Timeout*, QueueHandle*, void const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z30multiwaiter_queue_receive_initP17EventWaiterSourceP11QueueHandle", + "function": "multiwaiter_queue_receive_init(EventWaiterSource*, QueueHandle*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z9heap_freeP10SObjStructPv", + "function": "heap_free(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z13queue_receiveP7TimeoutP11QueueHandlePv", + "function": "queue_receive(Timeout*, QueueHandle*, void*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "compartment_name": "multiwaiter_test", + "export_symbol": "__export_multiwaiter_test__ZN11thread_pool6detail20wrap_callback_lambdaIZZ16test_multiwaitervENK3$_0clEPjjEUlvE_EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/multiwaiter_test.compartment" + }, + { + "compartment_name": "multiwaiter_test", + "export_symbol": "__export_multiwaiter_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ16test_multiwaitervE3$_2EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/multiwaiter_test.compartment" + }, + { + "compartment_name": "multiwaiter_test", + "export_symbol": "__export_multiwaiter_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ16test_multiwaitervE3$_1EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/multiwaiter_test.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13token_key_newv", + "function": "token_key_new()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "function": "token_obj_unseal(SKeyStruct*, SObjStruct*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cheriot.token_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z27token_sealed_unsealed_allocP7TimeoutP10SObjStructP10SKeyStructjPPv", + "function": "token_sealed_unsealed_alloc(Timeout*, SObjStruct*, SKeyStruct*, unsigned int, void**)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z27multiwaiter_queue_send_initP17EventWaiterSourceP11QueueHandle", + "function": "multiwaiter_queue_send_init(EventWaiterSource*, QueueHandle*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16multiwaiter_waitP7TimeoutP11MultiWaiterP17EventWaiterSourcej", + "function": "multiwaiter_wait(Timeout*, MultiWaiter*, EventWaiterSource*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z12thread_sleepP7Timeout", + "function": "thread_sleep(Timeout*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z18multiwaiter_deleteP10SObjStructP11MultiWaiter", + "function": "multiwaiter_delete(SObjStruct*, MultiWaiter*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z18multiwaiter_createP7TimeoutP10SObjStructPP11MultiWaiterj", + "function": "multiwaiter_create(Timeout*, SObjStruct*, MultiWaiter**, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_release", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + } + ] + }, + "queue_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/queue_test.compartment", + "section_name": ".text", + "sha256": "703a27c5ee13b93246c4e9f2a34c7163efe13a0053bc2015773de8fbaed8676d", + "size": 3410 + }, + { + "file": "build/cheriot/cheriot/release/queue_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/queue_test.compartment", + "section_name": ".rodata", + "sha256": "db325b5a645114b3f02ab0933031a9e5808bd5e948fbf8b600c999e1094116aa", + "size": 1555 + } + ], + "name": ".queue_test_code", + "output": { + "sha256": "181e3f28c2c3d145cf54cc3cc8a95eb6ee3d838020e9048911feb09e4cd7c5eb" + } + }, + "exports": [ + { + "export_symbol": "__export_queue_test__Z10test_queuev", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 2968 + } + ], + "imports": [ + { + "contents": "00100000 00000000 00000000 00000000 00000000 00000000", + "kind": "SealedObject", + "sealing_type": { + "compartment": "alloc", + "key": "MallocKey", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "symbol": "__export.sealing_type.alloc.MallocKey" + } + }, + { + "export_symbol": "__library_export_libcalls__Z12queue_createP7TimeoutP10SObjStructP11QueueHandlePPvjj", + "function": "queue_create(Timeout*, SObjStruct*, QueueHandle*, void**, unsigned int, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "compartment_name": "message_queue", + "export_symbol": "__export_message_queue__Z20queue_destroy_sealedP7TimeoutP10SObjStructS2_", + "function": "queue_destroy_sealed(Timeout*, SObjStruct*, SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/message_queue.compartment" + }, + { + "compartment_name": "message_queue", + "export_symbol": "__export_message_queue__Z28queue_items_remaining_sealedP10SObjStructPj", + "function": "queue_items_remaining_sealed(SObjStruct*, unsigned int*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/message_queue.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z10queue_sendP7TimeoutP11QueueHandlePKv", + "function": "queue_send(Timeout*, QueueHandle*, void const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z9heap_freeP10SObjStructPv", + "function": "heap_free(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z13queue_receiveP7TimeoutP11QueueHandlePv", + "function": "queue_receive(Timeout*, QueueHandle*, void*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z21queue_items_remainingP11QueueHandlePj", + "function": "queue_items_remaining(QueueHandle*, unsigned int*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/message_queue_library.library" + }, + { + "compartment_name": "message_queue", + "export_symbol": "__export_message_queue__Z20queue_receive_sealedP7TimeoutP10SObjStructPv", + "function": "queue_receive_sealed(Timeout*, SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/message_queue.compartment" + }, + { + "compartment_name": "message_queue", + "export_symbol": "__export_message_queue__Z17queue_send_sealedP7TimeoutP10SObjStructPKv", + "function": "queue_send_sealed(Timeout*, SObjStruct*, void const*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/message_queue.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "message_queue", + "export_symbol": "__export_message_queue__Z19queue_create_sealedP7TimeoutP10SObjStructPS2_S3_jj", + "function": "queue_create_sealed(Timeout*, SObjStruct*, SObjStruct**, SObjStruct**, unsigned int, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/message_queue.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z6memcmpPKvS0_j", + "function": "memcmp(void const*, void const*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/freestanding.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z13thread_id_getv", + "function": "thread_id_get()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z20heap_quota_remainingP10SObjStruct", + "function": "heap_quota_remaining(SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + } + ] + }, + "scheduler": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/test-suite.scheduler.compartment", + "section_name": ".text", + "sha256": "0a221cdbd4638181513dc8712abbb4e238343531e00347434d3dfb9d11582e81", + "size": 3726 + } + ], + "name": "scheduler_code", + "output": { + "sha256": "ac7f82ee99adaf04b175f4e81e774006ebc78f57beb5e0cd46bcb92aefdc30b8" + } + }, + "exports": [ + { + "export_symbol": "__export.sealing_type.sched.InterruptKey", + "exported": true, + "kind": "SealingKey" + }, + { + "export_symbol": "__export_sched__Z15simulation_exitj", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 128 + }, + { + "export_symbol": "__export_sched__ZN5sched15scheduler_entryEPK16ThreadLoaderInfo", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 170 + }, + { + "export_symbol": "__export_sched__ZN5sched15exception_entryEP19TrustedStackGenericILj0EEjjj", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 534 + }, + { + "export_symbol": "__export_sched__Z21thread_systemtick_getv", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 934 + }, + { + "export_symbol": "__export_sched__Z12thread_sleepP7Timeout", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 944 + }, + { + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 1234 + }, + { + "export_symbol": "__export_sched__Z10futex_wakePjj", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 1838 + }, + { + "export_symbol": "__export_sched__Z18multiwaiter_createP7TimeoutP10SObjStructPP11MultiWaiterj", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 2286 + }, + { + "export_symbol": "__export_sched__Z18multiwaiter_deleteP10SObjStructP11MultiWaiter", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 2448 + }, + { + "export_symbol": "__export_sched__Z16multiwaiter_waitP7TimeoutP11MultiWaiterP17EventWaiterSourcej", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 4, + "start_offset": 2586 + }, + { + "export_symbol": "__export_sched__Z19interrupt_futex_getP10SObjStruct", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 3002 + }, + { + "export_symbol": "__export_sched__Z18interrupt_completeP10SObjStruct", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 3152 + }, + { + "export_symbol": "__export_sched__Z12thread_countv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 3182 + }, + { + "export_symbol": "__export_sched__Z26thread_elapsed_cycles_idlev", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 3188 + }, + { + "export_symbol": "__export_sched__Z29thread_elapsed_cycles_currentv", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 3194 + } + ], + "imports": [ + { + "kind": "MMIO", + "length": 256, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 268435456 + }, + { + "kind": "MMIO", + "length": 65536, + "permits_load": true, + "permits_load_mutable": false, + "permits_load_store_capabilities": false, + "permits_store": true, + "start": 33554432 + }, + { + "export_symbol": "__export.sealing_type.sched.InterruptKey", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z15flaglock_unlockP13FlagLockState", + "function": "flaglock_unlock(FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z21check_timeout_pointerPK7Timeout", + "function": "check_timeout_pointer(Timeout const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z15simulation_exitj", + "function": "simulation_exit(unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "export_symbol": "__library_export_libcalls__Z3clzj", + "function": "clz(unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/crt.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z9heap_freeP10SObjStructPv", + "function": "heap_free(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16flaglock_trylockP7TimeoutP13FlagLockState", + "function": "flaglock_trylock(Timeout*, FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z13check_pointerPKvjjb", + "function": "check_pointer(void const*, unsigned int, unsigned int, bool)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13heap_allocateP7TimeoutP10SObjStructj", + "function": "heap_allocate(Timeout*, SObjStruct*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13heap_can_freeP10SObjStructPv", + "function": "heap_can_free(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + } + ] + }, + "software_revoker": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/cheriot.software_revoker.compartment", + "section_name": ".text", + "sha256": "6ed1052fc4590f19451c69f44e51674c8766dd44ae74a35bd64966cd49235966", + "size": 350 + } + ], + "name": "software_revoker_code", + "output": { + "sha256": "cf70a93aa4dd9201f5d28e8da877ff3f86c1b41944a555c27446419f3f547ed5" + } + }, + "exports": [ + { + "export_symbol": "__export_software_revoker__Z12revoker_tickv", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 42 + }, + { + "export_symbol": "__export_software_revoker__Z17revoker_epoch_getv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 290 + } + ] + }, + "stack_integrity_thread": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/stack_integrity_thread.compartment", + "section_name": ".text", + "sha256": "85a2d4f07b891617fe6dbd7f14a0d65e62ba569347fb223982654877cc09c158", + "size": 688 + }, + { + "file": "build/cheriot/cheriot/release/stack_integrity_thread.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/stack_integrity_thread.compartment", + "section_name": ".rodata", + "sha256": "1ca832dedecfbd0fef62bee40497b1924c8d15a7fa7f5262e40d887ca1bcf489", + "size": 455 + } + ], + "name": ".stack_integrity_thread_code", + "output": { + "sha256": "c3a006fd8de6ca880a626fe1839e5e3b1f3d2e51b5b3f9b4cb15d09e4a5612ce" + } + }, + "exports": [ + { + "export_symbol": "__export_stack_integrity_thread__Z22set_expected_behaviourPbb", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 274 + }, + { + "export_symbol": "__export_stack_integrity_thread__Z20exhaust_thread_stackv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 298 + }, + { + "export_symbol": "__export_stack_integrity_thread__Z28set_csp_permissions_on_faultN5CHERI13PermissionSetE", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 372 + }, + { + "export_symbol": "__export_stack_integrity_thread__Z27set_csp_permissions_on_callN5CHERI13PermissionSetEPU10chericcallFvvE", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 428 + }, + { + "export_symbol": "__export_stack_integrity_thread__Z27test_stack_invalid_on_faultv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 494 + }, + { + "export_symbol": "__export_stack_integrity_thread__Z26test_stack_invalid_on_callPU10chericcallFvvE", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 562 + }, + { + "export_symbol": "__export_stack_integrity_thread__Z21exhaust_trusted_stackPU10chericcallFvvEPb", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 630 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + } + ] + }, + "stack_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/stack_test.compartment", + "section_name": ".text", + "sha256": "5c5adee3f8d9653b6dee0092a3124cbf889456bdb1e5d56b771b9b17c62fe87a", + "size": 1106 + }, + { + "file": "build/cheriot/cheriot/release/stack_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/stack_test.compartment", + "section_name": ".rodata", + "sha256": "cc4374709740aa46cb769fc61b78cf4085dd1fbb676f03acd61525aba2407b22", + "size": 531 + } + ], + "name": ".stack_test_code", + "output": { + "sha256": "734b096a260d34af1becbeef1cfddf0740ac07af11a918a1e6aa1e7676d27c95" + } + }, + "exports": [ + { + "export_symbol": "__export_stack_test__Z29test_trusted_stack_exhaustionv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 268 + }, + { + "export_symbol": "__export_stack_test__Z22cross_compartment_callv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 316 + }, + { + "export_symbol": "__export_stack_test__Z10test_stackv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 364 + } + ], + "imports": [ + { + "compartment_name": "stack_integrity_thread", + "export_symbol": "__export_stack_integrity_thread__Z20exhaust_thread_stackv", + "function": "exhaust_thread_stack()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_integrity_thread.compartment" + }, + { + "compartment_name": "stack_integrity_thread", + "export_symbol": "__export_stack_integrity_thread__Z27set_csp_permissions_on_callN5CHERI13PermissionSetEPU10chericcallFvvE", + "function": "set_csp_permissions_on_call(CHERI::PermissionSet, void () chericcall*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_integrity_thread.compartment" + }, + { + "compartment_name": "stack_integrity_thread", + "export_symbol": "__export_stack_integrity_thread__Z26test_stack_invalid_on_callPU10chericcallFvvE", + "function": "test_stack_invalid_on_call(void () chericcall*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_integrity_thread.compartment" + }, + { + "compartment_name": "stack_test", + "export_symbol": "__export_stack_test__Z22cross_compartment_callv", + "function": "cross_compartment_call()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_test.compartment" + }, + { + "compartment_name": "stack_integrity_thread", + "export_symbol": "__export_stack_integrity_thread__Z28set_csp_permissions_on_faultN5CHERI13PermissionSetE", + "function": "set_csp_permissions_on_fault(CHERI::PermissionSet)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_integrity_thread.compartment" + }, + { + "compartment_name": "stack_integrity_thread", + "export_symbol": "__export_stack_integrity_thread__Z21exhaust_trusted_stackPU10chericcallFvvEPb", + "function": "exhaust_trusted_stack(void () chericcall*, bool*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_integrity_thread.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "stack_integrity_thread", + "export_symbol": "__export_stack_integrity_thread__Z22set_expected_behaviourPbb", + "function": "set_expected_behaviour(bool*, bool)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_integrity_thread.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "stack_test", + "export_symbol": "__export_stack_test__Z29test_trusted_stack_exhaustionv", + "function": "test_trusted_stack_exhaustion()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_test.compartment" + }, + { + "compartment_name": "stack_integrity_thread", + "export_symbol": "__export_stack_integrity_thread__Z27test_stack_invalid_on_faultv", + "function": "test_stack_invalid_on_fault()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_integrity_thread.compartment" + } + ] + }, + "static_sealing_inner": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/static_sealing_inner.compartment", + "section_name": ".text", + "sha256": "426caf43942c90e3b704feb7f122fb6f54beb8c53a4ff198e167ac560d7f31aa", + "size": 910 + }, + { + "file": "build/cheriot/cheriot/release/static_sealing_inner.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/static_sealing_inner.compartment", + "section_name": ".rodata", + "sha256": "25cfdc9fb478e75e0d21b20ffb577d0dbcd0ee8f7497b5f9c20d158d0c1e8f2a", + "size": 520 + } + ], + "name": ".static_sealing_inner_code", + "output": { + "sha256": "b758a880fd2245a9559465e2b906fbc3ce613ccd4ccc46f6ce73259178106476" + } + }, + "exports": [ + { + "export_symbol": "__export.sealing_type.static_sealing_inner.SealingType", + "exported": true, + "kind": "SealingKey" + }, + { + "export_symbol": "__export_static_sealing_inner__Z25test_static_sealed_object6SealedI8TestTypeE", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 48 + } + ], + "imports": [ + { + "export_symbol": "__export.sealing_type.static_sealing_inner.SealingType", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/static_sealing_inner.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "function": "token_obj_unseal(SKeyStruct*, SObjStruct*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cheriot.token_library.library" + }, + { + "export_symbol": "__library_export_libcalls__Z13check_pointerPKvjjb", + "function": "check_pointer(void const*, unsigned int, unsigned int, bool)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/compartment_helpers.library" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + } + ] + }, + "static_sealing_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/static_sealing_test.compartment", + "section_name": ".text", + "sha256": "1f1b0a3354573e1cb84f214b914ade4dd60f84687b6447b1598ae05276dd13db", + "size": 40 + }, + { + "file": "build/cheriot/cheriot/release/static_sealing_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + } + ], + "name": ".static_sealing_test_code", + "output": { + "sha256": "64974e4063ef26d1e8406a2d7b4982e9a426444afaacc18c8dd81663a8157376" + } + }, + "exports": [ + { + "export_symbol": "__export_static_sealing_test__Z19test_static_sealingv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 24 + } + ], + "imports": [ + { + "contents": "2a000000", + "kind": "SealedObject", + "sealing_type": { + "compartment": "static_sealing_inner", + "key": "SealingType", + "provided_by": "build/cheriot/cheriot/release/static_sealing_inner.compartment", + "symbol": "__export.sealing_type.static_sealing_inner.SealingType" + } + }, + { + "compartment_name": "static_sealing_inner", + "export_symbol": "__export_static_sealing_inner__Z25test_static_sealed_object6SealedI8TestTypeE", + "function": "test_static_sealed_object(Sealed)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/static_sealing_inner.compartment" + } + ] + }, + "string": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/string.library", + "section_name": ".text", + "sha256": "2260c22246277457466c2dd3287a092b480e8b49f51fe09a47b115f845844b0d", + "size": 342 + } + ], + "name": ".string_code", + "output": { + "sha256": "974f6fd8e064bacfdb6ac162770ebe2db84d3414c5be65f9d2bc6db0b6ad31be" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z7strnstrPKcS0_j", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 24 + }, + { + "export_symbol": "__library_export_libcalls__Z6strcmpPKcS0_", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 124 + }, + { + "export_symbol": "__library_export_libcalls__Z7strncmpPKcS0_j", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 156 + }, + { + "export_symbol": "__library_export_libcalls__Z6strlenPKc", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 1, + "start_offset": 194 + }, + { + "export_symbol": "__library_export_libcalls__Z7strncpyPcPKcj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 218 + }, + { + "export_symbol": "__library_export_libcalls__Z6strchrPKci", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 2, + "start_offset": 276 + }, + { + "export_symbol": "__library_export_libcalls__Z7strlcpyPcPKcj", + "exported": true, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 3, + "start_offset": 300 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls__Z7strncmpPKcS0_j", + "function": "strncmp(char const*, char const*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/string.library" + }, + { + "export_symbol": "__library_export_libcalls__Z6strlenPKc", + "function": "strlen(char const*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/string.library" + } + ] + }, + "test_runner": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/test_runner.compartment", + "section_name": ".text", + "sha256": "4c06a4b77b21393cfe4d035a9d79a9d8ec4fb063d28950a8ba75ebf36d5cba4e", + "size": 2650 + }, + { + "file": "build/cheriot/cheriot/release/test_runner.compartment", + "section_name": ".init_array", + "sha256": "2e3e0916ab5f70e566e88f35bf5e87d9671ca226336ed621d36a9162763404ad", + "size": 8 + }, + { + "file": "build/cheriot/cheriot/release/test_runner.compartment", + "section_name": ".rodata", + "sha256": "4d0f58dd7c9c5a7ecc730651c270fccbfa3f1e3781f2e2ba728101cb564ba5fc", + "size": 1504 + } + ], + "name": ".test_runner_code", + "output": { + "sha256": "c4017795d8271808571b33ae9a09ac2351c203d7386899c3ee6f3b8d5c9bcccd" + } + }, + "exports": [ + { + "export_symbol": "__export_test_runner__Z9run_testsv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 300 + }, + { + "export_symbol": "__library_export_libcalls__GLOBAL__sub_I___cpp_global_constructors_test.cc.cc", + "exported": false, + "interrupt_status": "inherit", + "kind": "Function", + "register_arguments": 0, + "start_offset": 2808 + } + ], + "imports": [ + { + "compartment_name": "mmio_test", + "export_symbol": "__export_mmio_test__Z9test_mmiov", + "function": "test_mmio()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/mmio_test.compartment" + }, + { + "compartment_name": "crash_recovery_test", + "export_symbol": "__export_crash_recovery_test__Z19test_crash_recoveryv", + "function": "test_crash_recovery()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/crash_recovery_test.compartment" + }, + { + "compartment_name": "locks_test", + "export_symbol": "__export_locks_test__Z10test_locksv", + "function": "test_locks()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/locks_test.compartment" + }, + { + "compartment_name": "queue_test", + "export_symbol": "__export_queue_test__Z10test_queuev", + "function": "test_queue()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/queue_test.compartment" + }, + { + "compartment_name": "stack_test", + "export_symbol": "__export_stack_test__Z10test_stackv", + "function": "test_stack()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/stack_test.compartment" + }, + { + "compartment_name": "futex_test", + "export_symbol": "__export_futex_test__Z10test_futexv", + "function": "test_futex()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/futex_test.compartment" + }, + { + "compartment_name": "eventgroup_test", + "export_symbol": "__export_eventgroup_test__Z15test_eventgroupv", + "function": "test_eventgroup()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/eventgroup_test.compartment" + }, + { + "compartment_name": "check_pointer_test", + "export_symbol": "__export_check_pointer_test__Z18test_check_pointerv", + "function": "test_check_pointer()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/check_pointer_test.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z15simulation_exitj", + "function": "simulation_exit(unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "static_sealing_test", + "export_symbol": "__export_static_sealing_test__Z19test_static_sealingv", + "function": "test_static_sealing()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/static_sealing_test.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "allocator_test", + "export_symbol": "__export_allocator_test__Z14test_allocatorv", + "function": "test_allocator()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/allocator_test.compartment" + }, + { + "compartment_name": "multiwaiter_test", + "export_symbol": "__export_multiwaiter_test__Z16test_multiwaiterv", + "function": "test_multiwaiter()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/multiwaiter_test.compartment" + }, + { + "compartment_name": "thread_pool_test", + "export_symbol": "__export_thread_pool_test__Z16test_thread_poolv", + "function": "test_thread_pool()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool_test.compartment" + }, + { + "compartment_name": "compartment_calls_test", + "export_symbol": "__export_compartment_calls_test__Z21test_compartment_callv", + "function": "test_compartment_call()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/compartment_calls_test.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z6memcpyPvPKvj", + "function": "memcpy(void*, void const*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/freestanding.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_acquire", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_release", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + } + ] + }, + "thread_pool": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/thread_pool.compartment", + "section_name": ".text", + "sha256": "c03c928ded1cd99ca629131f138313189b415ac6393fc4d32bc91388a8a2af32", + "size": 786 + }, + { + "file": "build/cheriot/cheriot/release/thread_pool.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + } + ], + "name": ".thread_pool_code", + "output": { + "sha256": "b3941735a676dc75dbd4f05da96a07bedb37c464deba2a4d2b2d765726846d50" + } + }, + "exports": [ + { + "export_symbol": "__export_thread_pool__Z17thread_pool_asyncPU10chericcallFvPvES_", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 72 + }, + { + "export_symbol": "__export_thread_pool__Z15thread_pool_runv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 374 + } + ], + "imports": [ + { + "export_symbol": "__library_export_libcalls__Z15flaglock_unlockP13FlagLockState", + "function": "flaglock_unlock(FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z15ticketlock_lockP15TicketLockState", + "function": "ticketlock_lock(TicketLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls__Z16flaglock_trylockP7TimeoutP13FlagLockState", + "function": "flaglock_trylock(Timeout*, FlagLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_fetch_add_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z10futex_wakePjj", + "function": "futex_wake(unsigned int*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z16futex_timed_waitP7TimeoutPKjj14FutexWaitFlags", + "function": "futex_timed_wait(Timeout*, unsigned int const*, unsigned int, FutexWaitFlags)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z17ticketlock_unlockP15TicketLockState", + "function": "ticketlock_unlock(TicketLockState*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/locks.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + } + ] + }, + "thread_pool_test": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/thread_pool_test.compartment", + "section_name": ".text", + "sha256": "d50052aa9c6aee0df87c4c4617ece84853433161652e05cdba8f914961481639", + "size": 2920 + }, + { + "file": "build/cheriot/cheriot/release/thread_pool_test.compartment", + "section_name": ".init_array", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/cheriot/cheriot/release/thread_pool_test.compartment", + "section_name": ".rodata", + "sha256": "29019633241a8382b59de4b09f4407390f282c79251efef66ad56f8711726533", + "size": 1201 + } + ], + "name": ".thread_pool_test_code", + "output": { + "sha256": "059fed5c0a3d031cb2e33e95ce1847c8fa8b5d7fbe81b48c6a4ebbbce2b942ae" + } + }, + "exports": [ + { + "export_symbol": "__export_thread_pool_test__Z16test_thread_poolv", + "exported": true, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 608 + }, + { + "export_symbol": "__export_thread_pool_test__ZN11thread_pool6detail22wrap_callback_functionIZ16test_thread_poolvE3$_0EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 1990 + }, + { + "export_symbol": "__library_export_thread_pool_test__ZN5CHERI24with_interrupts_disabledIZZ16test_thread_poolvENK3$_0clEvEUlvE_EEDaOT_", + "exported": false, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 2014 + }, + { + "export_symbol": "__export_thread_pool_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ16test_thread_poolvE3$_1EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 2146 + }, + { + "export_symbol": "__library_export_thread_pool_test__ZN5CHERI24with_interrupts_disabledIZZ16test_thread_poolvENK3$_1clEvEUlvE_EEDaOT_", + "exported": false, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 2250 + }, + { + "export_symbol": "__export_thread_pool_test__ZN11thread_pool6detail22wrap_callback_functionIZ16test_thread_poolvE3$_2EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 0, + "start_offset": 2428 + }, + { + "export_symbol": "__export_thread_pool_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ16test_thread_poolvE3$_3EEvPv", + "exported": false, + "interrupt_status": "enabled", + "kind": "Function", + "register_arguments": 1, + "start_offset": 2820 + } + ], + "imports": [ + { + "contents": "00100000 00000000 00000000 00000000 00000000 00000000", + "kind": "SealedObject", + "sealing_type": { + "compartment": "alloc", + "key": "MallocKey", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment", + "symbol": "__export.sealing_type.alloc.MallocKey" + } + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "compartment_name": "thread_pool", + "export_symbol": "__export_thread_pool__Z17thread_pool_asyncPU10chericcallFvPvES_", + "function": "thread_pool_async(void (void*) chericcall*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool.compartment" + }, + { + "compartment_name": "thread_pool_test", + "export_symbol": "__export_thread_pool_test__ZN11thread_pool6detail22wrap_callback_functionIZ16test_thread_poolvE3$_2EEvPv", + "function": "void thread_pool::detail::wrap_callback_function(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool_test.compartment" + }, + { + "compartment_name": "thread_pool_test", + "export_symbol": "__export_thread_pool_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ16test_thread_poolvE3$_1EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool_test.compartment" + }, + { + "export_symbol": "__library_export_thread_pool_test__ZN5CHERI24with_interrupts_disabledIZZ16test_thread_poolvENK3$_0clEvEUlvE_EEDaOT_", + "function": "auto CHERI::with_interrupts_disabled(test_thread_pool()::$_0::operator()() const::'lambda'()&&)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/thread_pool_test.compartment" + }, + { + "compartment_name": "thread_pool_test", + "export_symbol": "__export_thread_pool_test__ZN11thread_pool6detail22wrap_callback_functionIZ16test_thread_poolvE3$_0EEvPv", + "function": "void thread_pool::detail::wrap_callback_function(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool_test.compartment" + }, + { + "export_symbol": "__library_export_thread_pool_test__ZN5CHERI24with_interrupts_disabledIZZ16test_thread_poolvENK3$_1clEvEUlvE_EEDaOT_", + "function": "auto CHERI::with_interrupts_disabled(test_thread_pool()::$_1::operator()() const::'lambda'()&&)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/thread_pool_test.compartment" + }, + { + "compartment_name": "thread_pool_test", + "export_symbol": "__export_thread_pool_test__ZN11thread_pool6detail20wrap_callback_lambdaIZ16test_thread_poolvE3$_3EEvPv", + "function": "void thread_pool::detail::wrap_callback_lambda(void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/thread_pool_test.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z17token_obj_destroyP10SObjStructP10SKeyStructS0_", + "function": "token_obj_destroy(SObjStruct*, SKeyStruct*, SObjStruct*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_acquire", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + }, + { + "export_symbol": "__library_export_libcalls___atomic_store_1", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic1.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z9heap_freeP10SObjStructPv", + "function": "heap_free(SObjStruct*, void*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13token_key_newv", + "function": "token_key_new()", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "function": "token_obj_unseal(SKeyStruct*, SObjStruct*)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cheriot.token_library.library" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z27token_sealed_unsealed_allocP7TimeoutP10SObjStructP10SKeyStructjPPv", + "function": "token_sealed_unsealed_alloc(Timeout*, SObjStruct*, SKeyStruct*, unsigned int, void**)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "compartment_name": "alloc", + "export_symbol": "__export_alloc__Z13heap_allocateP7TimeoutP10SObjStructj", + "function": "heap_allocate(Timeout*, SObjStruct*, unsigned int)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/cheriot.allocator.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z20debug_report_failurePKcS0_S0_iS0_P19DebugFormatArgumentj", + "function": "debug_report_failure(char const*, char const*, char const*, int, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "export_symbol": "__library_export_libcalls__Z23debug_log_message_writePKcS0_P19DebugFormatArgumentj", + "function": "debug_log_message_write(char const*, char const*, DebugFormatArgument*, unsigned int)", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/debug.library" + }, + { + "compartment_name": "sched", + "export_symbol": "__export_sched__Z12thread_sleepP7Timeout", + "function": "thread_sleep(Timeout*)", + "kind": "CompartmentExport", + "provided_by": "build/cheriot/cheriot/release/test-suite.scheduler.compartment" + }, + { + "export_symbol": "__library_export_libcalls__Z13thread_id_getv", + "function": "thread_id_get()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "export_symbol": "__library_export_libcalls___atomic_load_4", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/atomic4.library" + }, + { + "export_symbol": "__library_export_libcalls__Z25switcher_interrupt_threadPv", + "function": "switcher_interrupt_thread(void*)", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "export_symbol": "__library_export_libcalls__Z23switcher_current_threadv", + "function": "switcher_current_thread()", + "kind": "LibraryFunction", + "provided_by": "build/.objs/cheriot.switcher/cheriot/cheriot/release/__/sdk/core/switcher/entry.S.o" + }, + { + "export_symbol": "__library_export_libcalls___cxa_guard_release", + "kind": "LibraryFunction", + "provided_by": "build/cheriot/cheriot/release/cxxrt.library" + } + ] + }, + "token_library": { + "code": { + "inputs": [ + { + "file": "build/cheriot/cheriot/release/cheriot.token_library.library", + "section_name": ".text", + "sha256": "479144f5724234ff3377f16feebcf2093b15515730546b5276692e92fdf67491", + "size": 90 + } + ], + "name": "token_library_code", + "output": { + "sha256": "6586b8443dae726c9fee616bc574cfc904a4d03bffead50b360e51bfa7e5e49e" + } + }, + "exports": [ + { + "export_symbol": "__library_export_libcalls__Z16token_obj_unsealP10SKeyStructP10SObjStruct", + "exported": true, + "interrupt_status": "disabled", + "kind": "Function", + "register_arguments": 2, + "start_offset": 24 + } + ] + } + }, + "core": { + ".loader_code": { + "inputs": [ + { + "file": "build/.objs/cheriot.loader/cheriot/cheriot/release/__/sdk/core/loader/boot.cc.o", + "section_name": ".text", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "file": "build/.objs/cheriot.loader/cheriot/cheriot/release/__/sdk/core/loader/boot.cc.o", + "section_name": ".text.loader_entry_point", + "sha256": "0eaecd91c2014d37a7d4ebebc8ec91fcbfdf461e432e1a7918deb8f0f7418d00", + "size": 10336 + }, + { + "file": "build/.objs/cheriot.loader/cheriot/cheriot/release/__/sdk/core/loader/boot.cc.o", + "section_name": ".text._Z6memcpyPvPKvj", + "sha256": "5eaa48d2037d1c2a7db49baa3e7389308b68dc874f4b6ef19fb9ce0465fb5b38", + "size": 28 + }, + { + "file": "build/.objs/cheriot.loader/cheriot/cheriot/release/__/sdk/core/loader/boot.cc.o", + "section_name": ".rodata..L__const._ZN12_GLOBAL__N_110seal_entryIvEEPT_N5CHERI10CapabilityIS1_EEN6loader15InterruptStatusE.Sentries", + "sha256": "e712069a78edaf3b369c83fd75ee3688daff095c9f7b25d1ba45d51e374a601f", + "size": 12 + } + ], + "output": { + "sha256": "6172d83d4ec3ac2416be06abaaf7a7295ca6f8f034f92df6b97a2c78f135ab20" + }, + "section_name": ".loader_code" + }, + ".loader_data": { + "inputs": [ + { + "file": "build/.objs/cheriot.loader/cheriot/cheriot/release/__/sdk/core/loader/boot.cc.o", + "section_name": ".bss._ZN6loader4Root5rootsE", + "size": 40 + }, + { + "file": "build/.objs/cheriot.loader/cheriot/cheriot/release/__/sdk/core/loader/boot.cc.o", + "section_name": ".sdata", + "sha256": "707bf0b938f307b5c222e670598b865d5e1f8a8003df82c7abbf7c9f8fa4d720", + "size": 2 + }, + { + "file": "build/.objs/cheriot.loader/cheriot/cheriot/release/__/sdk/core/loader/boot.cc.o", + "section_name": ".sbss", + "size": 24 + } + ], + "output": { + "sha256": "10378c0b1e9192f3b3254766f3d8fc544686f10564a65cb1e1bc8eab55d7777b" + }, + "section_name": ".loader_data" + }, + ".loader_start": { + "inputs": [ + { + "file": "build/.objs/cheriot.loader/cheriot/cheriot/release/__/sdk/core/loader/boot.S.o", + "section_name": ".loader_start", + "sha256": "f265277f8629df37ec2cc1d65eac7ba5e60e3add2516c4493b029067499692ba", + "size": 372 + } + ], + "output": { + "sha256": "309bcbdfec4205aa4b29e6ca8a2005325cecf6ab094f65c570ade7fd66897fa9" + }, + "section_name": ".loader_start" + } + }, + "file": "build/cheriot/cheriot/release/test-suite", + "final_hash": "1b7d7e85f44dc2b473ae42a8a76d470a84c3b242f159219edb99e1071d3abb89", + "threads": [ + { + "entry_point": { + "compartment_name": "test_runner", + "function": "run_tests()", + "provided_by": "build/cheriot/cheriot/release/test_runner.compartment" + }, + "priority": 3, + "stack": { + "length": 2048, + "start": 2147486416 + }, + "trusted_stack": { + "length": 408, + "start": 2147484216 + } + }, + { + "entry_point": { + "compartment_name": "thread_pool", + "function": "thread_pool_run()", + "provided_by": "build/cheriot/cheriot/release/thread_pool.compartment" + }, + "priority": 2, + "stack": { + "length": 1536, + "start": 2147488464 + }, + "trusted_stack": { + "length": 384, + "start": 2147484624 + } + }, + { + "entry_point": { + "compartment_name": "thread_pool", + "function": "thread_pool_run()", + "provided_by": "build/cheriot/cheriot/release/thread_pool.compartment" + }, + "priority": 1, + "stack": { + "length": 1536, + "start": 2147490000 + }, + "trusted_stack": { + "length": 384, + "start": 2147485008 + } + } + ] +} \ No newline at end of file diff --git a/tests/main.cc b/tests/main.cc index ca77b1cc..60de5eca 100644 --- a/tests/main.cc +++ b/tests/main.cc @@ -1,4 +1,4 @@ -#include "test_case.h" +#include "rego_test.h" #include #include diff --git a/tests/test_case.h b/tests/rego_test.h similarity index 96% rename from tests/test_case.h rename to tests/rego_test.h index 7cc83bfa..518715d1 100644 --- a/tests/test_case.h +++ b/tests/rego_test.h @@ -95,7 +95,7 @@ namespace rego_test std::ostream& os) const; static std::optional maybe_get_object( - const Node& mapping, const std::string& name); + const std::filesystem::path& dir, const Node& mapping, const std::string& name); static std::optional maybe_get_string( const Node& mapping, const std::string& name); static std::string get_string(const Node& mapping, const std::string& name); @@ -125,4 +125,5 @@ namespace rego_test bool m_broken; }; + std::vector cheriot_builtins(); } diff --git a/tests/test_case.cc b/tests/test_case.cc index 660d34fe..970fb68d 100644 --- a/tests/test_case.cc +++ b/tests/test_case.cc @@ -1,5 +1,4 @@ -#include "test_case.h" - +#include "rego_test.h" #include "trieste/json.h" #include "trieste/wf.h" #include "trieste/yaml.h" @@ -146,7 +145,9 @@ namespace rego_test {} std::optional TestCase::maybe_get_object( - const Node& mapping, const std::string& name) + const std::filesystem::path& dir, + const Node& mapping, + const std::string& name) { Location loc(name); Nodes defs = mapping->lookdown(loc); @@ -155,14 +156,61 @@ namespace rego_test throw std::runtime_error("Expected exactly one " + name + " block"); } - if (defs.size() == 1) + if (defs.size() != 1) { - assert(defs[0] == json::Member); - Node val = defs[0] / json::Value; - return Top << val; + return std::nullopt; } - return std::nullopt; + assert(defs[0] == json::Member); + Node val = defs[0] / json::Value; + + auto value = val->location().view(); + value = value.substr(1, value.size() - 2); // remove quotes + auto path = dir / value; + + if (ends_with(value, ".json")) + { + if (!std::filesystem::exists(path)) + { + logging::Error() << "Could not find file " << path; + return std::nullopt; + } + + auto result = json::reader().file(path).read(); + if (result.ok) + { + return result.ast; + } + else + { + logging::Error err; + result.print_errors(err); + return std::nullopt; + } + } + + if (ends_with(value, ".yaml")) + { + if (!std::filesystem::exists(path)) + { + logging::Error() << "Could not find file " << path; + return std::nullopt; + } + + auto result = yaml::reader().file(path) >> yaml::to_json(); + if (result.ok) + { + return result.ast; + } + else + { + logging::Error err; + result.print_errors(err); + return std::nullopt; + } + } + + return Top << val; } std::optional TestCase::maybe_get_string( @@ -497,13 +545,15 @@ namespace rego_test throw std::runtime_error("Query is required"); } - auto data = maybe_get_object(test_case_obj, "data"); + auto data = + maybe_get_object(filename.parent_path(), test_case_obj, "data"); if (data.has_value() && (*data)->front() == json::Object) { test_case = test_case.data(*data); } - auto input = maybe_get_object(test_case_obj, "input"); + auto input = + maybe_get_object(filename.parent_path(), test_case_obj, "input"); if (input.has_value()) { test_case = test_case.input(*input); @@ -575,7 +625,8 @@ namespace rego_test const std::filesystem::path& debug_path, bool wf_checks) const { rego::Interpreter interpreter; - interpreter.builtins()->strict_errors(m_strict_error); + interpreter.builtins().strict_errors(m_strict_error); + interpreter.builtins().register_builtins(cheriot_builtins()); interpreter.wf_check_enabled(wf_checks) .debug_enabled(!debug_path.empty()) .debug_path(debug_path);