infix_internals.h

Go to the documentation of this file.

 
#pragma once
#include "common/infix_config.h"
#include "common/platform.h"
#include <infix/infix.h>
typedef struct {
#if defined(INFIX_OS_WINDOWS)
    HANDLE handle;           
    void * seh_registration; 
#else
    int shm_fd;          
    void * eh_frame_ptr; 
#endif
    void * rx_ptr; 
    void * rw_ptr; 
    size_t size;   
} infix_executable_t;
typedef struct {
    void * rw_ptr; 
    size_t size;   
} infix_protected_t;
struct infix_forward_t {
    infix_arena_t * arena;   
    bool is_external_arena;  
    infix_executable_t exec; 
    infix_type * return_type;  
    infix_type ** arg_types;   
    size_t num_args;           
    size_t num_fixed_args;     
    void * target_fn;          
    bool is_direct_trampoline; 
    bool is_safe;              
    size_t ref_count;          
    char * signature;          
};
typedef void (*infix_internal_dispatch_callback_fn)(infix_reverse_t *, void *, void **);
struct infix_reverse_t {
    infix_arena_t * arena;           
    infix_executable_t exec;         
    infix_protected_t protected_ctx; 
    infix_type * return_type;        
    infix_type ** arg_types;         
    size_t num_args;                 
    size_t num_fixed_args;           
    bool is_variadic;                
    void * user_callback_fn;         
    void * user_data;                
    infix_internal_dispatch_callback_fn
        internal_dispatcher; 
    infix_forward_t *
        cached_forward_trampoline; 
};
struct infix_arena_t {
    char * buffer;                     
    size_t capacity;                   
    size_t current_offset;             
    bool error;                        
    struct infix_arena_t * next_block; 
    size_t block_size;                 
};
// Mutex Abstraction for Internal Synchronization
#if defined(INFIX_OS_WINDOWS)
#include <windows.h>
typedef SRWLOCK infix_mutex_t;
#define INFIX_MUTEX_INITIALIZER SRWLOCK_INIT
#define INFIX_MUTEX_LOCK(m) AcquireSRWLockExclusive(m)
#define INFIX_MUTEX_UNLOCK(m) ReleaseSRWLockExclusive(m)
#define INFIX_MUTEX_DESTROY(m) ((void)0)
#else
#include <pthread.h>
typedef pthread_mutex_t infix_mutex_t;
#define INFIX_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
#define INFIX_MUTEX_LOCK(m) pthread_mutex_lock(m)
#define INFIX_MUTEX_UNLOCK(m) pthread_mutex_unlock(m)
#define INFIX_MUTEX_DESTROY(m) pthread_mutex_destroy(m)
#endif
 
typedef struct _infix_registry_entry_t {
    const char * name;                     
    uint64_t hash;                         
    infix_type * type;                     
    bool is_forward_declaration;           
    struct _infix_registry_entry_t * next; 
} _infix_registry_entry_t;
struct infix_registry_t {
    infix_arena_t * arena;              
    bool is_external_arena;             
    size_t num_buckets;                 
    size_t num_items;                   
    _infix_registry_entry_t ** buckets; 
};
typedef struct {
    const char * p;        
    const char * start;    
    infix_arena_t * arena; 
    int depth;             
} parser_state;
 
