text: /**
   * \file wasmtime/config.h
   *
   * \brief Wasmtime-specific extensions to #wasm_config_t
   */
  
  #ifndef WASMTIME_CONFIG_H
  #define WASMTIME_CONFIG_H
  
  #include <wasm.h>
  #include <wasmtime/error.h>
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /**
   * \brief Specifier for how Wasmtime will compile code, values are in
   * #wasmtime_strategy_enum
   */
  typedef uint8_t wasmtime_strategy_t;
  
  /**
   * \brief Different ways that Wasmtime can compile WebAssembly
   *
   * The default value is #WASMTIME_STRATEGY_AUTO.
   */
  enum wasmtime_strategy_enum { // Strategy
    /// Wasmtime will automatically determine whether to use Cranelift or
    /// Lightbeam, and currently it will always pick Cranelift. This default may
    /// change over time though.
    WASMTIME_STRATEGY_AUTO,
  
    /// Indicates that Cranelift will unconditionally use Cranelift to compile
    /// WebAssembly code.
    WASMTIME_STRATEGY_CRANELIFT,
  
    /// Indicates that Cranelift will unconditionally use Lightbeam to compile
    /// WebAssembly code. Note that Lightbeam isn't always enabled at compile
    /// time, and if that's the case an error will be returned.
    WASMTIME_STRATEGY_LIGHTBEAM,
  };
  
  /**
   * \brief Specifier of what optimization level to use for generated JIT code.
   *
   * See #wasmtime_opt_level_enum for possible values.
   */
  typedef uint8_t wasmtime_opt_level_t;
  
  /**
   * \brief Different ways Wasmtime can optimize generated code.
   *
   * The default value is #WASMTIME_OPT_LEVEL_SPEED.
   */
  enum wasmtime_opt_level_enum { // OptLevel
    /// Generated code will not be optimized at all.
    WASMTIME_OPT_LEVEL_NONE,
    /// Generated code will be optimized purely for speed.
    WASMTIME_OPT_LEVEL_SPEED,
    /// Generated code will be optimized, but some speed optimizations are
    /// disabled if they cause the generated code to be significantly larger.
    WASMTIME_OPT_LEVEL_SPEED_AND_SIZE,
  };
  
  /**
   * \brief Different ways wasmtime can enable profiling JIT code.
   *
   * See #wasmtime_profiling_strategy_enum for possible values.
   */
  typedef uint8_t wasmtime_profiling_strategy_t;
  
  /**
   * \brief Different ways to profile JIT code.
   *
   * The default is #WASMTIME_PROFILING_STRATEGY_NONE.
   */
  enum wasmtime_profiling_strategy_enum { // ProfilingStrategy
    /// No profiling is enabled at runtime.
    WASMTIME_PROFILING_STRATEGY_NONE,
    /// Linux's "jitdump" support in `perf` is enabled and when Wasmtime is run
    /// under `perf` necessary calls will be made to profile generated JIT code.
    WASMTIME_PROFILING_STRATEGY_JITDUMP,
    /// Support for VTune will be enabled and the VTune runtime will be informed,
    /// at runtime, about JIT code.
    ///
    /// Note that this isn't always enabled at build time.
    WASMTIME_PROFILING_STRATEGY_VTUNE,
  };
  
  #define WASMTIME_CONFIG_PROP(ret, name, ty) \
      WASM_API_EXTERN ret wasmtime_config_##name##_set(wasm_config_t*, ty);
  
  /**
   * \brief Configures whether DWARF debug information is constructed at runtime
   * to describe JIT code.
   *
   * This setting is `false` by default. When enabled it will attempt to inform
   * native debuggers about DWARF debugging information for JIT code to more
   * easily debug compiled WebAssembly via native debuggers. This can also
   * sometimes improve the quality of output when profiling is enabled.
   */
  WASMTIME_CONFIG_PROP(void, debug_info, bool)
  
  /**
   * \brief Enables WebAssembly code to be interrupted.
   *
   * This setting is `false` by default. When enabled it will enable getting an
   * interrupt handle via #wasmtime_interrupt_handle_new which can be used to
   * interrupt currently-executing WebAssembly code.
   */
  WASMTIME_CONFIG_PROP(void, interruptable, bool)
  
  /**
   * \brief Whether or not fuel is enabled for generated code.
   *
   * This setting is `false` by default. When enabled it will enable fuel counting
   * meaning that fuel will be consumed every time a wasm instruction is executed,
   * and trap when reaching zero.
   */
  WASMTIME_CONFIG_PROP(void, consume_fuel, bool)
  
  /**
   * \brief Configures the maximum stack size, in bytes, that JIT code can use.
   *
   * This setting is 2MB by default. Configuring this setting will limit the
   * amount of native stack space that JIT code can use while it is executing. If
   * you're hitting stack overflow you can try making this setting larger, or if
   * you'd like to limit wasm programs to less stack you can also configure this.
   *
   * Note that this setting is not interpreted with 100% precision. Additionally
   * the amount of stack space that wasm takes is always relative to the first
   * invocation of wasm on the stack, so recursive calls with host frames in the
   * middle will all need to fit within this setting.
   */
  WASMTIME_CONFIG_PROP(void, max_wasm_stack, size_t)
  
  /**
   * \brief Configures whether the WebAssembly threading proposal is enabled.
   *
   * This setting is `false` by default.
   *
   * Note that threads are largely unimplemented in Wasmtime at this time.
   */
  WASMTIME_CONFIG_PROP(void, wasm_threads, bool)
  
  /**
   * \brief Configures whether the WebAssembly reference types proposal is
   * enabled.
   *
   * This setting is `false` by default.
   */
  WASMTIME_CONFIG_PROP(void, wasm_reference_types, bool)
  
  /**
   * \brief Configures whether the WebAssembly SIMD proposal is
   * enabled.
   *
   * This setting is `false` by default.
   */
  WASMTIME_CONFIG_PROP(void, wasm_simd, bool)
  
  /**
   * \brief Configures whether the WebAssembly bulk memory proposal is
   * enabled.
   *
   * This setting is `false` by default.
   */
  WASMTIME_CONFIG_PROP(void, wasm_bulk_memory, bool)
  
  /**
   * \brief Configures whether the WebAssembly multi value proposal is
   * enabled.
   *
   * This setting is `true` by default.
   */
  WASMTIME_CONFIG_PROP(void, wasm_multi_value, bool)
  
  /**
   * \brief Configures whether the WebAssembly multi-memory proposal is
   * enabled.
   *
   * This setting is `false` by default.
   */
  WASMTIME_CONFIG_PROP(void, wasm_multi_memory, bool)
  
  /**
   * \brief Configures whether the WebAssembly module linking proposal is
   * enabled.
   *
   * This setting is `false` by default.
   */
  WASMTIME_CONFIG_PROP(void, wasm_module_linking, bool)
  
  /**
   * \brief Configures how JIT code will be compiled.
   *
   * This setting is #WASMTIME_STRATEGY_AUTO by default.
   *
   * If the compilation strategy selected could not be enabled then an error is
   * returned.
   */
  WASMTIME_CONFIG_PROP(wasmtime_error_t*, strategy, wasmtime_strategy_t)
  
  /**
   * \brief Configures whether Cranelift's debug verifier is enabled.
   *
   * This setting in `false` by default.
   *
   * When cranelift is used for compilation this enables expensive debug checks
   * within Cranelift itself to verify it's correct.
   */
  WASMTIME_CONFIG_PROP(void, cranelift_debug_verifier, bool)
  
  /**
   * \brief Configures Cranelift's optimization level for JIT code.
   *
   * This setting in #WASMTIME_OPT_LEVEL_SPEED by default.
   */
  WASMTIME_CONFIG_PROP(void, cranelift_opt_level, wasmtime_opt_level_t)
  
  /**
   * \brief Configures the profiling strategy used for JIT code.
   *
   * This setting in #WASMTIME_PROFILING_STRATEGY_NONE by default.
   */
  WASMTIME_CONFIG_PROP(wasmtime_error_t*, profiler, wasmtime_profiling_strategy_t)
  
  /**
   * \brief Configures the maximum size for memory to be considered "static"
   *
   * For more information see the Rust documentation at
   * https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Config.html#method.static_memory_maximum_size.
   */
  WASMTIME_CONFIG_PROP(void, static_memory_maximum_size, uint64_t)
  
  /**
   * \brief Configures the guard region size for "static" memory.
   *
   * For more information see the Rust documentation at
   * https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Config.html#method.static_memory_guard_size.
   */
  WASMTIME_CONFIG_PROP(void, static_memory_guard_size, uint64_t)
  
  /**
   * \brief Configures the guard region size for "dynamic" memory.
   *
   * For more information see the Rust documentation at
   * https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Config.html#method.dynamic_memory_guard_size.
   */
  WASMTIME_CONFIG_PROP(void, dynamic_memory_guard_size, uint64_t)
  
  /**
   * \brief Enables Wasmtime's cache and loads configuration from the specified
   * path.
   *
   * By default the Wasmtime compilation cache is disabled. The configuration path
   * here can be `NULL` to use the default settings, and otherwise the argument
   * here must be a file on the filesystem with TOML configuration -
   * https://bytecodealliance.github.io/wasmtime/cli-cache.html.
   *
   * An error is returned if the cache configuration could not be loaded or if the
   * cache could not be enabled.
   */
  WASM_API_EXTERN wasmtime_error_t* wasmtime_config_cache_config_load(wasm_config_t*, const char*);
  
  #ifdef __cplusplus
  }  // extern "C"
  #endif
  
  #endif // WASMTIME_CONFIG_H
  
  