iree.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_IREE_H_
#define LOOMC_IREE_H_
 
#include <stddef.h>
 
#include "iree/base/api.h"
#include "iree/base/byte_sequence.h"
#include "loomc/byte_sequence.h"
#include "loomc/status.h"

 
#ifdef __cplusplus
extern "C" {
#endif

#if defined(__cplusplus)
#define LOOMC_IREE_STATIC_ASSERT static_assert
#else
#define LOOMC_IREE_STATIC_ASSERT _Static_assert
#endif
 
LOOMC_IREE_STATIC_ASSERT(sizeof(loomc_string_view_t) ==
                             sizeof(iree_string_view_t),
                         "loomc_string_view_t must match iree_string_view_t");
LOOMC_IREE_STATIC_ASSERT(offsetof(loomc_string_view_t, data) ==
                             offsetof(iree_string_view_t, data),
                         "string view data fields must match");
LOOMC_IREE_STATIC_ASSERT(offsetof(loomc_string_view_t, size) ==
                             offsetof(iree_string_view_t, size),
                         "string view size fields must match");
LOOMC_IREE_STATIC_ASSERT(sizeof(loomc_byte_span_t) ==
                             sizeof(iree_const_byte_span_t),
                         "loomc_byte_span_t must match iree_const_byte_span_t");
LOOMC_IREE_STATIC_ASSERT(offsetof(loomc_byte_span_t, data) ==
                             offsetof(iree_const_byte_span_t, data),
                         "byte span data fields must match");
LOOMC_IREE_STATIC_ASSERT(offsetof(loomc_byte_span_t, data_length) ==
                             offsetof(iree_const_byte_span_t, data_length),
                         "byte span length fields must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_OK, IREE_STATUS_OK,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_CANCELLED, IREE_STATUS_CANCELLED,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_UNKNOWN, IREE_STATUS_UNKNOWN,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_INVALID_ARGUMENT,
                           IREE_STATUS_INVALID_ARGUMENT,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_DEADLINE_EXCEEDED,
                           IREE_STATUS_DEADLINE_EXCEEDED,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_NOT_FOUND, IREE_STATUS_NOT_FOUND,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_ALREADY_EXISTS,
                           IREE_STATUS_ALREADY_EXISTS,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_PERMISSION_DENIED,
                           IREE_STATUS_PERMISSION_DENIED,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_RESOURCE_EXHAUSTED,
                           IREE_STATUS_RESOURCE_EXHAUSTED,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_FAILED_PRECONDITION,
                           IREE_STATUS_FAILED_PRECONDITION,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_ABORTED, IREE_STATUS_ABORTED,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_OUT_OF_RANGE, IREE_STATUS_OUT_OF_RANGE,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_UNIMPLEMENTED,
                           IREE_STATUS_UNIMPLEMENTED,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_INTERNAL, IREE_STATUS_INTERNAL,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_UNAVAILABLE, IREE_STATUS_UNAVAILABLE,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_DATA_LOSS, IREE_STATUS_DATA_LOSS,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_UNAUTHENTICATED,
                           IREE_STATUS_UNAUTHENTICATED,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_DEFERRED, IREE_STATUS_DEFERRED,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_INCOMPATIBLE, IREE_STATUS_INCOMPATIBLE,
                           "status code values must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_STATUS_CODE_MASK, IREE_STATUS_CODE_MASK,
                           "status code masks must match");
LOOMC_IREE_STATIC_ASSERT(LOOMC_STATUS_FEATURES == IREE_STATUS_FEATURES,
                         "status feature modes must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_ALLOCATOR_COMMAND_MALLOC,
                           IREE_ALLOCATOR_COMMAND_MALLOC,
                           "allocator malloc commands must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_ALLOCATOR_COMMAND_CALLOC,
                           IREE_ALLOCATOR_COMMAND_CALLOC,
                           "allocator calloc commands must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_ALLOCATOR_COMMAND_REALLOC,
                           IREE_ALLOCATOR_COMMAND_REALLOC,
                           "allocator realloc commands must match");
IREE_STATIC_ASSERT_ENUM_EQ(LOOMC_ALLOCATOR_COMMAND_FREE,
                           IREE_ALLOCATOR_COMMAND_FREE,
                           "allocator free commands must match");
LOOMC_IREE_STATIC_ASSERT(sizeof(loomc_allocator_alloc_params_t) ==
                             sizeof(iree_allocator_alloc_params_t),
                         "allocator parameter structures must match");
LOOMC_IREE_STATIC_ASSERT(offsetof(loomc_allocator_alloc_params_t,
                                  byte_length) ==
                             offsetof(iree_allocator_alloc_params_t,
                                      byte_length),
                         "allocator parameter byte lengths must match");

static inline loomc_status_t loomc_status_from_iree(iree_status_t status) {
  return status;
}

static inline iree_status_t iree_status_from_loomc(loomc_status_t status) {
  return status;
}

static inline loomc_string_view_t loomc_string_view_from_iree(
    iree_string_view_t value) {
  return loomc_make_string_view(value.data, value.size);
}

static inline iree_string_view_t iree_string_view_from_loomc(
    loomc_string_view_t value) {
  return iree_make_string_view(value.data, value.size);
}

static inline loomc_byte_span_t loomc_byte_span_from_iree(
    iree_const_byte_span_t value) {
  return loomc_make_byte_span(value.data, value.data_length);
}

static inline iree_const_byte_span_t iree_const_byte_span_from_loomc(
    loomc_byte_span_t value) {
  return iree_make_const_byte_span(value.data, value.data_length);
}

static inline loomc_byte_sequence_t* loomc_byte_sequence_from_iree(
    iree_byte_sequence_t* sequence) {
  return (loomc_byte_sequence_t*)sequence;
}

static inline iree_byte_sequence_t* iree_byte_sequence_from_loomc(
    loomc_byte_sequence_t* sequence) {
  return (iree_byte_sequence_t*)sequence;
}

static inline loomc_allocator_t loomc_allocator_from_iree(
    iree_allocator_t allocator) {
  loomc_allocator_t value = {
      allocator.self,
      allocator.ctl,
  };
  return value;
}

static inline iree_allocator_t iree_allocator_from_loomc(
    loomc_allocator_t allocator) {
  IREE_ASSERT_ARGUMENT(loomc_allocator_is_valid(allocator));
  iree_allocator_t value = {
      allocator.self,
      allocator.ctl,
  };
  return value;
}
 
#undef LOOMC_IREE_STATIC_ASSERT
 
#ifdef __cplusplus
}  // extern "C"
#endif
 
#endif  // LOOMC_IREE_H_