llvm.h

Go to the documentation of this file.

// Enhanced llvm.h - Complete module system declarations
#pragma once
// LLVM C API Headers
#include <llvm-c/Analysis.h>
#include <llvm-c/BitWriter.h>
#include <llvm-c/Core.h>
#include <llvm-c/ExecutionEngine.h>
#include <llvm-c/Target.h>
#include <llvm-c/TargetMachine.h>
#include <llvm-c/DebugInfo.h>
 
// Standard Library Headers
#include <llvm-c/Types.h>
#include <stdalign.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
// Project Headers
#include "../ast/ast.h"
#include "../c_libs/memory/memory.h"
 
#define SYMBOL_HASH_SIZE 1024
#define MAX_LINK_LIBS 64
 
typedef struct LLVM_Symbol LLVM_Symbol;
typedef struct CodeGenContext CodeGenContext;
typedef struct ModuleCompilationUnit ModuleCompilationUnit;
 
struct LLVM_Symbol {
  char *name;
  LLVMValueRef value;
  LLVMTypeRef type;         // The type of the symbol itself
  LLVMTypeRef element_type; // For pointer types, what it points to
  bool is_function;
  struct LLVM_Symbol *next;
};
 
// Individual module compilation unit
struct ModuleCompilationUnit {
  char *module_name;
  LLVMModuleRef module;
  LLVM_Symbol *symbols;
  bool is_main_module;
  struct ModuleCompilationUnit *next;
 
  const char *link_libs[MAX_LINK_LIBS];
  size_t link_lib_count;
 
  LLVMDIBuilderRef dibuilder;
  LLVMMetadataRef compile_unit;
  LLVMMetadataRef file_metadata;
};
 
typedef struct ModuleDependencyInfo {
  const char *module_name;
  char **dependencies; // Array of module names this depends on
  size_t dep_count;
  bool processed;
} ModuleDependencyInfo;
 
typedef struct DeferredStatement {
  AstNode *statement;
  LLVMBasicBlockRef cleanup_block;
  struct DeferredStatement *next;
} DeferredStatement;
 
typedef struct StructInfo {
  char *name;
  LLVMTypeRef llvm_type;
  char **field_names;
  LLVMTypeRef *field_types;
  LLVMTypeRef *field_element_types;
  bool *field_is_public;
  size_t field_count;
  bool is_public;
  struct StructInfo *next;
} StructInfo;
 
typedef struct CommonTypes {
  // Integer types
  LLVMTypeRef i1, i8, i16, i32, i64;
 
  // Float types
  LLVMTypeRef f32, f64;
 
  // Special types
  LLVMTypeRef void_type;
  LLVMTypeRef i8_ptr;
 
  // Common constants (cached for performance)
  LLVMValueRef const_i32_0, const_i32_1;
  LLVMValueRef const_i64_0, const_i64_1;
} CommonTypes;
 
// Code generation context
struct CodeGenContext {
  // LLVM Core Components
  LLVMContextRef context;
  LLVMBuilderRef builder;
 
  // Module Management (New System)
  ModuleCompilationUnit *modules;
  ModuleCompilationUnit *current_module;
 
  // Legacy Support (for backward compatibility)
  LLVMModuleRef module;
 
  // Defer statement tracking
  struct DeferredStatement *deferred_statements;
  size_t deferred_count;
  size_t deferred_capacity;
 
  // Code Generation State
  LLVMValueRef current_function;
  LLVMBasicBlockRef loop_continue_block;
  LLVMBasicBlockRef loop_break_block;
 
  CommonTypes common_types;
  StructInfo *struct_types;
 
  const char *target_os;
 
  // Debug Info
  bool is_debug;
  LLVMMetadataRef current_func_di;
 
  // Memory Management
  ArenaAllocator *arena;
};
 
typedef struct SymbolHashEntry {
  const char *key; // "module_name:symbol_name"
  LLVM_Symbol *symbol;
  struct SymbolHashEntry *next;
} SymbolHashEntry;
 
typedef struct SymbolHashTable {
  SymbolHashEntry *buckets[SYMBOL_HASH_SIZE];
} SymbolHashTable;
 
// Hash table for struct types
typedef struct StructHashEntry {
  const char *name;
  StructInfo *info;
  struct StructHashEntry *next;
} StructHashEntry;
 
typedef struct StructHashTable {
  StructHashEntry *buckets[SYMBOL_HASH_SIZE];
} StructHashTable;
 
// =============================================================================
// MODULE MANAGEMENT FUNCTIONS
// =============================================================================
 
// Create a new module compilation unit
ModuleCompilationUnit *create_module_unit(CodeGenContext *ctx,
                                          const char *module_name);
 
// Find module by name
ModuleCompilationUnit *find_module(CodeGenContext *ctx,
                                   const char *module_name);
 
