mirror of
https://github.com/Ed94/Odin.git
synced 2026-06-14 01:42:22 -07:00
gingerBill
325 lines
9.0 KiB
C++
325 lines
9.0 KiB
C++
#if defined(GB_SYSTEM_WINDOWS)
|
|
#pragma warning(push)
|
|
#pragma warning(disable: 4200)
|
|
#pragma warning(disable: 4201)
|
|
#define restrict gb_restrict
|
|
#endif
|
|
|
|
#include "tilde/tb.h"
|
|
|
|
#define TB_TYPE_F16 TB_DataType{ { TB_INT, 0, 16 } }
|
|
#define TB_TYPE_I128 TB_DataType{ { TB_INT, 0, 128 } }
|
|
#define TB_TYPE_INT TB_TYPE_INTN(cast(u16)(8*build_context.int_size))
|
|
#define TB_TYPE_INTPTR TB_TYPE_INTN(cast(u16)(8*build_context.ptr_size))
|
|
|
|
#if defined(GB_SYSTEM_WINDOWS)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#define CG_STARTUP_RUNTIME_PROC_NAME "__$startup_runtime"
|
|
#define CG_CLEANUP_RUNTIME_PROC_NAME "__$cleanup_runtime"
|
|
#define CG_STARTUP_TYPE_INFO_PROC_NAME "__$startup_type_info"
|
|
#define CG_TYPE_INFO_DATA_NAME "__$type_info_data"
|
|
#define CG_TYPE_INFO_TYPES_NAME "__$type_info_types_data"
|
|
#define CG_TYPE_INFO_NAMES_NAME "__$type_info_names_data"
|
|
#define CG_TYPE_INFO_OFFSETS_NAME "__$type_info_offsets_data"
|
|
#define CG_TYPE_INFO_USINGS_NAME "__$type_info_usings_data"
|
|
#define CG_TYPE_INFO_TAGS_NAME "__$type_info_tags_data"
|
|
|
|
struct cgModule;
|
|
|
|
|
|
enum cgValueKind : u32 {
|
|
cgValue_Value, // rvalue
|
|
cgValue_Addr, // lvalue
|
|
cgValue_Symbol, // global
|
|
cgValue_Multi, // multiple values
|
|
};
|
|
|
|
struct cgValueMulti;
|
|
|
|
struct cgValue {
|
|
cgValueKind kind;
|
|
Type * type;
|
|
union {
|
|
// NOTE: any value in this union must be a pointer
|
|
TB_Symbol * symbol;
|
|
TB_Node * node;
|
|
cgValueMulti *multi;
|
|
};
|
|
};
|
|
|
|
struct cgValueMulti {
|
|
Slice<cgValue> values;
|
|
};
|
|
|
|
|
|
enum cgAddrKind {
|
|
cgAddr_Default,
|
|
cgAddr_Map,
|
|
cgAddr_Context,
|
|
cgAddr_SoaVariable,
|
|
|
|
cgAddr_RelativePointer,
|
|
cgAddr_RelativeSlice,
|
|
|
|
cgAddr_Swizzle,
|
|
cgAddr_SwizzleLarge,
|
|
};
|
|
|
|
struct cgAddr {
|
|
cgAddrKind kind;
|
|
cgValue addr;
|
|
union {
|
|
struct {
|
|
cgValue key;
|
|
Type *type;
|
|
Type *result;
|
|
} map;
|
|
struct {
|
|
Selection sel;
|
|
} ctx;
|
|
struct {
|
|
cgValue index;
|
|
Ast *index_expr;
|
|
} soa;
|
|
struct {
|
|
cgValue index;
|
|
Ast *node;
|
|
} index_set;
|
|
struct {
|
|
bool deref;
|
|
} relative;
|
|
struct {
|
|
Type *type;
|
|
u8 count; // 2, 3, or 4 components
|
|
u8 indices[4];
|
|
} swizzle;
|
|
struct {
|
|
Type *type;
|
|
Slice<i32> indices;
|
|
} swizzle_large;
|
|
};
|
|
};
|
|
|
|
|
|
struct cgTargetList {
|
|
cgTargetList *prev;
|
|
bool is_block;
|
|
// control regions
|
|
TB_Node * break_;
|
|
TB_Node * continue_;
|
|
TB_Node * fallthrough_;
|
|
};
|
|
|
|
struct cgBranchRegions {
|
|
Ast * label;
|
|
TB_Node *break_;
|
|
TB_Node *continue_;
|
|
};
|
|
|
|
enum cgDeferExitKind {
|
|
cgDeferExit_Default,
|
|
cgDeferExit_Return,
|
|
cgDeferExit_Branch,
|
|
};
|
|
|
|
enum cgDeferKind {
|
|
cgDefer_Node,
|
|
cgDefer_Proc,
|
|
};
|
|
|
|
struct cgDefer {
|
|
cgDeferKind kind;
|
|
isize scope_index;
|
|
isize context_stack_count;
|
|
TB_Node * control_region;
|
|
union {
|
|
Ast *stmt;
|
|
struct {
|
|
cgValue deferred;
|
|
Slice<cgValue> result_as_args;
|
|
} proc;
|
|
};
|
|
};
|
|
|
|
|
|
struct cgContextData {
|
|
cgAddr ctx;
|
|
isize scope_index;
|
|
isize uses;
|
|
};
|
|
|
|
struct cgControlRegion {
|
|
TB_Node *control_region;
|
|
isize scope_index;
|
|
};
|
|
|
|
struct cgProcedure {
|
|
u32 flags;
|
|
u16 state_flags;
|
|
|
|
cgProcedure *parent;
|
|
Array<cgProcedure *> children;
|
|
|
|
TB_Function *func;
|
|
TB_FunctionPrototype *proto;
|
|
TB_Symbol *symbol;
|
|
|
|
Entity * entity;
|
|
cgModule *module;
|
|
String name;
|
|
Type * type;
|
|
Ast * type_expr;
|
|
Ast * body;
|
|
u64 tags;
|
|
ProcInlining inlining;
|
|
bool is_foreign;
|
|
bool is_export;
|
|
bool is_entry_point;
|
|
bool is_startup;
|
|
|
|
TB_DebugType *debug_type;
|
|
|
|
cgValue value;
|
|
|
|
Ast *curr_stmt;
|
|
|
|
cgTargetList * target_list;
|
|
Array<cgDefer> defer_stack;
|
|
Array<Scope *> scope_stack;
|
|
Array<cgContextData> context_stack;
|
|
|
|
Array<cgControlRegion> control_regions;
|
|
Array<cgBranchRegions> branch_regions;
|
|
|
|
Scope *curr_scope;
|
|
i32 scope_index;
|
|
bool in_multi_assignment;
|
|
isize split_returns_index;
|
|
bool return_by_ptr;
|
|
|
|
|
|
PtrMap<Entity *, cgAddr> variable_map;
|
|
};
|
|
|
|
|
|
struct cgModule {
|
|
TB_Module * mod;
|
|
Checker * checker;
|
|
CheckerInfo *info;
|
|
LinkerData * linker_data;
|
|
|
|
RwMutex values_mutex;
|
|
PtrMap<Entity *, cgValue> values;
|
|
StringMap<cgValue> members;
|
|
|
|
StringMap<cgProcedure *> procedures;
|
|
PtrMap<TB_Function *, Entity *> procedure_values;
|
|
Array<cgProcedure *> procedures_to_generate;
|
|
|
|
RecursiveMutex debug_type_mutex;
|
|
PtrMap<Type *, TB_DebugType *> debug_type_map;
|
|
PtrMap<Type *, TB_DebugType *> proc_debug_type_map; // not pointer to
|
|
|
|
RecursiveMutex proc_proto_mutex;
|
|
PtrMap<Type *, TB_FunctionPrototype *> proc_proto_map;
|
|
|
|
PtrMap<uintptr, TB_FileID> file_id_map; // Key: AstFile.id (i32 cast to uintptr)
|
|
|
|
std::atomic<u32> nested_type_name_guid;
|
|
std::atomic<u32> const_nil_guid;
|
|
};
|
|
|
|
#ifndef ABI_PKG_NAME_SEPARATOR
|
|
#define ABI_PKG_NAME_SEPARATOR "@"
|
|
#endif
|
|
|
|
gb_global Entity *cg_global_type_info_data_entity = {};
|
|
gb_global cgAddr cg_global_type_info_member_types = {};
|
|
gb_global cgAddr cg_global_type_info_member_names = {};
|
|
gb_global cgAddr cg_global_type_info_member_offsets = {};
|
|
gb_global cgAddr cg_global_type_info_member_usings = {};
|
|
gb_global cgAddr cg_global_type_info_member_tags = {};
|
|
|
|
gb_global isize cg_global_type_info_data_index = 0;
|
|
gb_global isize cg_global_type_info_member_types_index = 0;
|
|
gb_global isize cg_global_type_info_member_names_index = 0;
|
|
gb_global isize cg_global_type_info_member_offsets_index = 0;
|
|
gb_global isize cg_global_type_info_member_usings_index = 0;
|
|
gb_global isize cg_global_type_info_member_tags_index = 0;
|
|
|
|
|
|
gb_internal TB_Arena *cg_arena(void);
|
|
|
|
gb_internal cgValue cg_value(TB_Global * g, Type *type);
|
|
gb_internal cgValue cg_value(TB_External *e, Type *type);
|
|
gb_internal cgValue cg_value(TB_Function *f, Type *type);
|
|
gb_internal cgValue cg_value(TB_Symbol * s, Type *type);
|
|
gb_internal cgValue cg_value(TB_Node * node, Type *type);
|
|
|
|
gb_internal cgAddr cg_addr(cgValue const &value);
|
|
|
|
|
|
gb_internal cgValue cg_const_value(cgProcedure *p, Type *type, ExactValue const &value);
|
|
gb_internal cgValue cg_const_nil(cgProcedure *p, Type *type);
|
|
|
|
gb_internal cgValue cg_flatten_value(cgProcedure *p, cgValue value);
|
|
|
|
gb_internal void cg_build_stmt(cgProcedure *p, Ast *stmt);
|
|
gb_internal void cg_build_stmt_list(cgProcedure *p, Slice<Ast *> const &stmts);
|
|
gb_internal void cg_build_when_stmt(cgProcedure *p, AstWhenStmt *ws);
|
|
|
|
gb_internal cgValue cg_build_expr(cgProcedure *p, Ast *expr);
|
|
gb_internal cgAddr cg_build_addr(cgProcedure *p, Ast *expr);
|
|
gb_internal cgValue cg_build_addr_ptr(cgProcedure *p, Ast *expr);
|
|
gb_internal cgValue cg_build_cond(cgProcedure *p, Ast *cond, TB_Node *true_block, TB_Node *false_block);
|
|
|
|
gb_internal Type * cg_addr_type(cgAddr const &addr);
|
|
gb_internal cgValue cg_addr_load(cgProcedure *p, cgAddr addr);
|
|
gb_internal void cg_addr_store(cgProcedure *p, cgAddr addr, cgValue value);
|
|
gb_internal cgValue cg_addr_get_ptr(cgProcedure *p, cgAddr const &addr);
|
|
|
|
gb_internal cgValue cg_emit_load(cgProcedure *p, cgValue const &ptr, bool is_volatile=false);
|
|
gb_internal void cg_emit_store(cgProcedure *p, cgValue dst, cgValue src, bool is_volatile=false);
|
|
|
|
gb_internal cgAddr cg_add_local(cgProcedure *p, Type *type, Entity *e, bool zero_init);
|
|
gb_internal cgValue cg_address_from_load_or_generate_local(cgProcedure *p, cgValue value);
|
|
gb_internal cgValue cg_copy_value_to_ptr(cgProcedure *p, cgValue value, Type *original_type, isize min_alignment);
|
|
|
|
gb_internal cgValue cg_build_call_expr(cgProcedure *p, Ast *expr);
|
|
gb_internal void cg_build_return_stmt(cgProcedure *p, Slice<Ast *> const &return_results);
|
|
gb_internal void cg_build_return_stmt_internal(cgProcedure *p, Slice<cgValue> const &results);
|
|
|
|
gb_internal cgValue cg_find_procedure_value_from_entity(cgModule *m, Entity *e);
|
|
|
|
gb_internal TB_DebugType *cg_debug_type(cgModule *m, Type *type);
|
|
|
|
gb_internal String cg_get_entity_name(cgModule *m, Entity *e);
|
|
|
|
gb_internal cgValue cg_typeid(cgProcedure *m, Type *t);
|
|
|
|
gb_internal cgValue cg_emit_ptr_offset(cgProcedure *p, cgValue ptr, cgValue index);
|
|
gb_internal cgValue cg_emit_array_ep(cgProcedure *p, cgValue s, cgValue index);
|
|
gb_internal cgValue cg_emit_array_epi(cgProcedure *p, cgValue s, i64 index);
|
|
gb_internal cgValue cg_emit_struct_ep(cgProcedure *p, cgValue s, i64 index);
|
|
gb_internal cgValue cg_emit_deep_field_gep(cgProcedure *p, cgValue e, Selection const &sel);
|
|
gb_internal cgValue cg_emit_struct_ev(cgProcedure *p, cgValue s, i64 index);
|
|
|
|
gb_internal cgValue cg_emit_conv(cgProcedure *p, cgValue value, Type *t);
|
|
gb_internal cgValue cg_emit_comp_against_nil(cgProcedure *p, TokenKind op_kind, cgValue x);
|
|
gb_internal cgValue cg_emit_comp(cgProcedure *p, TokenKind op_kind, cgValue left, cgValue right);
|
|
gb_internal cgValue cg_emit_arith(cgProcedure *p, TokenKind op, cgValue lhs, cgValue rhs, Type *type);
|
|
|
|
gb_internal bool cg_emit_goto(cgProcedure *p, TB_Node *control_region);
|
|
|
|
gb_internal TB_Node *cg_control_region(cgProcedure *p, char const *name);
|
|
|
|
gb_internal isize cg_append_tuple_values(cgProcedure *p, Array<cgValue> *dst_values, cgValue src_value);
|
|
|
|
gb_internal cgValue cg_handle_param_value(cgProcedure *p, Type *parameter_type, ParameterValue const ¶m_value, TokenPos const &pos);
|
|
|
|
gb_internal cgValue cg_builtin_len(cgProcedure *p, cgValue value);
|
|
gb_internal cgValue cg_builtin_raw_data(cgProcedure *p, cgValue const &x);
|
|
|