base.h

Go to the documentation of this file.

// Copyright 2026 The IREE Authors
//
// Licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
#ifndef LOOMC_BASE_H_
#define LOOMC_BASE_H_
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>

 
#ifdef __cplusplus
extern "C" {
#endif

#if defined(_WIN32) && defined(LOOMC_BUILDING_SHARED_LIBRARY)
#define LOOMC_API_EXPORT __declspec(dllexport)
#elif defined(_WIN32) && defined(LOOMC_USING_SHARED_LIBRARY)
#define LOOMC_API_EXPORT __declspec(dllimport)
#elif defined(LOOMC_BUILDING_SHARED_LIBRARY)
#define LOOMC_API_EXPORT __attribute__((visibility("default")))
#else
#define LOOMC_API_EXPORT
#endif

#define LOOMC_API_PTR

typedef size_t loomc_host_size_t;

#define LOOMC_HOST_SIZE_MAX ((loomc_host_size_t)(SIZE_MAX))

typedef struct iree_status_handle_t* loomc_status_t;

typedef struct loomc_string_view_t {
  const char* data;

  loomc_host_size_t size;
} loomc_string_view_t;

static inline loomc_string_view_t loomc_string_view_empty(void) {
  loomc_string_view_t value = {NULL, 0};
  return value;
}

static inline bool loomc_string_view_is_empty(loomc_string_view_t value) {
  return value.data == NULL || value.size == 0;
}

static inline loomc_string_view_t loomc_make_string_view(
    const char* data, loomc_host_size_t size) {
  loomc_string_view_t value = {data, size};
  return value;
}

static inline loomc_string_view_t loomc_make_cstring_view(const char* data) {
  loomc_string_view_t value = {data, data ? strlen(data) : 0};
  return value;
}

static inline bool loomc_string_view_equal(loomc_string_view_t lhs,
                                           loomc_string_view_t rhs) {
  if (lhs.size != rhs.size) {
    return false;
  }
  if (lhs.size == 0) {
    return true;
  }
  return memcmp(lhs.data, rhs.data, lhs.size) == 0;
}

typedef struct loomc_byte_span_t {
  const uint8_t* data;

  loomc_host_size_t data_length;
} loomc_byte_span_t;

static inline loomc_byte_span_t loomc_byte_span_empty(void) {
  loomc_byte_span_t value = {NULL, 0};
  return value;
}

static inline bool loomc_byte_span_is_empty(loomc_byte_span_t span) {
  return span.data == NULL || span.data_length == 0;
}

static inline loomc_byte_span_t loomc_make_byte_span(
    const void* data, loomc_host_size_t data_length) {
  loomc_byte_span_t value = {(const uint8_t*)data, data_length};
  return value;
}

typedef struct loomc_dimension3_t {
  uint32_t x;

  uint32_t y;

  uint32_t z;
} loomc_dimension3_t;

typedef enum loomc_structure_type_e {
  LOOMC_STRUCTURE_TYPE_NONE = 0,

  LOOMC_STRUCTURE_TYPE_SOURCE_OPTIONS = 1,

  LOOMC_STRUCTURE_TYPE_WORKSPACE_OPTIONS = 2,

  LOOMC_STRUCTURE_TYPE_CONTEXT_OPTIONS = 3,

  LOOMC_STRUCTURE_TYPE_LINK_INDEX_BUILDER_OPTIONS = 4,

  LOOMC_STRUCTURE_TYPE_LINKER_OPTIONS = 5,

  LOOMC_STRUCTURE_TYPE_LINK_OPTIONS = 6,

  LOOMC_STRUCTURE_TYPE_MODULE_SERIALIZE_OPTIONS = 7,

  LOOMC_STRUCTURE_TYPE_MODULE_DESERIALIZE_OPTIONS = 8,

  LOOMC_STRUCTURE_TYPE_COMPILER_OPTIONS = 9,

  LOOMC_STRUCTURE_TYPE_COMPILE_OPTIONS = 10,

  LOOMC_STRUCTURE_TYPE_PASS_PROGRAM_OPTIONS = 11,

  LOOMC_STRUCTURE_TYPE_CONTEXT_TARGET_OPTIONS = 12,

  LOOMC_STRUCTURE_TYPE_TARGET_PIPELINE_OPTIONS = 13,

  LOOMC_STRUCTURE_TYPE_SPIRV_EMIT_OPTIONS = 14,

  LOOMC_STRUCTURE_TYPE_TARGET_SPECIALIZATION_OPTIONS = 16,

  LOOMC_STRUCTURE_TYPE_SPIRV_PROFILE_OPTIONS = 17,

  LOOMC_STRUCTURE_TYPE_EMIT_OPTIONS = 18,

  LOOMC_STRUCTURE_TYPE_OPTION_DICT = 19,

  LOOMC_STRUCTURE_TYPE_SPIRV_VULKANINFO_PROFILE_OPTIONS = 20,

  LOOMC_STRUCTURE_TYPE_SOURCE_LOAD_OPTIONS = 21,

  LOOMC_STRUCTURE_TYPE_SPIRV_VULKAN_FUNCTION_TABLE = 22,

  LOOMC_STRUCTURE_TYPE_SPIRV_VULKAN_PROFILE_OPTIONS = 23,

  LOOMC_STRUCTURE_TYPE_IREE_HAL_PROFILE_OPTIONS = 24,

  LOOMC_STRUCTURE_TYPE_SPIRV_IREE_HAL_PROFILE_OPTIONS = 25,

  LOOMC_STRUCTURE_TYPE_MODULE_FUNCTION_QUERY_OPTIONS = 26,

  LOOMC_STRUCTURE_TYPE_MODULE_GLOBAL_QUERY_OPTIONS = 27,

  LOOMC_STRUCTURE_TYPE_AMDGPU_PROFILE_OPTIONS = 28,

  LOOMC_STRUCTURE_TYPE_AMDGPU_EMIT_OPTIONS = 29,

  LOOMC_STRUCTURE_TYPE_ARTIFACT_MANIFEST_OPTIONS = 30,

  LOOMC_STRUCTURE_TYPE_COMPILE_REPORT_OPTIONS = 31,

  LOOMC_STRUCTURE_TYPE_SANITIZER_OPTIONS = 32,

  LOOMC_STRUCTURE_TYPE_LAUNCH_CONFIG = 34,

  LOOMC_STRUCTURE_TYPE_AMDGPU_IREE_HAL_PROFILE_OPTIONS = 35,
} loomc_structure_type_t;

typedef struct loomc_option_entry_t {
  loomc_string_view_t key;

  loomc_string_view_t value;
} loomc_option_entry_t;

typedef struct loomc_option_dict_t {
  loomc_structure_type_t type;

  loomc_host_size_t structure_size;

  const void* next;

  const loomc_option_entry_t* entries;

  loomc_host_size_t entry_count;
} loomc_option_dict_t;

typedef uint32_t loomc_allocator_command_t;
enum {
  LOOMC_ALLOCATOR_COMMAND_MALLOC = 0,

  LOOMC_ALLOCATOR_COMMAND_CALLOC = 1,

  LOOMC_ALLOCATOR_COMMAND_REALLOC = 2,

  LOOMC_ALLOCATOR_COMMAND_FREE = 3,
};
 
#if !defined(IREE_ALLOCATOR_ALLOC_PARAMS_T_DEFINED_)
#define IREE_ALLOCATOR_ALLOC_PARAMS_T_DEFINED_
typedef struct iree_allocator_alloc_params_t {
  loomc_host_size_t byte_length;
} loomc_allocator_alloc_params_t;
#else
typedef struct iree_allocator_alloc_params_t loomc_allocator_alloc_params_t;
#endif  // !IREE_ALLOCATOR_ALLOC_PARAMS_T_DEFINED_

typedef loomc_status_t(LOOMC_API_PTR* loomc_allocator_ctl_fn_t)(
    void* self, loomc_allocator_command_t command, const void* params,
    void** inout_ptr);

typedef struct loomc_allocator_t {
  void* self;

  loomc_allocator_ctl_fn_t ctl;
} loomc_allocator_t;

static inline bool loomc_allocator_is_valid(loomc_allocator_t allocator) {
  return allocator.ctl != NULL;
}

LOOMC_API_EXPORT loomc_allocator_t loomc_allocator_system(void);

LOOMC_API_EXPORT loomc_status_t loomc_allocator_malloc(
    loomc_allocator_t allocator, loomc_host_size_t byte_length, void** out_ptr);

LOOMC_API_EXPORT loomc_status_t loomc_allocator_malloc_uninitialized(
    loomc_allocator_t allocator, loomc_host_size_t byte_length, void** out_ptr);

LOOMC_API_EXPORT loomc_status_t
loomc_string_view_clone(loomc_string_view_t source, loomc_allocator_t allocator,
                        loomc_string_view_t* out_string);

LOOMC_API_EXPORT void loomc_allocator_free(loomc_allocator_t allocator,
                                           void* ptr);
 
#ifdef __cplusplus
}  // extern "C"
#endif
 
#endif  // LOOMC_BASE_H_