// Set current module for code generation
void set_current_module(CodeGenContext *ctx, ModuleCompilationUnit *module);
 
// Compile all modules to separate object files
bool compile_modules_to_objects(CodeGenContext *ctx, const char *output_dir);
 
// Generate external function declarations for cross-module calls
void generate_external_declarations(CodeGenContext *ctx,
                                    ModuleCompilationUnit *target_module);
void preprocess_all_modules(CodeGenContext *ctx);
StructInfo *find_struct_type_fast(CodeGenContext *ctx, const char *name);
void cleanup_module_caches(void);
void debug_object_files(const char *output_dir);
StructInfo *find_concrete_struct_for_base(CodeGenContext *ctx,
                                                  StructInfo *base_info,
                                                  const char *field_name);
 
unsigned int hash_string(const char *str);
 
void init_symbol_cache(void);
void cache_symbol(const char *module_name, const char *symbol_name,
                  LLVM_Symbol *symbol);
LLVM_Symbol *lookup_cached_symbol(const char *module_name,
                                  const char *symbol_name);
 
void init_struct_cache(void);
void cache_struct(const char *name, StructInfo *info);
StructInfo *lookup_cached_struct(const char *name);
StructInfo *find_struct_type_fast(CodeGenContext *ctx, const char *name);
LLVMValueRef codegen_expr_struct_assignment(CodeGenContext *ctx,
                                            AstNode *node);
 
// =============================================================================
// SYMBOL IMPORT AND MODULE INTEROP
// =============================================================================
 
// Import symbols from one module to another
void import_module_symbols(CodeGenContext *ctx,
                           ModuleCompilationUnit *source_module,
                           const char *alias);
 
// Import specific function symbol
void import_function_symbol(CodeGenContext *ctx, LLVM_Symbol *source_symbol,
                            ModuleCompilationUnit *source_module,
                            const char *alias);
 
// Import specific variable symbol
void import_variable_symbol(CodeGenContext *ctx, LLVM_Symbol *source_symbol,
                            ModuleCompilationUnit *source_module,
                            const char *alias);
 
// Enhanced symbol lookup with module support
LLVM_Symbol *find_symbol_with_module_support(CodeGenContext *ctx,
                                             const char *name);
 
// Debug info support
void setup_module_debug_info(CodeGenContext *ctx, ModuleCompilationUnit *unit,
                             const char *filename);
void finalize_module_debug_info(ModuleCompilationUnit *unit);
void finalize_all_debug_info(CodeGenContext *ctx);
void set_debug_location(CodeGenContext *ctx, unsigned line, unsigned column);
 
// =============================================================================
// MODULE UTILITY FUNCTIONS
// =============================================================================
 
// Check if module is the main module
bool is_main_module(ModuleCompilationUnit *unit);
 
// Set a module as the main module
void set_module_as_main(ModuleCompilationUnit *unit);
 
// Print module information for debugging
void print_module_info(CodeGenContext *ctx);
void debug_object_files(const char *output_dir);
 
// =============================================================================
// ENHANCED CORE API FUNCTIONS
// =============================================================================
 
// Context Management
CodeGenContext *init_codegen_context(ArenaAllocator *arena);
void cleanup_codegen_context(CodeGenContext *ctx);
 
// Enhanced Symbol Table Operations (now module-aware)
void add_symbol_to_module(ModuleCompilationUnit *module, const char *name,
                          LLVMValueRef value, LLVMTypeRef type,
                          bool is_function);
LLVM_Symbol *find_symbol_in_module(ModuleCompilationUnit *module,
                                   const char *name);
LLVM_Symbol *find_symbol_global(CodeGenContext *ctx, const char *name,
                                const char *module_name);
 
// Main Code Generation
bool generate_program_modules(CodeGenContext *ctx, AstNode *ast_root,
                              const char *output_dir);
 
// Object File Generation (per module)
bool generate_module_object_file(ModuleCompilationUnit *module,
                                 const char *output_path, bool is_debug);
 
// Existing API (preserved for compatibility)
void add_symbol(CodeGenContext *ctx, const char *name, LLVMValueRef value,
                LLVMTypeRef type, bool is_function);
LLVM_Symbol *find_symbol(CodeGenContext *ctx, const char *name);
char *print_llvm_ir(CodeGenContext *ctx);
bool generate_object_file(CodeGenContext *ctx, const char *object_filename);
bool generate_assembly_file(CodeGenContext *ctx, const char *asm_filename,
                            bool is_debug);
char *process_escape_sequences(const char *input);
LLVMLinkage get_function_linkage(AstNode *node);
 