typedef struct {
    uint8_t * code;        
    size_t capacity;       
    size_t size;           
    bool error;            
    infix_arena_t * arena; 
} code_buffer;
struct infix_library_t {
    void * handle; 
#if defined(INFIX_OS_WINDOWS)
    bool is_pseudo_handle; 
#endif
};
// ABI Abstraction Layer
#define INFIX_MAX_STACK_ALLOC (1024 * 1024 * 4)
#define INFIX_MAX_ARG_SIZE (1024 * 64)
typedef enum {
    ARG_LOCATION_GPR,
#if defined(INFIX_ABI_AAPCS64)
    ARG_LOCATION_VPR,
    ARG_LOCATION_GPR_PAIR,
    ARG_LOCATION_GPR_REFERENCE,
    ARG_LOCATION_VPR_HFA,
#else  // x64 ABIs
    ARG_LOCATION_XMM,
    ARG_LOCATION_GPR_PAIR,
    ARG_LOCATION_SSE_SSE_PAIR,
    ARG_LOCATION_INTEGER_SSE_PAIR,
    ARG_LOCATION_SSE_INTEGER_PAIR,
#endif
    ARG_LOCATION_STACK
} infix_arg_location_type;
typedef struct {
    infix_arg_location_type type; 
    uint8_t reg_index;            
    uint8_t reg_index2;           
    uint32_t num_regs;            
    uint32_t stack_offset;        
} infix_arg_location;
typedef struct {
    size_t total_stack_alloc; 
    uint8_t num_gpr_args;     
#if defined(INFIX_ABI_AAPCS64)
    uint8_t num_vpr_args; 
#else
    uint8_t num_xmm_args; 
#endif
    infix_arg_location * arg_locations; 
    bool return_value_in_memory; 
    bool is_variadic;            
    size_t num_stack_args;       
    size_t num_args;             
    void * target_fn;            
    uint32_t max_align;          
    uint32_t prologue_size;      
    uint32_t epilogue_offset;    
} infix_call_frame_layout;
typedef struct {
    size_t total_stack_alloc;     
    int32_t return_buffer_offset; 
    int32_t args_array_offset;    
    int32_t saved_args_offset;    
    int32_t gpr_save_area_offset; 
    int32_t xmm_save_area_offset; 
    uint32_t max_align;           
    uint32_t prologue_size;       
} infix_reverse_call_frame_layout;
typedef struct {
    infix_status (*prepare_forward_call_frame)(infix_arena_t * arena,
                                               infix_call_frame_layout ** out_layout,
                                               infix_type * ret_type,
                                               infix_type ** arg_types,
                                               size_t num_args,
                                               size_t num_fixed_args,
                                               void * target_fn);
    infix_status (*generate_forward_prologue)(code_buffer * buf, infix_call_frame_layout * layout);
    infix_status (*generate_forward_argument_moves)(code_buffer * buf,
                                                    infix_call_frame_layout * layout,
                                                    infix_type ** arg_types,
                                                    size_t num_args,
                                                    size_t num_fixed_args);
    infix_status (*generate_forward_call_instruction)(code_buffer * buf, infix_call_frame_layout * layout);
    infix_status (*generate_forward_epilogue)(code_buffer * buf,
                                              infix_call_frame_layout * layout,
                                              infix_type * ret_type);
} infix_forward_abi_spec;
typedef struct {
    infix_status (*prepare_reverse_call_frame)(infix_arena_t * arena,
                                               infix_reverse_call_frame_layout ** out_layout,
                                               infix_reverse_t * context);
    infix_status (*generate_reverse_prologue)(code_buffer * buf, infix_reverse_call_frame_layout * layout);
    infix_status (*generate_reverse_argument_marshalling)(code_buffer * buf,
                                                          infix_reverse_call_frame_layout * layout,
                                                          infix_reverse_t * context);
    infix_status (*generate_reverse_dispatcher_call)(code_buffer * buf,
                                                     infix_reverse_call_frame_layout * layout,
                                                     infix_reverse_t * context);
    infix_status (*generate_reverse_epilogue)(code_buffer * buf,
                                              infix_reverse_call_frame_layout * layout,
                                              infix_reverse_t * context);
} infix_reverse_abi_spec;
 
typedef struct {
    infix_arg_location location;                 
    const infix_type * type;                     
    const infix_direct_arg_handler_t * handler;  
} infix_direct_arg_layout;
 
typedef struct {
    size_t total_stack_alloc;        
    size_t num_args;                 
    void * target_fn;                
    bool return_value_in_memory;     
    infix_direct_arg_layout * args;  
    uint32_t prologue_size;          
    uint32_t epilogue_offset;        
} infix_direct_call_frame_layout;
 
typedef struct {
    infix_status (*prepare_direct_forward_call_frame)(infix_arena_t * arena,
                                                      infix_direct_call_frame_layout ** out_layout,
                                                      infix_type * ret_type,
                                                      infix_type ** arg_types,
                                                      size_t num_args,
                                                      infix_direct_arg_handler_t * handlers,
                                                      void * target_fn);
    infix_status (*generate_direct_forward_prologue)(code_buffer * buf, infix_direct_call_frame_layout * layout);
    infix_status (*generate_direct_forward_argument_moves)(code_buffer * buf, infix_direct_call_frame_layout * layout);
    infix_status (*generate_direct_forward_call_instruction)(code_buffer * buf,
                                                             infix_direct_call_frame_layout * layout);
    infix_status (*generate_direct_forward_epilogue)(code_buffer * buf,
                                                     infix_direct_call_frame_layout * layout,
                                                     infix_type * ret_type);
 
} infix_direct_forward_abi_spec;
 
// Internal Function Prototypes (Shared across modules)
INFIX_INTERNAL void _infix_set_error(infix_error_category_t category, infix_error_code_t code, size_t position);
INFIX_INTERNAL void _infix_set_system_error(infix_error_category_t category,
                                            infix_error_code_t code,
                                            long system_code,
                                            const char * msg);
INFIX_INTERNAL void _infix_clear_error(void);
INFIX_INTERNAL void skip_whitespace(parser_state * state);
INFIX_INTERNAL void _infix_set_parser_error(parser_state * state, infix_error_code_t code);
INFIX_INTERNAL infix_type * parse_type(parser_state * state);
INFIX_INTERNAL infix_type * parse_primitive(parser_state * state);
 
INFIX_INTERNAL void _infix_type_recalculate_layout(infix_type * type);
INFIX_INTERNAL c23_nodiscard infix_status _infix_resolve_type_graph_inplace(infix_type ** type_ptr,
                                                                            infix_registry_t * registry);