void init_type_cache(CodeGenContext *ctx);
LLVMTypeRef get_int_type(CodeGenContext *ctx, unsigned bits);
LLVMTypeRef get_float_type(CodeGenContext *ctx, bool is_double);
LLVMValueRef get_const_int(CodeGenContext *ctx, unsigned bits, uint64_t value);
bool is_int_type(LLVMTypeRef type);
bool is_float_type(LLVMTypeRef type);
bool pointer_type(LLVMTypeRef type);
bool types_are_equal(LLVMTypeRef a, LLVMTypeRef b);
bool needs_conversion(LLVMTypeRef from, LLVMTypeRef to);
LLVMValueRef get_default_value(LLVMTypeRef type);
 
LLVMValueRef alloca_and_store(CodeGenContext *ctx, LLVMTypeRef type,
                              LLVMValueRef value, const char *name);
LLVMValueRef struct_gep_load(CodeGenContext *ctx, LLVMTypeRef struct_type,
                             LLVMValueRef ptr, unsigned index,
                             LLVMTypeRef element_type, const char *name);
void struct_gep_store(CodeGenContext *ctx, LLVMTypeRef struct_type,
                      LLVMValueRef ptr, unsigned index, LLVMValueRef value);
LLVMValueRef array_gep(CodeGenContext *ctx, LLVMTypeRef array_type,
                       LLVMValueRef array_ptr, LLVMValueRef index,
                       const char *name);
bool block_has_terminator(LLVMBuilderRef builder);
void branch_if_no_terminator(CodeGenContext *ctx, LLVMBasicBlockRef target);
LLVMValueRef build_global_string(CodeGenContext *ctx, const char *str,
                                 const char *name);
 
LLVMValueRef codegen_module_access(CodeGenContext *ctx, AstNode *node);
bool is_module_identifier(CodeGenContext *ctx, const char *name);
bool validate_module_access(CodeGenContext *ctx, const char *prefix,
                            const char *symbol_name);
const char *get_module_name_from_access(AstNode *node);
 
// =============================================================================
// ENHANCED STRUCT SUPPORT FUNCTIONS
// =============================================================================
 
// Core struct management
StructInfo *find_struct_type(CodeGenContext *ctx, const char *name);
void add_struct_type(CodeGenContext *ctx, StructInfo *struct_info);
int get_field_index(StructInfo *struct_info, const char *field_name);
bool is_field_access_allowed(CodeGenContext *ctx, StructInfo *struct_info,
                             int field_index);
StructInfo *find_concrete_struct_for_base(
    CodeGenContext *ctx,
    StructInfo     *base_info,
    const char     *field_name);
LLVMValueRef codegen_struct_method(CodeGenContext *ctx, AstNode *func_node,
                                   StructInfo *struct_info,
                                   const char *method_name, bool is_public,
                                   bool is_static);
 
// Struct literal/initializer support
LLVMValueRef codegen_struct_literal(CodeGenContext *ctx,
                                    const char *struct_name,
                                    LLVMValueRef *field_values,
                                    size_t field_count);
 
// =============================================================================
// STRUCT TYPE SYSTEM INTEGRATION
// =============================================================================
 
// Enhanced type checking for structs
bool is_struct_type(CodeGenContext *ctx, LLVMTypeRef type);
const char *get_struct_name_from_type(CodeGenContext *ctx, LLVMTypeRef type);
 
// Struct construction helpers
LLVMValueRef create_struct_zero_initializer(CodeGenContext *ctx,
                                            const char *struct_name);
LLVMValueRef create_struct_copy(CodeGenContext *ctx, LLVMValueRef src_struct,
                                StructInfo *struct_info);
 
// Struct debugging and introspection
void print_struct_info(CodeGenContext *ctx, const char *struct_name);
void debug_struct_layout(CodeGenContext *ctx, const char *struct_name);
 
StructInfo *find_struct_type(CodeGenContext *ctx, const char *name);
void add_struct_type(CodeGenContext *ctx, StructInfo *struct_info);
LLVMValueRef codegen_stmt_struct(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_field(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_struct_access(CodeGenContext *ctx, AstNode *node);
LLVMTypeRef codegen_type_struct(CodeGenContext *ctx, const char *struct_name);
 
// =============================================================================
// AST NODE HANDLERS - PUBLIC INTERFACE
// =============================================================================
 
// Primary Dispatch Functions
LLVMValueRef codegen_expr(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt(CodeGenContext *ctx, AstNode *node);
LLVMTypeRef codegen_type(CodeGenContext *ctx, AstNode *node);
 
// Enhanced handlers for module system
LLVMValueRef codegen_stmt_program_multi_module(CodeGenContext *ctx,
                                               AstNode *node);
LLVMValueRef codegen_stmt_module(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_use(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_os(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_link(CodeGenContext *ctx, AstNode *node);
 
// =============================================================================
// AST NODE HANDLERS - EXPRESSION TYPES
// =============================================================================
 
LLVMValueRef convert_value_to_type(CodeGenContext *ctx, LLVMValueRef value,
                                   LLVMTypeRef from_type, LLVMTypeRef to_type);
LLVMValueRef codegen_multidim_array_access(CodeGenContext *ctx,
                                           AstNode *base_expr,
                                           AstNode **indices,
                                           size_t index_count);
void copy_array_elements(CodeGenContext *ctx, LLVMValueRef dest_array,
                         LLVMTypeRef dest_type, LLVMValueRef src_array,
                         LLVMTypeRef src_type);
 
// Enhanced symbol management with element type support
void add_symbol_with_element_type(CodeGenContext *ctx, const char *name,
                                  LLVMValueRef value, LLVMTypeRef type,
                                  LLVMTypeRef element_type, bool is_function);
 
void add_symbol_to_module_with_element_type(
    ModuleCompilationUnit *module, const char *name, LLVMValueRef value,
    LLVMTypeRef type, LLVMTypeRef element_type, bool is_function);
 
// Helper function to extract element type from AST
LLVMTypeRef extract_element_type_from_ast(CodeGenContext *ctx,
                                          AstNode *type_node);
 
LLVMValueRef codegen_expr_literal(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_identifier(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_binary(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_unary(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_call(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_assignment(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_array(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_index(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_cast(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_input(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_system(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_syscall(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_sizeof(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_alloc(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_free(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_deref(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_addr(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_expr_struct_literal(CodeGenContext *ctx, AstNode *node);
 
// =============================================================================
// AST NODE HANDLERS - STATEMENT TYPES
// =============================================================================
 
LLVMValueRef codegen_stmt_program(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_expression(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_var_decl(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_function(CodeGenContext *ctx, AstNode *node);
 
bool is_enum_constant(LLVM_Symbol *sym);
int64_t get_enum_constant_value(LLVM_Symbol *sym);
LLVMValueRef codegen_stmt_enum(CodeGenContext *ctx, AstNode *node);
 
LLVMValueRef codegen_stmt_return(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_block(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_if(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_print(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_defer(CodeGenContext *ctx, AstNode *node);
 
LLVMValueRef codegen_infinite_loop(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_while_loop(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_for_loop(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_loop(CodeGenContext *ctx, AstNode *node);
 
LLVMValueRef codegen_stmt_break_continue(CodeGenContext *ctx, AstNode *node);
 
LLVMValueRef codegen_stmt_switch(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_case(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_stmt_default(CodeGenContext *ctx, AstNode *node);
LLVMValueRef codegen_case_value(CodeGenContext *ctx, AstNode *case_value);
LLVMValueRef codegen_enum_member_case(CodeGenContext *ctx,
                                      AstNode *member_expr);
 
// =============================================================================
// DEFER MANAGEMENT FUNCTIONS
// =============================================================================
 
void init_defer_stack(CodeGenContext *ctx);
void push_defer_statement(CodeGenContext *ctx, AstNode *statement);
void execute_deferred_statements_inline(CodeGenContext *ctx,
                                        DeferredStatement *defers);
void generate_cleanup_blocks(CodeGenContext *ctx);
void clear_defer_stack(CodeGenContext *ctx);
 
// =============================================================================
// RANGE SUPPORT FUNCTIONS - Add this new section
// =============================================================================
 
// Range type checking and manipulation
bool is_range_type(LLVMTypeRef type);
LLVMValueRef get_range_start_value(CodeGenContext *ctx,
                                   LLVMValueRef range_struct);
LLVMValueRef get_range_end_value(CodeGenContext *ctx,
                                 LLVMValueRef range_struct);
 
// Range creation helper (optional - for consistent range creation)
LLVMValueRef create_range_struct(CodeGenContext *ctx, LLVMValueRef start,
                                 LLVMValueRef end);
LLVMTypeRef get_range_struct_type(CodeGenContext *ctx,
                                  LLVMTypeRef element_type);
 
// Range operations (add these if you need them later)
LLVMValueRef range_contains(CodeGenContext *ctx, LLVMValueRef range_struct,
                            LLVMValueRef value);
LLVMValueRef range_length(CodeGenContext *ctx, LLVMValueRef range_struct);
 
// =============================================================================
// AST NODE HANDLERS - TYPE SYSTEM
// =============================================================================
 
LLVMTypeRef codegen_type_basic(CodeGenContext *ctx, AstNode *node);
LLVMTypeRef codegen_type_pointer(CodeGenContext *ctx, AstNode *node);
LLVMTypeRef codegen_type_array(CodeGenContext *ctx, AstNode *node);
LLVMTypeRef codegen_type_function(CodeGenContext *ctx, AstNode *node);