INFIX_INTERNAL c23_nodiscard infix_status _infix_parse_type_internal(infix_type **, infix_arena_t **, const char *);
INFIX_INTERNAL c23_nodiscard infix_status _infix_type_print_body_only(char *,
                                                                      size_t,
                                                                      const infix_type *,
                                                                      infix_print_dialect_t);
INFIX_INTERNAL infix_type * _copy_type_graph_to_arena(infix_arena_t *, const infix_type *);
INFIX_INTERNAL size_t _infix_estimate_graph_size(infix_arena_t * temp_arena, const infix_type * type);
INFIX_INTERNAL const infix_forward_abi_spec * get_current_forward_abi_spec(void);
INFIX_INTERNAL const infix_reverse_abi_spec * get_current_reverse_abi_spec(void);
INFIX_INTERNAL const infix_direct_forward_abi_spec * get_current_direct_forward_abi_spec(void);
INFIX_INTERNAL void code_buffer_init(code_buffer * buf, infix_arena_t * arena);
INFIX_INTERNAL void code_buffer_append(code_buffer * buf, const void * data, size_t len);
INFIX_INTERNAL void emit_byte(code_buffer * buf, uint8_t byte);
INFIX_INTERNAL void emit_int32(code_buffer * buf, int32_t value);
INFIX_INTERNAL void emit_int64(code_buffer * buf, int64_t value);
INFIX_INTERNAL c23_nodiscard infix_executable_t infix_executable_alloc(size_t size);
INFIX_INTERNAL void infix_executable_free(infix_executable_t exec);
typedef enum {
    INFIX_EXECUTABLE_FORWARD,
    INFIX_EXECUTABLE_SAFE_FORWARD,
    INFIX_EXECUTABLE_REVERSE,
    INFIX_EXECUTABLE_DIRECT
} infix_executable_category_t;
 
INFIX_INTERNAL c23_nodiscard bool infix_executable_make_executable(infix_executable_t * exec,
                                                                   infix_executable_category_t category,
                                                                   uint32_t prologue_size,
                                                                   uint32_t epilogue_offset);
INFIX_INTERNAL c23_nodiscard infix_protected_t infix_protected_alloc(size_t size);
INFIX_INTERNAL void infix_protected_free(infix_protected_t prot);
INFIX_INTERNAL c23_nodiscard bool infix_protected_make_readonly(infix_protected_t prot);
INFIX_INTERNAL void infix_internal_dispatch_callback_fn_impl(infix_reverse_t * context,
                                                             void * return_value_ptr,
                                                             void ** args_array);
 
// Utility Macros & Inlines
#define EMIT_BYTES(buf, ...)                             \
    do {                                                 \
        const uint8_t bytes[] = {__VA_ARGS__};           \
        code_buffer_append((buf), bytes, sizeof(bytes)); \
    } while (0)
static inline size_t _infix_align_up(size_t value, size_t alignment) {
    return (value + alignment - 1) & ~(alignment - 1);
}
static inline bool is_float16(const infix_type * type) {
    return type->category == INFIX_TYPE_PRIMITIVE && type->meta.primitive_id == INFIX_PRIMITIVE_FLOAT16;
}
static inline bool is_float(const infix_type * type) {
    return type->category == INFIX_TYPE_PRIMITIVE && type->meta.primitive_id == INFIX_PRIMITIVE_FLOAT;
}
static inline bool is_double(const infix_type * type) {
    return type->category == INFIX_TYPE_PRIMITIVE && type->meta.primitive_id == INFIX_PRIMITIVE_DOUBLE;
}
static inline bool is_long_double(const infix_type * type) {
    return type->category == INFIX_TYPE_PRIMITIVE && type->meta.primitive_id == INFIX_PRIMITIVE_LONG_DOUBLE;
}
// Include architecture-specific emitter prototypes for internal use by the JIT engine.
#if defined(INFIX_ABI_SYSV_X64) || defined(INFIX_ABI_WINDOWS_X64)
#include "arch/x64/abi_x64_emitters.h"
#elif defined(INFIX_ABI_AAPCS64)
#include "arch/aarch64/abi_arm64_emitters.h"
#endif
 
// Trampoline Caching
INFIX_INTERNAL infix_forward_t * _infix_cache_lookup(const char * signature, void * target_fn, bool is_safe);
INFIX_INTERNAL void _infix_cache_insert(infix_forward_t * trampoline);
INFIX_INTERNAL bool _infix_cache_remove(infix_forward_t * trampoline);
INFIX_INTERNAL void _infix_cache_release(infix_forward_t * trampoline);
INFIX_INTERNAL void _infix_cache_clear(void);
 
// Internal Cleanup
INFIX_INTERNAL void _infix_forward_destroy_internal(infix_forward_t * trampoline);