|
|
@@ -1,13167 +0,0 @@
|
|
|
-struct irProcedure;
|
|
|
-struct irBlock;
|
|
|
-struct irValue;
|
|
|
-struct irDebugInfo;
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-struct irModule {
|
|
|
- CheckerInfo * info;
|
|
|
- gbArena tmp_arena;
|
|
|
- // gbAllocator allocator;
|
|
|
- gbAllocator tmp_allocator;
|
|
|
- bool generate_debug_info;
|
|
|
-
|
|
|
- u64 state_flags;
|
|
|
-
|
|
|
- // String source_filename;
|
|
|
- // String layout;
|
|
|
- // String triple;
|
|
|
-
|
|
|
- PtrSet<Entity *> min_dep_set;
|
|
|
- Map<irValue *> values; // Key: Entity *
|
|
|
- StringMap<irValue *> members;
|
|
|
- Map<String> entity_names; // Key: Entity * of the typename
|
|
|
- Map<irDebugInfo *> debug_info; // Key: Unique pointer
|
|
|
- Map<irValue *> anonymous_proc_lits; // Key: Ast *
|
|
|
-
|
|
|
- Map<irValue *> equal_procs; // Key: Type *
|
|
|
- Map<irValue *> hasher_procs; // Key: Type *
|
|
|
-
|
|
|
- irDebugInfo * debug_compile_unit;
|
|
|
- Array<irDebugInfo *> debug_location_stack;
|
|
|
-
|
|
|
-
|
|
|
- i32 global_string_index;
|
|
|
- i32 global_array_index; // For ConstantSlice
|
|
|
- i32 global_generated_index;
|
|
|
-
|
|
|
- // NOTE(bill): To prevent strings from being copied a lot
|
|
|
- // Mainly used for file names
|
|
|
- StringMap<irValue *> const_strings;
|
|
|
- StringMap<irValue *> const_string_byte_slices;
|
|
|
- Map<irValue *> constant_value_to_global; // Key: irValue *
|
|
|
-
|
|
|
-
|
|
|
- Entity * entry_point_entity;
|
|
|
-
|
|
|
- Array<irProcedure *> procs; // NOTE(bill): All procedures with bodies
|
|
|
- Array<irValue *> procs_to_generate; // NOTE(bill): Procedures to generate
|
|
|
-
|
|
|
- Array<String> foreign_library_paths; // Only the ones that were used
|
|
|
-};
|
|
|
-
|
|
|
-// NOTE(bill): For more info, see https://en.wikipedia.org/wiki/Dominator_(graph_theory)
|
|
|
-struct irDomNode {
|
|
|
- irBlock * idom; // Parent (Immediate Dominator)
|
|
|
- Array<irBlock *> children;
|
|
|
- i32 pre, post; // Ordering in tree
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-struct irBlock {
|
|
|
- i32 index;
|
|
|
- String label;
|
|
|
- irProcedure *proc;
|
|
|
- Ast * node; // Can be nullptr
|
|
|
- Scope * scope;
|
|
|
- isize scope_index;
|
|
|
- irDomNode dom;
|
|
|
- i32 gaps;
|
|
|
-
|
|
|
- Array<irValue *> instrs;
|
|
|
- Array<irValue *> locals;
|
|
|
-
|
|
|
- Array<irBlock *> preds;
|
|
|
- Array<irBlock *> succs;
|
|
|
-};
|
|
|
-
|
|
|
-struct irTargetList {
|
|
|
- irTargetList *prev;
|
|
|
- bool is_block;
|
|
|
- irBlock * break_;
|
|
|
- irBlock * continue_;
|
|
|
- irBlock * fallthrough_;
|
|
|
-};
|
|
|
-
|
|
|
-enum irDeferExitKind {
|
|
|
- irDeferExit_Default,
|
|
|
- irDeferExit_Return,
|
|
|
- irDeferExit_Branch,
|
|
|
-};
|
|
|
-enum irDeferKind {
|
|
|
- irDefer_Node,
|
|
|
- irDefer_Instr,
|
|
|
- irDefer_Proc,
|
|
|
-};
|
|
|
-
|
|
|
-struct irDefer {
|
|
|
- irDeferKind kind;
|
|
|
- isize scope_index;
|
|
|
- isize context_stack_count;
|
|
|
- irBlock * block;
|
|
|
- union {
|
|
|
- Ast *stmt;
|
|
|
- // NOTE(bill): 'instr' will be copied every time to create a new one
|
|
|
- irValue *instr;
|
|
|
- struct {
|
|
|
- irValue *deferred;
|
|
|
- Array<irValue *> result_as_args;
|
|
|
- } proc;
|
|
|
- };
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-struct irBranchBlocks {
|
|
|
- Ast *label;
|
|
|
- irBlock *break_;
|
|
|
- irBlock *continue_;
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-struct irContextData {
|
|
|
- irValue *value;
|
|
|
- isize scope_index;
|
|
|
-};
|
|
|
-
|
|
|
-struct irProcedure {
|
|
|
- irProcedure * parent;
|
|
|
- Array<irProcedure *> children;
|
|
|
-
|
|
|
- Entity * entity;
|
|
|
- irModule * module;
|
|
|
- String name;
|
|
|
- Type * type;
|
|
|
- Ast * proc_lit; // only for actual anonymous procedure literals
|
|
|
- Ast * type_expr;
|
|
|
- Ast * body;
|
|
|
- u64 tags;
|
|
|
- ProcInlining inlining;
|
|
|
- bool is_foreign;
|
|
|
- bool is_export;
|
|
|
- bool is_entry_point;
|
|
|
- bool is_startup;
|
|
|
-
|
|
|
- irDebugInfo * debug_scope;
|
|
|
-
|
|
|
- irValue * return_ptr;
|
|
|
- Array<irValue *> params;
|
|
|
- Array<irDefer> defer_stmts;
|
|
|
- Array<irBlock *> blocks;
|
|
|
- i32 scope_index;
|
|
|
- irBlock * decl_block;
|
|
|
- irBlock * entry_block;
|
|
|
- irBlock * curr_block;
|
|
|
- irTargetList * target_list;
|
|
|
- Array<irValue *> referrers;
|
|
|
-
|
|
|
- Ast *curr_stmt;
|
|
|
-
|
|
|
- Array<irContextData> context_stack;
|
|
|
-
|
|
|
- i32 parameter_count;
|
|
|
-
|
|
|
- irValue *return_ptr_hint_value;
|
|
|
- Ast * return_ptr_hint_ast;
|
|
|
- bool return_ptr_hint_used;
|
|
|
-
|
|
|
- bool ignore_dead_instr;
|
|
|
-
|
|
|
- Array<irBranchBlocks> branch_blocks;
|
|
|
-
|
|
|
- i32 local_count;
|
|
|
- i32 instr_count;
|
|
|
- i32 block_count;
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-gb_global Arena global_ir_arena = {};
|
|
|
-gbAllocator ir_allocator(void) {
|
|
|
- Arena *arena = &global_ir_arena;
|
|
|
- return arena_allocator(arena);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-#define IR_STARTUP_TYPE_INFO_PROC_NAME "__$startup_type_info"
|
|
|
-#define IR_STARTUP_RUNTIME_PROC_NAME "__$startup_runtime"
|
|
|
-#define IR_TYPE_INFO_DATA_NAME "__$type_info_data"
|
|
|
-#define IR_TYPE_INFO_TYPES_NAME "__$type_info_types_data"
|
|
|
-#define IR_TYPE_INFO_NAMES_NAME "__$type_info_names_data"
|
|
|
-#define IR_TYPE_INFO_OFFSETS_NAME "__$type_info_offsets_data"
|
|
|
-#define IR_TYPE_INFO_USINGS_NAME "__$type_info_usings_data"
|
|
|
-#define IR_TYPE_INFO_TAGS_NAME "__$type_info_tags_data"
|
|
|
-
|
|
|
-
|
|
|
-#define IR_INSTR_KINDS \
|
|
|
- IR_INSTR_KIND(Comment, struct { String text; }) \
|
|
|
- IR_INSTR_KIND(Local, struct { \
|
|
|
- Entity * entity; \
|
|
|
- Type * type; \
|
|
|
- bool zero_initialized; \
|
|
|
- Array<irValue *> referrers; \
|
|
|
- i64 alignment; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(ZeroInit, struct { irValue *address; }) \
|
|
|
- IR_INSTR_KIND(Store, struct { irValue *address, *value; bool is_volatile; }) \
|
|
|
- IR_INSTR_KIND(Load, struct { Type *type; irValue *address; i64 custom_align; bool is_volatile; }) \
|
|
|
- IR_INSTR_KIND(InlineCode, struct { BuiltinProcId id; Array<irValue *> operands; Type *type; }) \
|
|
|
- IR_INSTR_KIND(AtomicFence, struct { BuiltinProcId id; }) \
|
|
|
- IR_INSTR_KIND(AtomicStore, struct { \
|
|
|
- irValue *address, *value; \
|
|
|
- BuiltinProcId id; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(AtomicLoad, struct { \
|
|
|
- Type *type; irValue *address; \
|
|
|
- BuiltinProcId id; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(AtomicRmw, struct { \
|
|
|
- Type *type; irValue *address; \
|
|
|
- irValue *value; \
|
|
|
- BuiltinProcId id; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(AtomicCxchg, struct { \
|
|
|
- Type *type; irValue *address; \
|
|
|
- irValue *old_value; irValue *new_value; \
|
|
|
- BuiltinProcId id; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(PtrOffset, struct { \
|
|
|
- irValue *address; \
|
|
|
- irValue *offset; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(ArrayElementPtr, struct { \
|
|
|
- irValue *address; \
|
|
|
- Type * result_type; \
|
|
|
- irValue *elem_index; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(StructElementPtr, struct { \
|
|
|
- irValue *address; \
|
|
|
- Type * result_type; \
|
|
|
- i32 elem_index; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(StructExtractValue, struct { \
|
|
|
- irValue *address; \
|
|
|
- Type * result_type; \
|
|
|
- i32 index; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(UnionTagPtr, struct { \
|
|
|
- irValue *address; \
|
|
|
- Type *type; /* ^int */ \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(UnionTagValue, struct { \
|
|
|
- irValue *address; \
|
|
|
- Type *type; /* int */ \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(Conv, struct { \
|
|
|
- irConvKind kind; \
|
|
|
- irValue *value; \
|
|
|
- Type *from, *to; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(Jump, struct { irBlock *block; }) \
|
|
|
- IR_INSTR_KIND(If, struct { \
|
|
|
- irValue *cond; \
|
|
|
- irBlock *true_block; \
|
|
|
- irBlock *false_block; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(Return, struct { irValue *value; }) \
|
|
|
- IR_INSTR_KIND(Select, struct { \
|
|
|
- irValue *cond; \
|
|
|
- irValue *true_value; \
|
|
|
- irValue *false_value; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(Phi, struct { Array<irValue *> edges; Type *type; })\
|
|
|
- IR_INSTR_KIND(Unreachable, i32) \
|
|
|
- IR_INSTR_KIND(UnaryOp, struct { \
|
|
|
- Type * type; \
|
|
|
- TokenKind op; \
|
|
|
- irValue * expr; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(BinaryOp, struct { \
|
|
|
- Type * type; \
|
|
|
- TokenKind op; \
|
|
|
- irValue * left, *right; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(Call, struct { \
|
|
|
- Type * type; /* return type */ \
|
|
|
- irValue * value; \
|
|
|
- irValue * return_ptr; \
|
|
|
- Array<irValue *> args; \
|
|
|
- irValue * context_ptr; \
|
|
|
- ProcInlining inlining; \
|
|
|
- }) \
|
|
|
- IR_INSTR_KIND(StartupRuntime, i32) \
|
|
|
- IR_INSTR_KIND(DebugDeclare, struct { \
|
|
|
- Ast * expr; \
|
|
|
- Entity * entity; \
|
|
|
- bool is_addr; \
|
|
|
- irValue * value; \
|
|
|
- }) \
|
|
|
-
|
|
|
-// IR_INSTR_KIND(BoundsCheck, struct { \
|
|
|
-// TokenPos pos; \
|
|
|
-// irValue *index; \
|
|
|
-// irValue *len; \
|
|
|
-// }) \
|
|
|
-// IR_INSTR_KIND(SliceBoundsCheck, struct { \
|
|
|
-// TokenPos pos; \
|
|
|
-// irValue *low; \
|
|
|
-// irValue *high; \
|
|
|
-// irValue *max; \
|
|
|
-// bool is_substring; \
|
|
|
-// }) \
|
|
|
-
|
|
|
-
|
|
|
-#define IR_CONV_KINDS \
|
|
|
- IR_CONV_KIND(trunc) \
|
|
|
- IR_CONV_KIND(zext) \
|
|
|
- IR_CONV_KIND(sext) \
|
|
|
- IR_CONV_KIND(fptrunc) \
|
|
|
- IR_CONV_KIND(fpext) \
|
|
|
- IR_CONV_KIND(fptoui) \
|
|
|
- IR_CONV_KIND(fptosi) \
|
|
|
- IR_CONV_KIND(uitofp) \
|
|
|
- IR_CONV_KIND(sitofp) \
|
|
|
- IR_CONV_KIND(ptrtoint) \
|
|
|
- IR_CONV_KIND(inttoptr) \
|
|
|
- IR_CONV_KIND(bitcast) \
|
|
|
- IR_CONV_KIND(byteswap)
|
|
|
-/*
|
|
|
- Odin specifc conversion
|
|
|
- byteswap - swap bytes for endian change
|
|
|
-*/
|
|
|
-
|
|
|
-
|
|
|
-enum irInstrKind {
|
|
|
- irInstr_Invalid,
|
|
|
-#define IR_INSTR_KIND(x, ...) GB_JOIN2(irInstr_, x),
|
|
|
- IR_INSTR_KINDS
|
|
|
-#undef IR_INSTR_KIND
|
|
|
-};
|
|
|
-
|
|
|
-String const ir_instr_strings[] = {
|
|
|
- {cast(u8 *)"Invalid", gb_size_of("Invalid")-1},
|
|
|
-#define IR_INSTR_KIND(x, ...) {cast(u8 *)#x, gb_size_of(#x)-1},
|
|
|
- IR_INSTR_KINDS
|
|
|
-#undef IR_INSTR_KIND
|
|
|
-};
|
|
|
-
|
|
|
-enum irConvKind {
|
|
|
- irConv_Invalid,
|
|
|
-#define IR_CONV_KIND(x) GB_JOIN2(irConv_, x),
|
|
|
- IR_CONV_KINDS
|
|
|
-#undef IR_CONV_KIND
|
|
|
-};
|
|
|
-
|
|
|
-String const ir_conv_strings[] = {
|
|
|
- {cast(u8 *)"Invalid", gb_size_of("Invalid")-1},
|
|
|
-#define IR_CONV_KIND(x) {cast(u8 *)#x, gb_size_of(#x)-1},
|
|
|
- IR_CONV_KINDS
|
|
|
-#undef IR_CONV_KIND
|
|
|
-};
|
|
|
-
|
|
|
-#define IR_INSTR_KIND(k, ...) typedef __VA_ARGS__ GB_JOIN2(irInstr, k);
|
|
|
- IR_INSTR_KINDS
|
|
|
-#undef IR_INSTR_KIND
|
|
|
-
|
|
|
-struct irInstr {
|
|
|
- irInstrKind kind;
|
|
|
-
|
|
|
- irBlock *block;
|
|
|
- Type *type;
|
|
|
-
|
|
|
- union {
|
|
|
-#define IR_INSTR_KIND(k, ...) GB_JOIN2(irInstr, k) k;
|
|
|
- IR_INSTR_KINDS
|
|
|
-#undef IR_INSTR_KIND
|
|
|
- };
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-enum irValueKind {
|
|
|
- irValue_Invalid,
|
|
|
-
|
|
|
- irValue_Constant,
|
|
|
- irValue_ConstantSlice,
|
|
|
- irValue_Nil,
|
|
|
- irValue_Undef,
|
|
|
- irValue_TypeName,
|
|
|
- irValue_Global,
|
|
|
- irValue_Param,
|
|
|
- irValue_SourceCodeLocation,
|
|
|
-
|
|
|
- irValue_Proc,
|
|
|
- irValue_Block,
|
|
|
- irValue_Instr,
|
|
|
-
|
|
|
- irValue_Count,
|
|
|
-};
|
|
|
-
|
|
|
-struct irValueConstant {
|
|
|
- Type * type;
|
|
|
- ExactValue value;
|
|
|
-};
|
|
|
-
|
|
|
-struct irValueConstantSlice {
|
|
|
- Type * type;
|
|
|
- irValue *backing_array;
|
|
|
- i64 count;
|
|
|
-};
|
|
|
-
|
|
|
-struct irValueNil {
|
|
|
- Type *type;
|
|
|
-};
|
|
|
-
|
|
|
-struct irValueUndef {
|
|
|
- Type *type;
|
|
|
-};
|
|
|
-
|
|
|
-struct irValueTypeName {
|
|
|
- Type * type;
|
|
|
- String name;
|
|
|
-};
|
|
|
-
|
|
|
-struct irValueGlobal {
|
|
|
- String name;
|
|
|
- Entity * entity;
|
|
|
- Type * type;
|
|
|
- irValue * value;
|
|
|
- Array<irValue *> referrers;
|
|
|
- bool is_constant;
|
|
|
- bool is_export;
|
|
|
- bool is_private;
|
|
|
- bool is_internal;
|
|
|
- String thread_local_model;
|
|
|
- bool is_foreign;
|
|
|
- bool is_unnamed_addr;
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-enum irParamPasskind {
|
|
|
- irParamPass_Value, // Pass by value
|
|
|
- irParamPass_Pointer, // Pass as a pointer rather than by value
|
|
|
- irParamPass_Integer, // Pass as an integer of the same size
|
|
|
- irParamPass_ConstRef, // Pass as a pointer but the value is immutable
|
|
|
- irParamPass_BitCast, // Pass by value and bit cast to the correct type
|
|
|
- irParamPass_Tuple, // Pass across multiple parameters (System V AMD64, up to 2)
|
|
|
-};
|
|
|
-
|
|
|
-struct irValueParam {
|
|
|
- irParamPasskind kind;
|
|
|
- irProcedure * parent;
|
|
|
- Entity * entity;
|
|
|
- Type * type;
|
|
|
- Type * original_type;
|
|
|
- i32 index;
|
|
|
- Array<irValue *> referrers;
|
|
|
-};
|
|
|
-
|
|
|
-struct irValueSourceCodeLocation {
|
|
|
- irValue *file;
|
|
|
- irValue *line;
|
|
|
- irValue *column;
|
|
|
- irValue *procedure;
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-struct irValue {
|
|
|
- irValueKind kind;
|
|
|
- i32 index;
|
|
|
- bool index_set;
|
|
|
- irDebugInfo * loc;
|
|
|
- isize uses;
|
|
|
- union {
|
|
|
- irValueConstant Constant;
|
|
|
- irValueConstantSlice ConstantSlice;
|
|
|
- irValueNil Nil;
|
|
|
- irValueUndef Undef;
|
|
|
- irValueTypeName TypeName;
|
|
|
- irValueGlobal Global;
|
|
|
- irValueParam Param;
|
|
|
- irProcedure Proc;
|
|
|
- irBlock Block;
|
|
|
- irInstr Instr;
|
|
|
- irValueSourceCodeLocation SourceCodeLocation;
|
|
|
- };
|
|
|
-};
|
|
|
-
|
|
|
-gb_global irValue *v_zero = nullptr;
|
|
|
-gb_global irValue *v_one = nullptr;
|
|
|
-gb_global irValue *v_zero32 = nullptr;
|
|
|
-gb_global irValue *v_one32 = nullptr;
|
|
|
-gb_global irValue *v_two32 = nullptr;
|
|
|
-gb_global irValue *v_false = nullptr;
|
|
|
-gb_global irValue *v_true = nullptr;
|
|
|
-gb_global irValue *v_raw_nil = nullptr;
|
|
|
-
|
|
|
-enum irAddrKind {
|
|
|
- irAddr_Default,
|
|
|
- irAddr_Map,
|
|
|
- irAddr_Context,
|
|
|
- irAddr_SoaVariable,
|
|
|
- irAddr_RelativePointer,
|
|
|
- irAddr_RelativeSlice,
|
|
|
-};
|
|
|
-
|
|
|
-struct irAddr {
|
|
|
- irAddrKind kind;
|
|
|
- irValue * addr;
|
|
|
- union {
|
|
|
- struct {
|
|
|
- irValue *map_key;
|
|
|
- Type * map_type;
|
|
|
- Type * map_result;
|
|
|
- };
|
|
|
- struct {
|
|
|
- i32 bit_field_value_index;
|
|
|
- };
|
|
|
- struct {
|
|
|
- Selection sel;
|
|
|
- } ctx;
|
|
|
- struct {
|
|
|
- irValue *index;
|
|
|
- Ast *index_expr;
|
|
|
- } soa;
|
|
|
- struct {
|
|
|
- bool deref;
|
|
|
- } relative;
|
|
|
- };
|
|
|
-};
|
|
|
-
|
|
|
-Type *ir_type(irValue *value);
|
|
|
-irValue *ir_gen_anonymous_proc_lit(irModule *m, String prefix_name, Ast *expr, irProcedure *proc = nullptr);
|
|
|
-void ir_begin_procedure_body(irProcedure *proc);
|
|
|
-void ir_end_procedure_body(irProcedure *proc);
|
|
|
-irValue *ir_get_equal_proc_for_type(irModule *m, Type *type);
|
|
|
-irValue *ir_get_hasher_proc_for_type(irModule *m, Type *type);
|
|
|
-
|
|
|
-
|
|
|
-irAddr ir_addr(irValue *addr) {
|
|
|
- irAddr v = {irAddr_Default, addr};
|
|
|
- if (addr != nullptr && is_type_relative_pointer(type_deref(ir_type(addr)))) {
|
|
|
- GB_ASSERT(is_type_pointer(ir_type(addr)));
|
|
|
- v.kind = irAddr_RelativePointer;
|
|
|
- } else if (addr != nullptr && is_type_relative_slice(type_deref(ir_type(addr)))) {
|
|
|
- GB_ASSERT(is_type_pointer(ir_type(addr)));
|
|
|
- v.kind = irAddr_RelativeSlice;
|
|
|
- }
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irAddr ir_addr_map(irValue *addr, irValue *map_key, Type *map_type, Type *map_result) {
|
|
|
- irAddr v = {irAddr_Map, addr};
|
|
|
- v.map_key = map_key;
|
|
|
- v.map_type = map_type;
|
|
|
- v.map_result = map_result;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irAddr ir_addr_context(irValue *addr, Selection sel = empty_selection) {
|
|
|
- irAddr v = {irAddr_Context, addr};
|
|
|
- v.ctx.sel = sel;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irAddr ir_addr_soa_variable(irValue *addr, irValue *index, Ast *index_expr) {
|
|
|
- irAddr v = {irAddr_SoaVariable, addr};
|
|
|
- v.soa.index = index;
|
|
|
- v.soa.index_expr = index_expr;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-enum irDebugEncoding {
|
|
|
- irDebugBasicEncoding_Invalid = 0,
|
|
|
-
|
|
|
- irDebugBasicEncoding_address = 1,
|
|
|
- irDebugBasicEncoding_boolean = 2,
|
|
|
- irDebugBasicEncoding_float = 3,
|
|
|
- irDebugBasicEncoding_signed = 4,
|
|
|
- irDebugBasicEncoding_signed_char = 5,
|
|
|
- irDebugBasicEncoding_unsigned = 6,
|
|
|
- irDebugBasicEncoding_unsigned_char = 7,
|
|
|
-
|
|
|
- // TODO(lachsinc): Should the following be renamed from basic -> tag to mirror their DW_TAG_*
|
|
|
- // counterparts? Perhaps separate out if they truly have different meaning.
|
|
|
-
|
|
|
- irDebugBasicEncoding_member = 13,
|
|
|
- irDebugBasicEncoding_pointer_type = 15,
|
|
|
- irDebugBasicEncoding_typedef = 22,
|
|
|
-
|
|
|
- irDebugBasicEncoding_array_type = 1,
|
|
|
- irDebugBasicEncoding_enumeration_type = 4,
|
|
|
- irDebugBasicEncoding_structure_type = 19,
|
|
|
- irDebugBasicEncoding_union_type = 23,
|
|
|
-};
|
|
|
-
|
|
|
-enum irDebugInfoFlags {
|
|
|
- irDebugInfoFlag_Bitfield = (1 << 19),
|
|
|
-};
|
|
|
-
|
|
|
-enum irDebugInfoKind {
|
|
|
- irDebugInfo_Invalid,
|
|
|
-
|
|
|
- irDebugInfo_CompileUnit,
|
|
|
- irDebugInfo_File,
|
|
|
- irDebugInfo_Proc,
|
|
|
- irDebugInfo_ProcType,
|
|
|
- irDebugInfo_Location,
|
|
|
- irDebugInfo_LexicalBlock,
|
|
|
- irDebugInfo_AllProcs,
|
|
|
-
|
|
|
- irDebugInfo_BasicType, // primitive types
|
|
|
- irDebugInfo_DerivedType, // pointer, distinct etc.
|
|
|
- irDebugInfo_CompositeType, // array, struct, enum, union etc.
|
|
|
- irDebugInfo_Enumerator, // For irDebugInfo_CompositeType if enum
|
|
|
- irDebugInfo_GlobalVariableExpression, // used to describe if global is const or not
|
|
|
- irDebugInfo_GlobalVariable,
|
|
|
- irDebugInfo_LocalVariable,
|
|
|
-
|
|
|
- irDebugInfo_DebugInfoArray, // array of irDebugInfo *'s
|
|
|
-
|
|
|
- irDebugInfo_Count,
|
|
|
-};
|
|
|
-
|
|
|
-struct irDebugInfo {
|
|
|
- irDebugInfoKind kind;
|
|
|
- i32 id;
|
|
|
-
|
|
|
- union {
|
|
|
- struct {
|
|
|
- AstFile * file;
|
|
|
- String producer;
|
|
|
- irDebugInfo *enums; // DebugInfoArray
|
|
|
- irDebugInfo *globals; // DebugInfoArray
|
|
|
- } CompileUnit;
|
|
|
- struct {
|
|
|
- AstFile *file;
|
|
|
- String filename;
|
|
|
- String directory;
|
|
|
- } File;
|
|
|
- struct {
|
|
|
- Entity * entity;
|
|
|
- String name;
|
|
|
- irDebugInfo * file;
|
|
|
- TokenPos pos;
|
|
|
- irDebugInfo * type;
|
|
|
- // TODO(lachsinc): variables / retainedNodes ?
|
|
|
- } Proc;
|
|
|
- struct {
|
|
|
- irDebugInfo * types; // !{return, return, param, param, param.. etc.}
|
|
|
- } ProcType;
|
|
|
- struct {
|
|
|
- TokenPos pos;
|
|
|
- irDebugInfo *scope;
|
|
|
- } Location;
|
|
|
- struct {
|
|
|
- TokenPos pos;
|
|
|
- irDebugInfo *file;
|
|
|
- irDebugInfo *scope;
|
|
|
- } LexicalBlock;
|
|
|
-
|
|
|
- struct {
|
|
|
- Type * type;
|
|
|
- String name;
|
|
|
- i32 size;
|
|
|
- i32 align;
|
|
|
- irDebugEncoding encoding;
|
|
|
- } BasicType;
|
|
|
- struct {
|
|
|
- Type * type;
|
|
|
- irDebugEncoding tag;
|
|
|
- irDebugInfo * base_type;
|
|
|
- String name;
|
|
|
- irDebugInfo * scope;
|
|
|
- irDebugInfo * file;
|
|
|
- TokenPos pos;
|
|
|
- i32 size;
|
|
|
- i32 align;
|
|
|
- i32 offset;
|
|
|
- irDebugInfoFlags flags; // Used only for DIFlagBitField.
|
|
|
- } DerivedType;
|
|
|
- struct {
|
|
|
- irDebugEncoding tag;
|
|
|
- String name;
|
|
|
- irDebugInfo * scope;
|
|
|
- irDebugInfo * file;
|
|
|
- TokenPos pos;
|
|
|
- irDebugInfo * base_type; // optional, used for enumeration_type.
|
|
|
- i32 size;
|
|
|
- i32 align;
|
|
|
- irDebugInfo * elements;
|
|
|
- i32 array_count; // for DISubrange
|
|
|
- } CompositeType;
|
|
|
- struct {
|
|
|
- String name;
|
|
|
- i64 value;
|
|
|
- } Enumerator;
|
|
|
- struct {
|
|
|
- irDebugInfo *var;
|
|
|
- } GlobalVariableExpression;
|
|
|
- struct {
|
|
|
- String name;
|
|
|
- String linkage_name;
|
|
|
- irDebugInfo *scope;
|
|
|
- irDebugInfo *file;
|
|
|
- TokenPos pos;
|
|
|
- irDebugInfo *type;
|
|
|
- irValue *variable;
|
|
|
- } GlobalVariable;
|
|
|
- struct {
|
|
|
- String name;
|
|
|
- irDebugInfo *scope;
|
|
|
- irDebugInfo *file;
|
|
|
- TokenPos pos;
|
|
|
- i32 arg; // Non-zero if proc parameter
|
|
|
- irDebugInfo *type;
|
|
|
- } LocalVariable;
|
|
|
- struct {
|
|
|
- Array<irDebugInfo *> elements; // TODO(lachsinc): Leak?
|
|
|
- } DebugInfoArray;
|
|
|
- };
|
|
|
-};
|
|
|
-
|
|
|
-static irDebugInfo IR_DEBUG_INFO_EMPTY = {};
|
|
|
-
|
|
|
-
|
|
|
-struct irGen {
|
|
|
- irModule module;
|
|
|
- gbFile output_file;
|
|
|
- bool opt_called;
|
|
|
- String output_base;
|
|
|
- String output_name;
|
|
|
- bool print_chkstk;
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-gb_inline bool ir_min_dep_entity(irModule *m, Entity *e) {
|
|
|
- return ptr_set_exists(&m->min_dep_set, e);
|
|
|
-}
|
|
|
-
|
|
|
-Type *ir_instr_type(irInstr *instr) {
|
|
|
- switch (instr->kind) {
|
|
|
- case irInstr_InlineCode:
|
|
|
- return instr->InlineCode.type;
|
|
|
- case irInstr_Local:
|
|
|
- return instr->Local.type;
|
|
|
- case irInstr_Load:
|
|
|
- return instr->Load.type;
|
|
|
- case irInstr_AtomicLoad:
|
|
|
- return instr->AtomicLoad.type;
|
|
|
- case irInstr_AtomicRmw:
|
|
|
- return instr->AtomicRmw.type;
|
|
|
- case irInstr_AtomicCxchg:
|
|
|
- return instr->AtomicCxchg.type;
|
|
|
- case irInstr_StructElementPtr:
|
|
|
- return instr->StructElementPtr.result_type;
|
|
|
- case irInstr_ArrayElementPtr:
|
|
|
- return instr->ArrayElementPtr.result_type;
|
|
|
- case irInstr_PtrOffset:
|
|
|
- return ir_type(instr->PtrOffset.address);
|
|
|
- case irInstr_Phi:
|
|
|
- return instr->Phi.type;
|
|
|
- case irInstr_StructExtractValue:
|
|
|
- return instr->StructExtractValue.result_type;
|
|
|
- case irInstr_UnionTagPtr:
|
|
|
- return instr->UnionTagPtr.type;
|
|
|
- case irInstr_UnionTagValue:
|
|
|
- return instr->UnionTagValue.type;
|
|
|
- case irInstr_UnaryOp:
|
|
|
- return instr->UnaryOp.type;
|
|
|
- case irInstr_BinaryOp:
|
|
|
- return instr->BinaryOp.type;
|
|
|
- case irInstr_Conv:
|
|
|
- return instr->Conv.to;
|
|
|
- case irInstr_Select:
|
|
|
- return ir_type(instr->Select.true_value);
|
|
|
- case irInstr_Call: {
|
|
|
- Type *pt = base_type(instr->Call.type);
|
|
|
- if (pt != nullptr) {
|
|
|
- if (pt->kind == Type_Tuple && pt->Tuple.variables.count == 1) {
|
|
|
- return pt->Tuple.variables[0]->type;
|
|
|
- }
|
|
|
- return pt;
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-Type *ir_type(irValue *value) {
|
|
|
- if (value == nullptr) {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- switch (value->kind) {
|
|
|
- case irValue_Constant:
|
|
|
- return value->Constant.type;
|
|
|
- case irValue_ConstantSlice:
|
|
|
- return value->ConstantSlice.type;
|
|
|
- case irValue_Nil:
|
|
|
- return value->Nil.type;
|
|
|
- case irValue_Undef:
|
|
|
- return value->Undef.type;
|
|
|
- case irValue_TypeName:
|
|
|
- return value->TypeName.type;
|
|
|
- case irValue_Global:
|
|
|
- return value->Global.type;
|
|
|
- case irValue_Param:
|
|
|
- return value->Param.type;
|
|
|
- case irValue_SourceCodeLocation:
|
|
|
- return t_source_code_location;
|
|
|
- case irValue_Proc:
|
|
|
- return value->Proc.type;
|
|
|
- case irValue_Instr:
|
|
|
- return ir_instr_type(&value->Instr);
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irInstr *ir_get_last_instr(irBlock *block) {
|
|
|
- if (block != nullptr) {
|
|
|
- isize len = block->instrs.count;
|
|
|
- if (len > 0) {
|
|
|
- irValue *v = block->instrs[len-1];
|
|
|
- GB_ASSERT(v->kind == irValue_Instr);
|
|
|
- return &v->Instr;
|
|
|
- }
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-bool ir_is_instr_terminating(irInstr *i) {
|
|
|
- if (i != nullptr) {
|
|
|
- switch (i->kind) {
|
|
|
- case irInstr_Return:
|
|
|
- case irInstr_Unreachable:
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_add_edge(irBlock *from, irBlock *to) {
|
|
|
- GB_ASSERT(from->instrs.count > 0);
|
|
|
- if (!ir_is_instr_terminating(ir_get_last_instr(from))) {
|
|
|
- array_add(&from->succs, to);
|
|
|
- array_add(&to->preds, from);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_set_instr_block(irValue *instr, irBlock *block) {
|
|
|
- if (instr->kind == irValue_Instr) {
|
|
|
- instr->Instr.block = block;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-Array<irValue *> *ir_value_referrers(irValue *v) {
|
|
|
- switch (v->kind) {
|
|
|
- case irValue_Global:
|
|
|
- return &v->Global.referrers;
|
|
|
- case irValue_Param:
|
|
|
- return &v->Param.referrers;
|
|
|
- case irValue_Proc: {
|
|
|
- if (v->Proc.parent != nullptr) {
|
|
|
- return &v->Proc.referrers;
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- case irValue_Instr: {
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- switch (i->kind) {
|
|
|
- case irInstr_Local:
|
|
|
- return &i->Local.referrers;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// @Make
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-void ir_module_add_value (irModule *m, Entity *e, irValue *v);
|
|
|
-irValue *ir_emit_zero_init (irProcedure *p, irValue *address, Ast *expr);
|
|
|
-irValue *ir_emit_comment (irProcedure *p, String text);
|
|
|
-irValue *ir_emit_store (irProcedure *p, irValue *address, irValue *value, bool is_volatile=false);
|
|
|
-irValue *ir_emit_load (irProcedure *p, irValue *address, i64 custom_align=0);
|
|
|
-void ir_emit_jump (irProcedure *proc, irBlock *block);
|
|
|
-irValue *ir_emit_conv (irProcedure *proc, irValue *value, Type *t);
|
|
|
-irValue *ir_type_info (irProcedure *proc, Type *type);
|
|
|
-irValue *ir_typeid (irModule *m, Type *type);
|
|
|
-irValue *ir_build_expr (irProcedure *proc, Ast *expr);
|
|
|
-void ir_build_stmt (irProcedure *proc, Ast *node);
|
|
|
-irValue *ir_build_cond (irProcedure *proc, Ast *cond, irBlock *true_block, irBlock *false_block);
|
|
|
-void ir_build_defer_stmt (irProcedure *proc, irDefer d);
|
|
|
-irAddr ir_build_addr (irProcedure *proc, Ast *expr);
|
|
|
-void ir_build_proc (irValue *value, irProcedure *parent);
|
|
|
-void ir_gen_global_type_name(irModule *m, Entity *e, String name);
|
|
|
-irValue *ir_get_type_info_ptr (irProcedure *proc, Type *type);
|
|
|
-void ir_value_set_debug_location(irProcedure *proc, irValue *v);
|
|
|
-void ir_push_debug_location (irModule *m, Ast *node, irDebugInfo *scope, Entity *e=nullptr);
|
|
|
-void ir_pop_debug_location (irModule *m);
|
|
|
-irDebugInfo *ir_add_debug_info_local(irProcedure *proc, Entity *e, i32 arg_id);
|
|
|
-irDebugInfo *ir_add_debug_info_file(irModule *module, AstFile *file);
|
|
|
-irDebugInfo *ir_add_debug_info_proc(irProcedure *proc);
|
|
|
-void ir_emit_increment(irProcedure *proc, irValue *addr);
|
|
|
-irValue *ir_emit_array_ep(irProcedure *proc, irValue *s, irValue *index);
|
|
|
-irValue *ir_emit_array_epi(irProcedure *proc, irValue *s, i32 index);
|
|
|
-irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index);
|
|
|
-irValue *ir_emit_bitcast(irProcedure *proc, irValue *data, Type *type);
|
|
|
-irValue *ir_emit_byte_swap(irProcedure *proc, irValue *value, Type *t);
|
|
|
-irValue *ir_find_or_add_entity_string(irModule *m, String str);
|
|
|
-irValue *ir_find_or_add_entity_string_byte_slice(irModule *m, String str);
|
|
|
-irValue *ir_slice_elem(irProcedure *proc, irValue *slice);
|
|
|
-irValue *ir_slice_len(irProcedure *proc, irValue *slice);
|
|
|
-void ir_fill_slice(irProcedure *proc, irValue *slice_ptr, irValue *data, irValue *len);
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_alloc_value(irValueKind kind) {
|
|
|
- irValue *v = gb_alloc_item(ir_allocator(), irValue);
|
|
|
- v->kind = kind;
|
|
|
- return v;
|
|
|
-}
|
|
|
-irValue *ir_alloc_instr(irProcedure *proc, irInstrKind kind) {
|
|
|
- irValue *v = ir_alloc_value(irValue_Instr);
|
|
|
- v->Instr.kind = kind;
|
|
|
- proc->instr_count++;
|
|
|
- return v;
|
|
|
-}
|
|
|
-irDebugInfo *ir_alloc_debug_info(irDebugInfoKind kind) {
|
|
|
- irDebugInfo *di = gb_alloc_item(ir_allocator(), irDebugInfo);
|
|
|
- di->kind = kind;
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_value_type_name(String name, Type *type) {
|
|
|
- irValue *v = ir_alloc_value(irValue_TypeName);
|
|
|
- v->TypeName.name = name;
|
|
|
- v->TypeName.type = type;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_value_global(Entity *e, irValue *value) {
|
|
|
- irValue *v = ir_alloc_value(irValue_Global);
|
|
|
- v->Global.entity = e;
|
|
|
- v->Global.type = alloc_type_pointer(e->type);
|
|
|
- v->Global.value = value;
|
|
|
- array_init(&v->Global.referrers, ir_allocator()); // TODO(bill): Replace heap allocator here
|
|
|
-
|
|
|
- if (value) value->uses += 1;
|
|
|
- return v;
|
|
|
-}
|
|
|
-irValue *ir_value_param(irProcedure *parent, Entity *e, Type *abi_type, i32 index) {
|
|
|
- irValue *v = ir_alloc_value(irValue_Param);
|
|
|
- v->Param.kind = irParamPass_Value;
|
|
|
- v->Param.parent = parent;
|
|
|
- if (e != nullptr) {
|
|
|
- v->Param.entity = e;
|
|
|
- v->Param.original_type = e->type;
|
|
|
- }
|
|
|
- v->Param.type = abi_type;
|
|
|
- v->Param.index = index;
|
|
|
-
|
|
|
- if (e != nullptr && abi_type != e->type) {
|
|
|
- if (is_type_pointer(abi_type)) {
|
|
|
- GB_ASSERT(e->kind == Entity_Variable);
|
|
|
- Type *av = core_type(type_deref(abi_type));
|
|
|
- if (are_types_identical(av, core_type(e->type))) {
|
|
|
- v->Param.kind = irParamPass_Pointer;
|
|
|
- if (e->flags&EntityFlag_Value) {
|
|
|
- v->Param.kind = irParamPass_ConstRef;
|
|
|
- }
|
|
|
- } else {
|
|
|
- v->Param.kind = irParamPass_BitCast;
|
|
|
- }
|
|
|
- } else if (is_type_integer(abi_type)) {
|
|
|
- v->Param.kind = irParamPass_Integer;
|
|
|
- } else if (abi_type == t_llvm_bool) {
|
|
|
- v->Param.kind = irParamPass_Value;
|
|
|
- } else if (is_type_boolean(abi_type)) {
|
|
|
- v->Param.kind = irParamPass_Integer;
|
|
|
- } else if (is_type_simd_vector(abi_type)) {
|
|
|
- v->Param.kind = irParamPass_BitCast;
|
|
|
- } else if (is_type_float(abi_type)) {
|
|
|
- v->Param.kind = irParamPass_BitCast;
|
|
|
- } else if (is_type_tuple(abi_type)) {
|
|
|
- v->Param.kind = irParamPass_Tuple;
|
|
|
- } else {
|
|
|
- GB_PANIC("Invalid abi type pass kind: %s", type_to_string(abi_type));
|
|
|
- }
|
|
|
- }
|
|
|
- array_init(&v->Param.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
|
|
|
- return v;
|
|
|
-}
|
|
|
-irValue *ir_value_nil(Type *type) {
|
|
|
- irValue *v = ir_alloc_value(irValue_Nil);
|
|
|
- v->Nil.type = type;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_value_undef(Type *type) {
|
|
|
- irValue *v = ir_alloc_value(irValue_Undef);
|
|
|
- v->Undef.type = type;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-String ir_get_global_name(irModule *m, irValue *v) {
|
|
|
- if (v->kind != irValue_Global) {
|
|
|
- return str_lit("");
|
|
|
- }
|
|
|
- irValueGlobal *g = &v->Global;
|
|
|
- Entity *e = g->entity;
|
|
|
- String name = e->token.string;
|
|
|
- String *found = map_get(&m->entity_names, hash_entity(e));
|
|
|
- if (found != nullptr) {
|
|
|
- name = *found;
|
|
|
- } else {
|
|
|
- GB_ASSERT(name.len > 0);
|
|
|
- }
|
|
|
- return name;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_add_entity_name(irModule *m, Entity *e, String name) {
|
|
|
- GB_ASSERT(name.len > 0);
|
|
|
- if (e != nullptr && e->kind == Entity_TypeName) {
|
|
|
- e->TypeName.ir_mangled_name = name;
|
|
|
- }
|
|
|
- map_set(&m->entity_names, hash_entity(e), name);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_instr_local(irProcedure *p, Entity *e, bool zero_initialized) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Local);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->Local.entity = e;
|
|
|
- i->Local.type = alloc_type_pointer(e->type);
|
|
|
- i->Local.zero_initialized = zero_initialized;
|
|
|
- // i->Local.alignment = type_align_of(p->module->allocator, e->type);
|
|
|
- // TODO(bill): determine the correct alignment
|
|
|
- i->Local.alignment = gb_max(16, type_align_of(e->type));
|
|
|
- array_init(&i->Local.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
|
|
|
- ir_module_add_value(p->module, e, v);
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_zero_init(irProcedure *p, irValue *address) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_ZeroInit);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->ZeroInit.address = address;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_store(irProcedure *p, irValue *address, irValue *value, bool is_volatile) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Store);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->Store.address = address;
|
|
|
- i->Store.value = value;
|
|
|
- i->Store.is_volatile = is_volatile;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
- if (value) value->uses += 1;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_load(irProcedure *p, irValue *address, bool is_volatile) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Load);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->Load.address = address;
|
|
|
- i->Load.type = type_deref(ir_type(address));
|
|
|
- i->Load.is_volatile = is_volatile;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_inline_code(irProcedure *p, BuiltinProcId id, Array<irValue *> const &operands, Type *type) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_InlineCode);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->InlineCode.id = id;
|
|
|
- i->InlineCode.operands = operands;
|
|
|
- i->InlineCode.type = type;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_atomic_fence(irProcedure *p, BuiltinProcId id) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_AtomicFence);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->AtomicFence.id = id;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_atomic_store(irProcedure *p, irValue *address, irValue *value, BuiltinProcId id) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_AtomicStore);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->AtomicStore.address = address;
|
|
|
- i->AtomicStore.value = value;
|
|
|
- i->AtomicStore.id = id;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
- if (value) value->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_atomic_load(irProcedure *p, irValue *address, BuiltinProcId id) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_AtomicLoad);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->AtomicLoad.address = address;
|
|
|
- i->AtomicLoad.type = type_deref(ir_type(address));
|
|
|
- i->AtomicLoad.id = id;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_atomic_rmw(irProcedure *p, irValue *address, irValue *value, BuiltinProcId id) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_AtomicRmw);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->AtomicRmw.type = type_deref(ir_type(address));
|
|
|
- i->AtomicRmw.address = address;
|
|
|
- i->AtomicRmw.value = value;
|
|
|
- i->AtomicRmw.id = id;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
- if (value) value->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_instr_atomic_cxchg(irProcedure *p, Type *type, irValue *address, irValue *old_value, irValue *new_value, BuiltinProcId id) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_AtomicCxchg);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
-
|
|
|
-
|
|
|
- if (type->kind == Type_Tuple) {
|
|
|
- GB_ASSERT(type->Tuple.variables.count == 2);
|
|
|
- Type *elem = type->Tuple.variables[0]->type;
|
|
|
- // LEAK TODO(bill): LLVM returns {T, i1} whilst Odin does {T, bool}, fix this mapping hack
|
|
|
- gbAllocator a = permanent_allocator();
|
|
|
- Type *llvm_type = alloc_type_tuple();
|
|
|
- array_init(&llvm_type->Tuple.variables, a, 0, 2);
|
|
|
- array_add (&llvm_type->Tuple.variables, alloc_entity_field(nullptr, blank_token, elem, false, 0));
|
|
|
- array_add (&llvm_type->Tuple.variables, alloc_entity_field(nullptr, blank_token, t_llvm_bool, false, 1));
|
|
|
-
|
|
|
- type = llvm_type;
|
|
|
- }
|
|
|
- i->AtomicCxchg.type = type;
|
|
|
-
|
|
|
- i->AtomicCxchg.address = address;
|
|
|
- i->AtomicCxchg.old_value = old_value;
|
|
|
- i->AtomicCxchg.new_value = new_value;
|
|
|
- i->AtomicCxchg.id = id;
|
|
|
-
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
- if (old_value) old_value->uses += 1;
|
|
|
- if (new_value) new_value->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_array_element_ptr(irProcedure *p, irValue *address, irValue *elem_index) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_ArrayElementPtr);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- Type *t = ir_type(address);
|
|
|
- GB_ASSERT_MSG(is_type_pointer(t), "%s", type_to_string(t));
|
|
|
- t = base_type(type_deref(t));
|
|
|
- GB_ASSERT(is_type_array(t) || is_type_enumerated_array(t));
|
|
|
-
|
|
|
- Type *result_type = nullptr;
|
|
|
- if (t->kind == Type_Array) {
|
|
|
- result_type = alloc_type_pointer(t->Array.elem);
|
|
|
- } else if (t->kind == Type_EnumeratedArray) {
|
|
|
- result_type = alloc_type_pointer(t->EnumeratedArray.elem);
|
|
|
- }
|
|
|
-
|
|
|
- i->ArrayElementPtr.address = address;
|
|
|
- i->ArrayElementPtr.elem_index = elem_index;
|
|
|
- i->ArrayElementPtr.result_type = result_type;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
- if (elem_index) elem_index->uses += 1;
|
|
|
-
|
|
|
- GB_ASSERT_MSG(is_type_pointer(ir_type(address)),
|
|
|
- "%s", type_to_string(ir_type(address)));
|
|
|
- return v;
|
|
|
-}
|
|
|
-irValue *ir_instr_struct_element_ptr(irProcedure *p, irValue *address, i32 elem_index, Type *result_type) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_StructElementPtr);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->StructElementPtr.address = address;
|
|
|
- i->StructElementPtr.elem_index = elem_index;
|
|
|
- i->StructElementPtr.result_type = result_type;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
-
|
|
|
- GB_ASSERT_MSG(is_type_pointer(ir_type(address)),
|
|
|
- "%s", type_to_string(ir_type(address)));
|
|
|
- return v;
|
|
|
-}
|
|
|
-irValue *ir_instr_ptr_offset(irProcedure *p, irValue *address, irValue *offset) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_PtrOffset);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->PtrOffset.address = address;
|
|
|
- i->PtrOffset.offset = offset;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
- if (offset) offset->uses += 1;
|
|
|
-
|
|
|
-
|
|
|
- GB_ASSERT_MSG(is_type_pointer(ir_type(address)),
|
|
|
- "%s", type_to_string(ir_type(address)));
|
|
|
- GB_ASSERT_MSG(is_type_integer(ir_type(offset)),
|
|
|
- "%s", type_to_string(ir_type(address)));
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_instr_struct_extract_value(irProcedure *p, irValue *address, i32 index, Type *result_type) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_StructExtractValue);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->StructExtractValue.address = address;
|
|
|
- i->StructExtractValue.index = index;
|
|
|
- i->StructExtractValue.result_type = result_type;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_union_tag_ptr(irProcedure *p, irValue *address) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_UnionTagPtr);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->UnionTagPtr.address = address;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
-
|
|
|
- // i->UnionTagPtr.type = alloc_type_pointer(t_type_info_ptr);
|
|
|
- Type *u = type_deref(ir_type(address));
|
|
|
- if (is_type_union_maybe_pointer(u)) {
|
|
|
- GB_PANIC("union #maybe UnionTagPtr");
|
|
|
- }
|
|
|
- i->UnionTagPtr.type = alloc_type_pointer(union_tag_type(u));
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_union_tag_value(irProcedure *p, irValue *address) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_UnionTagValue);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->UnionTagValue.address = address;
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
-
|
|
|
- Type *u = type_deref(ir_type(address));
|
|
|
- if (is_type_union_maybe_pointer(u)) {
|
|
|
- GB_PANIC("union #maybe UnionTagValue");
|
|
|
- }
|
|
|
- i->UnionTagPtr.type = union_tag_type(u);
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_unary_op(irProcedure *p, TokenKind op, irValue *expr, Type *type) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_UnaryOp);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->UnaryOp.op = op;
|
|
|
- i->UnaryOp.expr = expr;
|
|
|
- i->UnaryOp.type = type;
|
|
|
-
|
|
|
- if (expr) expr->uses += 1;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_instr_binary_op(irProcedure *p, TokenKind op, irValue *left, irValue *right, Type *type) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_BinaryOp);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->BinaryOp.op = op;
|
|
|
- i->BinaryOp.left = left;
|
|
|
- i->BinaryOp.right = right;
|
|
|
- i->BinaryOp.type = type;
|
|
|
-
|
|
|
- if (left) left->uses += 1;
|
|
|
- if (right) right->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_jump(irProcedure *p, irBlock *block) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Jump);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->Jump.block = block;
|
|
|
- return v;
|
|
|
-}
|
|
|
-irValue *ir_instr_if(irProcedure *p, irValue *cond, irBlock *true_block, irBlock *false_block) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_If);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->If.cond = ir_emit_conv(p, cond, t_llvm_bool);
|
|
|
- i->If.true_block = true_block;
|
|
|
- i->If.false_block = false_block;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_instr_phi(irProcedure *p, Array<irValue *> edges, Type *type) {
|
|
|
- GB_ASSERT(is_type_typed(type));
|
|
|
-
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Phi);
|
|
|
- irInstr *i = &v->Instr;
|
|
|
- i->Phi.edges = edges;
|
|
|
- i->Phi.type = type;
|
|
|
-
|
|
|
- for_array(j, edges) {
|
|
|
- if (edges[j]) edges[j]->uses += 1;
|
|
|
- }
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_unreachable(irProcedure *p) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Unreachable);
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_return(irProcedure *p, irValue *value) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Return);
|
|
|
- v->Instr.Return.value = value;
|
|
|
-
|
|
|
- if (value) value->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_select(irProcedure *p, irValue *cond, irValue *t, irValue *f) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Select);
|
|
|
- v->Instr.Select.cond = cond;
|
|
|
- v->Instr.Select.true_value = t;
|
|
|
- v->Instr.Select.false_value = f;
|
|
|
-
|
|
|
- if (cond) cond->uses += 1;
|
|
|
- if (t) t->uses += 1;
|
|
|
- if (f) f->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_call(irProcedure *p, irValue *value, irValue *return_ptr, Array<irValue *> args, Type *result_type, irValue *context_ptr, ProcInlining inlining) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Call);
|
|
|
- v->Instr.Call.value = value;
|
|
|
- v->Instr.Call.return_ptr = return_ptr;
|
|
|
- v->Instr.Call.args = args;
|
|
|
- v->Instr.Call.type = result_type;
|
|
|
- v->Instr.Call.context_ptr = context_ptr;
|
|
|
- v->Instr.Call.inlining = inlining;
|
|
|
-
|
|
|
- if (value) value->uses += 1;
|
|
|
- if (return_ptr) return_ptr->uses += 1;
|
|
|
- for_array(i, args) {
|
|
|
- if (args[i]) args[i]->uses += 1;
|
|
|
- }
|
|
|
- if (context_ptr) context_ptr->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_conv(irProcedure *p, irConvKind kind, irValue *value, Type *from, Type *to) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Conv);
|
|
|
- v->Instr.Conv.kind = kind;
|
|
|
- v->Instr.Conv.value = value;
|
|
|
- v->Instr.Conv.from = from;
|
|
|
- v->Instr.Conv.to = to;
|
|
|
-
|
|
|
- if (value) value->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_comment(irProcedure *p, String text) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_Comment);
|
|
|
- v->Instr.Comment.text = text;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_instr_debug_declare(irProcedure *p, Ast *expr, Entity *entity, bool is_addr, irValue *value) {
|
|
|
- irValue *v = ir_alloc_instr(p, irInstr_DebugDeclare);
|
|
|
- v->Instr.DebugDeclare.expr = expr;
|
|
|
- v->Instr.DebugDeclare.entity = entity;
|
|
|
- v->Instr.DebugDeclare.is_addr = is_addr;
|
|
|
- v->Instr.DebugDeclare.value = value;
|
|
|
-
|
|
|
- if (value) value->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_value_constant(Type *type, ExactValue value) {
|
|
|
- irValue *v = ir_alloc_value(irValue_Constant);
|
|
|
- v->Constant.type = type;
|
|
|
- v->Constant.value = value;
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_value_constant_slice(Type *type, irValue *backing_array, i64 count) {
|
|
|
- irValue *v = ir_alloc_value(irValue_ConstantSlice);
|
|
|
- v->ConstantSlice.type = type;
|
|
|
- v->ConstantSlice.backing_array = backing_array;
|
|
|
- v->ConstantSlice.count = count;
|
|
|
-
|
|
|
- if (backing_array) backing_array->uses += 1;
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit(irProcedure *proc, irValue *instr) {
|
|
|
- GB_ASSERT(instr->kind == irValue_Instr);
|
|
|
- irModule *m = proc->module;
|
|
|
- irBlock *b = proc->curr_block;
|
|
|
- instr->Instr.block = b;
|
|
|
- if (b != nullptr) {
|
|
|
- irInstr *i = ir_get_last_instr(b);
|
|
|
- if (!ir_is_instr_terminating(i)) {
|
|
|
- array_add(&b->instrs, instr);
|
|
|
- }
|
|
|
- } else if (instr->Instr.kind != irInstr_Unreachable) {
|
|
|
- GB_PANIC("ir_emit: Instruction missing parent block");
|
|
|
- }
|
|
|
- if (m->generate_debug_info) {
|
|
|
- ir_value_set_debug_location(proc, instr);
|
|
|
- }
|
|
|
- return instr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_de_emit(irProcedure *proc, irValue *instr) {
|
|
|
- GB_ASSERT(instr->kind == irValue_Instr);
|
|
|
- irModule *m = proc->module;
|
|
|
- irBlock *b = proc->curr_block;
|
|
|
- GB_ASSERT(b != nullptr);
|
|
|
- irInstr *i = ir_get_last_instr(b);
|
|
|
- GB_ASSERT(i == &instr->Instr);
|
|
|
- array_pop(&b->instrs);
|
|
|
- return instr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_const_int(i64 i) {
|
|
|
- return ir_value_constant(t_int, exact_value_i64(i));
|
|
|
-}
|
|
|
-irValue *ir_const_uintptr(u64 i) {
|
|
|
- return ir_value_constant(t_uintptr, exact_value_i64(i));
|
|
|
-}
|
|
|
-irValue *ir_const_u8(u32 i) {
|
|
|
- return ir_value_constant(t_u8, exact_value_i64(i));
|
|
|
-}
|
|
|
-irValue *ir_const_i32(i32 i) {
|
|
|
- return ir_value_constant(t_i32, exact_value_i64(i));
|
|
|
-}
|
|
|
-irValue *ir_const_u32(u32 i) {
|
|
|
- return ir_value_constant(t_u32, exact_value_i64(i));
|
|
|
-}
|
|
|
-irValue *ir_const_i64(i64 i) {
|
|
|
- return ir_value_constant(t_i64, exact_value_i64(i));
|
|
|
-}
|
|
|
-irValue *ir_const_u64(u64 i) {
|
|
|
- return ir_value_constant(t_u64, exact_value_i64(i));
|
|
|
-}
|
|
|
-irValue *ir_const_f32(f32 f) {
|
|
|
- return ir_value_constant(t_f32, exact_value_float(f));
|
|
|
-}
|
|
|
-irValue *ir_const_f64(f64 f) {
|
|
|
- return ir_value_constant(t_f64, exact_value_float(f));
|
|
|
-}
|
|
|
-irValue *ir_const_bool(bool b) {
|
|
|
- return ir_value_constant(t_bool, exact_value_bool(b != 0));
|
|
|
-}
|
|
|
-irValue *ir_const_string(irModule *m, String s) {
|
|
|
- return ir_find_or_add_entity_string(m, s);
|
|
|
- // return ir_value_constant(t_string, exact_value_string(s));
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_value_procedure(irModule *m, Entity *entity, Type *type, Ast *type_expr, Ast *body, String name) {
|
|
|
- irValue *v = ir_alloc_value(irValue_Proc);
|
|
|
- v->Proc.module = m;
|
|
|
- v->Proc.entity = entity;
|
|
|
- v->Proc.type = type;
|
|
|
- v->Proc.type_expr = type_expr;
|
|
|
- v->Proc.body = body;
|
|
|
- v->Proc.name = name;
|
|
|
- array_init(&v->Proc.referrers, heap_allocator());
|
|
|
-
|
|
|
- Type *t = base_type(type);
|
|
|
- GB_ASSERT(is_type_proc(t));
|
|
|
- array_init(&v->Proc.params, heap_allocator(), 0, t->Proc.param_count);
|
|
|
-
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_generate_array(irModule *m, Type *elem_type, i64 count, String prefix, i64 id) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- Token token = {Token_Ident};
|
|
|
- isize name_len = prefix.len + 1 + 20;
|
|
|
-
|
|
|
- auto suffix_id = cast(unsigned long long)id;
|
|
|
- char *text = gb_alloc_array(a, char, name_len+1);
|
|
|
- gb_snprintf(text, name_len,
|
|
|
- "%.*s-%llu", LIT(prefix), suffix_id);
|
|
|
- text[name_len] = 0;
|
|
|
-
|
|
|
- String s = make_string_c(text);
|
|
|
-
|
|
|
- Entity *e = alloc_entity_variable(nullptr, make_token_ident(s), alloc_type_array(elem_type, count));
|
|
|
- irValue *value = ir_value_global(e, nullptr);
|
|
|
- value->Global.is_private = true;
|
|
|
- ir_module_add_value(m, e, value);
|
|
|
- string_map_set(&m->members, s, value);
|
|
|
- return value;
|
|
|
-}
|
|
|
-
|
|
|
-irBlock *ir_new_block(irProcedure *proc, Ast *node, char const *label) {
|
|
|
- Scope *scope = nullptr;
|
|
|
- if (node != nullptr) {
|
|
|
- scope = scope_of_node(node);
|
|
|
- GB_ASSERT_MSG(scope != nullptr, "Block scope not found for %.*s", LIT(ast_strings[node->kind]));
|
|
|
- }
|
|
|
-
|
|
|
- irValue *v = ir_alloc_value(irValue_Block);
|
|
|
- v->Block.label = make_string_c(label);
|
|
|
- v->Block.node = node;
|
|
|
- v->Block.scope = scope;
|
|
|
- v->Block.proc = proc;
|
|
|
- // TODO(bill): Is this correct or even needed?
|
|
|
- v->Block.scope_index = proc->scope_index;
|
|
|
-
|
|
|
- array_init(&v->Block.instrs, heap_allocator());
|
|
|
- array_init(&v->Block.locals, heap_allocator());
|
|
|
-
|
|
|
- array_init(&v->Block.preds, heap_allocator());
|
|
|
- array_init(&v->Block.succs, heap_allocator());
|
|
|
-
|
|
|
- irBlock *block = &v->Block;
|
|
|
- return block;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_add_block_to_proc(irProcedure *proc, irBlock *b) {
|
|
|
- for_array(i, proc->blocks) {
|
|
|
- if (proc->blocks[i] == b) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- array_add(&proc->blocks, b);
|
|
|
- b->index = proc->block_count++;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_start_block(irProcedure *proc, irBlock *block) {
|
|
|
- proc->curr_block = block;
|
|
|
- if (block != nullptr) {
|
|
|
- ir_add_block_to_proc(proc, block);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_transmute(irProcedure *proc, irValue *value, Type *t);
|
|
|
-irValue *ir_address_from_load_or_generate_local(irProcedure *proc, irValue *val);
|
|
|
-irValue *ir_emit_struct_ep(irProcedure *proc, irValue *s, i32 index);
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void ir_add_defer_node(irProcedure *proc, isize scope_index, Ast *stmt) {
|
|
|
- irDefer d = {irDefer_Node};
|
|
|
- d.scope_index = scope_index;
|
|
|
- d.context_stack_count = proc->context_stack.count;
|
|
|
- d.block = proc->curr_block;
|
|
|
- d.stmt = stmt;
|
|
|
- array_add(&proc->defer_stmts, d);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_add_defer_instr(irProcedure *proc, isize scope_index, irValue *instr) {
|
|
|
- irDefer d = {irDefer_Instr};
|
|
|
- d.scope_index = proc->scope_index;
|
|
|
- d.context_stack_count = proc->context_stack.count;
|
|
|
- d.block = proc->curr_block;
|
|
|
- d.instr = instr; // NOTE(bill): It will make a copy everytime it is called
|
|
|
- array_add(&proc->defer_stmts, d);
|
|
|
-}
|
|
|
-
|
|
|
-void ir_add_defer_proc(irProcedure *proc, isize scope_index, irValue *deferred, Array<irValue *> const &result_as_args) {
|
|
|
- irDefer d = {irDefer_Proc};
|
|
|
- d.scope_index = proc->scope_index;
|
|
|
- d.context_stack_count = proc->context_stack.count;
|
|
|
- d.block = proc->curr_block;
|
|
|
- d.proc.deferred = deferred;
|
|
|
- d.proc.result_as_args = result_as_args;
|
|
|
- array_add(&proc->defer_stmts, d);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_add_module_constant(irModule *m, Type *type, ExactValue value);
|
|
|
-
|
|
|
-irValue *ir_check_compound_lit_constant(irModule *m, Ast *expr) {
|
|
|
- expr = unparen_expr(expr);
|
|
|
- if (expr == nullptr) {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
-
|
|
|
- if (expr->kind == Ast_CompoundLit) {
|
|
|
- ast_node(cl, CompoundLit, expr);
|
|
|
- for_array(i, cl->elems) {
|
|
|
- Ast *elem = cl->elems[i];
|
|
|
- if (elem->kind == Ast_FieldValue) {
|
|
|
- ast_node(fv, FieldValue, elem);
|
|
|
- ir_check_compound_lit_constant(m, fv->value);
|
|
|
- } else {
|
|
|
- ir_check_compound_lit_constant(m, elem);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (expr->kind == Ast_ProcLit) {
|
|
|
- return ir_gen_anonymous_proc_lit(m, str_lit("_proclit"), expr);
|
|
|
- }
|
|
|
-
|
|
|
- if (expr->kind == Ast_Ident || expr->kind == Ast_SelectorExpr) {
|
|
|
- TypeAndValue tav = type_and_value_of_expr(expr);
|
|
|
- if (tav.mode == Addressing_Constant) {
|
|
|
- return ir_add_module_constant(m, tav.type, tav.value);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_add_module_constant(irModule *m, Type *type, ExactValue value) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
-
|
|
|
- if (is_type_slice(type)) {
|
|
|
- if (value.kind == ExactValue_String) {
|
|
|
- GB_ASSERT(is_type_u8_slice(type));
|
|
|
- return ir_find_or_add_entity_string_byte_slice(m, value.value_string);
|
|
|
- } else {
|
|
|
- ast_node(cl, CompoundLit, value.value_compound);
|
|
|
-
|
|
|
- isize count = cl->elems.count;
|
|
|
- if (count == 0) {
|
|
|
- return ir_value_nil(type);
|
|
|
- }
|
|
|
- count = gb_max(cl->max_count, count);
|
|
|
- Type *elem = base_type(type)->Slice.elem;
|
|
|
- Type *t = alloc_type_array(elem, count);
|
|
|
- irValue *backing_array = ir_add_module_constant(m, t, value);
|
|
|
-
|
|
|
-
|
|
|
- isize max_len = 7+8+1;
|
|
|
- u8 *str = cast(u8 *)gb_alloc_array(a, u8, max_len);
|
|
|
- isize len = gb_snprintf(cast(char *)str, max_len, "csba$%x", m->global_array_index);
|
|
|
- m->global_array_index++;
|
|
|
-
|
|
|
- String name = make_string(str, len-1);
|
|
|
-
|
|
|
- Entity *e = alloc_entity_constant(nullptr, make_token_ident(name), t, value);
|
|
|
- irValue *g = ir_value_global(e, backing_array);
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
-
|
|
|
- return ir_value_constant_slice(type, g, count);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (value.kind == ExactValue_Compound) {
|
|
|
- // NOTE(bill): Removed for numerous reasons
|
|
|
- irValue *lit = ir_check_compound_lit_constant(m, value.value_compound);
|
|
|
- if (lit != nullptr) {
|
|
|
- return lit;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ir_value_constant(type, value);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_add_global_string_array(irModule *m, String string) {
|
|
|
-
|
|
|
- irValue *global_constant_value = nullptr;
|
|
|
- {
|
|
|
- irValue **found = string_map_get(&m->const_string_byte_slices, string);
|
|
|
- if (found != nullptr) {
|
|
|
- global_constant_value = *found;
|
|
|
-
|
|
|
- irValue **global_found = map_get(&m->constant_value_to_global, hash_pointer(global_constant_value));
|
|
|
- if (global_found != nullptr) {
|
|
|
- return *global_found;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (global_constant_value == nullptr) {
|
|
|
- global_constant_value = ir_find_or_add_entity_string_byte_slice(m, string);
|
|
|
- }
|
|
|
- Type *type = alloc_type_array(t_u8, string.len+1);
|
|
|
-
|
|
|
-
|
|
|
- isize max_len = 6+8+1;
|
|
|
- u8 *str = cast(u8 *)gb_alloc_array(ir_allocator(), u8, max_len);
|
|
|
- isize len = gb_snprintf(cast(char *)str, max_len, "str$%x", m->global_string_index);
|
|
|
- m->global_string_index++;
|
|
|
-
|
|
|
- String name = make_string(str, len-1);
|
|
|
- Token token = {Token_String};
|
|
|
- token.string = name;
|
|
|
-
|
|
|
- Entity *entity = alloc_entity_constant(nullptr, token, type, exact_value_string(string));
|
|
|
-
|
|
|
- irValue *g = ir_value_global(entity, global_constant_value);
|
|
|
- g->Global.is_private = true;
|
|
|
- g->Global.is_unnamed_addr = true;
|
|
|
- g->Global.is_constant = true;
|
|
|
-
|
|
|
- map_set(&m->constant_value_to_global, hash_pointer(global_constant_value), g);
|
|
|
-
|
|
|
-
|
|
|
- ir_module_add_value(m, entity, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
-
|
|
|
- return g;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_add_foreign_library_path(irModule *m, Entity *e) {
|
|
|
- if (e == nullptr) {
|
|
|
- return;
|
|
|
- }
|
|
|
- GB_ASSERT(e->kind == Entity_LibraryName);
|
|
|
- GB_ASSERT(e->flags & EntityFlag_Used);
|
|
|
-
|
|
|
- for_array(i, e->LibraryName.paths) {
|
|
|
- String library_path = e->LibraryName.paths[i];
|
|
|
- if (library_path.len == 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- bool ok = true;
|
|
|
- for_array(path_index, m->foreign_library_paths) {
|
|
|
- String path = m->foreign_library_paths[path_index];
|
|
|
- #if defined(GB_SYSTEM_WINDOWS)
|
|
|
- if (str_eq_ignore_case(path, library_path)) {
|
|
|
- #else
|
|
|
- if (str_eq(path, library_path)) {
|
|
|
- #endif
|
|
|
- ok = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (ok) {
|
|
|
- array_add(&m->foreign_library_paths, library_path);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void ir_push_context_onto_stack(irProcedure *proc, irValue *ctx) {
|
|
|
- irContextData cd = {ctx, proc->scope_index};
|
|
|
- array_add(&proc->context_stack, cd);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_add_local(irProcedure *proc, Entity *e, Ast *expr, bool zero_initialized, i32 param_index = 0) {
|
|
|
- irBlock *b = proc->decl_block; // all variables must be in the first block
|
|
|
- irValue *instr = ir_instr_local(proc, e, true);
|
|
|
- instr->Instr.block = b;
|
|
|
- array_add(&b->instrs, instr);
|
|
|
- array_add(&b->locals, instr);
|
|
|
- proc->local_count++;
|
|
|
-
|
|
|
- if (zero_initialized) {
|
|
|
- ir_emit_zero_init(proc, instr, expr);
|
|
|
- }
|
|
|
- set_procedure_abi_types(e->type);
|
|
|
-
|
|
|
- // if (proc->module->generate_debug_info && expr != nullptr && proc->entity != nullptr) {
|
|
|
- // if (proc->module->generate_debug_info && proc->entity != nullptr) {
|
|
|
- if (proc->module->generate_debug_info) {
|
|
|
- // GB_ASSERT_NOT_NULL(proc->debug_scope);
|
|
|
- if (expr != nullptr) {
|
|
|
- ir_emit(proc, ir_instr_debug_declare(proc, expr, e, true, instr));
|
|
|
- }
|
|
|
- if (e->scope != nullptr && proc->debug_scope != nullptr) {
|
|
|
- irDebugInfo *di_local = ir_add_debug_info_local(proc, e, param_index);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return instr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_add_local_for_identifier(irProcedure *proc, Ast *ident, bool zero_initialized) {
|
|
|
- Entity *e = entity_of_node(ident);
|
|
|
- if (e != nullptr) {
|
|
|
- String name = e->token.string;
|
|
|
- ir_emit_comment(proc, name);
|
|
|
- if (e->kind == Entity_Variable &&
|
|
|
- e->Variable.is_foreign) {
|
|
|
- if (e->Variable.link_name.len != 0) {
|
|
|
- name = e->Variable.link_name;
|
|
|
- }
|
|
|
-
|
|
|
- StringHashKey key = string_hash_string(name);
|
|
|
- irValue **prev_value = string_map_get(&proc->module->members, key);
|
|
|
- if (prev_value == nullptr) {
|
|
|
- ir_add_foreign_library_path(proc->module, e->Variable.foreign_library);
|
|
|
- // NOTE(bill): Don't do mutliple declarations in the IR
|
|
|
- irValue *g = ir_value_global(e, nullptr);
|
|
|
- g->Global.name = name;
|
|
|
- g->Global.is_foreign = true;
|
|
|
- ir_module_add_value(proc->module, e, g);
|
|
|
- string_map_set(&proc->module->members, key, g);
|
|
|
- return g;
|
|
|
- } else {
|
|
|
- return *prev_value;
|
|
|
- }
|
|
|
- }
|
|
|
- return ir_add_local(proc, e, ident, zero_initialized);
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_add_local_generated(irProcedure *proc, Type *type, bool zero_initialized) {
|
|
|
- GB_ASSERT(type != nullptr);
|
|
|
- type = default_type(type);
|
|
|
-
|
|
|
- Scope *scope = nullptr;
|
|
|
- if (proc->curr_block) {
|
|
|
- scope = proc->curr_block->scope;
|
|
|
- }
|
|
|
- Entity *e = alloc_entity_variable(scope, empty_token, type);
|
|
|
- return ir_add_local(proc, e, nullptr, zero_initialized);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_add_global_generated(irModule *m, Type *type, irValue *value) {
|
|
|
- GB_ASSERT(type != nullptr);
|
|
|
- type = default_type(type);
|
|
|
-
|
|
|
- isize max_len = 7+8+1;
|
|
|
- u8 *str = cast(u8 *)gb_alloc_array(ir_allocator(), u8, max_len);
|
|
|
- isize len = gb_snprintf(cast(char *)str, max_len, "ggv$%x", m->global_generated_index);
|
|
|
- m->global_generated_index++;
|
|
|
- String name = make_string(str, len-1);
|
|
|
-
|
|
|
- Scope *scope = nullptr;
|
|
|
- Entity *e = alloc_entity_variable(scope, make_token_ident(name), type);
|
|
|
- irValue *g = ir_value_global(e, value);
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
- return g;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_add_param(irProcedure *proc, Entity *e, Ast *expr, Type *abi_type, i32 index) {
|
|
|
- irValue *v = ir_value_param(proc, e, abi_type, index);
|
|
|
- array_add(&proc->params, v);
|
|
|
- irValueParam *p = &v->Param;
|
|
|
-
|
|
|
- irValue *res = nullptr;
|
|
|
-
|
|
|
- ir_push_debug_location(proc->module, e ? e->identifier : nullptr, proc->debug_scope, e);
|
|
|
- defer (ir_pop_debug_location(proc->module));
|
|
|
-
|
|
|
- switch (p->kind) {
|
|
|
- case irParamPass_Value: {
|
|
|
- irValue *l = ir_add_local(proc, e, expr, false, index);
|
|
|
- irValue *x = v;
|
|
|
- if (abi_type == t_llvm_bool) {
|
|
|
- x = ir_emit_conv(proc, x, t_bool);
|
|
|
- }
|
|
|
- ir_emit_store(proc, l, x);
|
|
|
- return x;
|
|
|
- }
|
|
|
- case irParamPass_Pointer:
|
|
|
- ir_module_add_value(proc->module, e, v);
|
|
|
- return ir_emit_load(proc, v);
|
|
|
-
|
|
|
- case irParamPass_Integer: {
|
|
|
- irValue *l = ir_add_local(proc, e, expr, false, index);
|
|
|
- irValue *iptr = ir_emit_conv(proc, l, alloc_type_pointer(p->type));
|
|
|
- ir_emit_store(proc, iptr, v);
|
|
|
- return ir_emit_load(proc, l);
|
|
|
- }
|
|
|
-
|
|
|
- case irParamPass_ConstRef:
|
|
|
- ir_module_add_value(proc->module, e, v);
|
|
|
- return ir_emit_load(proc, v);
|
|
|
-
|
|
|
- case irParamPass_BitCast: {
|
|
|
- irValue *l = ir_add_local(proc, e, expr, false, index);
|
|
|
- irValue *x = ir_emit_transmute(proc, v, e->type);
|
|
|
- ir_emit_store(proc, l, x);
|
|
|
- return x;
|
|
|
- }
|
|
|
- case irParamPass_Tuple: {
|
|
|
- irValue *l = ir_add_local(proc, e, expr, true, index);
|
|
|
- Type *st = struct_type_from_systemv_distribute_struct_fields(abi_type);
|
|
|
- irValue *ptr = ir_emit_transmute(proc, l, alloc_type_pointer(st));
|
|
|
- if (abi_type->Tuple.variables.count > 0) {
|
|
|
- array_pop(&proc->params);
|
|
|
- }
|
|
|
- for_array(i, abi_type->Tuple.variables) {
|
|
|
- Type *t = abi_type->Tuple.variables[i]->type;
|
|
|
-
|
|
|
- irValue *elem = ir_value_param(proc, nullptr, t, index+cast(i32)i);
|
|
|
- array_add(&proc->params, elem);
|
|
|
-
|
|
|
- irValue *dst = ir_emit_struct_ep(proc, ptr, cast(i32)i);
|
|
|
- ir_emit_store(proc, dst, elem);
|
|
|
- }
|
|
|
- return ir_emit_load(proc, l);
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unreachable");
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// @Debug
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irDebugInfo *scope, irDebugInfo *file);
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_array(irModule *module, isize count, isize capacity) {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DebugInfoArray);
|
|
|
- array_init(&di->DebugInfoArray.elements, ir_allocator(), count, capacity);
|
|
|
- map_set(&module->debug_info, hash_pointer(di), di);
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_file(irModule *module, AstFile *file) {
|
|
|
- // if (!proc->module->generate_debug_info) {
|
|
|
- // return nullptr;
|
|
|
- // }
|
|
|
-
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_ast_file(file));
|
|
|
- if (existing != nullptr) {
|
|
|
- GB_ASSERT((*existing)->kind == irDebugInfo_File);
|
|
|
- return *existing;
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(file != nullptr);
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_File);
|
|
|
- di->File.file = file;
|
|
|
-
|
|
|
- String filename = file->tokenizer.fullpath;
|
|
|
- String directory = filename;
|
|
|
- isize slash_index = 0;
|
|
|
- for (isize i = filename.len-1; i >= 0; i--) {
|
|
|
- if (filename[i] == '\\' ||
|
|
|
- filename[i] == '/') {
|
|
|
- break;
|
|
|
- }
|
|
|
- slash_index = i;
|
|
|
- }
|
|
|
- directory.len = slash_index-1;
|
|
|
- filename.text = filename.text + slash_index;
|
|
|
- filename.len -= slash_index;
|
|
|
-
|
|
|
-
|
|
|
- di->File.filename = filename;
|
|
|
- di->File.directory = directory;
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_ast_file(file), di);
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugEncoding ir_debug_encoding_for_basic(BasicKind kind) {
|
|
|
- switch (kind) {
|
|
|
- case Basic_llvm_bool:
|
|
|
- case Basic_bool:
|
|
|
- case Basic_b8:
|
|
|
- case Basic_b16:
|
|
|
- case Basic_b32:
|
|
|
- case Basic_b64:
|
|
|
- return irDebugBasicEncoding_boolean;
|
|
|
-
|
|
|
- case Basic_i8:
|
|
|
- return irDebugBasicEncoding_signed_char;
|
|
|
-
|
|
|
- case Basic_u8:
|
|
|
- return irDebugBasicEncoding_unsigned_char;
|
|
|
-
|
|
|
-
|
|
|
- case Basic_i16:
|
|
|
- case Basic_i32:
|
|
|
- case Basic_i64:
|
|
|
- case Basic_i128:
|
|
|
- case Basic_i16le:
|
|
|
- case Basic_i32le:
|
|
|
- case Basic_i64le:
|
|
|
- case Basic_i128le:
|
|
|
- case Basic_i16be:
|
|
|
- case Basic_i32be:
|
|
|
- case Basic_i64be:
|
|
|
- case Basic_i128be:
|
|
|
- case Basic_int:
|
|
|
- case Basic_rune:
|
|
|
- case Basic_typeid:
|
|
|
- return irDebugBasicEncoding_signed;
|
|
|
-
|
|
|
- case Basic_u16:
|
|
|
- case Basic_u32:
|
|
|
- case Basic_u64:
|
|
|
- case Basic_u128:
|
|
|
- case Basic_u16le:
|
|
|
- case Basic_u32le:
|
|
|
- case Basic_u64le:
|
|
|
- case Basic_u128le:
|
|
|
- case Basic_u16be:
|
|
|
- case Basic_u32be:
|
|
|
- case Basic_u64be:
|
|
|
- case Basic_u128be:
|
|
|
- case Basic_uint:
|
|
|
- case Basic_uintptr:
|
|
|
- return irDebugBasicEncoding_unsigned;
|
|
|
-
|
|
|
- case Basic_f16:
|
|
|
- case Basic_f32:
|
|
|
- case Basic_f64:
|
|
|
- case Basic_f16le:
|
|
|
- case Basic_f32le:
|
|
|
- case Basic_f64le:
|
|
|
- case Basic_f16be:
|
|
|
- case Basic_f32be:
|
|
|
- case Basic_f64be:
|
|
|
- return irDebugBasicEncoding_float;
|
|
|
-
|
|
|
- case Basic_complex32:
|
|
|
- case Basic_complex64:
|
|
|
- case Basic_complex128:
|
|
|
- case Basic_quaternion64:
|
|
|
- case Basic_quaternion128:
|
|
|
- case Basic_quaternion256:
|
|
|
- case Basic_cstring:
|
|
|
- case Basic_string:
|
|
|
- case Basic_any:
|
|
|
- case Basic_rawptr:
|
|
|
- break; // not a "DIBasicType"
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unreachable %d", kind);
|
|
|
- return irDebugBasicEncoding_Invalid;
|
|
|
-}
|
|
|
-
|
|
|
-i32 ir_debug_info_bits(i64 size) {
|
|
|
- return 8*cast(i32)size;
|
|
|
-}
|
|
|
-
|
|
|
-i32 ir_debug_size_bits(Type *type) {
|
|
|
- return ir_debug_info_bits(type_size_of(type));
|
|
|
-}
|
|
|
-
|
|
|
-i32 ir_debug_align_bits(Type *type) {
|
|
|
- return ir_debug_info_bits(type_align_of(type));
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_field_internal(irModule *module, String name, Type *type, i32 offset_bits, Entity *e, irDebugInfo *scope) {
|
|
|
- // NOTE(lachsinc): Caller is expected to insert the returned value into map themselves.
|
|
|
- // "scope", if set, should be inserted into map prior to calling to ensure no cyclical dependency issues.
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
|
|
|
- // GB_ASSERT_MSG(name.len > 0, "%s", type_to_string(type));
|
|
|
- di->DerivedType.name = name;
|
|
|
- di->DerivedType.tag = irDebugBasicEncoding_member;
|
|
|
- di->DerivedType.size = ir_debug_size_bits(type);
|
|
|
- di->DerivedType.offset = offset_bits;
|
|
|
- di->DerivedType.scope = scope;
|
|
|
-
|
|
|
- // NOTE(lachsinc): It is "safe" to overwrite this base_type after a call to this function,
|
|
|
- // if you need to set a specific type for this field.
|
|
|
- di->DerivedType.base_type = ir_add_debug_info_type(module, type, e, scope, nullptr);
|
|
|
- GB_ASSERT_NOT_NULL(di->DerivedType.base_type);
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_field(irModule *module, irDebugInfo *scope, Entity *e, Type *scope_type, i32 index, Type *type, irDebugInfo *file) {
|
|
|
- // NOTE(lachsinc): This lookup will only work for struct fields!!
|
|
|
- if (e) {
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_entity(e));
|
|
|
- if (existing != nullptr) {
|
|
|
- return *existing;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *di = ir_add_debug_info_field_internal(module, make_string(nullptr, 0), type, 0, e, scope);
|
|
|
- void *ptr_to_hash = nullptr;
|
|
|
- if (scope_type) {
|
|
|
- Type *scope_base = base_type(scope_type);
|
|
|
- if (is_type_struct(scope_type) || is_type_tuple(scope_type)) {
|
|
|
- if (is_type_struct(scope_type) && scope_base->Struct.are_offsets_set) {
|
|
|
- di->DerivedType.offset = ir_debug_info_bits(scope_base->Struct.offsets[index]);
|
|
|
- } else if (is_type_tuple(scope_type) && scope_base->Tuple.are_offsets_set) {
|
|
|
- di->DerivedType.offset = ir_debug_info_bits(scope_base->Tuple.offsets[index]);
|
|
|
- } else {
|
|
|
- di->DerivedType.offset = ir_debug_info_bits(type_offset_of(scope_base, index));
|
|
|
- }
|
|
|
- if (e) {
|
|
|
- ptr_to_hash = e;
|
|
|
- di->DerivedType.name = e->token.string;
|
|
|
- if (e->token.string.len == 0) {
|
|
|
- // If no name available for field, use its field index as its name.
|
|
|
- isize max_len = 8;
|
|
|
- u8 *str = cast(u8 *)gb_alloc_array(permanent_allocator(), u8, max_len);
|
|
|
- isize len = gb_snprintf(cast(char *)str, 8, "%d", index);
|
|
|
- di->DerivedType.name = make_string(str, len-1);
|
|
|
- }
|
|
|
- di->DerivedType.pos = e->token.pos;
|
|
|
- } else {
|
|
|
- GB_PANIC("Unreachable"); // struct field Entity's should be provided.
|
|
|
- }
|
|
|
- } else if (is_type_union(scope_base)) {
|
|
|
- // TODO(lachsinc): Handle this in a more generic manner/pass in??...
|
|
|
- // Token token = base_type(scope_base)->Union.node->UnionType.token;
|
|
|
- // di->DerivedType.name = token.string;
|
|
|
- // di->DerivedType.pos = token.pos;
|
|
|
- if (is_type_named(type)) {
|
|
|
- di->DerivedType.name = type->kind == Type_Named ? type->Named.name : type->Basic.name;
|
|
|
- }
|
|
|
- ptr_to_hash = di;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- di->DerivedType.file = file;
|
|
|
-
|
|
|
- GB_ASSERT_NOT_NULL(ptr_to_hash);
|
|
|
- map_set(&module->debug_info, hash_pointer(ptr_to_hash), di);
|
|
|
-
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_enumerator(irModule *module, Entity *e) {
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_entity(e));
|
|
|
- if (existing != nullptr) {
|
|
|
- return *existing;
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_Enumerator);
|
|
|
- di->Enumerator.name = e->token.string;
|
|
|
- GB_ASSERT(e->kind == Entity_Constant);
|
|
|
- GB_ASSERT(e->Constant.value.kind == ExactValue_Integer);
|
|
|
- di->Enumerator.value = big_int_to_i64(&e->Constant.value.value_integer);
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_entity(e), di);
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_type_dynamic_array(irModule *module, Type *type, Entity *e, irDebugInfo *scope, irDebugInfo *file) {
|
|
|
- GB_ASSERT(type->kind == Type_DynamicArray);
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.name = str_lit("dynamic_array"); // TODO(lachsinc): [dynamic] .. type->DynamicArray.elem name
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.size = ir_debug_size_bits(t_rawptr) +
|
|
|
- ir_debug_size_bits(t_int) +
|
|
|
- ir_debug_size_bits(t_int) +
|
|
|
- ir_debug_size_bits(t_allocator);
|
|
|
- di->CompositeType.align = ir_debug_align_bits(t_rawptr);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
-
|
|
|
- // Data pointer type
|
|
|
- // TODO(lachsinc): Perhaps lookup/alloc-a-fake Type_Pointer type and go via ir_add_debug_info_type() with it.
|
|
|
- irDebugInfo *data_ptr_di = ir_alloc_debug_info(irDebugInfo_DerivedType);
|
|
|
- data_ptr_di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
|
|
|
- data_ptr_di->DerivedType.size = ir_debug_size_bits(t_rawptr);
|
|
|
- map_set(&module->debug_info, hash_pointer(data_ptr_di), data_ptr_di);
|
|
|
- data_ptr_di->DerivedType.base_type = ir_add_debug_info_type(module, type->DynamicArray.elem, e, scope, file);
|
|
|
-
|
|
|
- irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_rawptr,
|
|
|
- 0,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- data_di->DerivedType.base_type = data_ptr_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(data_di), data_di);
|
|
|
-
|
|
|
- irDebugInfo *len_di = ir_add_debug_info_field_internal(module, str_lit("len"), t_int,
|
|
|
- data_di->DerivedType.size,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(len_di), len_di);
|
|
|
-
|
|
|
- irDebugInfo *cap_di = ir_add_debug_info_field_internal(module, str_lit("cap"), t_int,
|
|
|
- data_di->DerivedType.size +
|
|
|
- len_di->DerivedType.size,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(cap_di), cap_di);
|
|
|
-
|
|
|
- irDebugInfo *alloc_di = ir_add_debug_info_field_internal(module, str_lit("allocator"), t_allocator,
|
|
|
- data_di->DerivedType.size +
|
|
|
- len_di->DerivedType.size +
|
|
|
- cap_di->DerivedType.size,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(alloc_di), alloc_di);
|
|
|
-
|
|
|
- irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 4);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, data_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, len_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, cap_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, alloc_di);
|
|
|
- di->CompositeType.elements = elements_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
|
|
|
-
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_type_bit_set(irModule *module, Type *type, Entity *e, irDebugInfo *scope) {
|
|
|
- GB_ASSERT(type->kind == Type_BitSet || type->kind == Type_Named);
|
|
|
-
|
|
|
- Type *base = base_type(type);
|
|
|
-
|
|
|
- Type *named = nullptr;
|
|
|
- if (type->kind == Type_Named) {
|
|
|
- named = type;
|
|
|
- }
|
|
|
-
|
|
|
- Type *elem_type = nullptr;
|
|
|
- if (base->BitSet.elem != nullptr) {
|
|
|
- // TODO(lachsinc): Do bitsets have integration with non-primitive types other than enums?
|
|
|
- elem_type = base->BitSet.elem;
|
|
|
- if (elem_type->kind == Type_Enum) {
|
|
|
- GB_ASSERT(elem_type->Enum.fields.count == base->BitSet.upper + 1);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.name = named != nullptr ? named->Named.name : str_lit("bit_set");
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.size = ir_debug_size_bits(base);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
-
|
|
|
- irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, base->BitSet.upper + 1);
|
|
|
- di->CompositeType.elements = elements_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
|
|
|
-
|
|
|
- for (i64 i = 0; i <= base->BitSet.upper; ++i) {
|
|
|
- u32 offset = cast(u32)i;
|
|
|
- // TODO(lachsinc): Maybe name these fields numbered ascending?
|
|
|
- String name = str_lit("field_todo");
|
|
|
- if (elem_type != nullptr && is_type_enum(elem_type)) {
|
|
|
- // name = base_type(elem_type)->Enum.fields[i]->token.string;
|
|
|
- }
|
|
|
- irDebugInfo *field_di = ir_add_debug_info_field_internal(module, name, t_u32, // TODO(lachsinc): u32 fine??
|
|
|
- 0,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- field_di->DerivedType.size = 1;
|
|
|
- field_di->DerivedType.offset = offset; // Offset stored in bits already, no need to convert
|
|
|
- field_di->DerivedType.flags = irDebugInfoFlag_Bitfield;
|
|
|
- map_set(&module->debug_info, hash_pointer(field_di), field_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, field_di);
|
|
|
- }
|
|
|
-
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_type_string(irModule *module, irDebugInfo *scope, Entity *e, Type *type) {
|
|
|
- // TODO(lachsinc): Does this only occur once ??
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_type(t_string));
|
|
|
- if (existing != nullptr) {
|
|
|
- GB_ASSERT((*existing)->kind == irDebugInfo_CompositeType);
|
|
|
- return *existing;
|
|
|
- } else {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.name = type->Basic.name;
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.size = ir_debug_size_bits(t_string);
|
|
|
- di->CompositeType.align = ir_debug_align_bits(t_string);
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
-
|
|
|
- // Field "data"
|
|
|
- irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_cstring,
|
|
|
- 0,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(data_di), data_di);
|
|
|
-
|
|
|
- // Field "len"
|
|
|
- irDebugInfo *len_di = ir_add_debug_info_field_internal(module, str_lit("len"), t_i64,
|
|
|
- data_di->DerivedType.size,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(len_di), len_di);
|
|
|
-
|
|
|
- irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, data_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, len_di);
|
|
|
- di->CompositeType.elements = elements_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
|
|
|
-
|
|
|
- return di;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_type_any(irModule *module) {
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_type(t_any));
|
|
|
- if (existing != nullptr) {
|
|
|
- GB_ASSERT((*existing)->kind == irDebugInfo_CompositeType);
|
|
|
- return *existing;
|
|
|
- } else {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.name = t_any->Basic.name;
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.size = ir_debug_size_bits(t_any);
|
|
|
- di->CompositeType.align = ir_debug_align_bits(t_any);
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_type(t_any), di);
|
|
|
-
|
|
|
- // Field "data"
|
|
|
- irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_rawptr,
|
|
|
- 0,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(data_di), data_di);
|
|
|
-
|
|
|
- // Field "id"
|
|
|
- irDebugInfo *id_di = ir_add_debug_info_field_internal(module, str_lit("id"), t_typeid,
|
|
|
- data_di->DerivedType.size,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(id_di), id_di);
|
|
|
-
|
|
|
- irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, data_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, id_di);
|
|
|
- di->CompositeType.elements = elements_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
|
|
|
-
|
|
|
- return di;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_type_complex(irModule *module, Type *type) {
|
|
|
- GB_ASSERT(type->kind == Type_Basic && is_type_complex(type));
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
-
|
|
|
- di->CompositeType.name = type->Basic.name;
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.size = ir_debug_size_bits(type);
|
|
|
-
|
|
|
- Type *field_type = base_complex_elem_type(type);
|
|
|
-
|
|
|
- irDebugInfo *real_di = ir_add_debug_info_field_internal(module, str_lit("real"), field_type, 0*cast(i32)type_size_of(field_type), nullptr, di);
|
|
|
- irDebugInfo *imag_di = ir_add_debug_info_field_internal(module, str_lit("imag"), field_type, 1*cast(i32)type_size_of(field_type), nullptr, di);
|
|
|
- map_set(&module->debug_info, hash_pointer(real_di), real_di);
|
|
|
- map_set(&module->debug_info, hash_pointer(imag_di), imag_di);
|
|
|
-
|
|
|
- irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, real_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, imag_di);
|
|
|
- di->CompositeType.elements = elements_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
|
|
|
-
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_type_quaternion(irModule *module, Type *type) {
|
|
|
- GB_ASSERT(type->kind == Type_Basic && is_type_quaternion(type));
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
-
|
|
|
- di->CompositeType.name = type->Basic.name;
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.size = ir_debug_size_bits(type);
|
|
|
-
|
|
|
- Type *field_type = base_complex_elem_type(type);
|
|
|
-
|
|
|
- // @QuaternionLayout
|
|
|
- irDebugInfo *imag_di = ir_add_debug_info_field_internal(module, str_lit("imag"), field_type, 0*cast(i32)type_size_of(field_type), nullptr, di);
|
|
|
- irDebugInfo *jmag_di = ir_add_debug_info_field_internal(module, str_lit("jmag"), field_type, 1*cast(i32)type_size_of(field_type), nullptr, di);
|
|
|
- irDebugInfo *kmag_di = ir_add_debug_info_field_internal(module, str_lit("kmag"), field_type, 2*cast(i32)type_size_of(field_type), nullptr, di);
|
|
|
- irDebugInfo *real_di = ir_add_debug_info_field_internal(module, str_lit("real"), field_type, 3*cast(i32)type_size_of(field_type), nullptr, di);
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_pointer(imag_di), imag_di);
|
|
|
- map_set(&module->debug_info, hash_pointer(jmag_di), jmag_di);
|
|
|
- map_set(&module->debug_info, hash_pointer(kmag_di), kmag_di);
|
|
|
- map_set(&module->debug_info, hash_pointer(real_di), real_di);
|
|
|
-
|
|
|
- irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 4);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, imag_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, jmag_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, kmag_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, real_di);
|
|
|
- di->CompositeType.elements = elements_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
|
|
|
-
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_proc_type(irModule *module, Type *type) {
|
|
|
- GB_ASSERT(type->kind == Type_Proc);
|
|
|
-
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_type(type));
|
|
|
- if (existing != nullptr) {
|
|
|
- GB_ASSERT((*existing)->kind == irDebugInfo_ProcType);
|
|
|
- return *existing;
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_ProcType);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
-
|
|
|
- isize result_count = type->Proc.result_count;
|
|
|
- isize param_count = type->Proc.param_count;
|
|
|
- // gb_max(result_count, 1) because llvm expects explicit "null" return type
|
|
|
- di->ProcType.types = ir_add_debug_info_array(module, 0, gb_max(result_count, 1) + param_count);
|
|
|
-
|
|
|
- // TODO(bill): Is this even correct?!
|
|
|
- irDebugInfo *scope = di;
|
|
|
-
|
|
|
- // Result/return types
|
|
|
- if (result_count >= 1) {
|
|
|
- TypeTuple *results_tuple = &type->Proc.results->Tuple;
|
|
|
- for_array(i, results_tuple->variables) {
|
|
|
- Entity *e = results_tuple->variables[i];
|
|
|
- if (e->kind != Entity_Variable) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *type_di = ir_add_debug_info_type(module, e->type, e, scope, nullptr);
|
|
|
- GB_ASSERT_NOT_NULL(type_di);
|
|
|
- array_add(&di->ProcType.types->DebugInfoArray.elements, type_di);
|
|
|
- }
|
|
|
- } else {
|
|
|
- // llvm expects "!{null}" for a function without return type, use nullptr to represent it.
|
|
|
- array_add(&di->ProcType.types->DebugInfoArray.elements, (irDebugInfo*)nullptr);
|
|
|
- }
|
|
|
-
|
|
|
- // Param types
|
|
|
- if (param_count >= 1) {
|
|
|
- TypeTuple *params_tuple = &type->Proc.params->Tuple;
|
|
|
- for_array(i, params_tuple->variables) {
|
|
|
- Entity *e = params_tuple->variables[i];
|
|
|
- if (e->kind != Entity_Variable) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *type_di = ir_add_debug_info_type(module, e->type, e, scope, nullptr);
|
|
|
- GB_ASSERT_NOT_NULL(type_di);
|
|
|
- array_add(&di->ProcType.types->DebugInfoArray.elements, type_di);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irDebugInfo *scope, irDebugInfo *file) {
|
|
|
- // NOTE(lachsinc): Special handling for procedure pointers - we hash their types directly into DISubroutineType's
|
|
|
- // but we need them interpreted as pointers when we use them as variables.
|
|
|
- if (type->kind == Type_Proc) {
|
|
|
- if (e->kind == Entity_Variable || e->kind == Entity_TypeName) {
|
|
|
- // TODO(lachsinc): Wasteful (maybe?). Create a derived type for _every_ different proc ptr type
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
|
|
|
- map_set(&module->debug_info, hash_pointer(di), di);
|
|
|
- di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
|
|
|
- di->DerivedType.size = ir_debug_size_bits(t_rawptr);
|
|
|
- di->DerivedType.base_type = ir_add_debug_info_proc_type(module, type);
|
|
|
- return di;
|
|
|
- } else {
|
|
|
- GB_PANIC("Proc definitions should have their type created manually (not through this function)");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_type(type));
|
|
|
- if (existing != nullptr) {
|
|
|
- return *existing;
|
|
|
- }
|
|
|
-
|
|
|
- // Reset entity/location info, if applicable, for every type we try add.
|
|
|
- // TODO(lachsinc): Confirm this doesn't mess up field's scopes etc.
|
|
|
- if (type->kind == Type_Named) {
|
|
|
- e = type->Named.type_name;
|
|
|
- if (e) {
|
|
|
- CheckerInfo *info = module->info;
|
|
|
- file = ir_add_debug_info_file(module, ast_file_of_filename(info, get_file_path_string(e->token.pos.file_id)));
|
|
|
- // TODO(lachsinc): Determine proper scope for type declaration location stuff.
|
|
|
- scope = file;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // TODO(lachsinc): Reorder if tests, "unique" types, like basic etc. should go last, they are most likely to hit the existing hashed type
|
|
|
- // and no point checking them for the rest of the types. Or just use a massive switch...
|
|
|
-
|
|
|
- // NOTE(lachsinc): Types should be inserted into debug_info map as their named, not base_type()'d counterparts.
|
|
|
- Type *base = base_type(type);
|
|
|
-
|
|
|
- if (type->kind == Type_Named) {
|
|
|
- Type *named_base = type->Named.base;
|
|
|
- // TODO(lachsinc): Better way to determine distinct etc. or just handle structs, enums before we reach here.
|
|
|
- // ir_is_type_aggregate() except with no call to base_type().
|
|
|
- if (named_base->kind != Type_Struct &&
|
|
|
- named_base->kind != Type_Union &&
|
|
|
- named_base->kind != Type_Enum &&
|
|
|
- named_base->kind != Type_Tuple) {
|
|
|
- // distinct / typedef etc.
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
|
|
|
- if (type->kind == Type_Named) {
|
|
|
- di->DerivedType.name = type->Named.name;
|
|
|
- } else if (named_base->kind == Type_Basic) {
|
|
|
- di->DerivedType.name = named_base->Basic.name;
|
|
|
- }
|
|
|
- di->DerivedType.tag = irDebugBasicEncoding_typedef;
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- // TODO(lachsinc): Do we need to try and resolve a new entity/scope for the base type?
|
|
|
- // Maybe we also want to pull out type->Named.type_name ?? in the case it is a Named
|
|
|
- di->DerivedType.base_type = ir_add_debug_info_type(module, named_base, e, scope, file);
|
|
|
- return di;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (type->kind == Type_Basic) {
|
|
|
- switch (type->Basic.kind) {
|
|
|
- // Composite basic types
|
|
|
- case Basic_complex32: case Basic_complex64: case Basic_complex128:
|
|
|
- return ir_add_debug_info_type_complex(module, type);
|
|
|
- case Basic_quaternion64: case Basic_quaternion128: case Basic_quaternion256:
|
|
|
- return ir_add_debug_info_type_quaternion(module, type);
|
|
|
- case Basic_string:
|
|
|
- return ir_add_debug_info_type_string(module, scope, e, type);
|
|
|
- case Basic_any:
|
|
|
- return ir_add_debug_info_type_any(module);
|
|
|
-
|
|
|
- // Derived basic types
|
|
|
- case Basic_cstring:
|
|
|
- case Basic_rawptr: {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
|
|
|
- di->DerivedType.name = type->Basic.name;
|
|
|
- di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
|
|
|
- di->DerivedType.size = ir_debug_size_bits(t_rawptr);
|
|
|
- di->DerivedType.align = ir_debug_align_bits(t_rawptr); // TODO(lachsinc): Not sure if align is required.
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- if (type->Basic.kind == Basic_cstring) {
|
|
|
- di->DerivedType.base_type = ir_add_debug_info_type(module, t_i8, e, scope, file);
|
|
|
- } else {
|
|
|
- // NOTE(lachsinc): llvm expects "null" for rawptr/voidptr
|
|
|
- }
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- // Basic basic types
|
|
|
- default: {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_BasicType);
|
|
|
- di->BasicType.encoding = ir_debug_encoding_for_basic(type->Basic.kind);
|
|
|
- di->BasicType.name = type->Basic.name;
|
|
|
- di->BasicType.size = ir_debug_size_bits(type);
|
|
|
- di->BasicType.align = ir_debug_align_bits(type);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- return di;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_pointer(type)) {
|
|
|
- // TODO(lachsinc): Ensure this handles pointer-to-pointer of same type etc. correctly.
|
|
|
- Type *deref = type_deref(base);
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_DerivedType);
|
|
|
- di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
|
|
|
- di->DerivedType.size = ir_debug_size_bits(type);
|
|
|
- // NOTE(lachsinc): Map set before creating base_type to avoid circular dependency issues.
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- if (is_type_struct(deref)) {
|
|
|
- int i = 123;
|
|
|
- }
|
|
|
- di->DerivedType.base_type = ir_add_debug_info_type(module, deref, e, scope, file);
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_struct(type) ||
|
|
|
- is_type_union(type) || is_type_enum(type) || is_type_tuple(type)) {
|
|
|
- if (type->kind == Type_Named) {
|
|
|
- // NOTE(lachsinc): Named named's should always be handled prior as typedefs.
|
|
|
- GB_ASSERT(type->Named.base->kind != Type_Named);
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- // NOTE(lachsinc): Set map value before resolving field types to avoid circular dependencies.
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- if (is_type_named(type)) {
|
|
|
- di->CompositeType.name = type->kind == Type_Named ? type->Named.name : type->Basic.name;
|
|
|
- }
|
|
|
- if (e) {
|
|
|
- di->CompositeType.file = file;
|
|
|
- di->CompositeType.scope = scope;
|
|
|
- di->CompositeType.pos = e->token.pos;
|
|
|
- }
|
|
|
- di->CompositeType.size = ir_debug_size_bits(type);
|
|
|
- // di->CompositeType.align = ir_debug_align_bits(type); // TODO(lachsinc): Necessary?
|
|
|
-
|
|
|
- if (is_type_struct(type)) {
|
|
|
- GB_ASSERT(base->kind == Type_Struct);
|
|
|
- if (!is_type_named(type)) {
|
|
|
- di->CompositeType.name = str_lit("struct");
|
|
|
- GB_ASSERT_NOT_NULL(scope);
|
|
|
- di->CompositeType.scope = scope;
|
|
|
- }
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Struct.fields.count);
|
|
|
- for_array(field_index, base->Struct.fields) {
|
|
|
- array_add(&di->CompositeType.elements->DebugInfoArray.elements,
|
|
|
- ir_add_debug_info_field(module, di, base->Struct.fields[field_index], type,
|
|
|
- cast(i32)field_index, base->Struct.fields[field_index]->type, file));
|
|
|
- }
|
|
|
- } else if (is_type_union(type)) {
|
|
|
- GB_ASSERT(base->kind == Type_Union);
|
|
|
- if (!is_type_named(type)) {
|
|
|
- di->CompositeType.name = str_lit("union");
|
|
|
- GB_ASSERT_NOT_NULL(scope);
|
|
|
- di->CompositeType.scope = scope;
|
|
|
- }
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_union_type;
|
|
|
- di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Union.variants.count);
|
|
|
- // TODO(lachsinc): Cleanup; this should be handled in a more generic manner for all types.
|
|
|
- file = ir_add_debug_info_file(module, base->Union.node->file);
|
|
|
- GB_ASSERT_NOT_NULL(file); // Union debug info requires file info
|
|
|
- di->CompositeType.file = file;
|
|
|
- di->CompositeType.pos = base->Union.node->UnionType.token.pos;
|
|
|
- for_array(field_index, base->Union.variants) {
|
|
|
- // TODO(bill): Union pseudo-"fields"
|
|
|
- // irDebugInfo *di = ir_add_debug_info_field(module, di, nullptr, type, cast(i32)field_index, base->Union.variants[field_index], file);
|
|
|
- // array_add(&di->CompositeType.elements->DebugInfoArray.elements, di);
|
|
|
- }
|
|
|
- } else if (is_type_enum(type)) {
|
|
|
- GB_ASSERT(base->kind == Type_Enum);
|
|
|
- if (!is_type_named(type)) {
|
|
|
- di->CompositeType.name = str_lit("enum");
|
|
|
- GB_ASSERT_NOT_NULL(scope);
|
|
|
- di->CompositeType.scope = scope;
|
|
|
- }
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_enumeration_type;
|
|
|
- di->CompositeType.base_type = ir_add_debug_info_type(module, base->Enum.base_type, e, scope, file);
|
|
|
- di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Enum.fields.count);
|
|
|
- for_array(field_index, base->Enum.fields) {
|
|
|
- array_add(&di->CompositeType.elements->DebugInfoArray.elements,
|
|
|
- ir_add_debug_info_enumerator(module, base->Enum.fields[field_index]));
|
|
|
- }
|
|
|
-
|
|
|
- // TODO(lachsinc): Do we want to ensure this is an enum in the global scope before
|
|
|
- // adding it into the modules enum array ??
|
|
|
- array_add(&module->debug_compile_unit->CompileUnit.enums->DebugInfoArray.elements, di);
|
|
|
- } else if (is_type_tuple(type)) {
|
|
|
- GB_ASSERT(base->kind == Type_Tuple);
|
|
|
- if (!is_type_named(type)) {
|
|
|
- di->CompositeType.name = str_lit("tuple");
|
|
|
- GB_ASSERT_NOT_NULL(scope);
|
|
|
- di->CompositeType.scope = scope;
|
|
|
- }
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.elements = ir_add_debug_info_array(module, 0, base->Tuple.variables.count);
|
|
|
- // TODO(lachsinc): Ensure offsets are set properly?
|
|
|
- for_array(var_index, base->Tuple.variables) {
|
|
|
- array_add(&di->CompositeType.elements->DebugInfoArray.elements,
|
|
|
- ir_add_debug_info_field(module, di, base->Tuple.variables[var_index], type,
|
|
|
- cast(i32)var_index, base->Tuple.variables[var_index]->type, file));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_dynamic_array(type)) {
|
|
|
- return ir_add_debug_info_type_dynamic_array(module, type, e, scope, file);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_array(type)) {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.size = ir_debug_size_bits(type);
|
|
|
- di->CompositeType.align = ir_debug_align_bits(type);
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_array_type;
|
|
|
- di->CompositeType.array_count = (i32)type->Array.count;
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- di->CompositeType.base_type = ir_add_debug_info_type(module, type->Array.elem, e, scope, file);
|
|
|
- GB_ASSERT(base->kind != Type_Named);
|
|
|
-
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_enumerated_array(type)) {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.size = ir_debug_size_bits(type);
|
|
|
- di->CompositeType.align = ir_debug_align_bits(type);
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_array_type;
|
|
|
- di->CompositeType.array_count = (i32)type->EnumeratedArray.count;
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- di->CompositeType.base_type = ir_add_debug_info_type(module, type->EnumeratedArray.elem, e, scope, file);
|
|
|
- GB_ASSERT(base->kind != Type_Named);
|
|
|
-
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_slice(type)) {
|
|
|
- // NOTE(lachsinc): Every slice type has its own composite type / field debug infos created. This is sorta wasteful.
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.name = str_lit("slice");
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.size = ir_debug_size_bits(type); // TODO(lachsinc): Correct ??
|
|
|
- di->CompositeType.align = ir_debug_align_bits(type);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
-
|
|
|
- // Data pointer type
|
|
|
- irDebugInfo *data_ptr_di = ir_alloc_debug_info(irDebugInfo_DerivedType);
|
|
|
- Type *elem_type = type->Slice.elem;
|
|
|
- if (is_type_named(elem_type)) {
|
|
|
- data_ptr_di->DerivedType.name = elem_type->kind == Type_Named ? elem_type->Named.name : elem_type->Basic.name;
|
|
|
- }
|
|
|
- data_ptr_di->DerivedType.tag = irDebugBasicEncoding_pointer_type;
|
|
|
- data_ptr_di->DerivedType.size = ir_debug_size_bits(t_rawptr);
|
|
|
- map_set(&module->debug_info, hash_pointer(data_ptr_di), data_ptr_di);
|
|
|
- data_ptr_di->DerivedType.base_type = ir_add_debug_info_type(module, elem_type, e, scope, file);
|
|
|
-
|
|
|
- irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), t_rawptr,
|
|
|
- 0,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- data_di->DerivedType.base_type = data_ptr_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(data_di), data_di);
|
|
|
-
|
|
|
- irDebugInfo *len_di = ir_add_debug_info_field_internal(module, str_lit("len"), t_int,
|
|
|
- data_di->DerivedType.size,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(len_di), len_di);
|
|
|
-
|
|
|
- irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, data_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, len_di);
|
|
|
- di->CompositeType.elements = elements_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
|
|
|
-
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_map(type)) {
|
|
|
- // TODO(lachsinc): Looks like "generated_struct_type" map.entries.data is just a u8*, we could
|
|
|
- // always look at the map header and create the debug info manually (if we
|
|
|
- // want struct members to be interpreted as the correct type).
|
|
|
- // Also; are hashes meant to be interpreted as bool*'s ?? or is that simply slot occupied data?
|
|
|
- return ir_add_debug_info_type(module, type->Map.generated_struct_type, e, scope, file);
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(lachsinc): For now we just interpret all BitFieldValues as i64 inside ir_add_debug_info_type_bit_field().
|
|
|
- /*
|
|
|
- if (is_type_bit_field_value(type)) {
|
|
|
- // NOTE(Lachsinc): Suboptimal; creates a new type for each unique bit field value type
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_BasicType);
|
|
|
- di->BasicType.encoding = irDebugBasicEncoding_unsigned;
|
|
|
- // di->BasicType.name = str_lit("todo");
|
|
|
- di->BasicType.size = base->BitFieldValue.bits;
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- return di;
|
|
|
- }
|
|
|
- */
|
|
|
-
|
|
|
- if (is_type_bit_set(type)) {
|
|
|
- return ir_add_debug_info_type_bit_set(module, type, e, scope);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_simd_vector(type)) {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.size = ir_debug_size_bits(type);
|
|
|
- di->CompositeType.align = ir_debug_align_bits(type);
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_array_type;
|
|
|
- di->CompositeType.array_count = (i32)type->SimdVector.count;
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- di->CompositeType.base_type = ir_add_debug_info_type(module, type->SimdVector.elem, e, scope, file);
|
|
|
- GB_ASSERT(base->kind != Type_Named);
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_relative_pointer(type)) {
|
|
|
- Type *base_integer = base_type(type)->RelativePointer.base_integer;
|
|
|
- base_integer = core_type(base_integer);
|
|
|
- GB_ASSERT(base_integer->kind == Type_Basic);
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_BasicType);
|
|
|
- di->BasicType.encoding = ir_debug_encoding_for_basic(base_integer->Basic.kind);
|
|
|
- di->BasicType.name = base_integer->Basic.name;
|
|
|
- di->BasicType.size = ir_debug_size_bits(type);
|
|
|
- di->BasicType.align = ir_debug_align_bits(type);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_relative_slice(type)) {
|
|
|
- Type *base_integer = base_type(type)->RelativeSlice.base_integer;
|
|
|
- base_integer = core_type(base_integer);
|
|
|
-
|
|
|
- // NOTE(lachsinc): Every slice type has its own composite type / field debug infos created. This is sorta wasteful.
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompositeType);
|
|
|
- di->CompositeType.name = str_lit("relative slice");
|
|
|
- di->CompositeType.tag = irDebugBasicEncoding_structure_type;
|
|
|
- di->CompositeType.size = ir_debug_size_bits(type); // TODO(lachsinc): Correct ??
|
|
|
- di->CompositeType.align = ir_debug_align_bits(type);
|
|
|
- map_set(&module->debug_info, hash_type(type), di);
|
|
|
-
|
|
|
- irDebugInfo *data_di = ir_add_debug_info_field_internal(module, str_lit("data"), base_integer,
|
|
|
- 0,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(data_di), data_di);
|
|
|
-
|
|
|
- irDebugInfo *len_di = ir_add_debug_info_field_internal(module, str_lit("len"), base_integer,
|
|
|
- data_di->DerivedType.size,
|
|
|
- nullptr,
|
|
|
- di);
|
|
|
- map_set(&module->debug_info, hash_pointer(len_di), len_di);
|
|
|
-
|
|
|
- irDebugInfo *elements_di = ir_add_debug_info_array(module, 0, 2);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, data_di);
|
|
|
- array_add(&elements_di->DebugInfoArray.elements, len_di);
|
|
|
- di->CompositeType.elements = elements_di;
|
|
|
- map_set(&module->debug_info, hash_pointer(elements_di), elements_di);
|
|
|
-
|
|
|
- return di;
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unreachable %s", type_to_string(type));
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_global(irModule *module, irValue *v) {
|
|
|
- if (!module->generate_debug_info) {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
-
|
|
|
- Entity *e = v->Global.entity;
|
|
|
-
|
|
|
- // NOTE(lachsinc): Just to be safe/robust; globals are likely added once only?
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_entity(e));
|
|
|
- if (existing != nullptr) {
|
|
|
- return *existing;
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_GlobalVariableExpression);
|
|
|
- map_set(&module->debug_info, hash_entity(e), di);
|
|
|
-
|
|
|
- // Create or fetch file debug info.
|
|
|
- CheckerInfo *info = module->info;
|
|
|
- String filename = get_file_path_string(e->token.pos.file_id);
|
|
|
- AstFile *f = ast_file_of_filename(info, filename);
|
|
|
- GB_ASSERT_NOT_NULL(f);
|
|
|
- irDebugInfo *scope = ir_add_debug_info_file(module, f);
|
|
|
-
|
|
|
- irDebugInfo *var_di = ir_alloc_debug_info(irDebugInfo_GlobalVariable);
|
|
|
- var_di->GlobalVariable.name = e->token.string;
|
|
|
- var_di->GlobalVariable.scope = scope;
|
|
|
- var_di->GlobalVariable.file = scope;
|
|
|
- var_di->GlobalVariable.pos = e->token.pos;
|
|
|
- var_di->GlobalVariable.variable = v;
|
|
|
-
|
|
|
- // NOTE(lachsinc): The "DIGlobalVariableExpression" owns us, and is what we refer to from other
|
|
|
- // locations in the ir source, so we will reserve the "e" hash for it, and use something else
|
|
|
- // unique for the DIGlobalVariable's hash.
|
|
|
- map_set(&module->debug_info, hash_pointer(var_di), var_di);
|
|
|
-
|
|
|
- var_di->GlobalVariable.type = ir_add_debug_info_type(module, e->type, nullptr, scope, nullptr);
|
|
|
- GB_ASSERT_NOT_NULL(var_di->GlobalVariable.type);
|
|
|
-
|
|
|
- di->GlobalVariableExpression.var = var_di;
|
|
|
-
|
|
|
- array_add(&module->debug_compile_unit->CompileUnit.globals->DebugInfoArray.elements, di);
|
|
|
-
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_block(irProcedure *proc, Scope *scope) {
|
|
|
- irModule *module = proc->module;
|
|
|
-
|
|
|
- irDebugInfo **existing = map_get(&module->debug_info, hash_pointer(scope));
|
|
|
- if (existing != nullptr) {
|
|
|
- GB_ASSERT((*existing)->kind == irDebugInfo_LexicalBlock);
|
|
|
- return *existing;
|
|
|
- }
|
|
|
-
|
|
|
- Ast *block = scope->node;
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_LexicalBlock);
|
|
|
- di->LexicalBlock.file = proc->debug_scope->Proc.file;
|
|
|
- di->LexicalBlock.scope = proc->debug_scope;
|
|
|
- di->LexicalBlock.pos = ast_token(block).pos;
|
|
|
- map_set(&module->debug_info, hash_pointer(scope), di);
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_local(irProcedure *proc, Entity *e, i32 arg_id) {
|
|
|
- // TODO(lachsinc): Not sure if this handles generated locals properly as they may not have
|
|
|
- // enough information contained inside "e".
|
|
|
-
|
|
|
- irModule *module = proc->module;
|
|
|
- if (!module->generate_debug_info) {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *scope = nullptr;
|
|
|
- irDebugInfo *file = nullptr;
|
|
|
- if (e->scope && e->scope->node->kind == Ast_ProcType) {
|
|
|
- scope = proc->debug_scope;
|
|
|
- file = proc->debug_scope->Proc.file;
|
|
|
- } else {
|
|
|
- scope = ir_add_debug_info_block(proc, e->scope);
|
|
|
- file = scope->LexicalBlock.file;
|
|
|
- }
|
|
|
- GB_ASSERT_NOT_NULL(scope);
|
|
|
- GB_ASSERT_NOT_NULL(file);
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_LocalVariable);
|
|
|
- di->LocalVariable.name = e->token.string;
|
|
|
- di->LocalVariable.scope = scope;
|
|
|
- di->LocalVariable.file = file;
|
|
|
- di->LocalVariable.pos = e->token.pos;
|
|
|
- di->LocalVariable.arg = arg_id;
|
|
|
- di->LocalVariable.type = ir_add_debug_info_type(module, e->type, e, scope, file); // TODO(lachsinc): Is this the correct entity to pass? Or do we want a TypeName ??
|
|
|
-
|
|
|
- map_set(&module->debug_info, hash_entity(e), di);
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_proc(irProcedure *proc) {
|
|
|
- irModule *module = proc->module;
|
|
|
- if (!module->generate_debug_info) {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
-
|
|
|
- Entity *entity = proc->entity;
|
|
|
-
|
|
|
- // Add / retrieve debug info for file.
|
|
|
- CheckerInfo *info = proc->module->info;
|
|
|
- String filename = get_file_path_string(proc->entity->token.pos.file_id);
|
|
|
- AstFile *f = ast_file_of_filename(info, filename);
|
|
|
- irDebugInfo *file = nullptr;
|
|
|
- if (f) {
|
|
|
- file = ir_add_debug_info_file(proc->module, f);
|
|
|
- }
|
|
|
- // TODO(lachsinc): Should scope be made separate to file?
|
|
|
- irDebugInfo *scope = file;
|
|
|
-
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_Proc);
|
|
|
- map_set(&proc->module->debug_info, hash_entity(entity), di);
|
|
|
- di->Proc.entity = entity;
|
|
|
- di->Proc.name = proc->name;
|
|
|
- di->Proc.file = file;
|
|
|
- di->Proc.pos = entity->token.pos;
|
|
|
- di->Proc.type = ir_add_debug_info_proc_type(proc->module, proc->type);
|
|
|
-
|
|
|
- proc->debug_scope = di;
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-irDebugInfo *ir_add_debug_info_location(irModule *m, Ast *node, irDebugInfo *scope, Entity *e) {
|
|
|
- if (node == nullptr || scope == nullptr) {
|
|
|
- if (e != nullptr && scope != nullptr) {
|
|
|
- // irDebugInfo **existing = map_get(&m->debug_info, hash_entity(e));
|
|
|
- // if (existing != nullptr) {
|
|
|
- // return *existing;
|
|
|
- // }
|
|
|
-
|
|
|
- // // TODO HACK(bill): This is a little dirty but it is should do for the weird edge cases
|
|
|
- // irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_Location);
|
|
|
- // di->Location.pos = e->token.pos;
|
|
|
- // di->Location.scope = scope;
|
|
|
- // map_set(&m->debug_info, hash_entity(e), di);
|
|
|
- // return di;
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- // TODO(lachsinc): Should we traverse the node/children until we find one with
|
|
|
- // valid token/pos and use that instead??
|
|
|
- irDebugInfo **existing = map_get(&m->debug_info, hash_node(node));
|
|
|
- if (existing != nullptr) {
|
|
|
- return *existing;
|
|
|
- }
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_Location);
|
|
|
- di->Location.pos = ast_token(node).pos;
|
|
|
- di->Location.scope = scope;
|
|
|
- map_set(&m->debug_info, hash_node(node), di);
|
|
|
- return di;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_push_debug_location(irModule *m, Ast *node, irDebugInfo *scope, Entity *e) {
|
|
|
- irDebugInfo *debug_location = ir_add_debug_info_location(m, node, scope, e);
|
|
|
- array_add(&m->debug_location_stack, debug_location);
|
|
|
-}
|
|
|
-
|
|
|
-void ir_pop_debug_location(irModule *m) {
|
|
|
- GB_ASSERT_MSG(m->debug_location_stack.count > 0, "Attempt to pop debug location stack too many times");
|
|
|
- array_pop(&m->debug_location_stack);
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// @Emit
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-irValue *ir_emit_runtime_call(irProcedure *proc, char const *name_, Array<irValue *> args, Ast *expr = nullptr, ProcInlining inlining = ProcInlining_none);
|
|
|
-irValue *ir_emit_package_call(irProcedure *proc, char const *package_name_, char const *name_, Array<irValue *> args, Ast *expr = nullptr, ProcInlining inlining = ProcInlining_none);
|
|
|
-
|
|
|
-bool ir_type_requires_mem_zero(Type *t) {
|
|
|
- t = core_type(t);
|
|
|
- isize sz = type_size_of(t);
|
|
|
- if (t->kind == Type_SimdVector) {
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- if (!(gb_is_power_of_two(sz) && sz <= build_context.max_align)) {
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- enum : i64 {LARGE_SIZE = 64};
|
|
|
- if (sz > LARGE_SIZE) {
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- switch (t->kind) {
|
|
|
- case Type_Union:
|
|
|
- return true;
|
|
|
- case Type_Struct:
|
|
|
- if (t->Struct.is_raw_union) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (t->Struct.is_packed) {
|
|
|
- return false;
|
|
|
- } else {
|
|
|
- i64 packed_sized = 0;
|
|
|
- for_array(i, t->Struct.fields) {
|
|
|
- Entity *f = t->Struct.fields[i];
|
|
|
- if (f->kind == Entity_Variable) {
|
|
|
- packed_sized += type_size_of(f->type);
|
|
|
- }
|
|
|
- }
|
|
|
- return sz != packed_sized;
|
|
|
- }
|
|
|
- break;
|
|
|
- case Type_Tuple:
|
|
|
- if (t->Tuple.is_packed) {
|
|
|
- return false;
|
|
|
- } else {
|
|
|
- i64 packed_sized = 0;
|
|
|
- for_array(i, t->Tuple.variables) {
|
|
|
- Entity *f = t->Tuple.variables[i];
|
|
|
- if (f->kind == Entity_Variable) {
|
|
|
- packed_sized += type_size_of(f->type);
|
|
|
- }
|
|
|
- }
|
|
|
- return sz != packed_sized;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_DynamicArray:
|
|
|
- case Type_Map:
|
|
|
- return true;
|
|
|
- case Type_Array:
|
|
|
- return ir_type_requires_mem_zero(t->Array.elem);
|
|
|
- case Type_EnumeratedArray:
|
|
|
- return ir_type_requires_mem_zero(t->EnumeratedArray.elem);
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_call_mem_zero(irProcedure *p, irValue *address, Ast *expr = nullptr) {
|
|
|
- Type *t = type_deref(ir_type(address));
|
|
|
- // TODO(bill): Is this a good idea?
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = ir_emit_conv(p, address, t_rawptr);
|
|
|
- args[1] = ir_const_int(type_size_of(t));
|
|
|
- AstPackage *pkg_runtime = get_core_package(p->module->info, str_lit("runtime"));
|
|
|
- if (p->entity != nullptr) {
|
|
|
- String name = p->entity->token.string;
|
|
|
- if (p->entity->pkg != pkg_runtime && !(name == "mem_zero" || name == "memset")) {
|
|
|
- ir_emit_comment(p, str_lit("ZeroInit"));
|
|
|
- return ir_emit_package_call(p, "runtime", "mem_zero", args, expr);
|
|
|
- }
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_store(irProcedure *p, irValue *address, irValue *value, bool is_volatile) {
|
|
|
- Type *a = type_deref(ir_type(address));
|
|
|
-
|
|
|
- if (is_type_boolean(a)) {
|
|
|
- // NOTE(bill): There are multiple sized booleans, thus force a conversion (if necessarily)
|
|
|
- value = ir_emit_conv(p, value, a);
|
|
|
- }
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
- if (value) value->uses += 1;
|
|
|
-
|
|
|
-
|
|
|
- Type *b = ir_type(value);
|
|
|
- if (!is_type_untyped(b)) {
|
|
|
- GB_ASSERT_MSG(are_types_identical(core_type(a), core_type(b)), "%s %s", type_to_string(a), type_to_string(b));
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- if (value->kind == irValue_Constant) {
|
|
|
- ExactValue const &v = value->Constant.value;
|
|
|
- irValue *res = nullptr;
|
|
|
- switch (v.kind) {
|
|
|
- case ExactValue_Invalid:
|
|
|
- res = ir_call_mem_zero(p, address);
|
|
|
- if (res) {
|
|
|
- return res;
|
|
|
- }
|
|
|
- goto end;
|
|
|
-
|
|
|
- case ExactValue_Compound:
|
|
|
- // NOTE(bill): This is to enforce the zeroing of the padding
|
|
|
- if (ir_type_requires_mem_zero(a)) {
|
|
|
- res = ir_call_mem_zero(p, address);
|
|
|
- if (res == nullptr || v.value_compound == nullptr) {
|
|
|
- goto end;
|
|
|
- }
|
|
|
- if (is_exact_value_zero(v)) {
|
|
|
- return res;
|
|
|
- }
|
|
|
- }
|
|
|
- goto end;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-end:;
|
|
|
- return ir_emit(p, ir_instr_store(p, address, value, is_volatile));
|
|
|
-}
|
|
|
-irValue *ir_emit_load(irProcedure *p, irValue *address, i64 custom_align) {
|
|
|
- GB_ASSERT(address != nullptr);
|
|
|
- Type *t = type_deref(ir_type(address));
|
|
|
- // if (is_type_boolean(t)) {
|
|
|
- // return ir_emit(p, ir_instr_load_bool(p, address));
|
|
|
- // }
|
|
|
- if (address) address->uses += 1;
|
|
|
- auto instr = ir_instr_load(p, address, false);
|
|
|
- instr->Instr.Load.custom_align = custom_align;
|
|
|
- return ir_emit(p, instr);
|
|
|
-}
|
|
|
-irValue *ir_emit_select(irProcedure *p, irValue *cond, irValue *t, irValue *f) {
|
|
|
- if (cond) cond->uses += 1;
|
|
|
- if (t) t->uses += 1;
|
|
|
- if (f) f->uses += 1;
|
|
|
-
|
|
|
- return ir_emit(p, ir_instr_select(p, cond, t, f));
|
|
|
-}
|
|
|
-
|
|
|
-void ir_value_set_debug_location(irProcedure *proc, irValue *v) {
|
|
|
- GB_ASSERT_NOT_NULL(proc);
|
|
|
- GB_ASSERT_NOT_NULL(v);
|
|
|
-
|
|
|
- if (v->loc != nullptr) {
|
|
|
- return; // Already set
|
|
|
- }
|
|
|
-
|
|
|
- if (proc->is_startup) {
|
|
|
- // ignore startup procedures
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- irModule *m = proc->module;
|
|
|
- GB_ASSERT(m->debug_location_stack.count > 0);
|
|
|
- v->loc = *array_end_ptr(&m->debug_location_stack);
|
|
|
-
|
|
|
- if (v->loc == nullptr && proc->entity != nullptr) {
|
|
|
- if (proc->is_entry_point || (string_compare(proc->name, str_lit(IR_STARTUP_RUNTIME_PROC_NAME)) == 0)) {
|
|
|
- // NOTE(lachsinc): Entry point (main()) and runtime_startup are the only ones where null location is considered valid.
|
|
|
- } else {
|
|
|
- if (v->kind == irValue_Instr) {
|
|
|
- auto *instr = &v->Instr;
|
|
|
- gb_printf_err("Instruction kind: %.*s\n", LIT(ir_instr_strings[instr->kind]));
|
|
|
- if (instr->kind == irInstr_DebugDeclare) {
|
|
|
- gb_printf_err("\t%.*s\n", LIT(instr->DebugDeclare.entity->token.string));
|
|
|
- }
|
|
|
- }
|
|
|
- GB_PANIC("Value without debug location: %.*s %p; %p :: %s", LIT(proc->name), proc->entity, v, type_to_string(proc->type));
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_zero_init(irProcedure *p, irValue *address, Ast *expr) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- Type *t = type_deref(ir_type(address));
|
|
|
-
|
|
|
- if (address) address->uses += 1;
|
|
|
-
|
|
|
- if (ir_type_requires_mem_zero(t)) {
|
|
|
- irValue *res = ir_call_mem_zero(p, address, expr);
|
|
|
- if (res) {
|
|
|
- return res;
|
|
|
- }
|
|
|
- }
|
|
|
- return ir_emit(p, ir_instr_zero_init(p, address));
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_comment(irProcedure *p, String text) {
|
|
|
- return ir_emit(p, ir_instr_comment(p, text));
|
|
|
-}
|
|
|
-
|
|
|
-void ir_emit_init_context(irProcedure *proc, irValue *c) {
|
|
|
- GB_ASSERT(c != nullptr);
|
|
|
- irModule *m = proc->module;
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- auto args = array_make<irValue *>(a, 1);
|
|
|
- args[0] = c;
|
|
|
- ir_emit_runtime_call(proc, "__init_context", args);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_copy_value_to_ptr(irProcedure *proc, irValue *val, Type *new_type, i64 alignment) {
|
|
|
- i64 type_alignment = type_align_of(new_type);
|
|
|
- if (alignment < type_alignment) {
|
|
|
- alignment = type_alignment;
|
|
|
- }
|
|
|
- GB_ASSERT_MSG(are_types_identical(new_type, ir_type(val)), "%s %s", type_to_string(new_type), type_to_string(ir_type(val)));
|
|
|
-
|
|
|
- irValue *ptr = ir_add_local_generated(proc, new_type, false);
|
|
|
- ptr->Instr.Local.alignment = alignment;
|
|
|
- ir_emit_store(proc, ptr, val);
|
|
|
-
|
|
|
- return ptr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_bitcast(irProcedure *proc, irValue *data, Type *type) {
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_bitcast, data, ir_type(data), type));
|
|
|
-}
|
|
|
-
|
|
|
-void ir_emit_unreachable(irProcedure *proc) {
|
|
|
- ir_emit(proc, ir_instr_unreachable(proc));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_get_package_value(irModule *m, String package_name, String entity_name) {
|
|
|
- AstPackage *rt_pkg = get_core_package(m->info, package_name);
|
|
|
- Entity *e = scope_lookup_current(rt_pkg->scope, entity_name);
|
|
|
- irValue **found = map_get(&m->values, hash_entity(e));
|
|
|
- GB_ASSERT_MSG(found != nullptr, "%.*s", LIT(e->token.string));
|
|
|
- return *found;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_find_or_generate_context_ptr(irProcedure *proc) {
|
|
|
- if (proc->context_stack.count > 0) {
|
|
|
- return proc->context_stack[proc->context_stack.count-1].value;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *c = ir_add_local_generated(proc, t_context, true);
|
|
|
- ir_push_context_onto_stack(proc, c);
|
|
|
- ir_emit_init_context(proc, c);
|
|
|
- return c;
|
|
|
-}
|
|
|
-
|
|
|
-Array<irValue *> ir_value_to_array(irProcedure *p, irValue *value) {
|
|
|
- Array<irValue *> array = {};
|
|
|
- Type *t = base_type(ir_type(value));
|
|
|
- if (t == nullptr) {
|
|
|
- // Do nothing
|
|
|
- } else if (is_type_tuple(t)) {
|
|
|
- GB_ASSERT(t->kind == Type_Tuple);
|
|
|
- auto *rt = &t->Tuple;
|
|
|
- if (rt->variables.count > 0) {
|
|
|
- array = array_make<irValue *>(ir_allocator(), rt->variables.count);
|
|
|
- for_array(i, rt->variables) {
|
|
|
- irValue *elem = ir_emit_struct_ev(p, value, cast(i32)i);
|
|
|
- array[i] = elem;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- array = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- array[0] = value;
|
|
|
- }
|
|
|
- return array;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_call(irProcedure *p, irValue *value, Array<irValue *> const &args, ProcInlining inlining = ProcInlining_none, bool use_return_ptr_hint = false) {
|
|
|
- Type *pt = base_type(ir_type(value));
|
|
|
- GB_ASSERT(pt->kind == Type_Proc);
|
|
|
- Type *results = pt->Proc.results;
|
|
|
-
|
|
|
- if (p->entity != nullptr) {
|
|
|
- if (p->entity->flags & EntityFlag_Disabled) {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- defer (if (pt->Proc.diverging) {
|
|
|
- ir_emit_unreachable(p);
|
|
|
- });
|
|
|
-
|
|
|
- irValue *context_ptr = nullptr;
|
|
|
- if (pt->Proc.calling_convention == ProcCC_Odin) {
|
|
|
- context_ptr = ir_find_or_generate_context_ptr(p);
|
|
|
- }
|
|
|
-
|
|
|
- set_procedure_abi_types(pt);
|
|
|
-
|
|
|
- bool is_c_vararg = pt->Proc.c_vararg;
|
|
|
- isize param_count = pt->Proc.param_count;
|
|
|
- if (is_c_vararg) {
|
|
|
- GB_ASSERT(param_count-1 <= args.count);
|
|
|
- param_count -= 1;
|
|
|
- } else {
|
|
|
- GB_ASSERT_MSG(param_count == args.count, "%.*s %td == %td", LIT(p->entity->token.string), param_count, args.count);
|
|
|
- }
|
|
|
-
|
|
|
- auto processed_args = array_make<irValue *>(permanent_allocator(), 0, args.count);
|
|
|
-
|
|
|
- for (isize i = 0; i < param_count; i++) {
|
|
|
- Entity *e = pt->Proc.params->Tuple.variables[i];
|
|
|
- if (e->kind != Entity_Variable) {
|
|
|
- array_add(&processed_args, args[i]);
|
|
|
- continue;
|
|
|
- }
|
|
|
- GB_ASSERT(e->flags & EntityFlag_Param);
|
|
|
-
|
|
|
- Type *original_type = e->type;
|
|
|
- Type *new_type = pt->Proc.abi_compat_params[i];
|
|
|
- Type *arg_type = ir_type(args[i]);
|
|
|
- if (are_types_identical(arg_type, new_type)) {
|
|
|
- // NOTE(bill): Done
|
|
|
- array_add(&processed_args, args[i]);
|
|
|
- } else if (!are_types_identical(original_type, new_type)) {
|
|
|
- if (is_type_pointer(new_type) && !is_type_pointer(original_type)) {
|
|
|
- Type *av = core_type(type_deref(new_type));
|
|
|
- if (are_types_identical(av, core_type(original_type))) {
|
|
|
- if (e->flags&EntityFlag_ImplicitReference) {
|
|
|
- array_add(&processed_args, ir_address_from_load_or_generate_local(p, args[i]));
|
|
|
- } else if (!is_type_pointer(arg_type)) {
|
|
|
- array_add(&processed_args, ir_copy_value_to_ptr(p, args[i], original_type, 16));
|
|
|
- }
|
|
|
- } else {
|
|
|
- array_add(&processed_args, ir_emit_transmute(p, args[i], new_type));
|
|
|
- }
|
|
|
- } else if (is_type_integer(new_type) || is_type_float(new_type)) {
|
|
|
- array_add(&processed_args, ir_emit_transmute(p, args[i], new_type));
|
|
|
- } else if (new_type == t_llvm_bool) {
|
|
|
- array_add(&processed_args, ir_emit_conv(p, args[i], new_type));
|
|
|
- } else if (is_type_simd_vector(new_type)) {
|
|
|
- array_add(&processed_args, ir_emit_transmute(p, args[i], new_type));
|
|
|
- } else if (is_type_tuple(new_type)) {
|
|
|
- Type *abi_type = pt->Proc.abi_compat_params[i];
|
|
|
- Type *st = struct_type_from_systemv_distribute_struct_fields(abi_type);
|
|
|
- irValue *x = nullptr;
|
|
|
- i64 st_sz = type_size_of(st);
|
|
|
- i64 arg_sz = type_size_of(ir_type(args[i]));
|
|
|
- if (st_sz == arg_sz) {
|
|
|
- x = ir_emit_transmute(p, args[i], st);
|
|
|
- } else {
|
|
|
- // NOTE(bill): struct{f32, f32, f32} != struct{#simd[2]f32, f32}
|
|
|
- GB_ASSERT(st_sz > arg_sz);
|
|
|
- irValue *xx = ir_add_local_generated(p, st, false);
|
|
|
- irValue *pp = ir_emit_conv(p, xx, alloc_type_pointer(ir_type(args[i])));
|
|
|
- ir_emit_store(p, pp, args[i]);
|
|
|
- x = ir_emit_load(p, xx);
|
|
|
- }
|
|
|
- for (isize j = 0; j < new_type->Tuple.variables.count; j++) {
|
|
|
- irValue *xx = ir_emit_struct_ev(p, x, cast(i32)j);
|
|
|
- array_add(&processed_args, xx);
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (type_size_of(new_type) == type_size_of(original_type)) {
|
|
|
- irValue *x = ir_emit_transmute(p, args[i], new_type);
|
|
|
- array_add(&processed_args, x);
|
|
|
- } else {
|
|
|
- GB_PANIC("ABI ERROR: %s %s %s\n", type_to_string(original_type), type_to_string(new_type), type_to_string(arg_type));
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- irValue *x = ir_emit_conv(p, args[i], new_type);
|
|
|
- array_add(&processed_args, x);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (is_c_vararg) {
|
|
|
- for (isize i = param_count; i < args.count; i++) {
|
|
|
- array_add(&processed_args, args[i]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (inlining == ProcInlining_none) {
|
|
|
- inlining = p->inlining;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *result = nullptr;
|
|
|
-
|
|
|
- Type *abi_rt = pt->Proc.abi_compat_result_type;
|
|
|
- Type *rt = reduce_tuple_to_single_type(results);
|
|
|
- if (pt->Proc.return_by_pointer) {
|
|
|
- irValue *return_ptr = nullptr;
|
|
|
- if (use_return_ptr_hint && p->return_ptr_hint_value != nullptr) {
|
|
|
- if (are_types_identical(type_deref(ir_type(p->return_ptr_hint_value)), rt)) {
|
|
|
- return_ptr = p->return_ptr_hint_value;
|
|
|
- p->return_ptr_hint_used = true;
|
|
|
- return_ptr->uses += 1;
|
|
|
- }
|
|
|
- }
|
|
|
- if (return_ptr == nullptr) {
|
|
|
- return_ptr = ir_add_local_generated(p, rt, true);
|
|
|
- }
|
|
|
- GB_ASSERT(is_type_pointer(ir_type(return_ptr)));
|
|
|
- ir_emit(p, ir_instr_call(p, value, return_ptr, processed_args, nullptr, context_ptr, inlining));
|
|
|
- result = ir_emit_load(p, return_ptr);
|
|
|
- } else {
|
|
|
- result = ir_emit(p, ir_instr_call(p, value, nullptr, processed_args, abi_rt, context_ptr, inlining));
|
|
|
- if (abi_rt != results) {
|
|
|
- result = ir_emit_transmute(p, result, rt);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (value->kind == irValue_Proc) {
|
|
|
- irProcedure *the_proc = &value->Proc;
|
|
|
- Entity *e = the_proc->entity;
|
|
|
- if (e != nullptr && entity_has_deferred_procedure(e)) {
|
|
|
- DeferredProcedureKind kind = e->Procedure.deferred_procedure.kind;
|
|
|
- Entity *deferred_entity = e->Procedure.deferred_procedure.entity;
|
|
|
- irValue **deferred_found = map_get(&p->module->values, hash_entity(deferred_entity));
|
|
|
- GB_ASSERT(deferred_found != nullptr);
|
|
|
- irValue *deferred = *deferred_found;
|
|
|
-
|
|
|
-
|
|
|
- auto in_args = args;
|
|
|
- Array<irValue *> result_as_args = {};
|
|
|
- switch (kind) {
|
|
|
- case DeferredProcedure_none:
|
|
|
- break;
|
|
|
- case DeferredProcedure_in:
|
|
|
- result_as_args = in_args;
|
|
|
- break;
|
|
|
- case DeferredProcedure_out:
|
|
|
- result_as_args = ir_value_to_array(p, result);
|
|
|
- break;
|
|
|
- case DeferredProcedure_in_out:
|
|
|
- {
|
|
|
- auto out_args = ir_value_to_array(p, result);
|
|
|
- array_init(&result_as_args, permanent_allocator(), in_args.count + out_args.count);
|
|
|
- array_copy(&result_as_args, in_args, 0);
|
|
|
- array_copy(&result_as_args, out_args, in_args.count);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- ir_add_defer_proc(p, p->scope_index, deferred, result_as_args);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_runtime_call(irProcedure *proc, char const *name_, Array<irValue *> args, Ast *expr, ProcInlining inlining) {
|
|
|
- String name = make_string_c(cast(char *)name_);
|
|
|
-
|
|
|
- AstPackage *p = proc->module->info->runtime_package;
|
|
|
- Entity *e = scope_lookup_current(p->scope, name);
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- GB_ASSERT_MSG(found != nullptr, "%.*s", LIT(name));
|
|
|
- irValue *gp = *found;
|
|
|
- irValue *call = ir_emit_call(proc, gp, args, inlining);
|
|
|
- return call;
|
|
|
-}
|
|
|
-irValue *ir_emit_package_call(irProcedure *proc, char const *package_name_, char const *name_, Array<irValue *> args, Ast *expr, ProcInlining inlining) {
|
|
|
- String name = make_string_c(cast(char *)name_);
|
|
|
- String package_name = make_string_c(cast(char *)package_name_);
|
|
|
-
|
|
|
- AstPackage *p = get_core_package(proc->module->info, package_name);
|
|
|
- Entity *e = scope_lookup_current(p->scope, name);
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- GB_ASSERT_MSG(found != nullptr, "%s.%.*s", package_name_, LIT(name));
|
|
|
- irValue *gp = *found;
|
|
|
- irValue *call = ir_emit_call(proc, gp, args, inlining);
|
|
|
- return call;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_emit_defer_stmts(irProcedure *proc, irDeferExitKind kind, irBlock *block) {
|
|
|
- isize count = proc->defer_stmts.count;
|
|
|
- isize i = count;
|
|
|
- while (i --> 0) {
|
|
|
- irDefer d = proc->defer_stmts[i];
|
|
|
-
|
|
|
- isize prev_context_stack_count = proc->context_stack.count;
|
|
|
- defer (proc->context_stack.count = prev_context_stack_count);
|
|
|
- proc->context_stack.count = d.context_stack_count;
|
|
|
-
|
|
|
- if (kind == irDeferExit_Default) {
|
|
|
- if (proc->scope_index == d.scope_index &&
|
|
|
- d.scope_index > 0) { // TODO(bill): Which is correct: > 0 or > 1?
|
|
|
- ir_build_defer_stmt(proc, d);
|
|
|
- array_pop(&proc->defer_stmts);
|
|
|
- continue;
|
|
|
- } else {
|
|
|
- break;
|
|
|
- }
|
|
|
- } else if (kind == irDeferExit_Return) {
|
|
|
- ir_build_defer_stmt(proc, d);
|
|
|
- } else if (kind == irDeferExit_Branch) {
|
|
|
- GB_ASSERT(block != nullptr);
|
|
|
- isize lower_limit = block->scope_index;
|
|
|
- if (lower_limit < d.scope_index) {
|
|
|
- ir_build_defer_stmt(proc, d);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_open_scope(irProcedure *proc) {
|
|
|
- proc->scope_index++;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_close_scope(irProcedure *proc, irDeferExitKind kind, irBlock *block, bool pop_stack=true) {
|
|
|
- ir_emit_defer_stmts(proc, kind, block);
|
|
|
- GB_ASSERT(proc->scope_index > 0);
|
|
|
-
|
|
|
-
|
|
|
- // NOTE(bill): Remove `context`s made in that scope
|
|
|
-
|
|
|
- isize end_idx = proc->context_stack.count-1;
|
|
|
- isize pop_count = 0;
|
|
|
-
|
|
|
- for (;;) {
|
|
|
- if (end_idx < 0) {
|
|
|
- break;
|
|
|
- }
|
|
|
- irContextData *end = &proc->context_stack[end_idx];
|
|
|
- if (end == nullptr) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if (end->scope_index != proc->scope_index) {
|
|
|
- break;
|
|
|
- }
|
|
|
- end_idx -= 1;
|
|
|
- pop_count += 1;
|
|
|
- }
|
|
|
- if (pop_stack) {
|
|
|
- for (isize i = 0; i < pop_count; i++) {
|
|
|
- array_pop(&proc->context_stack);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- proc->scope_index--;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void ir_emit_return(irProcedure *proc, irValue *v) {
|
|
|
- ir_emit_defer_stmts(proc, irDeferExit_Return, nullptr);
|
|
|
-
|
|
|
- if (proc->type->Proc.return_by_pointer) {
|
|
|
- ir_emit_store(proc, proc->return_ptr, v);
|
|
|
- ir_emit(proc, ir_instr_return(proc, nullptr));
|
|
|
- } else {
|
|
|
- Type *abi_rt = proc->type->Proc.abi_compat_result_type;
|
|
|
- if (abi_rt != proc->type->Proc.results) {
|
|
|
- v = ir_emit_transmute(proc, v, abi_rt);
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit(proc, ir_instr_return(proc, v));
|
|
|
- }
|
|
|
-
|
|
|
- if (v) v->uses += 1;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_emit_jump(irProcedure *proc, irBlock *target_block) {
|
|
|
- irBlock *b = proc->curr_block;
|
|
|
- if (b == nullptr) {
|
|
|
- return;
|
|
|
- }
|
|
|
- ir_emit(proc, ir_instr_jump(proc, target_block));
|
|
|
- ir_add_edge(b, target_block);
|
|
|
- ir_start_block(proc, nullptr);
|
|
|
-}
|
|
|
-
|
|
|
-void ir_emit_if(irProcedure *proc, irValue *cond, irBlock *true_block, irBlock *false_block) {
|
|
|
- irBlock *b = proc->curr_block;
|
|
|
- if (b == nullptr) {
|
|
|
- return;
|
|
|
- }
|
|
|
- ir_emit(proc, ir_instr_if(proc, cond, true_block, false_block));
|
|
|
- ir_add_edge(b, true_block);
|
|
|
- ir_add_edge(b, false_block);
|
|
|
- ir_start_block(proc, nullptr);
|
|
|
-
|
|
|
- if (cond) cond->uses += 1;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_comp(irProcedure *proc, TokenKind op_kind, irValue *left, irValue *right);
|
|
|
-
|
|
|
-irValue *ir_gen_map_header(irProcedure *proc, irValue *map_val_ptr, Type *map_type) {
|
|
|
- GB_ASSERT_MSG(is_type_pointer(ir_type(map_val_ptr)), "%s", type_to_string(ir_type(map_val_ptr)));
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *h = ir_add_local_generated(proc, t_map_header, false); // all the values will be initialzed later
|
|
|
- map_type = base_type(map_type);
|
|
|
-
|
|
|
- Type *key_type = map_type->Map.key;
|
|
|
- Type *val_type = map_type->Map.value;
|
|
|
-
|
|
|
- // NOTE(bill): Removes unnecessary allocation if split gep
|
|
|
- irValue *gep0 = ir_emit_struct_ep(proc, h, 0);
|
|
|
- irValue *m = ir_emit_conv(proc, map_val_ptr, type_deref(ir_type(gep0)));
|
|
|
- ir_emit_store(proc, gep0, m);
|
|
|
-
|
|
|
-
|
|
|
- i64 entry_size = type_size_of (map_type->Map.entry_type);
|
|
|
- i64 entry_align = type_align_of (map_type->Map.entry_type);
|
|
|
- i64 key_offset = type_offset_of(map_type->Map.entry_type, 2);
|
|
|
- i64 key_size = type_size_of (map_type->Map.key);
|
|
|
- i64 value_offset = type_offset_of(map_type->Map.entry_type, 3);
|
|
|
- i64 value_size = type_size_of (map_type->Map.value);
|
|
|
-
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, h, 1), ir_get_equal_proc_for_type(proc->module, key_type));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, h, 2), ir_const_int(entry_size));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, h, 3), ir_const_int(entry_align));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, h, 4), ir_const_uintptr(key_offset));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, h, 5), ir_const_int(key_size));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, h, 6), ir_const_uintptr(value_offset));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, h, 7), ir_const_int(value_size));
|
|
|
-
|
|
|
- return ir_emit_load(proc, h);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_const_hash(irModule *m, irValue *key, Type *key_type) {
|
|
|
- irValue *hashed_key = nullptr;
|
|
|
-
|
|
|
- if (key->kind == irValue_Constant) {
|
|
|
- u64 hash = 0xcbf29ce484222325;
|
|
|
- if (is_type_string(key_type)) {
|
|
|
- GB_ASSERT(key->Constant.value.kind == ExactValue_String);
|
|
|
- String s = key->Constant.value.value_string;
|
|
|
- hash = fnv64a(s.text, s.len);
|
|
|
- } else {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- // TODO(bill): other const hash types
|
|
|
-
|
|
|
- if (build_context.word_size == 4) {
|
|
|
- hash &= 0xffffffffull;
|
|
|
- }
|
|
|
- hashed_key = ir_const_uintptr(hash);
|
|
|
- }
|
|
|
-
|
|
|
- return hashed_key;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_gen_map_hash(irProcedure *proc, irValue *key, Type *key_type) {
|
|
|
- Type *hash_type = t_u64;
|
|
|
- irValue *v = ir_add_local_generated(proc, t_map_hash, true);
|
|
|
- Type *t = base_type(ir_type(key));
|
|
|
- key = ir_emit_conv(proc, key, key_type);
|
|
|
-
|
|
|
- irValue *key_ptr = ir_address_from_load_or_generate_local(proc, key);
|
|
|
- key_ptr = ir_emit_conv(proc, key_ptr, t_rawptr);
|
|
|
-
|
|
|
- irValue *hashed_key = ir_const_hash(proc->module, key, key_type);
|
|
|
- if (hashed_key == nullptr) {
|
|
|
- irValue *hasher = ir_get_hasher_proc_for_type(proc->module, key_type);
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = key_ptr;
|
|
|
- args[1] = ir_value_constant(t_uintptr, exact_value_i64(0));
|
|
|
- hashed_key = ir_emit_call(proc, hasher, args);
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, v, 0), hashed_key);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, v, 1), key_ptr);
|
|
|
-
|
|
|
- return ir_emit_load(proc, v);
|
|
|
-}
|
|
|
-
|
|
|
-// NOTE(bill): Returns nullptr if not possible
|
|
|
-irValue *ir_address_from_load_or_generate_local(irProcedure *proc, irValue *val) {
|
|
|
- if (val->kind == irValue_Instr) {
|
|
|
- if (val->Instr.kind == irInstr_Load) {
|
|
|
- return val->Instr.Load.address;
|
|
|
- }
|
|
|
- }
|
|
|
- Type *type = ir_type(val);
|
|
|
- irValue *local = ir_add_local_generated(proc, type, false);
|
|
|
- ir_emit_store(proc, local, val);
|
|
|
- return local;
|
|
|
-}
|
|
|
-irValue *ir_address_from_load(irProcedure *proc, irValue *val) {
|
|
|
- if (val->kind == irValue_Instr) {
|
|
|
- if (val->Instr.kind == irInstr_Load) {
|
|
|
- return val->Instr.Load.address;
|
|
|
- }
|
|
|
- }
|
|
|
- GB_PANIC("ir_address_from_load");
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-Type *ir_addr_type(irAddr const &addr) {
|
|
|
- if (addr.addr == nullptr) {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
-
|
|
|
- if (addr.kind == irAddr_Map) {
|
|
|
- Type *t = base_type(addr.map_type);
|
|
|
- GB_ASSERT(is_type_map(t));
|
|
|
- return t->Map.value;
|
|
|
- }
|
|
|
-
|
|
|
- Type *t = ir_type(addr.addr);
|
|
|
- GB_ASSERT(is_type_pointer(t));
|
|
|
- return type_deref(t);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_source_code_location(irProcedure *proc, String procedure, TokenPos pos);
|
|
|
-irValue *ir_emit_source_code_location(irProcedure *proc, Ast *node);
|
|
|
-irValue *ir_emit_ptr_offset(irProcedure *proc, irValue *ptr, irValue *offset);
|
|
|
-irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *right, Type *type);
|
|
|
-irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel);
|
|
|
-void ir_emit_bounds_check(irProcedure *proc, Token token, irValue *index, irValue *len);
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_insert_dynamic_map_key_and_value(irProcedure *proc, irValue *addr, Type *map_type,
|
|
|
- irValue *map_key, irValue *map_value, Ast *node) {
|
|
|
- map_type = base_type(map_type);
|
|
|
-
|
|
|
- irValue *h = ir_gen_map_header(proc, addr, map_type);
|
|
|
- irValue *key = ir_gen_map_hash(proc, map_key, map_type->Map.key);
|
|
|
- irValue *v = ir_emit_conv(proc, map_value, map_type->Map.value);
|
|
|
-
|
|
|
- irValue *ptr = ir_add_local_generated(proc, ir_type(v), false);
|
|
|
- ir_emit_store(proc, ptr, v);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 4);
|
|
|
- args[0] = h;
|
|
|
- args[1] = key;
|
|
|
- args[2] = ir_emit_conv(proc, ptr, t_rawptr);
|
|
|
- args[3] = ir_emit_source_code_location(proc, node);
|
|
|
- return ir_emit_runtime_call(proc, "__dynamic_map_set", args);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_soa_struct_len(irProcedure *proc, irValue *value) {
|
|
|
- Type *t = base_type(ir_type(value));
|
|
|
- bool is_ptr = false;
|
|
|
- if (is_type_pointer(t)) {
|
|
|
- is_ptr = true;
|
|
|
- t = base_type(type_deref(t));
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- if (t->Struct.soa_kind == StructSoa_Fixed) {
|
|
|
- return ir_const_int(t->Struct.soa_count);
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(t->Struct.soa_kind == StructSoa_Slice ||
|
|
|
- t->Struct.soa_kind == StructSoa_Dynamic);
|
|
|
-
|
|
|
- isize n = 0;
|
|
|
- Type *elem = base_type(t->Struct.soa_elem);
|
|
|
- if (elem->kind == Type_Struct) {
|
|
|
- n = elem->Struct.fields.count;
|
|
|
- } else if (elem->kind == Type_Array) {
|
|
|
- n = elem->Array.count;
|
|
|
- } else {
|
|
|
- GB_PANIC("Unreachable");
|
|
|
- }
|
|
|
-
|
|
|
- if (is_ptr) {
|
|
|
- irValue *v = ir_emit_struct_ep(proc, value, cast(i32)n);
|
|
|
- return ir_emit_load(proc, v);
|
|
|
- }
|
|
|
- return ir_emit_struct_ev(proc, value, cast(i32)n);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_soa_struct_cap(irProcedure *proc, irValue *value) {
|
|
|
- Type *t = base_type(ir_type(value));
|
|
|
-
|
|
|
- bool is_ptr = false;
|
|
|
- if (is_type_pointer(t)) {
|
|
|
- is_ptr = true;
|
|
|
- t = base_type(type_deref(t));
|
|
|
- }
|
|
|
-
|
|
|
- if (t->Struct.soa_kind == StructSoa_Fixed) {
|
|
|
- return ir_const_int(t->Struct.soa_count);
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(t->Struct.soa_kind == StructSoa_Dynamic);
|
|
|
-
|
|
|
- isize n = 0;
|
|
|
- Type *elem = base_type(t->Struct.soa_elem);
|
|
|
- if (elem->kind == Type_Struct) {
|
|
|
- n = elem->Struct.fields.count+1;
|
|
|
- } else if (elem->kind == Type_Array) {
|
|
|
- n = elem->Array.count+1;
|
|
|
- } else {
|
|
|
- GB_PANIC("Unreachable");
|
|
|
- }
|
|
|
-
|
|
|
- if (is_ptr) {
|
|
|
- irValue *v = ir_emit_struct_ep(proc, value, cast(i32)n);
|
|
|
- return ir_emit_load(proc, v);
|
|
|
- }
|
|
|
- return ir_emit_struct_ev(proc, value, cast(i32)n);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_addr_load(irProcedure *proc, irAddr const &addr);
|
|
|
-
|
|
|
-void ir_addr_store(irProcedure *proc, irAddr addr, irValue *value) {
|
|
|
- if (addr.addr == nullptr) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (addr.kind == irAddr_RelativePointer && addr.relative.deref) {
|
|
|
- addr = ir_addr(ir_address_from_load(proc, ir_addr_load(proc, addr)));
|
|
|
- }
|
|
|
-
|
|
|
- if (addr.kind == irAddr_RelativePointer) {
|
|
|
- Type *rel_ptr = base_type(ir_addr_type(addr));
|
|
|
- GB_ASSERT(rel_ptr->kind == Type_RelativePointer);
|
|
|
-
|
|
|
- value = ir_emit_conv(proc, value, rel_ptr->RelativePointer.pointer_type);
|
|
|
-
|
|
|
- GB_ASSERT(is_type_pointer(ir_type(addr.addr)));
|
|
|
- irValue *ptr = ir_emit_conv(proc, addr.addr, t_uintptr);
|
|
|
- irValue *val_ptr = ir_emit_conv(proc, value, t_uintptr);
|
|
|
- irValue *offset = offset = ir_emit_arith(proc, Token_Sub, val_ptr, ptr, t_uintptr);
|
|
|
-
|
|
|
- if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
|
|
|
- offset = ir_emit_conv(proc, offset, t_i64);
|
|
|
- }
|
|
|
- offset = ir_emit_conv(proc, offset, rel_ptr->RelativePointer.base_integer);
|
|
|
-
|
|
|
- irValue *offset_ptr = ir_emit_conv(proc, addr.addr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
|
|
|
- offset = ir_emit_select(proc,
|
|
|
- ir_emit_comp(proc, Token_CmpEq, val_ptr, ir_value_nil(t_uintptr)),
|
|
|
- ir_value_nil(rel_ptr->RelativePointer.base_integer),
|
|
|
- offset
|
|
|
- );
|
|
|
- ir_emit_store(proc, offset_ptr, offset);
|
|
|
- return;
|
|
|
-
|
|
|
- } else if (addr.kind == irAddr_RelativeSlice) {
|
|
|
- Type *rel_ptr = base_type(ir_addr_type(addr));
|
|
|
- GB_ASSERT(rel_ptr->kind == Type_RelativeSlice);
|
|
|
-
|
|
|
- value = ir_emit_conv(proc, value, rel_ptr->RelativeSlice.slice_type);
|
|
|
-
|
|
|
- GB_ASSERT(is_type_pointer(ir_type(addr.addr)));
|
|
|
- irValue *ptr = ir_emit_conv(proc, ir_emit_struct_ep(proc, addr.addr, 0), t_uintptr);
|
|
|
- irValue *val_ptr = ir_emit_conv(proc, ir_slice_elem(proc, value), t_uintptr);
|
|
|
- irValue *offset = ir_emit_arith(proc, Token_Sub, val_ptr, ptr, t_uintptr);
|
|
|
-
|
|
|
- if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
|
|
|
- offset = ir_emit_conv(proc, offset, t_i64);
|
|
|
- }
|
|
|
- offset = ir_emit_conv(proc, offset, rel_ptr->RelativePointer.base_integer);
|
|
|
-
|
|
|
- irValue *offset_ptr = ir_emit_conv(proc, addr.addr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
|
|
|
- offset = ir_emit_select(proc,
|
|
|
- ir_emit_comp(proc, Token_CmpEq, val_ptr, ir_value_nil(t_uintptr)),
|
|
|
- ir_value_nil(rel_ptr->RelativePointer.base_integer),
|
|
|
- offset
|
|
|
- );
|
|
|
- ir_emit_store(proc, offset_ptr, offset);
|
|
|
-
|
|
|
- irValue *len = ir_slice_len(proc, value);
|
|
|
- len = ir_emit_conv(proc, len, rel_ptr->RelativePointer.base_integer);
|
|
|
-
|
|
|
- irValue *len_ptr = ir_emit_struct_ep(proc, addr.addr, 1);
|
|
|
- ir_emit_store(proc, len_ptr, len);
|
|
|
-
|
|
|
- return;
|
|
|
-
|
|
|
- } else if (addr.kind == irAddr_Map) {
|
|
|
- ir_insert_dynamic_map_key_and_value(proc, addr.addr, addr.map_type, addr.map_key, value, proc->curr_stmt);
|
|
|
- return;
|
|
|
- } else if (addr.kind == irAddr_Context) {
|
|
|
- irValue *old = ir_emit_load(proc, ir_find_or_generate_context_ptr(proc));
|
|
|
- irValue *next = ir_add_local_generated(proc, t_context, true);
|
|
|
- ir_emit_store(proc, next, old);
|
|
|
- ir_push_context_onto_stack(proc, next);
|
|
|
-
|
|
|
- if (addr.ctx.sel.index.count > 0) {
|
|
|
- irValue *lhs = ir_emit_deep_field_gep(proc, next, addr.ctx.sel);
|
|
|
- irValue *rhs = ir_emit_conv(proc, value, type_deref(ir_type(lhs)));
|
|
|
- ir_emit_store(proc, lhs, rhs);
|
|
|
- } else {
|
|
|
- irValue *lhs = next;
|
|
|
- irValue *rhs = ir_emit_conv(proc, value, ir_addr_type(addr));
|
|
|
- ir_emit_store(proc, lhs, rhs);
|
|
|
- }
|
|
|
-
|
|
|
- return;
|
|
|
- } else if (addr.kind == irAddr_SoaVariable) {
|
|
|
- Type *t = type_deref(ir_type(addr.addr));
|
|
|
- t = base_type(t);
|
|
|
- GB_ASSERT(t->kind == Type_Struct && t->Struct.soa_kind != StructSoa_None);
|
|
|
- Type *elem_type = t->Struct.soa_elem;
|
|
|
- value = ir_emit_conv(proc, value, elem_type);
|
|
|
- elem_type = base_type(elem_type);
|
|
|
-
|
|
|
- irValue *index = addr.soa.index;
|
|
|
- if (index->kind != irValue_Constant || t->Struct.soa_kind != StructSoa_Fixed) {
|
|
|
- Type *t = base_type(type_deref(ir_type(addr.addr)));
|
|
|
- GB_ASSERT(t->kind == Type_Struct && t->Struct.soa_kind != StructSoa_None);
|
|
|
- irValue *len = ir_soa_struct_len(proc, addr.addr);
|
|
|
- ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), index, len);
|
|
|
- }
|
|
|
-
|
|
|
- isize field_count = 0;
|
|
|
-
|
|
|
- switch (elem_type->kind) {
|
|
|
- case Type_Struct:
|
|
|
- field_count = elem_type->Struct.fields.count;
|
|
|
- break;
|
|
|
- case Type_Array:
|
|
|
- field_count = elem_type->Array.count;
|
|
|
- break;
|
|
|
- }
|
|
|
- for (isize i = 0; i < field_count; i++) {
|
|
|
- irValue *dst = ir_emit_struct_ep(proc, addr.addr, cast(i32)i);
|
|
|
- irValue *src = ir_emit_struct_ev(proc, value, cast(i32)i);
|
|
|
- if (t->Struct.soa_kind == StructSoa_Fixed) {
|
|
|
- dst = ir_emit_array_ep(proc, dst, index);
|
|
|
- ir_emit_store(proc, dst, src);
|
|
|
- } else {
|
|
|
- irValue *field = ir_emit_load(proc, dst);
|
|
|
- dst = ir_emit_ptr_offset(proc, field, index);
|
|
|
- ir_emit_store(proc, dst, src);
|
|
|
- }
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *v = ir_emit_conv(proc, value, ir_addr_type(addr));
|
|
|
- ir_emit_store(proc, addr.addr, v);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_addr_load(irProcedure *proc, irAddr const &addr) {
|
|
|
- if (addr.addr == nullptr) {
|
|
|
- GB_PANIC("Illegal addr load");
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
-
|
|
|
- if (addr.kind == irAddr_RelativePointer) {
|
|
|
- Type *rel_ptr = base_type(ir_addr_type(addr));
|
|
|
- GB_ASSERT(rel_ptr->kind == Type_RelativePointer);
|
|
|
-
|
|
|
- irValue *ptr = ir_emit_conv(proc, addr.addr, t_uintptr);
|
|
|
- irValue *offset = ir_emit_conv(proc, ptr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
|
|
|
- offset = ir_emit_load(proc, offset);
|
|
|
-
|
|
|
-
|
|
|
- if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
|
|
|
- offset = ir_emit_conv(proc, offset, t_i64);
|
|
|
- }
|
|
|
- offset = ir_emit_conv(proc, offset, t_uintptr);
|
|
|
- irValue *absolute_ptr = ir_emit_arith(proc, Token_Add, ptr, offset, t_uintptr);
|
|
|
- absolute_ptr = ir_emit_conv(proc, absolute_ptr, rel_ptr->RelativePointer.pointer_type);
|
|
|
-
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_CmpEq, offset, ir_value_nil(rel_ptr->RelativePointer.base_integer));
|
|
|
-
|
|
|
- // NOTE(bill): nil check
|
|
|
- irValue *nil_ptr = ir_value_nil(rel_ptr->RelativePointer.pointer_type);
|
|
|
- irValue *final_ptr = ir_emit_select(proc, cond, nil_ptr, absolute_ptr);
|
|
|
-
|
|
|
- return ir_emit_load(proc, final_ptr);
|
|
|
-
|
|
|
- } else if (addr.kind == irAddr_RelativeSlice) {
|
|
|
- Type *rel_ptr = base_type(ir_addr_type(addr));
|
|
|
- GB_ASSERT(rel_ptr->kind == Type_RelativeSlice);
|
|
|
-
|
|
|
- irValue *offset_ptr = ir_emit_struct_ep(proc, addr.addr, 0);
|
|
|
- irValue *ptr = ir_emit_conv(proc, offset_ptr, t_uintptr);
|
|
|
- irValue *offset = ir_emit_load(proc, offset_ptr);
|
|
|
-
|
|
|
-
|
|
|
- if (!is_type_unsigned(rel_ptr->RelativeSlice.base_integer)) {
|
|
|
- offset = ir_emit_conv(proc, offset, t_i64);
|
|
|
- }
|
|
|
- offset = ir_emit_conv(proc, offset, t_uintptr);
|
|
|
- irValue *absolute_ptr = ir_emit_arith(proc, Token_Add, ptr, offset, t_uintptr);
|
|
|
-
|
|
|
- Type *slice_type = base_type(rel_ptr->RelativeSlice.slice_type);
|
|
|
- GB_ASSERT(rel_ptr->RelativeSlice.slice_type->kind == Type_Slice);
|
|
|
- Type *slice_elem = slice_type->Slice.elem;
|
|
|
- Type *slice_elem_ptr = alloc_type_pointer(slice_elem);
|
|
|
-
|
|
|
- absolute_ptr = ir_emit_conv(proc, absolute_ptr, slice_elem_ptr);
|
|
|
-
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_CmpEq, offset, ir_value_nil(rel_ptr->RelativeSlice.base_integer));
|
|
|
-
|
|
|
- // NOTE(bill): nil check
|
|
|
- irValue *nil_ptr = ir_value_nil(slice_elem_ptr);
|
|
|
- irValue *data = ir_emit_select(proc, cond, nil_ptr, absolute_ptr);
|
|
|
-
|
|
|
- irValue *len = ir_emit_load(proc, ir_emit_struct_ep(proc, addr.addr, 1));
|
|
|
- len = ir_emit_conv(proc, len, t_int);
|
|
|
-
|
|
|
- irValue *slice = ir_add_local_generated(proc, slice_type, false);
|
|
|
- ir_fill_slice(proc, slice, data, len);
|
|
|
- return ir_emit_load(proc, slice);
|
|
|
-
|
|
|
-
|
|
|
- } else if (addr.kind == irAddr_Map) {
|
|
|
- Type *map_type = base_type(addr.map_type);
|
|
|
- irValue *v = ir_add_local_generated(proc, map_type->Map.lookup_result_type, true);
|
|
|
- irValue *h = ir_gen_map_header(proc, addr.addr, map_type);
|
|
|
- irValue *key = ir_gen_map_hash(proc, addr.map_key, map_type->Map.key);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = h;
|
|
|
- args[1] = key;
|
|
|
-
|
|
|
- irValue *ptr = ir_emit_runtime_call(proc, "__dynamic_map_get", args);
|
|
|
- irValue *ok = ir_emit_conv(proc, ir_emit_comp(proc, Token_NotEq, ptr, v_raw_nil), t_bool);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, v, 1), ok);
|
|
|
-
|
|
|
- irBlock *then = ir_new_block(proc, nullptr, "map.get.then");
|
|
|
- irBlock *done = ir_new_block(proc, nullptr, "map.get.done");
|
|
|
- ir_emit_if(proc, ok, then, done);
|
|
|
- ir_start_block(proc, then);
|
|
|
- {
|
|
|
- // TODO(bill): mem copy it instead?
|
|
|
- irValue *gep0 = ir_emit_struct_ep(proc, v, 0);
|
|
|
- irValue *value = ir_emit_conv(proc, ptr, ir_type(gep0));
|
|
|
- ir_emit_store(proc, gep0, ir_emit_load(proc, value));
|
|
|
- }
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
-
|
|
|
-
|
|
|
- if (is_type_tuple(addr.map_result)) {
|
|
|
- return ir_emit_load(proc, v);
|
|
|
- } else {
|
|
|
- irValue *single = ir_emit_struct_ep(proc, v, 0);
|
|
|
- return ir_emit_load(proc, single);
|
|
|
- }
|
|
|
- } else if (addr.kind == irAddr_Context) {
|
|
|
- if (addr.ctx.sel.index.count > 0) {
|
|
|
- irValue *a = addr.addr;
|
|
|
- irValue *b = ir_emit_deep_field_gep(proc, a, addr.ctx.sel);
|
|
|
- return ir_emit_load(proc, b);
|
|
|
- }
|
|
|
- } else if (addr.kind == irAddr_SoaVariable) {
|
|
|
- Type *t = type_deref(ir_type(addr.addr));
|
|
|
- t = base_type(t);
|
|
|
- GB_ASSERT(t->kind == Type_Struct && t->Struct.soa_kind != StructSoa_None);
|
|
|
- Type *elem = t->Struct.soa_elem;
|
|
|
-
|
|
|
- irValue *len = nullptr;
|
|
|
- if (t->Struct.soa_kind == StructSoa_Fixed) {
|
|
|
- len = ir_const_int(t->Struct.soa_count);
|
|
|
- } else {
|
|
|
- irValue *v = ir_emit_load(proc, addr.addr);
|
|
|
- len = ir_soa_struct_len(proc, v);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *res = ir_add_local_generated(proc, elem, true);
|
|
|
-
|
|
|
- if (addr.soa.index->kind != irValue_Constant || t->Struct.soa_kind != StructSoa_Fixed) {
|
|
|
- ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), addr.soa.index, len);
|
|
|
- }
|
|
|
-
|
|
|
- if (t->Struct.soa_kind == StructSoa_Fixed) {
|
|
|
- for_array(i, t->Struct.fields) {
|
|
|
- Entity *field = t->Struct.fields[i];
|
|
|
- Type *base_type = field->type;
|
|
|
- GB_ASSERT(base_type->kind == Type_Array);
|
|
|
-
|
|
|
- irValue *dst = ir_emit_struct_ep(proc, res, cast(i32)i);
|
|
|
- irValue *src_ptr = ir_emit_struct_ep(proc, addr.addr, cast(i32)i);
|
|
|
- src_ptr = ir_emit_array_ep(proc, src_ptr, addr.soa.index);
|
|
|
- irValue *src = ir_emit_load(proc, src_ptr);
|
|
|
- ir_emit_store(proc, dst, src);
|
|
|
- }
|
|
|
- } else {
|
|
|
- isize field_count = t->Struct.fields.count;
|
|
|
- if (t->Struct.soa_kind == StructSoa_Slice) {
|
|
|
- field_count -= 1;
|
|
|
- } else if (t->Struct.soa_kind == StructSoa_Dynamic) {
|
|
|
- field_count -= 3;
|
|
|
- }
|
|
|
- for (isize i = 0; i < field_count; i++) {
|
|
|
- Entity *field = t->Struct.fields[i];
|
|
|
- Type *base_type = field->type;
|
|
|
- GB_ASSERT(base_type->kind == Type_Pointer);
|
|
|
- Type *elem = base_type->Pointer.elem;
|
|
|
-
|
|
|
- irValue *dst = ir_emit_struct_ep(proc, res, cast(i32)i);
|
|
|
- irValue *src_ptr = ir_emit_struct_ep(proc, addr.addr, cast(i32)i);
|
|
|
- src_ptr = ir_emit_ptr_offset(proc, src_ptr, addr.soa.index);
|
|
|
- irValue *src = ir_emit_load(proc, src_ptr);
|
|
|
- src = ir_emit_load(proc, src);
|
|
|
- ir_emit_store(proc, dst, src);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ir_emit_load(proc, res);
|
|
|
- }
|
|
|
-
|
|
|
- Type *t = base_type(ir_type(addr.addr));
|
|
|
- if (t->kind == Type_Proc) {
|
|
|
- // NOTE(bill): Imported procedures don't require a load as they are pointers
|
|
|
- return addr.addr;
|
|
|
- }
|
|
|
- return ir_emit_load(proc, addr.addr);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_addr_get_ptr(irProcedure *proc, irAddr const &addr, bool allow_reference=false) {
|
|
|
- if (addr.addr == nullptr) {
|
|
|
- GB_PANIC("Illegal addr -> nullptr");
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
-
|
|
|
- switch (addr.kind) {
|
|
|
- case irAddr_Map: {
|
|
|
- if (allow_reference) {
|
|
|
- Type *map_type = base_type(addr.map_type);
|
|
|
- irValue *h = ir_gen_map_header(proc, addr.addr, map_type);
|
|
|
- irValue *key = ir_gen_map_hash(proc, addr.map_key, map_type->Map.key);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = h;
|
|
|
- args[1] = key;
|
|
|
-
|
|
|
- irValue *ptr = ir_emit_runtime_call(proc, "__dynamic_map_get", args);
|
|
|
- return ir_emit_conv(proc, ptr, alloc_type_pointer(map_type->Map.value));
|
|
|
- } else {
|
|
|
- irValue *v = ir_addr_load(proc, addr);
|
|
|
- return ir_address_from_load_or_generate_local(proc, v);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- case irAddr_RelativePointer: {
|
|
|
- Type *rel_ptr = base_type(ir_addr_type(addr));
|
|
|
- GB_ASSERT(rel_ptr->kind == Type_RelativePointer);
|
|
|
-
|
|
|
- irValue *ptr = ir_emit_conv(proc, addr.addr, t_uintptr);
|
|
|
- irValue *offset = ir_emit_conv(proc, ptr, alloc_type_pointer(rel_ptr->RelativePointer.base_integer));
|
|
|
- offset = ir_emit_load(proc, offset);
|
|
|
-
|
|
|
- if (!is_type_unsigned(rel_ptr->RelativePointer.base_integer)) {
|
|
|
- offset = ir_emit_conv(proc, offset, t_i64);
|
|
|
- }
|
|
|
- offset = ir_emit_conv(proc, offset, t_uintptr);
|
|
|
- irValue *absolute_ptr = ir_emit_arith(proc, Token_Add, ptr, offset, t_uintptr);
|
|
|
- absolute_ptr = ir_emit_conv(proc, absolute_ptr, rel_ptr->RelativePointer.pointer_type);
|
|
|
-
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_CmpEq, offset, ir_value_nil(rel_ptr->RelativePointer.base_integer));
|
|
|
-
|
|
|
- // NOTE(bill): nil check
|
|
|
- irValue *nil_ptr = ir_value_nil(rel_ptr->RelativePointer.pointer_type);
|
|
|
- irValue *final_ptr = ir_emit_select(proc, cond, nil_ptr, absolute_ptr);
|
|
|
- return final_ptr;
|
|
|
- }
|
|
|
-
|
|
|
- case irAddr_Context:
|
|
|
- GB_PANIC("irAddr_Context should be handled elsewhere");
|
|
|
- }
|
|
|
-
|
|
|
- return addr.addr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_build_addr_ptr(irProcedure *proc, Ast *expr) {
|
|
|
- irAddr addr = ir_build_addr(proc, expr);
|
|
|
- return ir_addr_get_ptr(proc, addr);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_dynamic_array_len(irProcedure *proc, irValue *da);
|
|
|
-irValue *ir_dynamic_array_cap(irProcedure *proc, irValue *da);
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_map_entries(irProcedure *proc, irValue *value) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- Type *t = base_type(ir_type(value));
|
|
|
- GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t));
|
|
|
- init_map_internal_types(t);
|
|
|
- Type *gst = t->Map.generated_struct_type;
|
|
|
- i32 index = 1;
|
|
|
- irValue *entries = ir_emit(proc, ir_instr_struct_extract_value(proc, value, index, gst->Struct.fields[index]->type));
|
|
|
- return entries;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_map_entries_ptr(irProcedure *proc, irValue *value) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- Type *t = base_type(type_deref(ir_type(value)));
|
|
|
- if (is_type_pointer(t)) {
|
|
|
- value = ir_emit_load(proc, value);
|
|
|
- t = base_type(type_deref(t));
|
|
|
- }
|
|
|
- GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t));
|
|
|
- init_map_internal_types(t);
|
|
|
- Type *gst = t->Map.generated_struct_type;
|
|
|
- i32 index = 1;
|
|
|
- Type *ptr_t = alloc_type_pointer(gst->Struct.fields[index]->type);
|
|
|
- irValue *entries = ir_emit(proc, ir_instr_struct_element_ptr(proc, value, index, ptr_t));
|
|
|
- return entries;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_map_len(irProcedure *proc, irValue *value) {
|
|
|
- irValue *entries = ir_map_entries(proc, value);
|
|
|
- return ir_dynamic_array_len(proc, entries);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_map_cap(irProcedure *proc, irValue *value) {
|
|
|
- irValue *entries = ir_map_entries(proc, value);
|
|
|
- return ir_dynamic_array_cap(proc, entries);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-struct irLoopData {
|
|
|
- irValue *idx_addr;
|
|
|
- irValue *idx;
|
|
|
- irBlock *body;
|
|
|
- irBlock *done;
|
|
|
- irBlock *loop;
|
|
|
-};
|
|
|
-
|
|
|
-irLoopData ir_loop_start(irProcedure *proc, isize count, Type *index_type=t_int) {
|
|
|
- irLoopData data = {};
|
|
|
-
|
|
|
- irValue *max = ir_const_int(count);
|
|
|
-
|
|
|
- data.idx_addr = ir_add_local_generated(proc, index_type, true);
|
|
|
-
|
|
|
- data.body = ir_new_block(proc, nullptr, "loop.body");
|
|
|
- data.done = ir_new_block(proc, nullptr, "loop.done");
|
|
|
- data.loop = ir_new_block(proc, nullptr, "loop.loop");
|
|
|
-
|
|
|
- ir_emit_jump(proc, data.loop);
|
|
|
- ir_start_block(proc, data.loop);
|
|
|
-
|
|
|
- data.idx = ir_emit_load(proc, data.idx_addr);
|
|
|
-
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_Lt, data.idx, max);
|
|
|
- ir_emit_if(proc, cond, data.body, data.done);
|
|
|
- ir_start_block(proc, data.body);
|
|
|
-
|
|
|
- return data;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_loop_end(irProcedure *proc, irLoopData const &data) {
|
|
|
- if (data.idx_addr != nullptr) {
|
|
|
- ir_emit_increment(proc, data.idx_addr);
|
|
|
- ir_emit_jump(proc, data.loop);
|
|
|
- ir_start_block(proc, data.done);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_ptr_offset(irProcedure *proc, irValue *ptr, irValue *offset) {
|
|
|
- offset = ir_emit_conv(proc, offset, t_int);
|
|
|
- return ir_emit(proc, ir_instr_ptr_offset(proc, ptr, offset));
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_unary_arith(irProcedure *proc, TokenKind op, irValue *x, Type *type) {
|
|
|
- switch (op) {
|
|
|
- case Token_Add:
|
|
|
- return x;
|
|
|
- case Token_Not: // Boolean not
|
|
|
- case Token_Xor: // Bitwise not
|
|
|
- case Token_Sub: // Bitwise Not
|
|
|
- break;
|
|
|
- case Token_Pointer:
|
|
|
- GB_PANIC("This should be handled elsewhere");
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_array(ir_type(x))) {
|
|
|
- ir_emit_comment(proc, str_lit("array.arith.begin"));
|
|
|
- // IMPORTANT TODO(bill): This is very wasteful with regards to stack memory
|
|
|
- Type *tl = base_type(ir_type(x));
|
|
|
- irValue *val = ir_address_from_load_or_generate_local(proc, x);
|
|
|
- GB_ASSERT(is_type_array(type));
|
|
|
- Type *elem_type = base_array_type(type);
|
|
|
-
|
|
|
- // NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
|
|
|
- irValue *res = ir_add_local_generated(proc, type, false);
|
|
|
-
|
|
|
- bool inline_array_arith = type_size_of(type) <= build_context.max_align;
|
|
|
-
|
|
|
- i32 count = cast(i32)tl->Array.count;
|
|
|
-
|
|
|
- if (inline_array_arith) {
|
|
|
- // inline
|
|
|
- for (i32 i = 0; i < count; i++) {
|
|
|
- irValue *e = ir_emit_load(proc, ir_emit_array_epi(proc, val, i));
|
|
|
- irValue *z = ir_emit_unary_arith(proc, op, e, elem_type);
|
|
|
- ir_emit_store(proc, ir_emit_array_epi(proc, res, i), z);
|
|
|
- }
|
|
|
- } else {
|
|
|
- auto loop_data = ir_loop_start(proc, count, t_i32);
|
|
|
-
|
|
|
- irValue *e = ir_emit_load(proc, ir_emit_array_ep(proc, val, loop_data.idx));
|
|
|
- irValue *z = ir_emit_unary_arith(proc, op, e, elem_type);
|
|
|
- ir_emit_store(proc, ir_emit_array_ep(proc, res, loop_data.idx), z);
|
|
|
-
|
|
|
- ir_loop_end(proc, loop_data);
|
|
|
- }
|
|
|
- ir_emit_comment(proc, str_lit("array.arith.end"));
|
|
|
- return ir_emit_load(proc, res);
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- if (op == Token_Not) {
|
|
|
- irValue *cmp = ir_emit_comp(proc, Token_CmpEq, x, v_false);
|
|
|
- return ir_emit_conv(proc, cmp, type);
|
|
|
- }
|
|
|
-
|
|
|
- if (op == Token_Sub && is_type_integer(type) && is_type_different_to_arch_endianness(type)) {
|
|
|
- Type *platform_type = integer_endian_type_to_platform_type(type);
|
|
|
- irValue *v = ir_emit_byte_swap(proc, x, platform_type);
|
|
|
- irValue *res = ir_emit(proc, ir_instr_unary_op(proc, op, v, platform_type));
|
|
|
- return ir_emit_byte_swap(proc, res, type);
|
|
|
- }
|
|
|
-
|
|
|
- if (op == Token_Sub && is_type_float(type) && is_type_different_to_arch_endianness(type)) {
|
|
|
- Type *platform_type = integer_endian_type_to_platform_type(type);
|
|
|
- irValue *v = ir_emit_byte_swap(proc, x, platform_type);
|
|
|
- irValue *res = ir_emit(proc, ir_instr_unary_op(proc, op, v, platform_type));
|
|
|
- return ir_emit_byte_swap(proc, res, type);
|
|
|
- }
|
|
|
-
|
|
|
- if (op == Token_Sub) {
|
|
|
- if (is_type_integer(ir_type(x))) {
|
|
|
- return ir_emit(proc, ir_instr_unary_op(proc, op, x, type));
|
|
|
- } else if (is_type_float(ir_type(x))) {
|
|
|
- return ir_emit(proc, ir_instr_unary_op(proc, op, x, type));
|
|
|
- } else if (is_type_complex(ir_type(x))) {
|
|
|
- irValue *addr = ir_add_local_generated(proc, ir_type(x), false);
|
|
|
-
|
|
|
- irValue *v0 = ir_emit_struct_ev(proc, x, 0);
|
|
|
- irValue *v1 = ir_emit_struct_ev(proc, x, 1);
|
|
|
- v0 = ir_emit(proc, ir_instr_unary_op(proc, op, v0, ir_type(v0)));
|
|
|
- v1 = ir_emit(proc, ir_instr_unary_op(proc, op, v1, ir_type(v1)));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 0), v0);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 1), v1);
|
|
|
-
|
|
|
- return ir_emit_load(proc, addr);
|
|
|
- } else if (is_type_quaternion(ir_type(x))) {
|
|
|
- irValue *addr = ir_add_local_generated(proc, ir_type(x), false);
|
|
|
-
|
|
|
- irValue *v0 = ir_emit_struct_ev(proc, x, 0);
|
|
|
- irValue *v1 = ir_emit_struct_ev(proc, x, 1);
|
|
|
- irValue *v2 = ir_emit_struct_ev(proc, x, 2);
|
|
|
- irValue *v3 = ir_emit_struct_ev(proc, x, 3);
|
|
|
- v0 = ir_emit(proc, ir_instr_unary_op(proc, op, v0, ir_type(v0)));
|
|
|
- v1 = ir_emit(proc, ir_instr_unary_op(proc, op, v1, ir_type(v1)));
|
|
|
- v2 = ir_emit(proc, ir_instr_unary_op(proc, op, v2, ir_type(v2)));
|
|
|
- v3 = ir_emit(proc, ir_instr_unary_op(proc, op, v3, ir_type(v3)));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 0), v0);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 1), v1);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 2), v2);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, addr, 3), v3);
|
|
|
-
|
|
|
- return ir_emit_load(proc, addr);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_unary_op(proc, op, x, type));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *right, Type *type) {
|
|
|
- Type *t_left = ir_type(left);
|
|
|
- Type *t_right = ir_type(right);
|
|
|
-
|
|
|
- if (is_type_array(t_left) || is_type_array(t_right)) {
|
|
|
- ir_emit_comment(proc, str_lit("array.arith.begin"));
|
|
|
- // IMPORTANT TODO(bill): This is very wasteful with regards to stack memory
|
|
|
- left = ir_emit_conv(proc, left, type);
|
|
|
- right = ir_emit_conv(proc, right, type);
|
|
|
- irValue *lhs = ir_address_from_load_or_generate_local(proc, left);
|
|
|
- irValue *rhs = ir_address_from_load_or_generate_local(proc, right);
|
|
|
- GB_ASSERT(is_type_array(type));
|
|
|
- Type *elem_type = base_array_type(type);
|
|
|
-
|
|
|
- // NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
|
|
|
- irValue *res = ir_add_local_generated(proc, type, false);
|
|
|
- i64 count = base_type(type)->Array.count;
|
|
|
-
|
|
|
- bool inline_array_arith = type_size_of(type) <= build_context.max_align;
|
|
|
-
|
|
|
- if (inline_array_arith) {
|
|
|
- // inline
|
|
|
- for (i32 i = 0; i < count; i++) {
|
|
|
- irValue *x_ptr = ir_emit_array_epi(proc, lhs, i);
|
|
|
- irValue *y_ptr = ir_emit_array_epi(proc, rhs, i);
|
|
|
- irValue *dst_ptr = ir_emit_array_epi(proc, res, i);
|
|
|
- irValue *x = ir_emit_load(proc, x_ptr);
|
|
|
- irValue *y = ir_emit_load(proc, y_ptr);
|
|
|
- irValue *z = ir_emit_arith(proc, op, x, y, elem_type);
|
|
|
- ir_emit_store(proc, dst_ptr, z);
|
|
|
- }
|
|
|
- } else {
|
|
|
- auto loop_data = ir_loop_start(proc, count, t_i32);
|
|
|
-
|
|
|
- irValue *x_ptr = ir_emit_array_ep(proc, lhs, loop_data.idx);
|
|
|
- irValue *y_ptr = ir_emit_array_ep(proc, rhs, loop_data.idx);
|
|
|
- irValue *dst_ptr = ir_emit_array_ep(proc, res, loop_data.idx);
|
|
|
-
|
|
|
- irValue *x = ir_emit_load(proc, x_ptr);
|
|
|
- irValue *y = ir_emit_load(proc, y_ptr);
|
|
|
- irValue *z = ir_emit_arith(proc, op, x, y, elem_type);
|
|
|
- ir_emit_store(proc, dst_ptr, z);
|
|
|
-
|
|
|
- ir_loop_end(proc, loop_data);
|
|
|
- }
|
|
|
- ir_emit_comment(proc, str_lit("array.arith.end"));
|
|
|
- return ir_emit_load(proc, res);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_complex(t_left)) {
|
|
|
- ir_emit_comment(proc, str_lit("complex.arith.begin"));
|
|
|
- defer (ir_emit_comment(proc, str_lit("complex.arith.end")));
|
|
|
-
|
|
|
- Type *ft = base_complex_elem_type(t_left);
|
|
|
-
|
|
|
- if (op == Token_Quo) {
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = left;
|
|
|
- args[1] = right;
|
|
|
-
|
|
|
- switch (type_size_of(ft)) {
|
|
|
- case 4: return ir_emit_runtime_call(proc, "quo_complex64", args);
|
|
|
- case 8: return ir_emit_runtime_call(proc, "quo_complex128", args);
|
|
|
- default: GB_PANIC("Unknown float type"); break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- irValue *res = ir_add_local_generated(proc, type, false); // NOTE: initialized in full later
|
|
|
- irValue *a = ir_emit_struct_ev(proc, left, 0);
|
|
|
- irValue *b = ir_emit_struct_ev(proc, left, 1);
|
|
|
- irValue *c = ir_emit_struct_ev(proc, right, 0);
|
|
|
- irValue *d = ir_emit_struct_ev(proc, right, 1);
|
|
|
-
|
|
|
- irValue *real = nullptr;
|
|
|
- irValue *imag = nullptr;
|
|
|
-
|
|
|
- switch (op) {
|
|
|
- case Token_Add:
|
|
|
- real = ir_emit_arith(proc, Token_Add, a, c, ft);
|
|
|
- imag = ir_emit_arith(proc, Token_Add, b, d, ft);
|
|
|
- break;
|
|
|
- case Token_Sub:
|
|
|
- real = ir_emit_arith(proc, Token_Sub, a, c, ft);
|
|
|
- imag = ir_emit_arith(proc, Token_Sub, b, d, ft);
|
|
|
- break;
|
|
|
- case Token_Mul: {
|
|
|
- irValue *x = ir_emit_arith(proc, Token_Mul, a, c, ft);
|
|
|
- irValue *y = ir_emit_arith(proc, Token_Mul, b, d, ft);
|
|
|
- real = ir_emit_arith(proc, Token_Sub, x, y, ft);
|
|
|
- irValue *z = ir_emit_arith(proc, Token_Mul, b, c, ft);
|
|
|
- irValue *w = ir_emit_arith(proc, Token_Mul, a, d, ft);
|
|
|
- imag = ir_emit_arith(proc, Token_Add, z, w, ft);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), real);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), imag);
|
|
|
-
|
|
|
- return ir_emit_load(proc, res);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_quaternion(t_left)) {
|
|
|
- ir_emit_comment(proc, str_lit("complex.arith.begin"));
|
|
|
- defer (ir_emit_comment(proc, str_lit("complex.arith.end")));
|
|
|
-
|
|
|
- right = ir_emit_conv(proc, right, t_left);
|
|
|
-
|
|
|
- Type *ft = base_complex_elem_type(t_left);
|
|
|
-
|
|
|
- if (op == Token_Add || op == Token_Sub) {
|
|
|
- irValue *res = ir_add_local_generated(proc, type, false); // NOTE: initialized in full later
|
|
|
- irValue *x0 = ir_emit_struct_ev(proc, left, 0);
|
|
|
- irValue *x1 = ir_emit_struct_ev(proc, left, 1);
|
|
|
- irValue *x2 = ir_emit_struct_ev(proc, left, 2);
|
|
|
- irValue *x3 = ir_emit_struct_ev(proc, left, 3);
|
|
|
-
|
|
|
- irValue *y0 = ir_emit_struct_ev(proc, right, 0);
|
|
|
- irValue *y1 = ir_emit_struct_ev(proc, right, 1);
|
|
|
- irValue *y2 = ir_emit_struct_ev(proc, right, 2);
|
|
|
- irValue *y3 = ir_emit_struct_ev(proc, right, 3);
|
|
|
-
|
|
|
- irValue *z0 = ir_emit_arith(proc, op, x0, y0, ft);
|
|
|
- irValue *z1 = ir_emit_arith(proc, op, x1, y1, ft);
|
|
|
- irValue *z2 = ir_emit_arith(proc, op, x2, y2, ft);
|
|
|
- irValue *z3 = ir_emit_arith(proc, op, x3, y3, ft);
|
|
|
-
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), z0);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), z1);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 2), z2);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 3), z3);
|
|
|
-
|
|
|
- return ir_emit_load(proc, res);
|
|
|
- } else if (op == Token_Mul) {
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = left;
|
|
|
- args[1] = right;
|
|
|
-
|
|
|
- switch (8*type_size_of(ft)) {
|
|
|
- case 32: return ir_emit_runtime_call(proc, "mul_quaternion128", args);
|
|
|
- case 64: return ir_emit_runtime_call(proc, "mul_quaternion256", args);
|
|
|
- default: GB_PANIC("Unknown float type"); break;
|
|
|
- }
|
|
|
- } else if (op == Token_Quo) {
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = left;
|
|
|
- args[1] = right;
|
|
|
-
|
|
|
- switch (8*type_size_of(ft)) {
|
|
|
- case 32: return ir_emit_runtime_call(proc, "quo_quaternion128", args);
|
|
|
- case 64: return ir_emit_runtime_call(proc, "quo_quaternion256", args);
|
|
|
- default: GB_PANIC("Unknown float type"); break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-#if 0
|
|
|
- if (op == Token_Add) {
|
|
|
- if (is_type_pointer(t_left)) {
|
|
|
- irValue *ptr = ir_emit_conv(proc, left, type);
|
|
|
- irValue *offset = right;
|
|
|
- return ir_emit_ptr_offset(proc, ptr, offset);
|
|
|
- } else if (is_type_pointer(ir_type(right))) {
|
|
|
- irValue *ptr = ir_emit_conv(proc, right, type);
|
|
|
- irValue *offset = left;
|
|
|
- return ir_emit_ptr_offset(proc, ptr, offset);
|
|
|
- }
|
|
|
- } else if (op == Token_Sub) {
|
|
|
- if (is_type_pointer(t_left) && is_type_integer(t_right)) {
|
|
|
- // ptr - int
|
|
|
- irValue *ptr = ir_emit_conv(proc, left, type);
|
|
|
- irValue *offset = ir_emit_unary_arith(proc, Token_Sub, right, t_int);
|
|
|
- return ir_emit_ptr_offset(proc, ptr, offset);
|
|
|
- } else if (is_type_pointer(t_left) && is_type_pointer(t_right)) {
|
|
|
- GB_ASSERT(is_type_integer(type));
|
|
|
- irModule *m = proc->module;
|
|
|
- Type *ptr_type = base_type(t_left);
|
|
|
- GB_ASSERT(!is_type_rawptr(ptr_type));
|
|
|
- irValue *elem_size = ir_const_int(type_size_of(ptr_type->Pointer.elem));
|
|
|
- irValue *x = ir_emit_conv(proc, ir_emit_conv(proc, left, t_uintptr), type);
|
|
|
- irValue *y = ir_emit_conv(proc, ir_emit_conv(proc, right, t_uintptr), type);
|
|
|
- irValue *diff = ir_emit_arith(proc, op, x, y, type);
|
|
|
- return ir_emit_arith(proc, Token_Quo, diff, elem_size, type);
|
|
|
- }
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
- if (is_type_integer(type) && is_type_different_to_arch_endianness(type)) {
|
|
|
- switch (op) {
|
|
|
- case Token_AndNot:
|
|
|
- case Token_And:
|
|
|
- case Token_Or:
|
|
|
- case Token_Xor:
|
|
|
- goto handle_op;
|
|
|
- }
|
|
|
- Type *platform_type = integer_endian_type_to_platform_type(type);
|
|
|
- irValue *x = ir_emit_conv(proc, left, integer_endian_type_to_platform_type(t_left));
|
|
|
- irValue *y = ir_emit_conv(proc, right, integer_endian_type_to_platform_type(t_right));
|
|
|
-
|
|
|
- irValue *res = ir_emit_arith(proc, op, x, y, platform_type);
|
|
|
-
|
|
|
- return ir_emit_byte_swap(proc, res, type);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_float(type) && is_type_different_to_arch_endianness(type)) {
|
|
|
- Type *platform_type = integer_endian_type_to_platform_type(type);
|
|
|
- irValue *x = ir_emit_conv(proc, left, integer_endian_type_to_platform_type(t_left));
|
|
|
- irValue *y = ir_emit_conv(proc, right, integer_endian_type_to_platform_type(t_right));
|
|
|
-
|
|
|
- irValue *res = ir_emit_arith(proc, op, x, y, platform_type);
|
|
|
-
|
|
|
- return ir_emit_byte_swap(proc, res, type);
|
|
|
- }
|
|
|
-
|
|
|
-handle_op:
|
|
|
-
|
|
|
- // NOTE(bill): Bit Set Aliases for + and -
|
|
|
- if (is_type_bit_set(type)) {
|
|
|
- switch (op) {
|
|
|
- case Token_Add: op = Token_Or; break;
|
|
|
- case Token_Sub: op = Token_AndNot; break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- switch (op) {
|
|
|
- case Token_Shl:
|
|
|
- {
|
|
|
- left = ir_emit_conv(proc, left, type);
|
|
|
- right = ir_emit_conv(proc, right, type);
|
|
|
- ir_emit(proc, ir_instr_binary_op(proc, op, left, right, type));
|
|
|
-
|
|
|
- irValue *bits = right;
|
|
|
-
|
|
|
- irValue *bit_size = ir_value_constant(type, exact_value_i64(8*type_size_of(type)));
|
|
|
- irValue *width_test = ir_emit(proc, ir_instr_binary_op(proc, Token_Lt, bits, bit_size, t_llvm_bool));
|
|
|
-
|
|
|
- irValue *zero = ir_value_constant(type, exact_value_i64(0));
|
|
|
- irValue *res = ir_emit(proc, ir_instr_binary_op(proc, op, left, bits, type));
|
|
|
- return ir_emit_select(proc, width_test, res, zero);
|
|
|
- }
|
|
|
- case Token_Shr:
|
|
|
- {
|
|
|
- left = ir_emit_conv(proc, left, type);
|
|
|
- right = ir_emit_conv(proc, right, type);
|
|
|
- bool is_unsigned = is_type_unsigned(ir_type(left));
|
|
|
-
|
|
|
- irValue *bits = right;
|
|
|
-
|
|
|
- irValue *bit_size = ir_value_constant(type, exact_value_i64(8*type_size_of(type)));
|
|
|
- irValue *width_test = ir_emit(proc, ir_instr_binary_op(proc, Token_Lt, bits, bit_size, t_llvm_bool));
|
|
|
-
|
|
|
- irValue *zero = ir_value_constant(type, exact_value_i64(0));
|
|
|
- irValue *res = ir_emit(proc, ir_instr_binary_op(proc, op, left, bits, type));
|
|
|
- return ir_emit_select(proc, width_test, res, zero);
|
|
|
- }
|
|
|
-
|
|
|
- case Token_AndNot: {
|
|
|
- // NOTE(bill): x &~ y == x & (~y) == x & (y ~ -1)
|
|
|
- // NOTE(bill): "not" 'x' == 'x' "xor" '-1'
|
|
|
- irValue *neg = ir_add_module_constant(proc->module, type, exact_value_i64(-1));
|
|
|
- op = Token_Xor;
|
|
|
- right = ir_emit_arith(proc, op, right, neg, type);
|
|
|
- GB_ASSERT(right->Instr.kind == irInstr_BinaryOp);
|
|
|
- right->Instr.BinaryOp.type = type;
|
|
|
- op = Token_And;
|
|
|
- } /* fallthrough */
|
|
|
- case Token_Add:
|
|
|
- case Token_Sub:
|
|
|
- case Token_Mul:
|
|
|
- case Token_Quo:
|
|
|
- case Token_Mod:
|
|
|
- case Token_ModMod:
|
|
|
- case Token_And:
|
|
|
- case Token_Or:
|
|
|
- case Token_Xor:
|
|
|
- left = ir_emit_conv(proc, left, type);
|
|
|
- right = ir_emit_conv(proc, right, type);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if (op == Token_ModMod) {
|
|
|
- if (is_type_unsigned(type)) {
|
|
|
- op = Token_Mod;
|
|
|
- } else {
|
|
|
- irValue *a = ir_emit_arith(proc, Token_Mod, left, right, type);
|
|
|
- irValue *b = ir_emit_arith(proc, Token_Add, a, right, type);
|
|
|
- return ir_emit_arith(proc, Token_Mod, b, right, type);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_binary_op(proc, op, left, right, type));
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_union_tag_ptr(irProcedure *proc, irValue *u) {
|
|
|
- Type *t = ir_type(u);
|
|
|
- GB_ASSERT_MSG(is_type_pointer(t) &&
|
|
|
- is_type_union(type_deref(t)), "%s", type_to_string(t));
|
|
|
- irValue *tag_ptr = ir_emit(proc, ir_instr_union_tag_ptr(proc, u));
|
|
|
- return tag_ptr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_union_tag_value(irProcedure *proc, irValue *u) {
|
|
|
- Type *t = ir_type(u);
|
|
|
- GB_ASSERT(is_type_union(t));
|
|
|
- GB_ASSERT(are_types_identical(t, ir_type(u)));
|
|
|
- return ir_emit(proc, ir_instr_union_tag_value(proc, u));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_comp_against_nil(irProcedure *proc, TokenKind op_kind, irValue *x) {
|
|
|
- Type *t = ir_type(x);
|
|
|
- if (is_type_pointer(t)) {
|
|
|
- return ir_emit_comp(proc, op_kind, x, v_raw_nil);
|
|
|
- } else if (is_type_cstring(t)) {
|
|
|
- irValue *ptr = ir_emit_conv(proc, x, t_u8_ptr);
|
|
|
- return ir_emit_comp(proc, op_kind, ptr, v_raw_nil);
|
|
|
- } else if (is_type_any(t)) {
|
|
|
- // TODO(bill): is this correct behaviour for nil comparison for any?
|
|
|
- irValue *data = ir_emit_struct_ev(proc, x, 0);
|
|
|
- irValue *ti = ir_emit_struct_ev(proc, x, 1);
|
|
|
- if (op_kind == Token_CmpEq) {
|
|
|
- irValue *a = ir_emit_comp(proc, Token_CmpEq, data, v_raw_nil);
|
|
|
- irValue *b = ir_emit_comp(proc, Token_CmpEq, ti, v_raw_nil);
|
|
|
- return ir_emit_arith(proc, Token_Or, a, b, t_bool);
|
|
|
- } else if (op_kind == Token_NotEq) {
|
|
|
- irValue *a = ir_emit_comp(proc, Token_NotEq, data, v_raw_nil);
|
|
|
- irValue *b = ir_emit_comp(proc, Token_NotEq, ti, v_raw_nil);
|
|
|
- return ir_emit_arith(proc, Token_And, a, b, t_bool);
|
|
|
- }
|
|
|
- } else if (is_type_slice(t)) {
|
|
|
- irValue *len = ir_emit_struct_ev(proc, x, 1);
|
|
|
- return ir_emit_comp(proc, op_kind, len, v_zero);
|
|
|
- } else if (is_type_dynamic_array(t)) {
|
|
|
- irValue *cap = ir_emit_struct_ev(proc, x, 2);
|
|
|
- return ir_emit_comp(proc, op_kind, cap, v_zero);
|
|
|
- } else if (is_type_map(t)) {
|
|
|
- irValue *cap = ir_map_cap(proc, x);
|
|
|
- return ir_emit_comp(proc, op_kind, cap, v_zero);
|
|
|
- } else if (is_type_union(t)) {
|
|
|
- if (type_size_of(t) == 0) {
|
|
|
- return ir_emit_comp(proc, op_kind, v_zero, v_zero);
|
|
|
- } else if (is_type_union_maybe_pointer(t)) {
|
|
|
- Type *bt = base_type(t);
|
|
|
- irValue *ptr = ir_address_from_load_or_generate_local(proc, x);
|
|
|
- ptr = ir_emit_bitcast(proc, ptr, alloc_type_pointer(bt->Union.variants[0]));
|
|
|
- irValue *data = ir_emit_load(proc, ptr);
|
|
|
- return ir_emit_comp_against_nil(proc, op_kind, data);
|
|
|
- } else {
|
|
|
- irValue *tag = ir_emit_union_tag_value(proc, x);
|
|
|
- return ir_emit_comp(proc, op_kind, tag, v_zero);
|
|
|
- }
|
|
|
- } else if (is_type_typeid(t)) {
|
|
|
- irValue *invalid_typeid = ir_value_constant(t_typeid, exact_value_i64(0));
|
|
|
- return ir_emit_comp(proc, op_kind, x, invalid_typeid);
|
|
|
- } else if (is_type_soa_struct(t)) {
|
|
|
- Type *bt = base_type(t);
|
|
|
- if (bt->Struct.soa_kind == StructSoa_Slice) {
|
|
|
- ir_emit_comment(proc, str_lit("soa-slice-nil-comp"));
|
|
|
- irValue *len = ir_soa_struct_len(proc, x);
|
|
|
- return ir_emit_comp(proc, op_kind, len, v_zero);
|
|
|
- } else if (bt->Struct.soa_kind == StructSoa_Dynamic) {
|
|
|
- ir_emit_comment(proc, str_lit("soa-dynamic-array-nil-comp"));
|
|
|
-
|
|
|
- irValue *cap = ir_soa_struct_cap(proc, x);
|
|
|
- return ir_emit_comp(proc, op_kind, cap, v_zero);
|
|
|
- }
|
|
|
- } else if (is_type_struct(t) && type_has_nil(t)) {
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- irValue *lhs = ir_address_from_load_or_generate_local(proc, x);
|
|
|
- args[0] = ir_emit_conv(proc, lhs, t_rawptr);
|
|
|
- args[1] = ir_const_int(type_size_of(t));
|
|
|
- irValue *val = ir_emit_runtime_call(proc, "memory_compare_zero", args);
|
|
|
- irValue *res = ir_emit_comp(proc, op_kind, val, v_zero);
|
|
|
- return ir_emit_conv(proc, res, t_bool);
|
|
|
- }
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_get_equal_proc_for_type(irModule *m, Type *type) {
|
|
|
- Type *original_type = type;
|
|
|
- type = base_type(type);
|
|
|
- Type *pt = alloc_type_pointer(type);
|
|
|
-
|
|
|
- auto key = hash_type(type);
|
|
|
- irValue **found = map_get(&m->equal_procs, key);
|
|
|
- if (found) {
|
|
|
- return *found;
|
|
|
- }
|
|
|
-
|
|
|
- static u32 proc_index = 0;
|
|
|
-
|
|
|
- char buf[16] = {};
|
|
|
- isize n = gb_snprintf(buf, 16, "__$equal%u", ++proc_index);
|
|
|
- char *str = gb_alloc_str_len(permanent_allocator(), buf, n-1);
|
|
|
- String proc_name = make_string_c(str);
|
|
|
-
|
|
|
-
|
|
|
- Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
|
|
|
- Entity *e = alloc_entity_procedure(nullptr, make_token_ident(proc_name), t_equal_proc, 0);
|
|
|
- e->Procedure.link_name = proc_name;
|
|
|
- irValue *p = ir_value_procedure(m, e, t_equal_proc, nullptr, body, proc_name);
|
|
|
- map_set(&m->values, hash_entity(e), p);
|
|
|
- string_map_set(&m->members, proc_name, p);
|
|
|
- map_set(&m->equal_procs, key, p);
|
|
|
-
|
|
|
- irProcedure *proc = &p->Proc;
|
|
|
- proc->is_startup = true;
|
|
|
- proc->ignore_dead_instr = true;
|
|
|
- ir_begin_procedure_body(proc);
|
|
|
- // ir_start_block(proc, proc->decl_block);
|
|
|
- GB_ASSERT(proc->curr_block != nullptr);
|
|
|
-
|
|
|
- irValue *x = proc->params[0];
|
|
|
- irValue *y = proc->params[1];
|
|
|
- irValue *lhs = ir_emit_conv(proc, x, pt);
|
|
|
- irValue *rhs = ir_emit_conv(proc, y, pt);
|
|
|
-
|
|
|
- irBlock *block_same_ptr = ir_new_block(proc, nullptr, "same_ptr");
|
|
|
- irBlock *block_diff_ptr = ir_new_block(proc, nullptr, "diff_ptr");
|
|
|
-
|
|
|
- irValue *same_ptr = ir_emit_comp(proc, Token_CmpEq, lhs, rhs);
|
|
|
- ir_emit_if(proc, same_ptr, block_same_ptr, block_diff_ptr);
|
|
|
- ir_start_block(proc, block_same_ptr);
|
|
|
- ir_emit(proc, ir_instr_return(proc, ir_const_bool(true)));
|
|
|
-
|
|
|
- ir_start_block(proc, block_diff_ptr);
|
|
|
-
|
|
|
- if (type->kind == Type_Struct) {
|
|
|
- type_set_offsets(type);
|
|
|
-
|
|
|
- irBlock *done = ir_new_block(proc, nullptr, "done"); // NOTE(bill): Append later
|
|
|
-
|
|
|
- irBlock *block_false = ir_new_block(proc, nullptr, "bfalse");
|
|
|
-
|
|
|
- for_array(i, type->Struct.fields) {
|
|
|
- irBlock *next_block = ir_new_block(proc, nullptr, "btrue");
|
|
|
-
|
|
|
- irValue *pleft = ir_emit_struct_ep(proc, lhs, cast(i32)i);
|
|
|
- irValue *pright = ir_emit_struct_ep(proc, rhs, cast(i32)i);
|
|
|
- irValue *left = ir_emit_load(proc, pleft);
|
|
|
- irValue *right = ir_emit_load(proc, pright);
|
|
|
- irValue *ok = ir_emit_comp(proc, Token_CmpEq, left, right);
|
|
|
-
|
|
|
- ir_emit_if(proc, ok, next_block, block_false);
|
|
|
-
|
|
|
- ir_emit_jump(proc, next_block);
|
|
|
- ir_start_block(proc, next_block);
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, block_false);
|
|
|
-
|
|
|
- ir_emit(proc, ir_instr_return(proc, ir_const_bool(false)));
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
- ir_emit(proc, ir_instr_return(proc, ir_const_bool(true)));
|
|
|
- } else {
|
|
|
- irValue *left = ir_emit_load(proc, lhs);
|
|
|
- irValue *right = ir_emit_load(proc, rhs);
|
|
|
- irValue *ok = ir_emit_comp(proc, Token_CmpEq, left, right);
|
|
|
- ok = ir_emit_conv(proc, ok, t_bool);
|
|
|
- ir_emit(proc, ir_instr_return(proc, ok));
|
|
|
- }
|
|
|
-
|
|
|
- ir_end_procedure_body(proc);
|
|
|
-
|
|
|
- return p;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_simple_compare_hash(irProcedure *p, Type *type, irValue *data, irValue *seed) {
|
|
|
- GB_ASSERT_MSG(is_type_simple_compare(type), "%s", type_to_string(type));
|
|
|
-
|
|
|
- i64 sz = type_size_of(type);
|
|
|
- if (1 <= sz && sz <= 16) {
|
|
|
- char name[20] = {};
|
|
|
- gb_snprintf(name, 20, "default_hasher%d", cast(i32)sz);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = data;
|
|
|
- args[1] = seed;
|
|
|
- return ir_emit_runtime_call(p, name, args);
|
|
|
- }
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 3);
|
|
|
- args[0] = data;
|
|
|
- args[1] = seed;
|
|
|
- args[2] = ir_const_int(type_size_of(type));
|
|
|
- return ir_emit_runtime_call(p, "default_hasher_n", args);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_get_hasher_proc_for_type(irModule *m, Type *type) {
|
|
|
- Type *original_type = type;
|
|
|
- type = core_type(type);
|
|
|
- Type *pt = alloc_type_pointer(type);
|
|
|
-
|
|
|
- GB_ASSERT(is_type_valid_for_keys(type));
|
|
|
-
|
|
|
- auto key = hash_type(type);
|
|
|
- irValue **found = map_get(&m->hasher_procs, key);
|
|
|
- if (found) {
|
|
|
- return *found;
|
|
|
- }
|
|
|
-
|
|
|
- static u32 proc_index = 0;
|
|
|
-
|
|
|
- char buf[16] = {};
|
|
|
- isize n = gb_snprintf(buf, 16, "__$hasher%u", ++proc_index);
|
|
|
- char *str = gb_alloc_str_len(permanent_allocator(), buf, n-1);
|
|
|
- String proc_name = make_string_c(str);
|
|
|
-
|
|
|
-
|
|
|
- Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
|
|
|
- Entity *e = alloc_entity_procedure(nullptr, make_token_ident(proc_name), t_hasher_proc, 0);
|
|
|
- e->Procedure.link_name = proc_name;
|
|
|
- irValue *p = ir_value_procedure(m, e, t_hasher_proc, nullptr, body, proc_name);
|
|
|
- map_set(&m->values, hash_entity(e), p);
|
|
|
- string_map_set(&m->members, proc_name, p);
|
|
|
- map_set(&m->hasher_procs, key, p);
|
|
|
-
|
|
|
- irProcedure *proc = &p->Proc;
|
|
|
- proc->is_startup = true;
|
|
|
- proc->ignore_dead_instr = true;
|
|
|
- ir_begin_procedure_body(proc);
|
|
|
- defer (ir_end_procedure_body(proc));
|
|
|
-
|
|
|
- // ir_start_block(proc, proc->decl_block);
|
|
|
- GB_ASSERT(proc->curr_block != nullptr);
|
|
|
-
|
|
|
- irValue *data = proc->params[0];
|
|
|
- irValue *seed = proc->params[1];
|
|
|
-
|
|
|
- if (is_type_simple_compare(type)) {
|
|
|
- irValue *res = ir_simple_compare_hash(proc, type, data, seed);
|
|
|
- ir_emit(proc, ir_instr_return(proc, res));
|
|
|
- return p;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_cstring(type)) {
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = data;
|
|
|
- args[1] = seed;
|
|
|
- irValue *res = ir_emit_runtime_call(proc, "default_hasher_cstring", args);
|
|
|
- ir_emit(proc, ir_instr_return(proc, res));
|
|
|
- } else if (is_type_string(type)) {
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = data;
|
|
|
- args[1] = seed;
|
|
|
- irValue *res = ir_emit_runtime_call(proc, "default_hasher_string", args);
|
|
|
- ir_emit(proc, ir_instr_return(proc, res));
|
|
|
- } else if (type->kind == Type_Struct) {
|
|
|
- type_set_offsets(type);
|
|
|
- data = ir_emit_conv(proc, data, t_u8_ptr);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- for_array(i, type->Struct.fields) {
|
|
|
- i64 offset = type->Struct.offsets[i];
|
|
|
- Entity *field = type->Struct.fields[i];
|
|
|
- irValue *field_hasher = ir_get_hasher_proc_for_type(m, field->type);
|
|
|
- irValue *ptr = ir_emit_ptr_offset(proc, data, ir_const_uintptr(offset));
|
|
|
-
|
|
|
- args[0] = ptr;
|
|
|
- args[1] = seed;
|
|
|
- seed = ir_emit_call(proc, field_hasher, args);
|
|
|
- }
|
|
|
- ir_emit(proc, ir_instr_return(proc, seed));
|
|
|
- } else if (type->kind == Type_Array) {
|
|
|
- irValue *pres = ir_add_local_generated(proc, t_uintptr, false);
|
|
|
- ir_emit_store(proc, pres, seed);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- irValue *elem_hasher = ir_get_hasher_proc_for_type(m, type->Array.elem);
|
|
|
-
|
|
|
- auto loop_data = ir_loop_start(proc, type->Array.count, t_i32);
|
|
|
-
|
|
|
- data = ir_emit_conv(proc, data, pt);
|
|
|
-
|
|
|
- irValue *ptr = ir_emit_array_ep(proc, data, loop_data.idx);
|
|
|
- args[0] = ptr;
|
|
|
- args[1] = ir_emit_load(proc, pres);
|
|
|
- irValue *new_seed = ir_emit_call(proc, elem_hasher, args);
|
|
|
- ir_emit_store(proc, pres, new_seed);
|
|
|
-
|
|
|
- ir_loop_end(proc, loop_data);
|
|
|
-
|
|
|
- irValue *res = ir_emit_load(proc, pres);
|
|
|
- ir_emit(proc, ir_instr_return(proc, res));
|
|
|
- } else if (type->kind == Type_EnumeratedArray) {
|
|
|
- irValue *pres = ir_add_local_generated(proc, t_uintptr, false);
|
|
|
- ir_emit_store(proc, pres, seed);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- irValue *elem_hasher = ir_get_hasher_proc_for_type(m, type->Array.elem);
|
|
|
-
|
|
|
- auto loop_data = ir_loop_start(proc, type->Array.count, t_i32);
|
|
|
-
|
|
|
- data = ir_emit_conv(proc, data, pt);
|
|
|
-
|
|
|
- irValue *ptr = ir_emit_array_ep(proc, data, loop_data.idx);
|
|
|
- args[0] = ptr;
|
|
|
- args[1] = ir_emit_load(proc, pres);
|
|
|
- irValue *new_seed = ir_emit_call(proc, elem_hasher, args);
|
|
|
- ir_emit_store(proc, pres, new_seed);
|
|
|
-
|
|
|
- ir_loop_end(proc, loop_data);
|
|
|
-
|
|
|
- irValue *res = ir_emit_load(proc, pres);
|
|
|
- ir_emit(proc, ir_instr_return(proc, res));
|
|
|
- } else {
|
|
|
- GB_PANIC("Unhandled type for hasher: %s", type_to_string(type));
|
|
|
- }
|
|
|
-
|
|
|
- return p;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_comp(irProcedure *proc, TokenKind op_kind, irValue *left, irValue *right) {
|
|
|
- Type *a = base_type(ir_type(left));
|
|
|
- Type *b = base_type(ir_type(right));
|
|
|
-
|
|
|
- GB_ASSERT(gb_is_between(op_kind, Token__ComparisonBegin+1, Token__ComparisonEnd-1));
|
|
|
-
|
|
|
- irValue *nil_check = nullptr;
|
|
|
- if (left->kind == irValue_Nil) {
|
|
|
- nil_check = ir_emit_comp_against_nil(proc, op_kind, right);
|
|
|
- } else if (right->kind == irValue_Nil) {
|
|
|
- nil_check = ir_emit_comp_against_nil(proc, op_kind, left);
|
|
|
- }
|
|
|
- if (nil_check != nullptr) {
|
|
|
- return nil_check;
|
|
|
- }
|
|
|
-
|
|
|
- if (are_types_identical(a, b)) {
|
|
|
- // NOTE(bill): No need for a conversion
|
|
|
- } else if (left->kind == irValue_Constant || left->kind == irValue_Nil) {
|
|
|
- left = ir_emit_conv(proc, left, ir_type(right));
|
|
|
- } else if (right->kind == irValue_Constant || right->kind == irValue_Nil) {
|
|
|
- right = ir_emit_conv(proc, right, ir_type(left));
|
|
|
- } else {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
-
|
|
|
- Type *lt = ir_type(left);
|
|
|
- Type *rt = ir_type(right);
|
|
|
-
|
|
|
- // if (is_type_bit_set(lt) && is_type_bit_set(rt)) {
|
|
|
- // Type *blt = base_type(lt);
|
|
|
- // Type *brt = base_type(rt);
|
|
|
- // i64 bits = gb_max(blt->BitFieldValue.bits, brt->BitFieldValue.bits);
|
|
|
- // i64 bytes = bits / 8;
|
|
|
- // switch (bytes) {
|
|
|
- // case 1:
|
|
|
- // left = ir_emit_conv(proc, left, t_u8);
|
|
|
- // right = ir_emit_conv(proc, right, t_u8);
|
|
|
- // break;
|
|
|
- // case 2:
|
|
|
- // left = ir_emit_conv(proc, left, t_u16);
|
|
|
- // right = ir_emit_conv(proc, right, t_u16);
|
|
|
- // break;
|
|
|
- // case 4:
|
|
|
- // left = ir_emit_conv(proc, left, t_u32);
|
|
|
- // right = ir_emit_conv(proc, right, t_u32);
|
|
|
- // break;
|
|
|
- // case 8:
|
|
|
- // left = ir_emit_conv(proc, left, t_u64);
|
|
|
- // right = ir_emit_conv(proc, right, t_u64);
|
|
|
- // break;
|
|
|
- // default: GB_PANIC("Unknown integer size"); break;
|
|
|
- // }
|
|
|
- // }
|
|
|
-
|
|
|
- lt = ir_type(left);
|
|
|
- rt = ir_type(right);
|
|
|
- i64 ls = type_size_of(lt);
|
|
|
- i64 rs = type_size_of(rt);
|
|
|
- if (ls < rs) {
|
|
|
- left = ir_emit_conv(proc, left, rt);
|
|
|
- } else if (ls > rs) {
|
|
|
- right = ir_emit_conv(proc, right, lt);
|
|
|
- } else {
|
|
|
- right = ir_emit_conv(proc, right, lt);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_array(a)) {
|
|
|
- ir_emit_comment(proc, str_lit("array.comp.begin"));
|
|
|
- defer (ir_emit_comment(proc, str_lit("array.comp.end")));
|
|
|
-
|
|
|
- Type *tl = base_type(a);
|
|
|
- irValue *lhs = ir_address_from_load_or_generate_local(proc, left);
|
|
|
- irValue *rhs = ir_address_from_load_or_generate_local(proc, right);
|
|
|
-
|
|
|
-
|
|
|
- TokenKind cmp_op = Token_And;
|
|
|
- irValue *res = v_true;
|
|
|
- if (op_kind == Token_NotEq) {
|
|
|
- res = v_false;
|
|
|
- cmp_op = Token_Or;
|
|
|
- } else if (op_kind == Token_CmpEq) {
|
|
|
- res = v_true;
|
|
|
- cmp_op = Token_And;
|
|
|
- }
|
|
|
-
|
|
|
- bool inline_array_arith = type_size_of(tl) <= build_context.max_align;
|
|
|
- i32 count = cast(i32)tl->Array.count;
|
|
|
-
|
|
|
- if (inline_array_arith) {
|
|
|
- // inline
|
|
|
- irValue *val = ir_add_local_generated(proc, t_bool, false);
|
|
|
- ir_emit_store(proc, val, res);
|
|
|
- for (i32 i = 0; i < count; i++) {
|
|
|
- irValue *x = ir_emit_load(proc, ir_emit_array_epi(proc, lhs, i));
|
|
|
- irValue *y = ir_emit_load(proc, ir_emit_array_epi(proc, rhs, i));
|
|
|
- irValue *cmp = ir_emit_comp(proc, op_kind, x, y);
|
|
|
- irValue *new_res = ir_emit_arith(proc, cmp_op, ir_emit_load(proc, val), cmp, t_bool);
|
|
|
- ir_emit_store(proc, val, ir_emit_conv(proc, new_res, t_bool));
|
|
|
- }
|
|
|
-
|
|
|
- return ir_emit_load(proc, val);
|
|
|
- } else {
|
|
|
- if (is_type_simple_compare(tl) && (op_kind == Token_CmpEq || op_kind == Token_NotEq)) {
|
|
|
- // TODO(bill): Test to see if this is actually faster!!!!
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 3);
|
|
|
- args[0] = ir_emit_conv(proc, lhs, t_rawptr);
|
|
|
- args[1] = ir_emit_conv(proc, rhs, t_rawptr);
|
|
|
- args[2] = ir_const_int(type_size_of(tl));
|
|
|
- irValue *val = ir_emit_runtime_call(proc, "memory_compare", args);
|
|
|
- irValue *res = ir_emit_comp(proc, op_kind, val, v_zero);
|
|
|
- return ir_emit_conv(proc, res, t_bool);
|
|
|
- } else {
|
|
|
- irValue *val = ir_add_local_generated(proc, t_bool, false);
|
|
|
- ir_emit_store(proc, val, res);
|
|
|
- auto loop_data = ir_loop_start(proc, count, t_i32);
|
|
|
- {
|
|
|
- irValue *i = loop_data.idx;
|
|
|
- irValue *x = ir_emit_load(proc, ir_emit_array_ep(proc, lhs, i));
|
|
|
- irValue *y = ir_emit_load(proc, ir_emit_array_ep(proc, rhs, i));
|
|
|
- irValue *cmp = ir_emit_comp(proc, op_kind, x, y);
|
|
|
- irValue *new_res = ir_emit_arith(proc, cmp_op, ir_emit_load(proc, val), cmp, t_bool);
|
|
|
- ir_emit_store(proc, val, ir_emit_conv(proc, new_res, t_bool));
|
|
|
- }
|
|
|
- ir_loop_end(proc, loop_data);
|
|
|
-
|
|
|
- return ir_emit_load(proc, val);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_struct(a) && is_type_comparable(a)) {
|
|
|
- irValue *left_ptr = ir_address_from_load_or_generate_local(proc, left);
|
|
|
- irValue *right_ptr = ir_address_from_load_or_generate_local(proc, right);
|
|
|
- irValue *res = {};
|
|
|
- if (is_type_simple_compare(a)) {
|
|
|
- // TODO(bill): Test to see if this is actually faster!!!!
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 3);
|
|
|
- args[0] = ir_emit_conv(proc, left_ptr, t_rawptr);
|
|
|
- args[1] = ir_emit_conv(proc, right_ptr, t_rawptr);
|
|
|
- args[2] = ir_const_int(type_size_of(a));
|
|
|
- res = ir_emit_runtime_call(proc, "memory_equal", args);
|
|
|
- } else {
|
|
|
- irValue *value = ir_get_equal_proc_for_type(proc->module, a);
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = ir_emit_conv(proc, left_ptr, t_rawptr);
|
|
|
- args[1] = ir_emit_conv(proc, right_ptr, t_rawptr);
|
|
|
- res = ir_emit_call(proc, value, args);
|
|
|
- }
|
|
|
- if (op_kind == Token_NotEq) {
|
|
|
- res = ir_emit_unary_arith(proc, Token_Not, res, ir_type(res));
|
|
|
- }
|
|
|
- return res;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_string(a)) {
|
|
|
- if (is_type_cstring(a)) {
|
|
|
- left = ir_emit_conv(proc, left, t_string);
|
|
|
- right = ir_emit_conv(proc, right, t_string);
|
|
|
- }
|
|
|
-
|
|
|
- char const *runtime_proc = nullptr;
|
|
|
- switch (op_kind) {
|
|
|
- case Token_CmpEq: runtime_proc = "string_eq"; break;
|
|
|
- case Token_NotEq: runtime_proc = "string_ne"; break;
|
|
|
- case Token_Lt: runtime_proc = "string_lt"; break;
|
|
|
- case Token_Gt: runtime_proc = "string_gt"; break;
|
|
|
- case Token_LtEq: runtime_proc = "string_le"; break;
|
|
|
- case Token_GtEq: runtime_proc = "string_gt"; break;
|
|
|
- }
|
|
|
- GB_ASSERT(runtime_proc != nullptr);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = left;
|
|
|
- args[1] = right;
|
|
|
- return ir_emit_runtime_call(proc, runtime_proc, args);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_complex(a)) {
|
|
|
- char const *runtime_proc = "";
|
|
|
- i64 sz = 8*type_size_of(a);
|
|
|
- switch (sz) {
|
|
|
- case 64:
|
|
|
- switch (op_kind) {
|
|
|
- case Token_CmpEq: runtime_proc = "complex64_eq"; break;
|
|
|
- case Token_NotEq: runtime_proc = "complex64_ne"; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- case 128:
|
|
|
- switch (op_kind) {
|
|
|
- case Token_CmpEq: runtime_proc = "complex128_eq"; break;
|
|
|
- case Token_NotEq: runtime_proc = "complex128_ne"; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- GB_ASSERT(runtime_proc != nullptr);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = left;
|
|
|
- args[1] = right;
|
|
|
- return ir_emit_runtime_call(proc, runtime_proc, args);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_quaternion(a)) {
|
|
|
- char const *runtime_proc = "";
|
|
|
- i64 sz = 8*type_size_of(a);
|
|
|
- switch (sz) {
|
|
|
- case 128:
|
|
|
- switch (op_kind) {
|
|
|
- case Token_CmpEq: runtime_proc = "quaternion128_eq"; break;
|
|
|
- case Token_NotEq: runtime_proc = "quaternion128_ne"; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- case 256:
|
|
|
- switch (op_kind) {
|
|
|
- case Token_CmpEq: runtime_proc = "quaternion256_eq"; break;
|
|
|
- case Token_NotEq: runtime_proc = "quaternion256_ne"; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- GB_ASSERT(runtime_proc != nullptr);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = left;
|
|
|
- args[1] = right;
|
|
|
- return ir_emit_runtime_call(proc, runtime_proc, args);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_bit_set(a)) {
|
|
|
- switch (op_kind) {
|
|
|
- case Token_Lt:
|
|
|
- case Token_LtEq:
|
|
|
- case Token_Gt:
|
|
|
- case Token_GtEq:
|
|
|
- {
|
|
|
- Type *it = bit_set_to_int(a);
|
|
|
- irValue *lhs = ir_emit_bitcast(proc, left, it);
|
|
|
- irValue *rhs = ir_emit_bitcast(proc, right, it);
|
|
|
- irValue *res = ir_emit_arith(proc, Token_And, lhs, rhs, it);
|
|
|
-
|
|
|
- if (op_kind == Token_Lt || op_kind == Token_LtEq) {
|
|
|
- // (lhs & rhs) == lhs
|
|
|
- res = ir_emit(proc, ir_instr_binary_op(proc, Token_CmpEq, res, lhs, t_llvm_bool));
|
|
|
- } else if (op_kind == Token_Gt || op_kind == Token_GtEq) {
|
|
|
- // (lhs & rhs) == rhs
|
|
|
- res = ir_emit(proc, ir_instr_binary_op(proc, Token_CmpEq, res, rhs, t_llvm_bool));
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(bill): Strict subsets
|
|
|
- if (op_kind == Token_Lt || op_kind == Token_Gt) {
|
|
|
- // res &~ (lhs == rhs)
|
|
|
- irValue *eq = ir_emit(proc, ir_instr_binary_op(proc, Token_CmpEq, lhs, rhs, t_llvm_bool));
|
|
|
- res = ir_emit_arith(proc, Token_AndNot, res, eq, t_llvm_bool);
|
|
|
- }
|
|
|
-
|
|
|
- return res;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (op_kind != Token_CmpEq && op_kind != Token_NotEq) {
|
|
|
- Type *t = ir_type(left);
|
|
|
- if (is_type_integer(t) && is_type_different_to_arch_endianness(t)) {
|
|
|
- Type *platform_type = integer_endian_type_to_platform_type(t);
|
|
|
- irValue *x = ir_emit_byte_swap(proc, left, platform_type);
|
|
|
- irValue *y = ir_emit_byte_swap(proc, right, platform_type);
|
|
|
- return ir_emit(proc, ir_instr_binary_op(proc, op_kind, x, y, t_llvm_bool));
|
|
|
- } else if (is_type_float(t) && is_type_different_to_arch_endianness(t)) {
|
|
|
- Type *platform_type = integer_endian_type_to_platform_type(t);
|
|
|
- irValue *x = ir_emit_conv(proc, left, platform_type);
|
|
|
- irValue *y = ir_emit_conv(proc, right, platform_type);
|
|
|
- return ir_emit(proc, ir_instr_binary_op(proc, op_kind, x, y, t_llvm_bool));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_binary_op(proc, op_kind, left, right, t_llvm_bool));
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_array_ep(irProcedure *proc, irValue *s, irValue *index) {
|
|
|
- GB_ASSERT(index != nullptr);
|
|
|
- Type *t = ir_type(s);
|
|
|
- GB_ASSERT(is_type_pointer(t));
|
|
|
- Type *st = base_type(type_deref(t));
|
|
|
- GB_ASSERT_MSG(is_type_array(st) || is_type_enumerated_array(st), "%s", type_to_string(st));
|
|
|
-
|
|
|
- // NOTE(bill): For some weird legacy reason in LLVM, structure elements must be accessed as an i32
|
|
|
- index = ir_emit_conv(proc, index, t_i32);
|
|
|
- return ir_emit(proc, ir_instr_array_element_ptr(proc, s, index));
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_array_epi(irProcedure *proc, irValue *s, i32 index) {
|
|
|
- return ir_emit_array_ep(proc, s, ir_const_i32(index));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_struct_ep(irProcedure *proc, irValue *s, i32 index) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- GB_ASSERT(is_type_pointer(ir_type(s)));
|
|
|
- Type *t = base_type(type_deref(ir_type(s)));
|
|
|
- Type *result_type = nullptr;
|
|
|
-
|
|
|
- if (is_type_relative_pointer(t)) {
|
|
|
- s = ir_addr_get_ptr(proc, ir_addr(s));
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_struct(t)) {
|
|
|
- result_type = alloc_type_pointer(t->Struct.fields[index]->type);
|
|
|
- } else if (is_type_union(t)) {
|
|
|
- GB_ASSERT(index == -1);
|
|
|
- return ir_emit_union_tag_ptr(proc, s);
|
|
|
- } else if (is_type_tuple(t)) {
|
|
|
- GB_ASSERT(t->Tuple.variables.count > 0);
|
|
|
- result_type = alloc_type_pointer(t->Tuple.variables[index]->type);
|
|
|
- } else if (is_type_complex(t)) {
|
|
|
- Type *ft = base_complex_elem_type(t);
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(ft); break;
|
|
|
- case 1: result_type = alloc_type_pointer(ft); break;
|
|
|
- }
|
|
|
- } else if (is_type_quaternion(t)) {
|
|
|
- Type *ft = base_complex_elem_type(t);
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(ft); break;
|
|
|
- case 1: result_type = alloc_type_pointer(ft); break;
|
|
|
- case 2: result_type = alloc_type_pointer(ft); break;
|
|
|
- case 3: result_type = alloc_type_pointer(ft); break;
|
|
|
- }
|
|
|
- } else if (is_type_slice(t)) {
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(alloc_type_pointer(t->Slice.elem)); break;
|
|
|
- case 1: result_type = alloc_type_pointer(t_int); break;
|
|
|
- }
|
|
|
- } else if (is_type_string(t)) {
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(t_u8_ptr); break;
|
|
|
- case 1: result_type = alloc_type_pointer(t_int); break;
|
|
|
- }
|
|
|
- } else if (is_type_any(t)) {
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(t_rawptr); break;
|
|
|
- case 1: result_type = alloc_type_pointer(t_typeid); break;
|
|
|
- }
|
|
|
- } else if (is_type_dynamic_array(t)) {
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(alloc_type_pointer(t->DynamicArray.elem)); break;
|
|
|
- case 1: result_type = t_int_ptr; break;
|
|
|
- case 2: result_type = t_int_ptr; break;
|
|
|
- case 3: result_type = t_allocator_ptr; break;
|
|
|
- }
|
|
|
- } else if (is_type_map(t)) {
|
|
|
- init_map_internal_types(t);
|
|
|
- Type *itp = alloc_type_pointer(t->Map.internal_type);
|
|
|
- s = ir_emit_transmute(proc, s, itp);
|
|
|
-
|
|
|
- Type *gst = t->Map.internal_type;
|
|
|
- GB_ASSERT(gst->kind == Type_Struct);
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(gst->Struct.fields[0]->type); break;
|
|
|
- case 1: result_type = alloc_type_pointer(gst->Struct.fields[1]->type); break;
|
|
|
- }
|
|
|
- } else if (is_type_array(t)) {
|
|
|
- return ir_emit_array_epi(proc, s, index);
|
|
|
- } else if (is_type_relative_slice(t)) {
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(t->RelativeSlice.base_integer); break;
|
|
|
- case 1: result_type = alloc_type_pointer(t->RelativeSlice.base_integer); break;
|
|
|
- }
|
|
|
- } else {
|
|
|
- GB_PANIC("TODO(bill): struct_gep type: %s, %d", type_to_string(ir_type(s)), index);
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT_MSG(result_type != nullptr, "%s %d", type_to_string(t), index);
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_struct_element_ptr(proc, s, index, result_type));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) {
|
|
|
- // NOTE(bill): For some weird legacy reason in LLVM, structure elements must be accessed as an i32
|
|
|
-
|
|
|
- if (s->kind == irValue_Instr) {
|
|
|
- if (s->Instr.kind == irInstr_Load) {
|
|
|
- irValue *addr = s->Instr.Load.address;
|
|
|
- irValue *ptr = ir_emit_struct_ep(proc, addr, index);
|
|
|
- return ir_emit_load(proc, ptr);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- Type *t = base_type(ir_type(s));
|
|
|
- Type *result_type = nullptr;
|
|
|
-
|
|
|
- switch (t->kind) {
|
|
|
- case Type_Basic:
|
|
|
- switch (t->Basic.kind) {
|
|
|
- case Basic_string:
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = t_u8_ptr; break;
|
|
|
- case 1: result_type = t_int; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- case Basic_any:
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = t_rawptr; break;
|
|
|
- case 1: result_type = t_typeid; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- case Basic_complex32:
|
|
|
- case Basic_complex64:
|
|
|
- case Basic_complex128:
|
|
|
- {
|
|
|
- Type *ft = base_complex_elem_type(t);
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = ft; break;
|
|
|
- case 1: result_type = ft; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case Basic_quaternion64:
|
|
|
- case Basic_quaternion128:
|
|
|
- case Basic_quaternion256:
|
|
|
- {
|
|
|
- Type *ft = base_complex_elem_type(t);
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = ft; break;
|
|
|
- case 1: result_type = ft; break;
|
|
|
- case 2: result_type = ft; break;
|
|
|
- case 3: result_type = ft; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- case Type_Struct:
|
|
|
- result_type = t->Struct.fields[index]->type;
|
|
|
- break;
|
|
|
- case Type_Union:
|
|
|
- GB_ASSERT(index == -1);
|
|
|
- return ir_emit_union_tag_value(proc, s);
|
|
|
- case Type_Tuple:
|
|
|
- GB_ASSERT(t->Tuple.variables.count > 0);
|
|
|
- result_type = t->Tuple.variables[index]->type;
|
|
|
- break;
|
|
|
- case Type_Slice:
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(t->Slice.elem); break;
|
|
|
- case 1: result_type = t_int; break;
|
|
|
- }
|
|
|
- break;
|
|
|
- case Type_DynamicArray:
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = alloc_type_pointer(t->DynamicArray.elem); break;
|
|
|
- case 1: result_type = t_int; break;
|
|
|
- case 2: result_type = t_int; break;
|
|
|
- case 3: result_type = t_allocator; break;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_Map:
|
|
|
- {
|
|
|
- init_map_internal_types(t);
|
|
|
- Type *gst = t->Map.generated_struct_type;
|
|
|
- switch (index) {
|
|
|
- case 0: result_type = gst->Struct.fields[0]->type; break;
|
|
|
- case 1: result_type = gst->Struct.fields[1]->type; break;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_Array:
|
|
|
- result_type = t->Array.elem;
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- GB_PANIC("TODO(bill): struct_ev type: %s, %d", type_to_string(ir_type(s)), index);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT_MSG(result_type != nullptr, "%s, %d", type_to_string(ir_type(s)), index);
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_struct_extract_value(proc, s, index, result_type));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel) {
|
|
|
- GB_ASSERT(sel.index.count > 0);
|
|
|
- Type *type = type_deref(ir_type(e));
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
-
|
|
|
- for_array(i, sel.index) {
|
|
|
- i32 index = cast(i32)sel.index[i];
|
|
|
- if (is_type_pointer(type)) {
|
|
|
- type = type_deref(type);
|
|
|
- e = ir_emit_load(proc, e);
|
|
|
- // e = ir_emit_ptr_offset(proc, e, v_zero); // TODO(bill): Do I need these copies?
|
|
|
- }
|
|
|
- type = core_type(type);
|
|
|
-
|
|
|
- if (is_type_quaternion(type)) {
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- } else if (is_type_raw_union(type)) {
|
|
|
- type = type->Struct.fields[index]->type;
|
|
|
- GB_ASSERT(is_type_pointer(ir_type(e)));
|
|
|
- e = ir_emit_bitcast(proc, e, alloc_type_pointer(type));
|
|
|
- } else if (is_type_struct(type)) {
|
|
|
- type = type->Struct.fields[index]->type;
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- } else if (type->kind == Type_Union) {
|
|
|
- GB_ASSERT(index == -1);
|
|
|
- type = t_type_info_ptr;
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- } else if (type->kind == Type_Tuple) {
|
|
|
- type = type->Tuple.variables[index]->type;
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- } else if (type->kind == Type_Basic) {
|
|
|
- switch (type->Basic.kind) {
|
|
|
- case Basic_any: {
|
|
|
- if (index == 0) {
|
|
|
- type = t_rawptr;
|
|
|
- } else if (index == 1) {
|
|
|
- type = t_type_info_ptr;
|
|
|
- }
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Basic_string:
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- GB_PANIC("un-gep-able type");
|
|
|
- break;
|
|
|
- }
|
|
|
- } else if (type->kind == Type_Slice) {
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- } else if (type->kind == Type_DynamicArray) {
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- } else if (type->kind == Type_Array) {
|
|
|
- e = ir_emit_array_epi(proc, e, index);
|
|
|
- } else if (type->kind == Type_Map) {
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- } else if (type->kind == Type_RelativePointer) {
|
|
|
- e = ir_emit_struct_ep(proc, e, index);
|
|
|
- } else {
|
|
|
- GB_PANIC("un-gep-able type %s", type_to_string(type));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return e;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_deep_field_ev(irProcedure *proc, irValue *e, Selection sel) {
|
|
|
- GB_ASSERT(sel.index.count > 0);
|
|
|
-
|
|
|
- if (e->kind == irValue_Instr) {
|
|
|
- if (e->Instr.kind == irInstr_Load) {
|
|
|
- irValue *addr = e->Instr.Load.address;
|
|
|
- irValue *ptr = ir_emit_deep_field_gep(proc, addr, sel);
|
|
|
- return ir_emit_load(proc, ptr);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- Type *type = ir_type(e);
|
|
|
-
|
|
|
- for_array(i, sel.index) {
|
|
|
- i32 index = cast(i32)sel.index[i];
|
|
|
- if (is_type_pointer(type)) {
|
|
|
- type = type_deref(type);
|
|
|
- e = ir_emit_load(proc, e);
|
|
|
- e = ir_emit_ptr_offset(proc, e, v_zero); // TODO(bill): Do I need these copies?
|
|
|
- }
|
|
|
- type = base_type(type);
|
|
|
-
|
|
|
-
|
|
|
- if (is_type_raw_union(type)) {
|
|
|
- GB_PANIC("TODO(bill): IS THIS EVEN CORRECT?");
|
|
|
- type = type->Struct.fields[index]->type;
|
|
|
- e = ir_emit_conv(proc, e, type);
|
|
|
- } else if (type->kind == Type_Map) {
|
|
|
- e = ir_emit_struct_ev(proc, e, 1);
|
|
|
- switch (index) {
|
|
|
- case 0: e = ir_emit_struct_ev(proc, e, 1); break; // count
|
|
|
- case 1: e = ir_emit_struct_ev(proc, e, 2); break; // capacity
|
|
|
- case 2: e = ir_emit_struct_ev(proc, e, 3); break; // allocator
|
|
|
- }
|
|
|
- } else {
|
|
|
- e = ir_emit_struct_ev(proc, e, index);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return e;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_array_elem(irProcedure *proc, irValue *array) {
|
|
|
- return ir_emit_array_ep(proc, array, v_zero32);
|
|
|
-}
|
|
|
-irValue *ir_array_len(irProcedure *proc, irValue *array) {
|
|
|
- Type *t = base_type(ir_type(array));
|
|
|
- GB_ASSERT(t->kind == Type_Array);
|
|
|
- return ir_const_int(t->Array.count);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_slice_elem(irProcedure *proc, irValue *slice) {
|
|
|
- GB_ASSERT(is_type_slice(ir_type(slice)));
|
|
|
- return ir_emit_struct_ev(proc, slice, 0);
|
|
|
-}
|
|
|
-irValue *ir_slice_len(irProcedure *proc, irValue *slice) {
|
|
|
- GB_ASSERT(is_type_slice(ir_type(slice)));
|
|
|
- return ir_emit_struct_ev(proc, slice, 1);
|
|
|
-}
|
|
|
-irValue *ir_dynamic_array_elem(irProcedure *proc, irValue *da) {
|
|
|
- GB_ASSERT(is_type_dynamic_array(ir_type(da)));
|
|
|
- return ir_emit_struct_ev(proc, da, 0);
|
|
|
-}
|
|
|
-irValue *ir_dynamic_array_len(irProcedure *proc, irValue *da) {
|
|
|
- GB_ASSERT(is_type_dynamic_array(ir_type(da)));
|
|
|
- return ir_emit_struct_ev(proc, da, 1);
|
|
|
-}
|
|
|
-irValue *ir_dynamic_array_cap(irProcedure *proc, irValue *da) {
|
|
|
- GB_ASSERT(is_type_dynamic_array(ir_type(da)));
|
|
|
- return ir_emit_struct_ev(proc, da, 2);
|
|
|
-}
|
|
|
-irValue *ir_dynamic_array_allocator(irProcedure *proc, irValue *da) {
|
|
|
- GB_ASSERT(is_type_dynamic_array(ir_type(da)));
|
|
|
- return ir_emit_struct_ev(proc, da, 3);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_string_elem(irProcedure *proc, irValue *string) {
|
|
|
- Type *t = base_type(ir_type(string));
|
|
|
- GB_ASSERT(t->kind == Type_Basic && t->Basic.kind == Basic_string);
|
|
|
- return ir_emit_struct_ev(proc, string, 0);
|
|
|
-}
|
|
|
-irValue *ir_string_len(irProcedure *proc, irValue *string) {
|
|
|
- Type *t = base_type(ir_type(string));
|
|
|
- GB_ASSERT_MSG(t->kind == Type_Basic && t->Basic.kind == Basic_string, "%s", type_to_string(t));
|
|
|
- return ir_emit_struct_ev(proc, string, 1);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_cstring_len(irProcedure *proc, irValue *value) {
|
|
|
- GB_ASSERT(is_type_cstring(ir_type(value)));
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = ir_emit_conv(proc, value, t_cstring);
|
|
|
- return ir_emit_runtime_call(proc, "cstring_len", args);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void ir_fill_slice(irProcedure *proc, irValue *slice_ptr, irValue *data, irValue *len) {
|
|
|
- Type *t = ir_type(slice_ptr);
|
|
|
- GB_ASSERT(is_type_pointer(t));
|
|
|
- t = type_deref(t);
|
|
|
- GB_ASSERT(is_type_slice(t));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, slice_ptr, 0), data);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, slice_ptr, 1), len);
|
|
|
-}
|
|
|
-void ir_fill_string(irProcedure *proc, irValue *string_ptr, irValue *data, irValue *len) {
|
|
|
- Type *t = ir_type(string_ptr);
|
|
|
- GB_ASSERT(is_type_pointer(t));
|
|
|
- t = type_deref(t);
|
|
|
- GB_ASSERT(is_type_string(t));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, string_ptr, 0), data);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, string_ptr, 1), len);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_string(irProcedure *proc, irValue *elem, irValue *len) {
|
|
|
- irValue *str = ir_add_local_generated(proc, t_string, false);
|
|
|
- ir_fill_string(proc, str, elem, len);
|
|
|
- return ir_emit_load(proc, str);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_add_local_slice(irProcedure *proc, Type *slice_type, irValue *base, irValue *low, irValue *high) {
|
|
|
- // TODO(bill): array bounds checking for slice creation
|
|
|
- // TODO(bill): check that low < high <= max
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- Type *bt = base_type(ir_type(base));
|
|
|
-
|
|
|
- if (low == nullptr) {
|
|
|
- low = v_zero;
|
|
|
- }
|
|
|
- if (high == nullptr) {
|
|
|
- switch (bt->kind) {
|
|
|
- case Type_Array: high = ir_array_len(proc, base); break;
|
|
|
- case Type_Slice: high = ir_slice_len(proc, base); break;
|
|
|
- case Type_Pointer: high = v_one; break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- irValue *len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
|
|
|
-
|
|
|
- irValue *elem = nullptr;
|
|
|
- switch (bt->kind) {
|
|
|
- case Type_Array: elem = ir_array_elem(proc, base); break;
|
|
|
- case Type_Slice: elem = ir_slice_elem(proc, base); break;
|
|
|
- case Type_Pointer: elem = ir_emit_load(proc, base); break;
|
|
|
- }
|
|
|
-
|
|
|
- elem = ir_emit_ptr_offset(proc, elem, low);
|
|
|
-
|
|
|
- irValue *slice = ir_add_local_generated(proc, slice_type, false);
|
|
|
- ir_fill_slice(proc, slice, elem, len);
|
|
|
- return slice;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_find_or_add_entity_string(irModule *m, String str) {
|
|
|
- StringHashKey key = string_hash_string(str);
|
|
|
- irValue **found = string_map_get(&m->const_strings, key);
|
|
|
- if (found != nullptr) {
|
|
|
- return *found;
|
|
|
- }
|
|
|
- irValue *v = ir_value_constant(t_string, exact_value_string(str));
|
|
|
- string_map_set(&m->const_strings, key, v);
|
|
|
- return v;
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_find_or_add_entity_string_byte_slice(irModule *m, String str) {
|
|
|
- StringHashKey key = string_hash_string(str);
|
|
|
- irValue **found = string_map_get(&m->const_string_byte_slices, key);
|
|
|
- if (found != nullptr) {
|
|
|
- return *found;
|
|
|
- }
|
|
|
- Type *t = t_u8_slice;
|
|
|
- irValue *v = ir_value_constant(t, exact_value_string(str));
|
|
|
- string_map_set(&m->const_string_byte_slices, key, v);
|
|
|
- return v;
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_const_union_tag(Type *u, Type *v) {
|
|
|
- return ir_value_constant(union_tag_type(u), exact_value_i64(union_variant_index(u, v)));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-String ir_lookup_subtype_polymorphic_field(CheckerInfo *info, Type *dst, Type *src) {
|
|
|
- Type *prev_src = src;
|
|
|
- // Type *prev_dst = dst;
|
|
|
- src = base_type(type_deref(src));
|
|
|
- // dst = base_type(type_deref(dst));
|
|
|
- bool src_is_ptr = src != prev_src;
|
|
|
- // bool dst_is_ptr = dst != prev_dst;
|
|
|
-
|
|
|
- GB_ASSERT(is_type_struct(src) || is_type_union(src));
|
|
|
- for_array(i, src->Struct.fields) {
|
|
|
- Entity *f = src->Struct.fields[i];
|
|
|
- if (f->kind == Entity_Variable && f->flags & EntityFlag_Using) {
|
|
|
- if (are_types_identical(dst, f->type)) {
|
|
|
- return f->token.string;
|
|
|
- }
|
|
|
- if (src_is_ptr && is_type_pointer(dst)) {
|
|
|
- if (are_types_identical(type_deref(dst), f->type)) {
|
|
|
- return f->token.string;
|
|
|
- }
|
|
|
- }
|
|
|
- if (is_type_struct(f->type)) {
|
|
|
- String name = ir_lookup_subtype_polymorphic_field(info, dst, f->type);
|
|
|
- if (name.len > 0) {
|
|
|
- return name;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return str_lit("");
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_ptr_to_uintptr(irProcedure *proc, irValue *value, Type *t, bool allow_type_type = false) {
|
|
|
- Type *vt = core_type(ir_type(value));
|
|
|
- GB_ASSERT(is_type_pointer(vt));
|
|
|
- if (allow_type_type) {
|
|
|
- GB_ASSERT(is_type_uintptr(core_type(t)));
|
|
|
- } else {
|
|
|
- GB_ASSERT(is_type_uintptr(core_type(t)));
|
|
|
- }
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_ptrtoint, value, vt, t));
|
|
|
-}
|
|
|
-irValue *ir_emit_uintptr_to_ptr(irProcedure *proc, irValue *value, Type *t) {
|
|
|
- Type *vt = core_type(ir_type(value));
|
|
|
- GB_ASSERT(is_type_uintptr(vt));
|
|
|
- GB_ASSERT(is_type_pointer(core_type(t)));
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_inttoptr, value, vt, t));
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_byte_swap(irProcedure *proc, irValue *value, Type *t) {
|
|
|
- Type *vt = core_type(ir_type(value));
|
|
|
- if (is_type_untyped(vt)) {
|
|
|
- return value;
|
|
|
- }
|
|
|
- GB_ASSERT(type_size_of(vt) == type_size_of(t));
|
|
|
- if (is_type_float(t)) {
|
|
|
- i64 sz = type_size_of(t);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = value;
|
|
|
-
|
|
|
- char const *proc_name = nullptr;
|
|
|
- switch (sz*8) {
|
|
|
- case 16: proc_name = "bswap_f16"; break;
|
|
|
- case 32: proc_name = "bswap_f32"; break;
|
|
|
- case 64: proc_name = "bswap_f64"; break;
|
|
|
- }
|
|
|
- GB_ASSERT(proc_name != nullptr);
|
|
|
-
|
|
|
- String name = make_string_c(proc_name);
|
|
|
-
|
|
|
- AstPackage *p = proc->module->info->runtime_package;
|
|
|
- Entity *e = scope_lookup_current(p->scope, name);
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- GB_ASSERT_MSG(found != nullptr, "%.*s", LIT(name));
|
|
|
- irValue *gp = *found;
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_call(proc, gp, nullptr, args, t, nullptr, ProcInlining_none));
|
|
|
- }
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_byteswap, value, vt, t));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_emit_store_union_variant(irProcedure *proc, irValue *parent, irValue *variant, Type *variant_type) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *underlying = ir_emit_conv(proc, parent, alloc_type_pointer(variant_type));
|
|
|
-
|
|
|
- ir_emit_store(proc, underlying, variant);
|
|
|
-
|
|
|
- Type *t = type_deref(ir_type(parent));
|
|
|
-
|
|
|
- if (is_type_union_maybe_pointer(t)) {
|
|
|
- // No tag needed!
|
|
|
- } else {
|
|
|
- irValue *tag_ptr = ir_emit_union_tag_ptr(proc, parent);
|
|
|
- ir_emit_store(proc, tag_ptr, ir_const_union_tag(t, variant_type));
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) {
|
|
|
- Type *src_type = ir_type(value);
|
|
|
- if (are_types_identical(t, src_type)) {
|
|
|
- return value;
|
|
|
- }
|
|
|
-
|
|
|
- Type *src = core_type(src_type);
|
|
|
- Type *dst = core_type(t);
|
|
|
-
|
|
|
-
|
|
|
- // if (is_type_untyped_nil(src) && type_has_nil(dst)) {
|
|
|
- if (is_type_untyped_nil(src)) {
|
|
|
- return ir_value_nil(t);
|
|
|
- }
|
|
|
- if (is_type_untyped_undef(src)) {
|
|
|
- return ir_value_undef(t);
|
|
|
- }
|
|
|
-
|
|
|
- if (value->kind == irValue_Constant) {
|
|
|
- if (is_type_any(dst)) {
|
|
|
- irValue *default_value = ir_add_local_generated(proc, default_type(src_type), false);
|
|
|
- ir_emit_store(proc, default_value, value);
|
|
|
- return ir_emit_conv(proc, ir_emit_load(proc, default_value), t_any);
|
|
|
- } else if (dst->kind == Type_Basic) {
|
|
|
- ExactValue ev = value->Constant.value;
|
|
|
- if (is_type_float(dst)) {
|
|
|
- ev = exact_value_to_float(ev);
|
|
|
- } else if (is_type_complex(dst)) {
|
|
|
- ev = exact_value_to_complex(ev);
|
|
|
- } else if (is_type_quaternion(dst)) {
|
|
|
- ev = exact_value_to_quaternion(ev);
|
|
|
- } else if (is_type_string(dst)) {
|
|
|
- // Handled elsewhere
|
|
|
- GB_ASSERT_MSG(ev.kind == ExactValue_String, "%d", ev.kind);
|
|
|
- } else if (is_type_integer(dst)) {
|
|
|
- ev = exact_value_to_integer(ev);
|
|
|
- } else if (is_type_pointer(dst)) {
|
|
|
- // IMPORTANT NOTE(bill): LLVM doesn't support pointer constants expect 'null'
|
|
|
- irValue *i = ir_add_module_constant(proc->module, t_uintptr, ev);
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_inttoptr, i, t_uintptr, dst));
|
|
|
- }
|
|
|
- return ir_add_module_constant(proc->module, t, ev);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (are_types_identical(src, dst)) {
|
|
|
- if (!are_types_identical(src_type, t)) {
|
|
|
- return ir_emit_transmute(proc, value, t);
|
|
|
- }
|
|
|
- return value;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- // bool <-> llvm bool
|
|
|
- if (is_type_boolean(src) && dst == t_llvm_bool) {
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_trunc, value, src_type, t));
|
|
|
- }
|
|
|
- if (src == t_llvm_bool && is_type_boolean(dst)) {
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_zext, value, src_type, t));
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // integer -> integer
|
|
|
- if (is_type_integer(src) && is_type_integer(dst)) {
|
|
|
- GB_ASSERT(src->kind == Type_Basic &&
|
|
|
- dst->kind == Type_Basic);
|
|
|
- i64 sz = type_size_of(default_type(src));
|
|
|
- i64 dz = type_size_of(default_type(dst));
|
|
|
-
|
|
|
- if (sz > 1 && is_type_different_to_arch_endianness(src)) {
|
|
|
- Type *platform_src_type = integer_endian_type_to_platform_type(src);
|
|
|
- value = ir_emit_byte_swap(proc, value, platform_src_type);
|
|
|
- }
|
|
|
- irConvKind kind = irConv_trunc;
|
|
|
-
|
|
|
- if (dz < sz) {
|
|
|
- kind = irConv_trunc;
|
|
|
- } else if (dz == sz) {
|
|
|
- // NOTE(bill): In LLVM, all integers are signed and rely upon 2's compliment
|
|
|
- // NOTE(bill): Copy the value just for type correctness
|
|
|
- kind = irConv_bitcast;
|
|
|
- } else if (dz > sz) {
|
|
|
- if (is_type_unsigned(src)) {
|
|
|
- kind = irConv_zext; // zero extent
|
|
|
- } else {
|
|
|
- kind = irConv_sext; // sign extent
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (dz > 1 && is_type_different_to_arch_endianness(dst)) {
|
|
|
- Type *platform_dst_type = integer_endian_type_to_platform_type(dst);
|
|
|
- irValue *res = ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, platform_dst_type));
|
|
|
- return ir_emit_byte_swap(proc, res, t);
|
|
|
- } else {
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, t));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // boolean -> boolean/integer
|
|
|
- if (is_type_boolean(src) && (is_type_boolean(dst) || is_type_integer(dst))) {
|
|
|
- irValue *b = ir_emit(proc, ir_instr_binary_op(proc, Token_NotEq, value, v_zero, t_llvm_bool));
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_zext, b, t_llvm_bool, t));
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_cstring(src) && is_type_u8_ptr(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, dst);
|
|
|
- }
|
|
|
- if (is_type_u8_ptr(src) && is_type_cstring(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, dst);
|
|
|
- }
|
|
|
- if (is_type_cstring(src) && is_type_rawptr(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, dst);
|
|
|
- }
|
|
|
- if (is_type_rawptr(src) && is_type_cstring(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, dst);
|
|
|
- }
|
|
|
-
|
|
|
- if (are_types_identical(src, t_cstring) && are_types_identical(dst, t_string)) {
|
|
|
- irValue *c = ir_emit_conv(proc, value, t_cstring);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = c;
|
|
|
- irValue *s = ir_emit_runtime_call(proc, "cstring_to_string", args);
|
|
|
- return ir_emit_conv(proc, s, dst);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // integer -> boolean
|
|
|
- if (is_type_integer(src) && is_type_boolean(dst)) {
|
|
|
- return ir_emit_comp(proc, Token_NotEq, value, v_zero);
|
|
|
- }
|
|
|
-
|
|
|
- // float -> float
|
|
|
- if (is_type_float(src) && is_type_float(dst)) {
|
|
|
- GB_ASSERT(!are_types_identical(src, dst));
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- i64 sz = type_size_of(src);
|
|
|
- i64 dz = type_size_of(dst);
|
|
|
- irConvKind kind = irConv_fptrunc;
|
|
|
- if (dz == sz) {
|
|
|
- if (types_have_same_internal_endian(src, dst)) {
|
|
|
- return ir_emit_transmute(proc, value, t);
|
|
|
- } else {
|
|
|
- return ir_emit_byte_swap(proc, value, t);
|
|
|
- }
|
|
|
- }
|
|
|
- if (dz >= sz) {
|
|
|
- kind = irConv_fpext;
|
|
|
- }
|
|
|
- if (is_type_different_to_arch_endianness(src) || is_type_different_to_arch_endianness(dst)) {
|
|
|
- Type *platform_src_type = integer_endian_type_to_platform_type(src);
|
|
|
- Type *platform_dst_type = integer_endian_type_to_platform_type(dst);
|
|
|
- irValue *res = nullptr;
|
|
|
- res = ir_emit_conv(proc, value, platform_src_type);
|
|
|
- res = ir_emit_conv(proc, res, platform_dst_type);
|
|
|
- if (is_type_different_to_arch_endianness(dst)) {
|
|
|
- res = ir_emit_byte_swap(proc, res, t);
|
|
|
- }
|
|
|
- return ir_emit_conv(proc, res, t);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, t));
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_complex(src) && is_type_complex(dst)) {
|
|
|
- Type *ft = base_complex_elem_type(dst);
|
|
|
- irValue *gen = ir_add_local_generated(proc, dst, false);
|
|
|
- irValue *real = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 0), ft);
|
|
|
- irValue *imag = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 1), ft);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 0), real);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 1), imag);
|
|
|
- return ir_emit_load(proc, gen);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_quaternion(src) && is_type_quaternion(dst)) {
|
|
|
- // @QuaternionLayout
|
|
|
- Type *ft = base_complex_elem_type(dst);
|
|
|
- irValue *gen = ir_add_local_generated(proc, dst, false);
|
|
|
- irValue *q0 = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 0), ft);
|
|
|
- irValue *q1 = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 1), ft);
|
|
|
- irValue *q2 = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 2), ft);
|
|
|
- irValue *q3 = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 3), ft);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 0), q0);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 1), q1);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 2), q2);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 3), q3);
|
|
|
- return ir_emit_load(proc, gen);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_float(src) && is_type_complex(dst)) {
|
|
|
- Type *ft = base_complex_elem_type(dst);
|
|
|
- irValue *gen = ir_add_local_generated(proc, dst, true);
|
|
|
- irValue *real = ir_emit_conv(proc, value, ft);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 0), real);
|
|
|
- return ir_emit_load(proc, gen);
|
|
|
- }
|
|
|
- if (is_type_float(src) && is_type_quaternion(dst)) {
|
|
|
- Type *ft = base_complex_elem_type(dst);
|
|
|
- irValue *gen = ir_add_local_generated(proc, dst, true);
|
|
|
- irValue *real = ir_emit_conv(proc, value, ft);
|
|
|
- // @QuaternionLayout
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 3), real);
|
|
|
- return ir_emit_load(proc, gen);
|
|
|
- }
|
|
|
- if (is_type_complex(src) && is_type_quaternion(dst)) {
|
|
|
- Type *ft = base_complex_elem_type(dst);
|
|
|
- irValue *gen = ir_add_local_generated(proc, dst, true);
|
|
|
- irValue *real = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 0), ft);
|
|
|
- irValue *imag = ir_emit_conv(proc, ir_emit_struct_ev(proc, value, 1), ft);
|
|
|
- // @QuaternionLayout
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 3), real);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, gen, 0), imag);
|
|
|
- return ir_emit_load(proc, gen);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- // float <-> integer
|
|
|
- if (is_type_float(src) && is_type_integer(dst)) {
|
|
|
- irConvKind kind = irConv_fptosi;
|
|
|
- if (is_type_unsigned(dst)) {
|
|
|
- kind = irConv_fptoui;
|
|
|
- }
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, t));
|
|
|
- }
|
|
|
- if (is_type_integer(src) && is_type_float(dst)) {
|
|
|
- irConvKind kind = irConv_sitofp;
|
|
|
- if (is_type_unsigned(src)) {
|
|
|
- kind = irConv_uitofp;
|
|
|
- }
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, kind, value, src_type, t));
|
|
|
- }
|
|
|
-
|
|
|
- // Pointer <-> uintptr
|
|
|
- if (is_type_pointer(src) && is_type_uintptr(dst)) {
|
|
|
- return ir_emit_ptr_to_uintptr(proc, value, t);
|
|
|
- }
|
|
|
- if (is_type_uintptr(src) && is_type_pointer(dst)) {
|
|
|
- return ir_emit_uintptr_to_ptr(proc, value, t);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_union(dst)) {
|
|
|
- for_array(i, dst->Union.variants) {
|
|
|
- Type *vt = dst->Union.variants[i];
|
|
|
- if (are_types_identical(vt, src_type)) {
|
|
|
- ir_emit_comment(proc, str_lit("union - child to parent"));
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *parent = ir_add_local_generated(proc, t, true);
|
|
|
- ir_emit_store_union_variant(proc, parent, value, vt);
|
|
|
- return ir_emit_load(proc, parent);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(bill): This has to be done before 'Pointer <-> Pointer' as it's
|
|
|
- // subtype polymorphism casting
|
|
|
- if (check_is_assignable_to_using_subtype(src_type, t)) {
|
|
|
- Type *st = type_deref(src_type);
|
|
|
- Type *pst = st;
|
|
|
- st = type_deref(st);
|
|
|
-
|
|
|
- bool st_is_ptr = is_type_pointer(src_type);
|
|
|
- st = base_type(st);
|
|
|
-
|
|
|
- Type *dt = t;
|
|
|
- bool dt_is_ptr = type_deref(dt) != dt;
|
|
|
-
|
|
|
- GB_ASSERT(is_type_struct(st) || is_type_raw_union(st));
|
|
|
- String field_name = ir_lookup_subtype_polymorphic_field(proc->module->info, t, src_type);
|
|
|
- if (field_name.len > 0) {
|
|
|
- // NOTE(bill): It can be casted
|
|
|
- Selection sel = lookup_field(st, field_name, false, true);
|
|
|
- if (sel.entity != nullptr) {
|
|
|
- ir_emit_comment(proc, str_lit("cast - polymorphism"));
|
|
|
- if (st_is_ptr) {
|
|
|
- irValue *res = ir_emit_deep_field_gep(proc, value, sel);
|
|
|
- Type *rt = ir_type(res);
|
|
|
- if (!are_types_identical(rt, dt) && are_types_identical(type_deref(rt), dt)) {
|
|
|
- res = ir_emit_load(proc, res);
|
|
|
- }
|
|
|
- return res;
|
|
|
- } else {
|
|
|
- if (is_type_pointer(ir_type(value))) {
|
|
|
- Type *rt = ir_type(value);
|
|
|
- if (!are_types_identical(rt, dt) && are_types_identical(type_deref(rt), dt)) {
|
|
|
- value = ir_emit_load(proc, value);
|
|
|
- } else {
|
|
|
- value = ir_emit_deep_field_gep(proc, value, sel);
|
|
|
- return ir_emit_load(proc, value);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ir_emit_deep_field_ev(proc, value, sel);
|
|
|
-
|
|
|
- }
|
|
|
- } else {
|
|
|
- GB_PANIC("invalid subtype cast %s.%.*s", type_to_string(src_type), LIT(field_name));
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- // Pointer <-> Pointer
|
|
|
- if (is_type_pointer(src) && is_type_pointer(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, t);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- // proc <-> proc
|
|
|
- if (is_type_proc(src) && is_type_proc(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, t);
|
|
|
- }
|
|
|
-
|
|
|
- // pointer -> proc
|
|
|
- if (is_type_pointer(src) && is_type_proc(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, t);
|
|
|
- }
|
|
|
- // proc -> pointer
|
|
|
- if (is_type_proc(src) && is_type_pointer(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, t);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- // []byte/[]u8 <-> string
|
|
|
- if (is_type_u8_slice(src) && is_type_string(dst)) {
|
|
|
- irValue *elem = ir_slice_elem(proc, value);
|
|
|
- irValue *len = ir_slice_len(proc, value);
|
|
|
- return ir_emit_string(proc, elem, len);
|
|
|
- }
|
|
|
- if (is_type_string(src) && is_type_u8_slice(dst)) {
|
|
|
- irValue *elem = ir_string_elem(proc, value);
|
|
|
- irValue *elem_ptr = ir_add_local_generated(proc, ir_type(elem), false);
|
|
|
- ir_emit_store(proc, elem_ptr, elem);
|
|
|
-
|
|
|
- irValue *len = ir_string_len(proc, value);
|
|
|
- irValue *slice = ir_add_local_slice(proc, t, elem_ptr, v_zero, len);
|
|
|
- return ir_emit_load(proc, slice);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_array(dst)) {
|
|
|
- Type *elem = dst->Array.elem;
|
|
|
- irValue *e = ir_emit_conv(proc, value, elem);
|
|
|
- // NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
|
|
|
- irValue *v = ir_add_local_generated(proc, t, false);
|
|
|
- isize index_count = cast(isize)dst->Array.count;
|
|
|
-
|
|
|
- for (i32 i = 0; i < index_count; i++) {
|
|
|
- irValue *elem = ir_emit_array_epi(proc, v, i);
|
|
|
- ir_emit_store(proc, elem, e);
|
|
|
- }
|
|
|
- return ir_emit_load(proc, v);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_any(dst)) {
|
|
|
- irValue *result = ir_add_local_generated(proc, t_any, true);
|
|
|
-
|
|
|
- if (is_type_untyped_nil(src)) {
|
|
|
- return ir_emit_load(proc, result);
|
|
|
- }
|
|
|
-
|
|
|
- Type *st = default_type(src_type);
|
|
|
-
|
|
|
- irValue *data = ir_address_from_load_or_generate_local(proc, value);
|
|
|
- GB_ASSERT_MSG(is_type_pointer(ir_type(data)), type_to_string(ir_type(data)));
|
|
|
- GB_ASSERT_MSG(is_type_typed(st), "%s", type_to_string(st));
|
|
|
- data = ir_emit_conv(proc, data, t_rawptr);
|
|
|
-
|
|
|
-
|
|
|
- irValue *id = ir_typeid(proc->module, st);
|
|
|
-
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, result, 0), data);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, result, 1), id);
|
|
|
-
|
|
|
- return ir_emit_load(proc, result);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_untyped(src)) {
|
|
|
- if (is_type_string(src) && is_type_string(dst)) {
|
|
|
- irValue *result = ir_add_local_generated(proc, t, false);
|
|
|
- ir_emit_store(proc, result, value);
|
|
|
- return ir_emit_load(proc, result);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- gb_printf_err("ir_emit_conv: src -> dst\n");
|
|
|
- gb_printf_err("Not Identical %s != %s\n", type_to_string(src_type), type_to_string(t));
|
|
|
- gb_printf_err("Not Identical %s != %s\n", type_to_string(src), type_to_string(dst));
|
|
|
-
|
|
|
-
|
|
|
- GB_PANIC("Invalid type conversion: '%s' to '%s' for procedure '%.*s'",
|
|
|
- type_to_string(src_type), type_to_string(t),
|
|
|
- LIT(proc->name));
|
|
|
-
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-bool ir_is_type_aggregate(Type *t) {
|
|
|
- t = base_type(t);
|
|
|
- switch (t->kind) {
|
|
|
- case Type_Basic:
|
|
|
- switch (t->Basic.kind) {
|
|
|
- case Basic_string:
|
|
|
- case Basic_any:
|
|
|
- return true;
|
|
|
-
|
|
|
- case Basic_complex32:
|
|
|
- case Basic_complex64:
|
|
|
- case Basic_complex128:
|
|
|
- case Basic_quaternion64:
|
|
|
- case Basic_quaternion128:
|
|
|
- case Basic_quaternion256:
|
|
|
- return true;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_Pointer:
|
|
|
- return false;
|
|
|
-
|
|
|
- case Type_Array:
|
|
|
- case Type_Slice:
|
|
|
- case Type_Struct:
|
|
|
- case Type_Union:
|
|
|
- case Type_Tuple:
|
|
|
- case Type_DynamicArray:
|
|
|
- case Type_Map:
|
|
|
- case Type_SimdVector:
|
|
|
- return true;
|
|
|
-
|
|
|
- case Type_Named:
|
|
|
- return ir_is_type_aggregate(t->Named.base);
|
|
|
- }
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_transmute(irProcedure *proc, irValue *value, Type *t) {
|
|
|
- Type *src_type = ir_type(value);
|
|
|
- if (are_types_identical(t, src_type)) {
|
|
|
- return value;
|
|
|
- }
|
|
|
-
|
|
|
- Type *src = base_type(src_type);
|
|
|
- Type *dst = base_type(t);
|
|
|
-
|
|
|
- irModule *m = proc->module;
|
|
|
-
|
|
|
- i64 sz = type_size_of(src);
|
|
|
- i64 dz = type_size_of(dst);
|
|
|
-
|
|
|
- GB_ASSERT_MSG(sz == dz, "Invalid transmute conversion: '%s' to '%s'", type_to_string(src_type), type_to_string(t));
|
|
|
-
|
|
|
- // NOTE(bill): Casting between an integer and a pointer cannot be done through a bitcast
|
|
|
- if (is_type_uintptr(src) && is_type_pointer(dst)) {
|
|
|
- return ir_emit_uintptr_to_ptr(proc, value, t);
|
|
|
- }
|
|
|
- if (is_type_pointer(src) && is_type_uintptr(dst)) {
|
|
|
- return ir_emit_ptr_to_uintptr(proc, value, t);
|
|
|
- }
|
|
|
- if (is_type_uintptr(src) && is_type_proc(dst)) {
|
|
|
- irValue *ptr = ir_emit_uintptr_to_ptr(proc, value, t_rawptr);
|
|
|
- return ir_emit_bitcast(proc, ptr, dst);
|
|
|
- }
|
|
|
- if (is_type_proc(src) && is_type_uintptr(dst)) {
|
|
|
- irValue *ptr = ir_emit_uintptr_to_ptr(proc, value, t_rawptr);
|
|
|
- return ir_emit_bitcast(proc, ptr, dst);
|
|
|
- }
|
|
|
- if (is_type_float(src) && is_type_float(dst)) {
|
|
|
- return ir_emit_bitcast(proc, value, t);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_integer(src) && (is_type_pointer(dst) || is_type_cstring(dst))) {
|
|
|
- Type *vt = core_type(ir_type(value));
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_inttoptr, value, vt, t));
|
|
|
- } else if ((is_type_pointer(src) || is_type_cstring(src)) && is_type_integer(dst)) {
|
|
|
- Type *vt = core_type(ir_type(value));
|
|
|
- return ir_emit(proc, ir_instr_conv(proc, irConv_ptrtoint, value, vt, t));
|
|
|
- }
|
|
|
-
|
|
|
- if (ir_is_type_aggregate(src) || ir_is_type_aggregate(dst)) {
|
|
|
- irValue *s = ir_address_from_load_or_generate_local(proc, value);
|
|
|
- irValue *d = ir_emit_bitcast(proc, s, alloc_type_pointer(t));
|
|
|
- return ir_emit_load(proc, d);
|
|
|
- }
|
|
|
-
|
|
|
- // TODO(bill): Actually figure out what the conversion needs to be correctly 'cause LLVM
|
|
|
- return ir_emit_bitcast(proc, value, t);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_union_cast(irProcedure *proc, irValue *value, Type *type, TokenPos pos, bool do_conversion_check=true) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
-
|
|
|
- Type *src_type = ir_type(value);
|
|
|
- bool is_ptr = is_type_pointer(src_type);
|
|
|
-
|
|
|
- bool is_tuple = true;
|
|
|
- Type *tuple = type;
|
|
|
- if (type->kind != Type_Tuple) {
|
|
|
- is_tuple = false;
|
|
|
- tuple = make_optional_ok_type(type);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *v = ir_add_local_generated(proc, tuple, true);
|
|
|
-
|
|
|
- if (is_ptr) {
|
|
|
- value = ir_emit_load(proc, value);
|
|
|
- }
|
|
|
- Type *src = base_type(type_deref(src_type));
|
|
|
- GB_ASSERT_MSG(is_type_union(src), "%s", type_to_string(src_type));
|
|
|
- Type *dst = tuple->Tuple.variables[0]->type;
|
|
|
-
|
|
|
- irValue *value_ = ir_address_from_load_or_generate_local(proc, value);
|
|
|
-
|
|
|
- irValue *tag = nullptr;
|
|
|
- irValue *dst_tag = nullptr;
|
|
|
- irValue *cond = nullptr;
|
|
|
- irValue *data = nullptr;
|
|
|
-
|
|
|
- irValue *gep0 = ir_emit_struct_ep(proc, v, 0);
|
|
|
- irValue *gep1 = ir_emit_struct_ep(proc, v, 1);
|
|
|
-
|
|
|
- if (is_type_union_maybe_pointer(src)) {
|
|
|
- data = ir_emit_load(proc, ir_emit_conv(proc, value_, ir_type(gep0)));
|
|
|
- } else {
|
|
|
- tag = ir_emit_load(proc, ir_emit_union_tag_ptr(proc, value_));
|
|
|
- dst_tag = ir_const_union_tag(src, dst);
|
|
|
- }
|
|
|
-
|
|
|
- irBlock *ok_block = ir_new_block(proc, nullptr, "union_cast.ok");
|
|
|
- irBlock *end_block = ir_new_block(proc, nullptr, "union_cast.end");
|
|
|
-
|
|
|
- if (data != nullptr) {
|
|
|
- GB_ASSERT(is_type_union_maybe_pointer(src));
|
|
|
- cond = ir_emit_comp_against_nil(proc, Token_NotEq, data);
|
|
|
- } else {
|
|
|
- cond = ir_emit_comp(proc, Token_CmpEq, tag, dst_tag);
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit_if(proc, cond, ok_block, end_block);
|
|
|
- ir_start_block(proc, ok_block);
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- if (data == nullptr) {
|
|
|
- data = ir_emit_load(proc, ir_emit_conv(proc, value_, ir_type(gep0)));
|
|
|
- }
|
|
|
- ir_emit_store(proc, gep0, data);
|
|
|
- ir_emit_store(proc, gep1, v_true);
|
|
|
-
|
|
|
- ir_emit_jump(proc, end_block);
|
|
|
- ir_start_block(proc, end_block);
|
|
|
-
|
|
|
- if (!is_tuple) {
|
|
|
- if (do_conversion_check) {
|
|
|
- // NOTE(bill): Panic on invalid conversion
|
|
|
- Type *dst_type = tuple->Tuple.variables[0]->type;
|
|
|
-
|
|
|
- irValue *ok = ir_emit_load(proc, ir_emit_struct_ep(proc, v, 1));
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 6);
|
|
|
- args[0] = ok;
|
|
|
-
|
|
|
- args[1] = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
|
|
|
- args[2] = ir_const_i32(pos.line);
|
|
|
- args[3] = ir_const_i32(pos.column);
|
|
|
-
|
|
|
- args[4] = ir_typeid(proc->module, src_type);
|
|
|
- args[5] = ir_typeid(proc->module, dst_type);
|
|
|
- ir_emit_runtime_call(proc, "type_assertion_check", args);
|
|
|
- }
|
|
|
-
|
|
|
- return ir_emit_load(proc, ir_emit_struct_ep(proc, v, 0));
|
|
|
- }
|
|
|
- return ir_emit_load(proc, v);
|
|
|
-}
|
|
|
-
|
|
|
-irAddr ir_emit_any_cast_addr(irProcedure *proc, irValue *value, Type *type, TokenPos pos) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- Type *src_type = ir_type(value);
|
|
|
-
|
|
|
- if (is_type_pointer(src_type)) {
|
|
|
- value = ir_emit_load(proc, value);
|
|
|
- }
|
|
|
-
|
|
|
- bool is_tuple = true;
|
|
|
- Type *tuple = type;
|
|
|
- if (type->kind != Type_Tuple) {
|
|
|
- is_tuple = false;
|
|
|
- tuple = make_optional_ok_type(type);
|
|
|
- }
|
|
|
- Type *dst_type = tuple->Tuple.variables[0]->type;
|
|
|
-
|
|
|
- irValue *v = ir_add_local_generated(proc, tuple, true);
|
|
|
-
|
|
|
- irValue *dst_typeid = ir_typeid(proc->module, dst_type);
|
|
|
- irValue *any_typeid = ir_emit_struct_ev(proc, value, 1);
|
|
|
-
|
|
|
-
|
|
|
- irBlock *ok_block = ir_new_block(proc, nullptr, "any_cast.ok");
|
|
|
- irBlock *end_block = ir_new_block(proc, nullptr, "any_cast.end");
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_CmpEq, any_typeid, dst_typeid);
|
|
|
- ir_emit_if(proc, cond, ok_block, end_block);
|
|
|
- ir_start_block(proc, ok_block);
|
|
|
-
|
|
|
- irValue *gep0 = ir_emit_struct_ep(proc, v, 0);
|
|
|
- irValue *gep1 = ir_emit_struct_ep(proc, v, 1);
|
|
|
-
|
|
|
- irValue *any_data = ir_emit_struct_ev(proc, value, 0);
|
|
|
- irValue *ptr = ir_emit_conv(proc, any_data, alloc_type_pointer(dst_type));
|
|
|
- ir_emit_store(proc, gep0, ir_emit_load(proc, ptr));
|
|
|
- ir_emit_store(proc, gep1, v_true);
|
|
|
-
|
|
|
- ir_emit_jump(proc, end_block);
|
|
|
- ir_start_block(proc, end_block);
|
|
|
-
|
|
|
- if (!is_tuple) {
|
|
|
- // NOTE(bill): Panic on invalid conversion
|
|
|
-
|
|
|
- irValue *ok = ir_emit_load(proc, ir_emit_struct_ep(proc, v, 1));
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 6);
|
|
|
- args[0] = ok;
|
|
|
-
|
|
|
- args[1] = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
|
|
|
- args[2] = ir_const_i32(pos.line);
|
|
|
- args[3] = ir_const_i32(pos.column);
|
|
|
-
|
|
|
- args[4] = any_typeid;
|
|
|
- args[5] = dst_typeid;
|
|
|
- ir_emit_runtime_call(proc, "type_assertion_check", args);
|
|
|
-
|
|
|
- return ir_addr(ir_emit_struct_ep(proc, v, 0));
|
|
|
- }
|
|
|
- return ir_addr(v);
|
|
|
-}
|
|
|
-irValue *ir_emit_any_cast(irProcedure *proc, irValue *value, Type *type, TokenPos pos) {
|
|
|
- return ir_addr_load(proc, ir_emit_any_cast_addr(proc, value, type, pos));
|
|
|
-}
|
|
|
-
|
|
|
-// TODO(bill): Try and make a lot of this constant aggregate literals in LLVM IR
|
|
|
-gb_global irValue *ir_global_type_info_data = nullptr;
|
|
|
-gb_global irValue *ir_global_type_info_member_types = nullptr;
|
|
|
-gb_global irValue *ir_global_type_info_member_names = nullptr;
|
|
|
-gb_global irValue *ir_global_type_info_member_offsets = nullptr;
|
|
|
-gb_global irValue *ir_global_type_info_member_usings = nullptr;
|
|
|
-gb_global irValue *ir_global_type_info_member_tags = nullptr;
|
|
|
-
|
|
|
-gb_global i32 ir_global_type_info_data_index = 0;
|
|
|
-gb_global i32 ir_global_type_info_member_types_index = 0;
|
|
|
-gb_global i32 ir_global_type_info_member_names_index = 0;
|
|
|
-gb_global i32 ir_global_type_info_member_offsets_index = 0;
|
|
|
-gb_global i32 ir_global_type_info_member_usings_index = 0;
|
|
|
-gb_global i32 ir_global_type_info_member_tags_index = 0;
|
|
|
-
|
|
|
-isize ir_type_info_count(CheckerInfo *info) {
|
|
|
- return info->minimum_dependency_type_info_set.entries.count+1;
|
|
|
-}
|
|
|
-
|
|
|
-isize ir_type_info_index(CheckerInfo *info, Type *type, bool err_on_not_found=true) {
|
|
|
- isize index = type_info_index(info, type, false);
|
|
|
- if (index >= 0) {
|
|
|
- auto *set = &info->minimum_dependency_type_info_set;
|
|
|
- for_array(i, set->entries) {
|
|
|
- if (set->entries[i].ptr == index) {
|
|
|
- return i+1;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (err_on_not_found) {
|
|
|
- GB_PANIC("NOT FOUND ir_type_info_index %s @ index %td", type_to_string(type), index);
|
|
|
- }
|
|
|
- return -1;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_type_info(irProcedure *proc, Type *type) {
|
|
|
- CheckerInfo *info = proc->module->info;
|
|
|
- type = default_type(type);
|
|
|
-
|
|
|
- i32 id = cast(i32)ir_type_info_index(info, type);
|
|
|
- GB_ASSERT(id >= 0);
|
|
|
- return ir_emit_array_ep(proc, ir_global_type_info_data, ir_const_i32(id));
|
|
|
-}
|
|
|
-
|
|
|
-u64 ir_typeid_as_integer(irModule *m, Type *type) {
|
|
|
- if (type == nullptr) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- type = default_type(type);
|
|
|
-
|
|
|
- u64 id = cast(u64)ir_type_info_index(m->info, type);
|
|
|
- GB_ASSERT(id >= 0);
|
|
|
-
|
|
|
- u64 kind = Typeid_Invalid;
|
|
|
- u64 named = is_type_named(type) && type->kind != Type_Basic;
|
|
|
- u64 special = 0;
|
|
|
- u64 reserved = 0;
|
|
|
-
|
|
|
- Type *bt = base_type(type);
|
|
|
- TypeKind tk = bt->kind;
|
|
|
- switch (tk) {
|
|
|
- case Type_Basic: {
|
|
|
- u32 flags = bt->Basic.flags;
|
|
|
- if (flags & BasicFlag_Boolean) kind = Typeid_Boolean;
|
|
|
- if (flags & BasicFlag_Integer) kind = Typeid_Integer;
|
|
|
- if (flags & BasicFlag_Unsigned) kind = Typeid_Integer;
|
|
|
- if (flags & BasicFlag_Float) kind = Typeid_Float;
|
|
|
- if (flags & BasicFlag_Complex) kind = Typeid_Complex;
|
|
|
- if (flags & BasicFlag_Pointer) kind = Typeid_Pointer;
|
|
|
- if (flags & BasicFlag_String) kind = Typeid_String;
|
|
|
- if (flags & BasicFlag_Rune) kind = Typeid_Rune;
|
|
|
- } break;
|
|
|
- case Type_Pointer: kind = Typeid_Pointer; break;
|
|
|
- case Type_Array: kind = Typeid_Array; break;
|
|
|
- case Type_EnumeratedArray: kind = Typeid_Enumerated_Array; break;
|
|
|
- case Type_Slice: kind = Typeid_Slice; break;
|
|
|
- case Type_DynamicArray: kind = Typeid_Dynamic_Array; break;
|
|
|
- case Type_Map: kind = Typeid_Map; break;
|
|
|
- case Type_Struct: kind = Typeid_Struct; break;
|
|
|
- case Type_Enum: kind = Typeid_Enum; break;
|
|
|
- case Type_Union: kind = Typeid_Union; break;
|
|
|
- case Type_Tuple: kind = Typeid_Tuple; break;
|
|
|
- case Type_Proc: kind = Typeid_Procedure; break;
|
|
|
- case Type_BitSet: kind = Typeid_Bit_Set; break;
|
|
|
- case Type_SimdVector: kind = Typeid_Simd_Vector; break;
|
|
|
- case Type_RelativePointer: kind = Typeid_Relative_Pointer; break;
|
|
|
- case Type_RelativeSlice: kind = Typeid_Relative_Slice; break;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_cstring(type)) {
|
|
|
- special = 1;
|
|
|
- } else if (is_type_integer(type) && !is_type_unsigned(type)) {
|
|
|
- special = 1;
|
|
|
- }
|
|
|
-
|
|
|
- u64 data = 0;
|
|
|
- if (build_context.word_size == 4) {
|
|
|
- data |= (id &~ (1u<<24)) << 0u; // index
|
|
|
- data |= (kind &~ (1u<<5)) << 24u; // kind
|
|
|
- data |= (named &~ (1u<<1)) << 29u; // kind
|
|
|
- data |= (special &~ (1u<<1)) << 30u; // kind
|
|
|
- data |= (reserved &~ (1u<<1)) << 31u; // kind
|
|
|
- } else {
|
|
|
- GB_ASSERT(build_context.word_size == 8);
|
|
|
- data |= (id &~ (1ull<<56)) << 0ul; // index
|
|
|
- data |= (kind &~ (1ull<<5)) << 56ull; // kind
|
|
|
- data |= (named &~ (1ull<<1)) << 61ull; // kind
|
|
|
- data |= (special &~ (1ull<<1)) << 62ull; // kind
|
|
|
- data |= (reserved &~ (1ull<<1)) << 63ull; // kind
|
|
|
- }
|
|
|
-
|
|
|
- return id;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_typeid(irModule *m, Type *type) {
|
|
|
- return ir_value_constant(t_typeid, exact_value_u64(ir_typeid_as_integer(m, type)));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_logical_binary_expr(irProcedure *proc, TokenKind op, Ast *left, Ast *right, Type *type) {
|
|
|
- irBlock *rhs = ir_new_block(proc, nullptr, "logical.cmp.rhs");
|
|
|
- irBlock *done = ir_new_block(proc, nullptr, "logical.cmp.done");
|
|
|
-
|
|
|
- type = default_type(type);
|
|
|
-
|
|
|
- irValue *short_circuit = nullptr;
|
|
|
- if (op == Token_CmpAnd) {
|
|
|
- ir_build_cond(proc, left, rhs, done);
|
|
|
- short_circuit = v_false;
|
|
|
- } else if (op == Token_CmpOr) {
|
|
|
- ir_build_cond(proc, left, done, rhs);
|
|
|
- short_circuit = v_true;
|
|
|
- }
|
|
|
-
|
|
|
- if (rhs->preds.count == 0) {
|
|
|
- ir_start_block(proc, done);
|
|
|
- return short_circuit;
|
|
|
- }
|
|
|
-
|
|
|
- if (done->preds.count == 0) {
|
|
|
- ir_start_block(proc, rhs);
|
|
|
- return ir_build_expr(proc, right);
|
|
|
- }
|
|
|
-
|
|
|
- auto edges = array_make<irValue *>(ir_allocator(), 0, done->preds.count+1);
|
|
|
- for_array(i, done->preds) {
|
|
|
- irValue *edge = ir_emit_conv(proc, short_circuit, type);
|
|
|
- array_add(&edges, edge);
|
|
|
- }
|
|
|
-
|
|
|
- ir_start_block(proc, rhs);
|
|
|
- irValue *edge = ir_emit_conv(proc, ir_build_expr(proc, right), type);
|
|
|
- array_add(&edges, edge);
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_phi(proc, edges, type));
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_logical_binary_expr(irProcedure *proc, Ast *expr) {
|
|
|
- ast_node(be, BinaryExpr, expr);
|
|
|
-
|
|
|
- Type *type = type_of_expr(expr);
|
|
|
- type = default_type(type);
|
|
|
-
|
|
|
- return ir_emit_logical_binary_expr(proc, be->op.kind, be->left, be->right, type);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_emit_bounds_check(irProcedure *proc, Token token, irValue *index, irValue *len) {
|
|
|
- if (build_context.no_bounds_check) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if ((proc->module->state_flags & StateFlag_no_bounds_check) != 0) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- index = ir_emit_conv(proc, index, t_int);
|
|
|
- len = ir_emit_conv(proc, len, t_int);
|
|
|
-
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *file = ir_find_or_add_entity_string(proc->module, get_file_path_string(token.pos.file_id));
|
|
|
- irValue *line = ir_const_i32(token.pos.line);
|
|
|
- irValue *column = ir_const_i32(token.pos.column);
|
|
|
-
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 5);
|
|
|
- args[0] = file;
|
|
|
- args[1] = line;
|
|
|
- args[2] = column;
|
|
|
- args[3] = index;
|
|
|
- args[4] = len;
|
|
|
-
|
|
|
- ir_emit_runtime_call(proc, "bounds_check_error", args);
|
|
|
-}
|
|
|
-
|
|
|
-void ir_emit_slice_bounds_check(irProcedure *proc, Token token, irValue *low, irValue *high, irValue *len, bool lower_value_used) {
|
|
|
- if (build_context.no_bounds_check) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if ((proc->module->state_flags & StateFlag_no_bounds_check) != 0) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *file = ir_find_or_add_entity_string(proc->module, get_file_path_string(token.pos.file_id));
|
|
|
- irValue *line = ir_const_i32(token.pos.line);
|
|
|
- irValue *column = ir_const_i32(token.pos.column);
|
|
|
- high = ir_emit_conv(proc, high, t_int);
|
|
|
-
|
|
|
- if (!lower_value_used) {
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 5);
|
|
|
- args[0] = file;
|
|
|
- args[1] = line;
|
|
|
- args[2] = column;
|
|
|
- args[3] = high;
|
|
|
- args[4] = len;
|
|
|
-
|
|
|
- ir_emit_runtime_call(proc, "slice_expr_error_hi", args);
|
|
|
- } else {
|
|
|
- // No need to convert unless used
|
|
|
- low = ir_emit_conv(proc, low, t_int);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 6);
|
|
|
- args[0] = file;
|
|
|
- args[1] = line;
|
|
|
- args[2] = column;
|
|
|
- args[3] = low;
|
|
|
- args[4] = high;
|
|
|
- args[5] = len;
|
|
|
-
|
|
|
- ir_emit_runtime_call(proc, "slice_expr_error_lo_hi", args);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_emit_dynamic_array_bounds_check(irProcedure *proc, Token token, irValue *low, irValue *high, irValue *max) {
|
|
|
- if (build_context.no_bounds_check) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if ((proc->module->state_flags & StateFlag_no_bounds_check) != 0) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *file = ir_find_or_add_entity_string(proc->module, get_file_path_string(token.pos.file_id));
|
|
|
- irValue *line = ir_const_i32(token.pos.line);
|
|
|
- irValue *column = ir_const_i32(token.pos.column);
|
|
|
- low = ir_emit_conv(proc, low, t_int);
|
|
|
- high = ir_emit_conv(proc, high, t_int);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 6);
|
|
|
- args[0] = file;
|
|
|
- args[1] = line;
|
|
|
- args[2] = column;
|
|
|
- args[3] = low;
|
|
|
- args[4] = high;
|
|
|
- args[5] = max;
|
|
|
-
|
|
|
- ir_emit_runtime_call(proc, "dynamic_array_expr_error", args);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// @Build
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-String ir_mangle_name(irGen *s, Entity *e) {
|
|
|
- irModule *m = &s->module;
|
|
|
- CheckerInfo *info = m->info;
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
-
|
|
|
- String name = e->token.string;
|
|
|
-
|
|
|
- AstPackage *pkg = e->pkg;
|
|
|
- GB_ASSERT_MSG(pkg != nullptr, "Missing package for '%.*s'", LIT(name));
|
|
|
- String pkgn = pkg->name;
|
|
|
- GB_ASSERT(!rune_is_digit(pkgn[0]));
|
|
|
- if (pkgn == "llvm") {
|
|
|
- pkgn = str_lit("llvm$");
|
|
|
- }
|
|
|
-
|
|
|
- isize max_len = pkgn.len + 1 + name.len + 1;
|
|
|
- bool require_suffix_id = is_type_polymorphic(e->type, true);
|
|
|
- if (e->flags & EntityFlag_NotExported) {
|
|
|
- require_suffix_id = true;
|
|
|
- }
|
|
|
- if (require_suffix_id) {
|
|
|
- max_len += 21;
|
|
|
- }
|
|
|
-
|
|
|
- u8 *new_name = gb_alloc_array(a, u8, max_len);
|
|
|
- isize new_name_len = gb_snprintf(
|
|
|
- cast(char *)new_name, max_len,
|
|
|
- "%.*s.%.*s", LIT(pkgn), LIT(name)
|
|
|
- );
|
|
|
- if (require_suffix_id) {
|
|
|
- char *str = cast(char *)new_name + new_name_len-1;
|
|
|
- isize len = max_len-new_name_len;
|
|
|
- isize extra = gb_snprintf(str, len, "-%llu", cast(unsigned long long)e->id);
|
|
|
- new_name_len += extra-1;
|
|
|
- }
|
|
|
-
|
|
|
- return make_string(new_name, new_name_len-1);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_mangle_add_sub_type_name(irModule *m, Entity *field, String parent) {
|
|
|
- if (field->kind != Entity_TypeName) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (is_type_proc(field->type)) {
|
|
|
- set_procedure_abi_types(field->type);
|
|
|
- }
|
|
|
-
|
|
|
- String cn = field->token.string;
|
|
|
- isize max_len = parent.len + 1 + 16 + 1 + cn.len;
|
|
|
- bool require_suffix_id = is_type_polymorphic(field->type, true);
|
|
|
- if (require_suffix_id) {
|
|
|
- max_len += 21;
|
|
|
- }
|
|
|
-
|
|
|
- u8 *new_name = gb_alloc_array(ir_allocator(), u8, max_len);
|
|
|
- isize new_name_len = gb_snprintf(cast(char *)new_name, max_len,
|
|
|
- "%.*s.%.*s", LIT(parent), LIT(cn));
|
|
|
-
|
|
|
- if (require_suffix_id) {
|
|
|
- char *str = cast(char *)new_name + new_name_len-1;
|
|
|
- isize len = max_len-new_name_len;
|
|
|
- isize extra = gb_snprintf(str, len, "-%llu", cast(unsigned long long)field->id);
|
|
|
- new_name_len += extra-1;
|
|
|
- }
|
|
|
-
|
|
|
- String child = {new_name, new_name_len-1};
|
|
|
- GB_ASSERT(child.len > 0);
|
|
|
- ir_add_entity_name(m, field, child);
|
|
|
- ir_gen_global_type_name(m, field, child);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irBranchBlocks ir_lookup_branch_blocks(irProcedure *proc, Ast *ident) {
|
|
|
- GB_ASSERT(ident->kind == Ast_Ident);
|
|
|
- Entity *e = entity_of_node(ident);
|
|
|
- GB_ASSERT(e->kind == Entity_Label);
|
|
|
- for_array(i, proc->branch_blocks) {
|
|
|
- irBranchBlocks *b = &proc->branch_blocks[i];
|
|
|
- if (b->label == e->Label.node) {
|
|
|
- return *b;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unreachable");
|
|
|
- irBranchBlocks empty = {};
|
|
|
- return empty;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irTargetList *ir_push_target_list(irProcedure *proc, Ast *label, irBlock *break_, irBlock *continue_, irBlock *fallthrough_) {
|
|
|
- irTargetList *tl = gb_alloc_item(ir_allocator(), irTargetList);
|
|
|
- tl->prev = proc->target_list;
|
|
|
- tl->break_ = break_;
|
|
|
- tl->continue_ = continue_;
|
|
|
- tl->fallthrough_ = fallthrough_;
|
|
|
- proc->target_list = tl;
|
|
|
-
|
|
|
- if (label != nullptr) { // Set label blocks
|
|
|
- GB_ASSERT(label->kind == Ast_Label);
|
|
|
-
|
|
|
- for_array(i, proc->branch_blocks) {
|
|
|
- irBranchBlocks *b = &proc->branch_blocks[i];
|
|
|
- GB_ASSERT(b->label != nullptr && label != nullptr);
|
|
|
- GB_ASSERT(b->label->kind == Ast_Label);
|
|
|
- if (b->label == label) {
|
|
|
- b->break_ = break_;
|
|
|
- b->continue_ = continue_;
|
|
|
- return tl;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("ir_set_label_blocks: Unreachable; Unable to find label: %s", expr_to_string(label->Label.name));
|
|
|
- }
|
|
|
-
|
|
|
- return tl;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_pop_target_list(irProcedure *proc) {
|
|
|
- proc->target_list = proc->target_list->prev;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_gen_anonymous_proc_lit(irModule *m, String prefix_name, Ast *expr, irProcedure *proc) {
|
|
|
- auto *found = map_get(&m->anonymous_proc_lits, hash_pointer(expr));
|
|
|
- if (found != nullptr) {
|
|
|
- return *found;
|
|
|
- }
|
|
|
-
|
|
|
- ast_node(pl, ProcLit, expr);
|
|
|
-
|
|
|
- // NOTE(bill): Generate a new name
|
|
|
- // parent$count
|
|
|
- isize name_len = prefix_name.len + 1 + 8 + 1;
|
|
|
- u8 *name_text = gb_alloc_array(ir_allocator(), u8, name_len);
|
|
|
- i32 name_id = cast(i32)m->anonymous_proc_lits.entries.count;
|
|
|
-
|
|
|
- name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s$anon-%d", LIT(prefix_name), name_id);
|
|
|
- String name = make_string(name_text, name_len-1);
|
|
|
-
|
|
|
- Type *type = type_of_expr(expr);
|
|
|
- set_procedure_abi_types(type);
|
|
|
- irValue *value = ir_value_procedure(m, nullptr, type, pl->type, pl->body, name);
|
|
|
-
|
|
|
- value->Proc.proc_lit = expr;
|
|
|
- value->Proc.tags = pl->tags;
|
|
|
- value->Proc.inlining = pl->inlining;
|
|
|
- value->Proc.parent = proc;
|
|
|
-
|
|
|
- array_add(&m->procs_to_generate, value);
|
|
|
- if (proc != nullptr) {
|
|
|
- array_add(&proc->children, &value->Proc);
|
|
|
- } else {
|
|
|
- string_map_set(&m->members, name, value);
|
|
|
- }
|
|
|
-
|
|
|
- map_set(&m->anonymous_proc_lits, hash_pointer(expr), value);
|
|
|
-
|
|
|
- return value;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_gen_global_type_name(irModule *m, Entity *e, String name) {
|
|
|
- if (e->type == nullptr) return;
|
|
|
-
|
|
|
- if (e->kind == Entity_TypeName && e->type->kind == Type_Named) {
|
|
|
- if (e != e->type->Named.type_name) {
|
|
|
- // NOTE(bill): Is alias
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- Type *bt = base_type(e->type);
|
|
|
-
|
|
|
- bool is_poly = is_type_polymorphic(bt);
|
|
|
- if (!is_poly) {
|
|
|
- if (bt->kind == Type_Struct &&
|
|
|
- bt->Struct.is_polymorphic &&
|
|
|
- !bt->Struct.is_poly_specialized) {
|
|
|
- is_poly = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (is_poly) {
|
|
|
- auto found = map_get(&m->info->gen_types, hash_pointer(e->type));
|
|
|
- if (found != nullptr) {
|
|
|
- for_array(i, *found) {
|
|
|
- Entity *sub = (*found)[i];
|
|
|
- // gb_printf_err("--> %.*s %p\n", LIT(sub->token.string), sub);
|
|
|
- if (ir_min_dep_entity(m, sub)) {
|
|
|
- ir_mangle_add_sub_type_name(m, sub, name);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (!ir_min_dep_entity(m, e)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (is_type_proc(e->type)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- irValue *t = ir_value_type_name(name, e->type);
|
|
|
- ir_module_add_value(m, e, t);
|
|
|
- string_map_set(&m->members, name, t);
|
|
|
-
|
|
|
- // if (bt->kind == Type_Struct) {
|
|
|
- // Scope *s = bt->Struct.scope;
|
|
|
- // if (s != nullptr) {
|
|
|
- // for_array(i, s->elements.entries) {
|
|
|
- // Entity *e = s->elements.entries[i].value;
|
|
|
- // if (e->kind == Entity_TypeName) {
|
|
|
- // ir_mangle_add_sub_type_name(m, e, name);
|
|
|
- // }
|
|
|
- // }
|
|
|
- // }
|
|
|
- // }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void ir_build_defer_stmt(irProcedure *proc, irDefer d) {
|
|
|
- irBlock *b = ir_new_block(proc, nullptr, "defer");
|
|
|
- // NOTE(bill): The prev block may defer injection before it's terminator
|
|
|
- irInstr *last_instr = ir_get_last_instr(proc->curr_block);
|
|
|
- if (last_instr == nullptr || !ir_is_instr_terminating(last_instr)) {
|
|
|
- ir_emit_jump(proc, b);
|
|
|
- }
|
|
|
- ir_start_block(proc, b);
|
|
|
- ir_emit_comment(proc, str_lit("defer"));
|
|
|
- if (d.kind == irDefer_Node) {
|
|
|
- ir_build_stmt(proc, d.stmt);
|
|
|
- } else if (d.kind == irDefer_Instr) {
|
|
|
- // NOTE(bill): Need to make a new copy
|
|
|
- irValue *instr = cast(irValue *)gb_alloc_copy(ir_allocator(), d.instr, gb_size_of(irValue));
|
|
|
- ir_emit(proc, instr);
|
|
|
- } else if (d.kind == irDefer_Proc) {
|
|
|
- ir_emit_call(proc, d.proc.deferred, d.proc.result_as_args);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_min(irProcedure *proc, Type *t, irValue *x, irValue *y) {
|
|
|
- x = ir_emit_conv(proc, x, t);
|
|
|
- y = ir_emit_conv(proc, y, t);
|
|
|
-
|
|
|
- if (is_type_float(t)) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- i64 sz = 8*type_size_of(t);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = x;
|
|
|
- args[1] = y;
|
|
|
- switch (sz) {
|
|
|
- case 16: return ir_emit_runtime_call(proc, "min_f16", args);
|
|
|
- case 32: return ir_emit_runtime_call(proc, "min_f32", args);
|
|
|
- case 64: return ir_emit_runtime_call(proc, "min_f64", args);
|
|
|
- }
|
|
|
- GB_PANIC("Unknown float type");
|
|
|
- }
|
|
|
- return ir_emit_select(proc, ir_emit_comp(proc, Token_Lt, x, y), x, y);
|
|
|
-}
|
|
|
-irValue *ir_emit_max(irProcedure *proc, Type *t, irValue *x, irValue *y) {
|
|
|
- x = ir_emit_conv(proc, x, t);
|
|
|
- y = ir_emit_conv(proc, y, t);
|
|
|
-
|
|
|
- if (is_type_float(t)) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- i64 sz = 8*type_size_of(t);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = x;
|
|
|
- args[1] = y;
|
|
|
- switch (sz) {
|
|
|
- case 16: return ir_emit_runtime_call(proc, "max_f16", args);
|
|
|
- case 32: return ir_emit_runtime_call(proc, "max_f32", args);
|
|
|
- case 64: return ir_emit_runtime_call(proc, "max_f64", args);
|
|
|
- }
|
|
|
- GB_PANIC("Unknown float type");
|
|
|
- }
|
|
|
- return ir_emit_select(proc, ir_emit_comp(proc, Token_Gt, x, y), x, y);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_clamp(irProcedure *proc, Type *t, irValue *x, irValue *min, irValue *max) {
|
|
|
- ir_emit_comment(proc, str_lit("clamp"));
|
|
|
- irValue *z = nullptr;
|
|
|
- z = ir_emit_max(proc, t, x, min);
|
|
|
- z = ir_emit_min(proc, t, z, max);
|
|
|
- return z;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_find_global_variable(irProcedure *proc, String name) {
|
|
|
- AstPackage *pkg = proc->module->info->runtime_package;
|
|
|
- Entity *e = scope_lookup_current(pkg->scope, name);
|
|
|
- irValue **value = map_get(&proc->module->values, hash_entity(e));
|
|
|
- GB_ASSERT_MSG(value != nullptr, "Unable to find global variable '%.*s'", LIT(name));
|
|
|
- return *value;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_stmt_list(irProcedure *proc, Slice<Ast *> stmts);
|
|
|
-void ir_build_assign_op(irProcedure *proc, irAddr const &lhs, irValue *value, TokenKind op);
|
|
|
-
|
|
|
-bool is_double_pointer(Type *t) {
|
|
|
- if (!is_type_pointer(t)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- Type *td = type_deref(t);
|
|
|
- if (td == nullptr || td == t) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return is_type_pointer(td);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_emit_source_code_location(irProcedure *proc, String procedure, TokenPos pos) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *v = ir_alloc_value(irValue_SourceCodeLocation);
|
|
|
- v->SourceCodeLocation.file = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
|
|
|
- v->SourceCodeLocation.line = ir_const_i32(pos.line);
|
|
|
- v->SourceCodeLocation.column = ir_const_i32(pos.column);
|
|
|
- v->SourceCodeLocation.procedure = ir_find_or_add_entity_string(proc->module, procedure);
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_emit_source_code_location(irProcedure *proc, Ast *node) {
|
|
|
- String proc_name = {};
|
|
|
- if (proc->entity) {
|
|
|
- proc_name = proc->entity->token.string;
|
|
|
- }
|
|
|
- TokenPos pos = {};
|
|
|
- if (node) {
|
|
|
- pos = ast_token(node).pos;
|
|
|
- }
|
|
|
- return ir_emit_source_code_location(proc, proc_name, pos);
|
|
|
-}
|
|
|
-
|
|
|
-void ir_emit_increment(irProcedure *proc, irValue *addr) {
|
|
|
- GB_ASSERT(is_type_pointer(ir_type(addr)));
|
|
|
- Type *type = type_deref(ir_type(addr));
|
|
|
- ir_emit_store(proc, addr, ir_emit_arith(proc, Token_Add, ir_emit_load(proc, addr), v_one, type));
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-void ir_init_data_with_defaults(irProcedure *proc, irValue *ptr, irValue *count, Ast *expr) {
|
|
|
- Type *elem_type = type_deref(ir_type(ptr));
|
|
|
- GB_ASSERT(is_type_struct(elem_type) || is_type_array(elem_type));
|
|
|
-
|
|
|
- irValue *index = ir_add_local_generated(proc, t_int, false);
|
|
|
- ir_emit_store(proc, index, ir_const_int(0));
|
|
|
-
|
|
|
- irBlock *loop = nullptr;
|
|
|
- irBlock *done = nullptr;
|
|
|
- irBlock *body = nullptr;
|
|
|
-
|
|
|
- loop = ir_new_block(proc, nullptr, "make.init.loop");
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, loop);
|
|
|
-
|
|
|
- body = ir_new_block(proc, nullptr, "make.init.body");
|
|
|
- done = ir_new_block(proc, nullptr, "make.init.done");
|
|
|
-
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_Lt, ir_emit_load(proc, index), count);
|
|
|
- ir_emit_if(proc, cond, body, done);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- irValue *offset_ptr = ir_emit_ptr_offset(proc, ptr, ir_emit_load(proc, index));
|
|
|
- ir_emit(proc, ir_instr_zero_init(proc, offset_ptr)); // Use simple zero for this
|
|
|
- // ir_emit_zero_init(proc, offset_ptr, expr);
|
|
|
-
|
|
|
- ir_emit_increment(proc, index);
|
|
|
-
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, done);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_build_builtin_proc(irProcedure *proc, Ast *expr, TypeAndValue tv, BuiltinProcId id) {
|
|
|
- ast_node(ce, CallExpr, expr);
|
|
|
-
|
|
|
- switch (id) {
|
|
|
- case BuiltinProc_DIRECTIVE: {
|
|
|
- ast_node(bd, BasicDirective, ce->proc);
|
|
|
- String name = bd->name;
|
|
|
- GB_ASSERT(name == "location");
|
|
|
- String procedure = proc->entity->token.string;
|
|
|
- TokenPos pos = ast_token(ce->proc).pos;
|
|
|
- if (ce->args.count > 0) {
|
|
|
- Ast *ident = unselector_expr(ce->args[0]);
|
|
|
- GB_ASSERT(ident->kind == Ast_Ident);
|
|
|
- Entity *e = entity_of_node(ident);
|
|
|
- GB_ASSERT(e != nullptr);
|
|
|
-
|
|
|
- if (e->parent_proc_decl != nullptr && e->parent_proc_decl->entity != nullptr) {
|
|
|
- procedure = e->parent_proc_decl->entity->token.string;
|
|
|
- } else {
|
|
|
- procedure = str_lit("");
|
|
|
- }
|
|
|
- pos = e->token.pos;
|
|
|
-
|
|
|
- }
|
|
|
- return ir_emit_source_code_location(proc, procedure, pos);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_type_info_of: {
|
|
|
- Ast *arg = ce->args[0];
|
|
|
- TypeAndValue tav = type_and_value_of_expr(arg);
|
|
|
- if (tav.mode == Addressing_Type) {
|
|
|
- Type *t = default_type(type_of_expr(arg));
|
|
|
- return ir_type_info(proc, t);
|
|
|
- }
|
|
|
- GB_ASSERT(is_type_typeid(tav.type));
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = ir_build_expr(proc, arg);
|
|
|
- return ir_emit_runtime_call(proc, "__type_info_of", args);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_typeid_of: {
|
|
|
- Ast *arg = ce->args[0];
|
|
|
- TypeAndValue tav = type_and_value_of_expr(arg);
|
|
|
- if (tav.mode == Addressing_Type) {
|
|
|
- Type *t = default_type(type_of_expr(arg));
|
|
|
- return ir_typeid(proc->module, t);
|
|
|
- }
|
|
|
- Type *t = base_type(tav.type);
|
|
|
- GB_ASSERT(are_types_identical(t, t_type_info_ptr));
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = ir_emit_conv(proc, ir_build_expr(proc, arg), t_type_info_ptr);
|
|
|
- return ir_emit_runtime_call(proc, "__typeid_of", args);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_len: {
|
|
|
- irValue *v = ir_build_expr(proc, ce->args[0]);
|
|
|
- Type *t = base_type(ir_type(v));
|
|
|
- if (is_type_pointer(t)) {
|
|
|
- // IMPORTANT TODO(bill): Should there be a nil pointer check?
|
|
|
- v = ir_emit_load(proc, v);
|
|
|
- t = type_deref(t);
|
|
|
- }
|
|
|
- if (is_type_cstring(t)) {
|
|
|
- return ir_cstring_len(proc, v);
|
|
|
- } else if (is_type_string(t)) {
|
|
|
- return ir_string_len(proc, v);
|
|
|
- } else if (is_type_array(t)) {
|
|
|
- GB_PANIC("Array lengths are constant");
|
|
|
- } else if (is_type_slice(t)) {
|
|
|
- return ir_slice_len(proc, v);
|
|
|
- } else if (is_type_dynamic_array(t)) {
|
|
|
- return ir_dynamic_array_len(proc, v);
|
|
|
- } else if (is_type_map(t)) {
|
|
|
- return ir_map_len(proc, v);
|
|
|
- } else if (is_type_soa_struct(t)) {
|
|
|
- return ir_soa_struct_len(proc, v);
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unreachable");
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_cap: {
|
|
|
- irValue *v = ir_build_expr(proc, ce->args[0]);
|
|
|
- Type *t = base_type(ir_type(v));
|
|
|
- if (is_type_pointer(t)) {
|
|
|
- // IMPORTANT TODO(bill): Should there be a nil pointer check?
|
|
|
- v = ir_emit_load(proc, v);
|
|
|
- t = type_deref(t);
|
|
|
- }
|
|
|
- if (is_type_string(t)) {
|
|
|
- GB_PANIC("Unreachable");
|
|
|
- } else if (is_type_array(t)) {
|
|
|
- GB_PANIC("Array lengths are constant");
|
|
|
- } else if (is_type_slice(t)) {
|
|
|
- return ir_slice_len(proc, v);
|
|
|
- } else if (is_type_dynamic_array(t)) {
|
|
|
- return ir_dynamic_array_cap(proc, v);
|
|
|
- } else if (is_type_map(t)) {
|
|
|
- return ir_map_cap(proc, v);
|
|
|
- } else if (is_type_soa_struct(t)) {
|
|
|
- return ir_soa_struct_cap(proc, v);
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unreachable");
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_swizzle: {
|
|
|
- ir_emit_comment(proc, str_lit("swizzle.begin"));
|
|
|
- irAddr addr = ir_build_addr(proc, ce->args[0]);
|
|
|
- isize index_count = ce->args.count-1;
|
|
|
- if (index_count == 0) {
|
|
|
- return ir_addr_load(proc, addr);
|
|
|
- }
|
|
|
- irValue *src = ir_addr_get_ptr(proc, addr);
|
|
|
- // TODO(bill): Should this be zeroed or not?
|
|
|
- irValue *dst = ir_add_local_generated(proc, tv.type, true);
|
|
|
-
|
|
|
- for (i32 i = 1; i < ce->args.count; i++) {
|
|
|
- TypeAndValue tv = type_and_value_of_expr(ce->args[i]);
|
|
|
- GB_ASSERT(is_type_integer(tv.type));
|
|
|
- GB_ASSERT(tv.value.kind == ExactValue_Integer);
|
|
|
-
|
|
|
- i32 src_index = cast(i32)big_int_to_i64(&tv.value.value_integer);
|
|
|
- i32 dst_index = i-1;
|
|
|
-
|
|
|
- irValue *src_elem = ir_emit_array_epi(proc, src, src_index);
|
|
|
- irValue *dst_elem = ir_emit_array_epi(proc, dst, dst_index);
|
|
|
-
|
|
|
- ir_emit_store(proc, dst_elem, ir_emit_load(proc, src_elem));
|
|
|
- }
|
|
|
- ir_emit_comment(proc, str_lit("swizzle.end"));
|
|
|
- return ir_emit_load(proc, dst);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_complex: {
|
|
|
- ir_emit_comment(proc, str_lit("complex"));
|
|
|
- irValue *real = ir_build_expr(proc, ce->args[0]);
|
|
|
- irValue *imag = ir_build_expr(proc, ce->args[1]);
|
|
|
- irValue *dst = ir_add_local_generated(proc, tv.type, false);
|
|
|
-
|
|
|
- Type *ft = base_complex_elem_type(tv.type);
|
|
|
- real = ir_emit_conv(proc, real, ft);
|
|
|
- imag = ir_emit_conv(proc, imag, ft);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 0), real);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 1), imag);
|
|
|
-
|
|
|
- return ir_emit_load(proc, dst);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_quaternion: {
|
|
|
- ir_emit_comment(proc, str_lit("quaternion"));
|
|
|
- irValue *real = ir_build_expr(proc, ce->args[0]);
|
|
|
- irValue *imag = ir_build_expr(proc, ce->args[1]);
|
|
|
- irValue *jmag = ir_build_expr(proc, ce->args[2]);
|
|
|
- irValue *kmag = ir_build_expr(proc, ce->args[3]);
|
|
|
-
|
|
|
- // @QuaternionLayout
|
|
|
- irValue *dst = ir_add_local_generated(proc, tv.type, false);
|
|
|
- Type *ft = base_complex_elem_type(tv.type);
|
|
|
- real = ir_emit_conv(proc, real, ft);
|
|
|
- imag = ir_emit_conv(proc, imag, ft);
|
|
|
- jmag = ir_emit_conv(proc, jmag, ft);
|
|
|
- kmag = ir_emit_conv(proc, kmag, ft);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 3), real);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 0), imag);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 1), jmag);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, dst, 2), kmag);
|
|
|
-
|
|
|
- return ir_emit_load(proc, dst);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_real: {
|
|
|
- ir_emit_comment(proc, str_lit("real"));
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[0]);
|
|
|
- if (is_type_complex(ir_type(val))) {
|
|
|
- irValue *real = ir_emit_struct_ev(proc, val, 0);
|
|
|
- return ir_emit_conv(proc, real, tv.type);
|
|
|
- } else if (is_type_quaternion(ir_type(val))) {
|
|
|
- // @QuaternionLayout
|
|
|
- irValue *real = ir_emit_struct_ev(proc, val, 3);
|
|
|
- return ir_emit_conv(proc, real, tv.type);
|
|
|
- }
|
|
|
- GB_PANIC("invalid type for real");
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- case BuiltinProc_imag: {
|
|
|
- ir_emit_comment(proc, str_lit("imag"));
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[0]);
|
|
|
- if (is_type_complex(ir_type(val))) {
|
|
|
- irValue *imag = ir_emit_struct_ev(proc, val, 1);
|
|
|
- return ir_emit_conv(proc, imag, tv.type);
|
|
|
- } else if (is_type_quaternion(ir_type(val))) {
|
|
|
- // @QuaternionLayout
|
|
|
- irValue *imag = ir_emit_struct_ev(proc, val, 0);
|
|
|
- return ir_emit_conv(proc, imag, tv.type);
|
|
|
- }
|
|
|
- GB_PANIC("invalid type for imag");
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- case BuiltinProc_jmag: {
|
|
|
- ir_emit_comment(proc, str_lit("jmag"));
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[0]);
|
|
|
- if (is_type_quaternion(ir_type(val))) {
|
|
|
- // @QuaternionLayout
|
|
|
- irValue *imag = ir_emit_struct_ev(proc, val, 1);
|
|
|
- return ir_emit_conv(proc, imag, tv.type);
|
|
|
- }
|
|
|
- GB_PANIC("invalid type for jmag");
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- case BuiltinProc_kmag: {
|
|
|
- ir_emit_comment(proc, str_lit("kmag"));
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[0]);
|
|
|
- if (is_type_quaternion(ir_type(val))) {
|
|
|
- // @QuaternionLayout
|
|
|
- irValue *imag = ir_emit_struct_ev(proc, val, 2);
|
|
|
- return ir_emit_conv(proc, imag, tv.type);
|
|
|
- }
|
|
|
- GB_PANIC("invalid type for kmag");
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_conj: {
|
|
|
- ir_emit_comment(proc, str_lit("conj"));
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[0]);
|
|
|
- irValue *res = nullptr;
|
|
|
- Type *t = ir_type(val);
|
|
|
- if (is_type_complex(t)) {
|
|
|
- res = ir_add_local_generated(proc, tv.type, false);
|
|
|
- irValue *real = ir_emit_struct_ev(proc, val, 0);
|
|
|
- irValue *imag = ir_emit_struct_ev(proc, val, 1);
|
|
|
- imag = ir_emit_unary_arith(proc, Token_Sub, imag, ir_type(imag));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), real);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), imag);
|
|
|
- } else if (is_type_quaternion(t)) {
|
|
|
- // @QuaternionLayout
|
|
|
- res = ir_add_local_generated(proc, tv.type, false);
|
|
|
- irValue *real = ir_emit_struct_ev(proc, val, 3);
|
|
|
- irValue *imag = ir_emit_struct_ev(proc, val, 0);
|
|
|
- irValue *jmag = ir_emit_struct_ev(proc, val, 1);
|
|
|
- irValue *kmag = ir_emit_struct_ev(proc, val, 2);
|
|
|
- imag = ir_emit_unary_arith(proc, Token_Sub, imag, ir_type(imag));
|
|
|
- jmag = ir_emit_unary_arith(proc, Token_Sub, jmag, ir_type(jmag));
|
|
|
- kmag = ir_emit_unary_arith(proc, Token_Sub, kmag, ir_type(kmag));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 3), real);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 0), imag);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 1), jmag);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, res, 2), kmag);
|
|
|
- }
|
|
|
- return ir_emit_load(proc, res);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_expand_to_tuple: {
|
|
|
- ir_emit_comment(proc, str_lit("expand_to_tuple"));
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[0]);
|
|
|
- Type *t = base_type(ir_type(val));
|
|
|
-
|
|
|
- if (!is_type_tuple(tv.type)) {
|
|
|
- if (t->kind == Type_Struct) {
|
|
|
- GB_ASSERT(t->Struct.fields.count == 1);
|
|
|
- return ir_emit_struct_ev(proc, val, 0);
|
|
|
- } else if (t->kind == Type_Array) {
|
|
|
- GB_ASSERT(t->Array.count == 1);
|
|
|
- return ir_emit_array_epi(proc, val, 0);
|
|
|
- } else {
|
|
|
- GB_PANIC("Unknown type of expand_to_tuple");
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(is_type_tuple(tv.type));
|
|
|
- // NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
|
|
|
- irValue *tuple = ir_add_local_generated(proc, tv.type, false);
|
|
|
- if (t->kind == Type_Struct) {
|
|
|
- for_array(src_index, t->Struct.fields) {
|
|
|
- Entity *field = t->Struct.fields[src_index];
|
|
|
- i32 field_index = field->Variable.field_index;
|
|
|
- irValue *f = ir_emit_struct_ev(proc, val, field_index);
|
|
|
- irValue *ep = ir_emit_struct_ep(proc, tuple, cast(i32)src_index);
|
|
|
- ir_emit_store(proc, ep, f);
|
|
|
- }
|
|
|
- } else if (t->kind == Type_Array) {
|
|
|
- // TODO(bill): Clean-up this code
|
|
|
- irValue *ap = ir_address_from_load_or_generate_local(proc, val);
|
|
|
- for (i32 i = 0; i < cast(i32)t->Array.count; i++) {
|
|
|
- irValue *f = ir_emit_load(proc, ir_emit_array_epi(proc, ap, i));
|
|
|
- irValue *ep = ir_emit_struct_ep(proc, tuple, i);
|
|
|
- ir_emit_store(proc, ep, f);
|
|
|
- }
|
|
|
- } else {
|
|
|
- GB_PANIC("Unknown type of expand_to_tuple");
|
|
|
- }
|
|
|
- return ir_emit_load(proc, tuple);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_min: {
|
|
|
- ir_emit_comment(proc, str_lit("min"));
|
|
|
- Type *t = type_of_expr(expr);
|
|
|
- if (ce->args.count == 2) {
|
|
|
- return ir_emit_min(proc, t, ir_build_expr(proc, ce->args[0]), ir_build_expr(proc, ce->args[1]));
|
|
|
- } else {
|
|
|
- irValue *x = ir_build_expr(proc, ce->args[0]);
|
|
|
- for (isize i = 1; i < ce->args.count; i++) {
|
|
|
- x = ir_emit_min(proc, t, x, ir_build_expr(proc, ce->args[i]));
|
|
|
- }
|
|
|
- return x;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_max: {
|
|
|
- ir_emit_comment(proc, str_lit("max"));
|
|
|
- Type *t = type_of_expr(expr);
|
|
|
- if (ce->args.count == 2) {
|
|
|
- return ir_emit_max(proc, t, ir_build_expr(proc, ce->args[0]), ir_build_expr(proc, ce->args[1]));
|
|
|
- } else {
|
|
|
- irValue *x = ir_build_expr(proc, ce->args[0]);
|
|
|
- for (isize i = 1; i < ce->args.count; i++) {
|
|
|
- x = ir_emit_max(proc, t, x, ir_build_expr(proc, ce->args[i]));
|
|
|
- }
|
|
|
- return x;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_abs: {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *x = ir_build_expr(proc, ce->args[0]);
|
|
|
- Type *t = ir_type(x);
|
|
|
- if (is_type_unsigned(t)) {
|
|
|
- return x;
|
|
|
- }
|
|
|
- ir_emit_comment(proc, str_lit("abs"));
|
|
|
- if (is_type_quaternion(t)) {
|
|
|
- i64 sz = 8*type_size_of(t);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = x;
|
|
|
- switch (sz) {
|
|
|
- case 64: return ir_emit_runtime_call(proc, "abs_quaternion64", args);
|
|
|
- case 128: return ir_emit_runtime_call(proc, "abs_quaternion128", args);
|
|
|
- case 256: return ir_emit_runtime_call(proc, "abs_quaternion256", args);
|
|
|
- }
|
|
|
- GB_PANIC("Unknown complex type");
|
|
|
- } else if (is_type_complex(t)) {
|
|
|
- i64 sz = 8*type_size_of(t);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = x;
|
|
|
- switch (sz) {
|
|
|
- case 32: return ir_emit_runtime_call(proc, "abs_complex32", args);
|
|
|
- case 64: return ir_emit_runtime_call(proc, "abs_complex64", args);
|
|
|
- case 128: return ir_emit_runtime_call(proc, "abs_complex128", args);
|
|
|
- }
|
|
|
- GB_PANIC("Unknown complex type");
|
|
|
- } else if (is_type_float(t)) {
|
|
|
- i64 sz = 8*type_size_of(t);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = x;
|
|
|
- switch (sz) {
|
|
|
- case 16: return ir_emit_runtime_call(proc, "abs_f16", args);
|
|
|
- case 32: return ir_emit_runtime_call(proc, "abs_f32", args);
|
|
|
- case 64: return ir_emit_runtime_call(proc, "abs_f64", args);
|
|
|
- }
|
|
|
- GB_PANIC("Unknown float type");
|
|
|
- }
|
|
|
- irValue *zero = ir_emit_conv(proc, v_zero, t);
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_Lt, x, zero);
|
|
|
- irValue *neg = ir_emit(proc, ir_instr_unary_op(proc, Token_Sub, x, t));
|
|
|
- return ir_emit_select(proc, cond, neg, x);
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_clamp:
|
|
|
- ir_emit_comment(proc, str_lit("clamp"));
|
|
|
- return ir_emit_clamp(proc, type_of_expr(expr),
|
|
|
- ir_build_expr(proc, ce->args[0]),
|
|
|
- ir_build_expr(proc, ce->args[1]),
|
|
|
- ir_build_expr(proc, ce->args[2]));
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- // "Intrinsics"
|
|
|
- case BuiltinProc_alloca:
|
|
|
- {
|
|
|
- auto args = array_make<irValue *>(permanent_allocator(), 2);
|
|
|
- args[0] = ir_emit_conv(proc, ir_build_expr(proc, ce->args[0]), t_i32);
|
|
|
- args[1] = ir_build_expr(proc, ce->args[1]);
|
|
|
- return ir_emit(proc, ir_instr_inline_code(proc, id, args, t_u8_ptr));
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_cpu_relax:
|
|
|
- return ir_emit(proc, ir_instr_inline_code(proc, id, {}, nullptr));
|
|
|
-
|
|
|
- case BuiltinProc_volatile_store: {
|
|
|
- irValue *dst = ir_build_expr(proc, ce->args[0]);
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[1]);
|
|
|
- val = ir_emit_conv(proc, val, type_deref(ir_type(dst)));
|
|
|
- return ir_emit(proc, ir_instr_store(proc, dst, val, true));
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_volatile_load: {
|
|
|
- irValue *dst = ir_build_expr(proc, ce->args[0]);
|
|
|
- return ir_emit(proc, ir_instr_load(proc, dst, true));
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_atomic_fence:
|
|
|
- case BuiltinProc_atomic_fence_acq:
|
|
|
- case BuiltinProc_atomic_fence_rel:
|
|
|
- case BuiltinProc_atomic_fence_acqrel:
|
|
|
- return ir_emit(proc, ir_instr_atomic_fence(proc, id));
|
|
|
-
|
|
|
- case BuiltinProc_atomic_store:
|
|
|
- case BuiltinProc_atomic_store_rel:
|
|
|
- case BuiltinProc_atomic_store_relaxed:
|
|
|
- case BuiltinProc_atomic_store_unordered: {
|
|
|
- irValue *dst = ir_build_expr(proc, ce->args[0]);
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[1]);
|
|
|
- val = ir_emit_conv(proc, val, type_deref(ir_type(dst)));
|
|
|
- return ir_emit(proc, ir_instr_atomic_store(proc, dst, val, id));
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_atomic_load:
|
|
|
- case BuiltinProc_atomic_load_acq:
|
|
|
- case BuiltinProc_atomic_load_relaxed:
|
|
|
- case BuiltinProc_atomic_load_unordered: {
|
|
|
- irValue *dst = ir_build_expr(proc, ce->args[0]);
|
|
|
- return ir_emit(proc, ir_instr_atomic_load(proc, dst, id));
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_atomic_add:
|
|
|
- case BuiltinProc_atomic_add_acq:
|
|
|
- case BuiltinProc_atomic_add_rel:
|
|
|
- case BuiltinProc_atomic_add_acqrel:
|
|
|
- case BuiltinProc_atomic_add_relaxed:
|
|
|
- case BuiltinProc_atomic_sub:
|
|
|
- case BuiltinProc_atomic_sub_acq:
|
|
|
- case BuiltinProc_atomic_sub_rel:
|
|
|
- case BuiltinProc_atomic_sub_acqrel:
|
|
|
- case BuiltinProc_atomic_sub_relaxed:
|
|
|
- case BuiltinProc_atomic_and:
|
|
|
- case BuiltinProc_atomic_and_acq:
|
|
|
- case BuiltinProc_atomic_and_rel:
|
|
|
- case BuiltinProc_atomic_and_acqrel:
|
|
|
- case BuiltinProc_atomic_and_relaxed:
|
|
|
- case BuiltinProc_atomic_nand:
|
|
|
- case BuiltinProc_atomic_nand_acq:
|
|
|
- case BuiltinProc_atomic_nand_rel:
|
|
|
- case BuiltinProc_atomic_nand_acqrel:
|
|
|
- case BuiltinProc_atomic_nand_relaxed:
|
|
|
- case BuiltinProc_atomic_or:
|
|
|
- case BuiltinProc_atomic_or_acq:
|
|
|
- case BuiltinProc_atomic_or_rel:
|
|
|
- case BuiltinProc_atomic_or_acqrel:
|
|
|
- case BuiltinProc_atomic_or_relaxed:
|
|
|
- case BuiltinProc_atomic_xor:
|
|
|
- case BuiltinProc_atomic_xor_acq:
|
|
|
- case BuiltinProc_atomic_xor_rel:
|
|
|
- case BuiltinProc_atomic_xor_acqrel:
|
|
|
- case BuiltinProc_atomic_xor_relaxed:
|
|
|
- case BuiltinProc_atomic_xchg:
|
|
|
- case BuiltinProc_atomic_xchg_acq:
|
|
|
- case BuiltinProc_atomic_xchg_rel:
|
|
|
- case BuiltinProc_atomic_xchg_acqrel:
|
|
|
- case BuiltinProc_atomic_xchg_relaxed: {
|
|
|
- irValue *dst = ir_build_expr(proc, ce->args[0]);
|
|
|
- irValue *val = ir_build_expr(proc, ce->args[1]);
|
|
|
- val = ir_emit_conv(proc, val, type_deref(ir_type(dst)));
|
|
|
- return ir_emit(proc, ir_instr_atomic_rmw(proc, dst, val, id));
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_atomic_cxchg:
|
|
|
- case BuiltinProc_atomic_cxchg_acq:
|
|
|
- case BuiltinProc_atomic_cxchg_rel:
|
|
|
- case BuiltinProc_atomic_cxchg_acqrel:
|
|
|
- case BuiltinProc_atomic_cxchg_relaxed:
|
|
|
- case BuiltinProc_atomic_cxchg_failrelaxed:
|
|
|
- case BuiltinProc_atomic_cxchg_failacq:
|
|
|
- case BuiltinProc_atomic_cxchg_acq_failrelaxed:
|
|
|
- case BuiltinProc_atomic_cxchg_acqrel_failrelaxed:
|
|
|
- case BuiltinProc_atomic_cxchgweak:
|
|
|
- case BuiltinProc_atomic_cxchgweak_acq:
|
|
|
- case BuiltinProc_atomic_cxchgweak_rel:
|
|
|
- case BuiltinProc_atomic_cxchgweak_acqrel:
|
|
|
- case BuiltinProc_atomic_cxchgweak_relaxed:
|
|
|
- case BuiltinProc_atomic_cxchgweak_failrelaxed:
|
|
|
- case BuiltinProc_atomic_cxchgweak_failacq:
|
|
|
- case BuiltinProc_atomic_cxchgweak_acq_failrelaxed:
|
|
|
- case BuiltinProc_atomic_cxchgweak_acqrel_failrelaxed: {
|
|
|
- Type *type = expr->tav.type;
|
|
|
-
|
|
|
- irValue *address = ir_build_expr(proc, ce->args[0]);
|
|
|
- Type *elem = type_deref(ir_type(address));
|
|
|
- irValue *old_value = ir_build_expr(proc, ce->args[1]);
|
|
|
- irValue *new_value = ir_build_expr(proc, ce->args[2]);
|
|
|
- old_value = ir_emit_conv(proc, old_value, elem);
|
|
|
- new_value = ir_emit_conv(proc, new_value, elem);
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_atomic_cxchg(proc, type, address, old_value, new_value, id));
|
|
|
- }
|
|
|
-
|
|
|
- case BuiltinProc_type_equal_proc:
|
|
|
- return ir_get_equal_proc_for_type(proc->module, ce->args[0]->tav.type);
|
|
|
-
|
|
|
- case BuiltinProc_type_hasher_proc:
|
|
|
- return ir_get_hasher_proc_for_type(proc->module, ce->args[0]->tav.type);
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unhandled built-in procedure");
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_handle_param_value(irProcedure *proc, Type *parameter_type, ParameterValue const ¶m_value, TokenPos const &pos) {
|
|
|
- switch (param_value.kind) {
|
|
|
- case ParameterValue_Constant:
|
|
|
- if (is_type_constant_type(parameter_type)) {
|
|
|
- return ir_value_constant(parameter_type, param_value.value);
|
|
|
- } else {
|
|
|
- ExactValue ev = param_value.value;
|
|
|
- irValue *arg = nullptr;
|
|
|
- Type *type = type_of_expr(param_value.original_ast_expr);
|
|
|
- if (type != nullptr) {
|
|
|
- arg = ir_value_constant(type, ev);
|
|
|
- } else {
|
|
|
- arg = ir_value_constant(parameter_type, param_value.value);
|
|
|
- }
|
|
|
- return ir_emit_conv(proc, arg, parameter_type);
|
|
|
- }
|
|
|
-
|
|
|
- case ParameterValue_Nil:
|
|
|
- return ir_value_nil(parameter_type);
|
|
|
- case ParameterValue_Location:
|
|
|
- {
|
|
|
- String proc_name = {};
|
|
|
- if (proc->entity != nullptr) {
|
|
|
- proc_name = proc->entity->token.string;
|
|
|
- }
|
|
|
- return ir_emit_source_code_location(proc, proc_name, pos);
|
|
|
- }
|
|
|
- case ParameterValue_Value:
|
|
|
- return ir_build_expr(proc, param_value.ast_value);
|
|
|
- }
|
|
|
- return ir_value_nil(parameter_type);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_build_expr_internal(irProcedure *proc, Ast *expr);
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_build_expr(irProcedure *proc, Ast *expr) {
|
|
|
- u64 prev_state_flags = proc->module->state_flags;
|
|
|
- defer (proc->module->state_flags = prev_state_flags);
|
|
|
-
|
|
|
- if (expr->state_flags != 0) {
|
|
|
- u64 in = expr->state_flags;
|
|
|
- u64 out = proc->module->state_flags;
|
|
|
-
|
|
|
- if (in & StateFlag_bounds_check) {
|
|
|
- out |= StateFlag_bounds_check;
|
|
|
- out &= ~StateFlag_no_bounds_check;
|
|
|
- } else if (in & StateFlag_no_bounds_check) {
|
|
|
- out |= StateFlag_no_bounds_check;
|
|
|
- out &= ~StateFlag_bounds_check;
|
|
|
- }
|
|
|
-
|
|
|
- proc->module->state_flags = out;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *v = ir_build_expr_internal(proc, expr);
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_build_call_expr(irProcedure *proc, Ast *expr) {
|
|
|
- ast_node(ce, CallExpr, expr);
|
|
|
- TypeAndValue tv = type_and_value_of_expr(expr);
|
|
|
- TypeAndValue proc_tv = type_and_value_of_expr(ce->proc);
|
|
|
- AddressingMode proc_mode = proc_tv.mode;
|
|
|
- if (proc_mode == Addressing_Type) {
|
|
|
- GB_ASSERT(ce->args.count == 1);
|
|
|
- irValue *x = ir_build_expr(proc, ce->args[0]);
|
|
|
- irValue *y = ir_emit_conv(proc, x, tv.type);
|
|
|
- return y;
|
|
|
- }
|
|
|
-
|
|
|
- Ast *p = unparen_expr(ce->proc);
|
|
|
- if (proc_mode == Addressing_Builtin) {
|
|
|
- Entity *e = entity_of_node(p);
|
|
|
- BuiltinProcId id = BuiltinProc_Invalid;
|
|
|
- if (e != nullptr) {
|
|
|
- id = cast(BuiltinProcId)e->Builtin.id;
|
|
|
- } else {
|
|
|
- id = BuiltinProc_DIRECTIVE;
|
|
|
- }
|
|
|
- return ir_build_builtin_proc(proc, expr, tv, id);
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(bill): Regular call
|
|
|
- irValue *value = nullptr;
|
|
|
- Ast *proc_expr = unparen_expr(ce->proc);
|
|
|
- if (proc_expr->tav.mode == Addressing_Constant) {
|
|
|
- ExactValue v = proc_expr->tav.value;
|
|
|
- switch (v.kind) {
|
|
|
- case ExactValue_Integer:
|
|
|
- {
|
|
|
- u64 u = big_int_to_u64(&v.value_integer);
|
|
|
- irValue *x = ir_const_uintptr(u);
|
|
|
- x = ir_emit_conv(proc, x, t_rawptr);
|
|
|
- value = ir_emit_conv(proc, x, proc_expr->tav.type);
|
|
|
- break;
|
|
|
- }
|
|
|
- case ExactValue_Pointer:
|
|
|
- {
|
|
|
- u64 u = cast(u64)v.value_pointer;
|
|
|
- irValue *x = ir_const_uintptr(u);
|
|
|
- x = ir_emit_conv(proc, x, t_rawptr);
|
|
|
- value = ir_emit_conv(proc, x, proc_expr->tav.type);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- Entity *proc_entity = entity_of_node(proc_expr);
|
|
|
- if (proc_entity != nullptr) {
|
|
|
- if (proc_entity->flags & EntityFlag_Disabled) {
|
|
|
- return nullptr;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (value == nullptr) {
|
|
|
- value = ir_build_expr(proc, proc_expr);
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(value != nullptr);
|
|
|
- Type *proc_type_ = base_type(ir_type(value));
|
|
|
- GB_ASSERT(proc_type_->kind == Type_Proc);
|
|
|
- TypeProc *pt = &proc_type_->Proc;
|
|
|
- set_procedure_abi_types(proc_type_);
|
|
|
-
|
|
|
- if (is_call_expr_field_value(ce)) {
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), pt->param_count);
|
|
|
-
|
|
|
- for_array(arg_index, ce->args) {
|
|
|
- Ast *arg = ce->args[arg_index];
|
|
|
- ast_node(fv, FieldValue, arg);
|
|
|
- GB_ASSERT(fv->field->kind == Ast_Ident);
|
|
|
- String name = fv->field->Ident.token.string;
|
|
|
- isize index = lookup_procedure_parameter(pt, name);
|
|
|
- GB_ASSERT(index >= 0);
|
|
|
- TypeAndValue tav = type_and_value_of_expr(fv->value);
|
|
|
- if (tav.mode == Addressing_Type) {
|
|
|
- args[index] = ir_value_nil(tav.type);
|
|
|
- } else {
|
|
|
- args[index] = ir_build_expr(proc, fv->value);
|
|
|
- }
|
|
|
- }
|
|
|
- TypeTuple *params = &pt->params->Tuple;
|
|
|
- for (isize i = 0; i < args.count; i++) {
|
|
|
- Entity *e = params->variables[i];
|
|
|
- if (e->kind == Entity_TypeName) {
|
|
|
- args[i] = ir_value_nil(e->type);
|
|
|
- } else if (e->kind == Entity_Constant) {
|
|
|
- continue;
|
|
|
- } else {
|
|
|
- GB_ASSERT(e->kind == Entity_Variable);
|
|
|
- if (args[i] == nullptr) {
|
|
|
- args[i] = ir_handle_param_value(proc, e->type, e->Variable.param_value, ast_token(expr).pos);
|
|
|
- } else {
|
|
|
- args[i] = ir_emit_conv(proc, args[i], e->type);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return ir_emit_call(proc, value, args, ce->inlining, proc->return_ptr_hint_ast == expr);
|
|
|
- }
|
|
|
-
|
|
|
- isize arg_index = 0;
|
|
|
-
|
|
|
- isize arg_count = 0;
|
|
|
- for_array(i, ce->args) {
|
|
|
- Ast *arg = ce->args[i];
|
|
|
- TypeAndValue tav = type_and_value_of_expr(arg);
|
|
|
- GB_ASSERT_MSG(tav.mode != Addressing_Invalid, "%s %s", expr_to_string(arg), expr_to_string(expr));
|
|
|
- GB_ASSERT_MSG(tav.mode != Addressing_ProcGroup, "%s", expr_to_string(arg));
|
|
|
- Type *at = tav.type;
|
|
|
- if (at->kind == Type_Tuple) {
|
|
|
- arg_count += at->Tuple.variables.count;
|
|
|
- } else {
|
|
|
- arg_count++;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- isize param_count = 0;
|
|
|
- if (pt->params) {
|
|
|
- GB_ASSERT(pt->params->kind == Type_Tuple);
|
|
|
- param_count = pt->params->Tuple.variables.count;
|
|
|
- }
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), cast(isize)gb_max(param_count, arg_count));
|
|
|
- isize variadic_index = pt->variadic_index;
|
|
|
- bool variadic = pt->variadic && variadic_index >= 0;
|
|
|
- bool vari_expand = ce->ellipsis.pos.line != 0;
|
|
|
- bool is_c_vararg = pt->c_vararg;
|
|
|
-
|
|
|
- TypeTuple *param_tuple = nullptr;
|
|
|
- if (pt->params) {
|
|
|
- GB_ASSERT(pt->params->kind == Type_Tuple);
|
|
|
- param_tuple = &pt->params->Tuple;
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, ce->args) {
|
|
|
- Ast *arg = ce->args[i];
|
|
|
- TypeAndValue arg_tv = type_and_value_of_expr(arg);
|
|
|
- if (arg_tv.mode == Addressing_Type) {
|
|
|
- args[arg_index++] = ir_value_nil(arg_tv.type);
|
|
|
- } else {
|
|
|
- irValue *a = ir_build_expr(proc, arg);
|
|
|
- Type *at = ir_type(a);
|
|
|
- if (at->kind == Type_Tuple) {
|
|
|
- for_array(i, at->Tuple.variables) {
|
|
|
- Entity *e = at->Tuple.variables[i];
|
|
|
- irValue *v = ir_emit_struct_ev(proc, a, cast(i32)i);
|
|
|
- args[arg_index++] = v;
|
|
|
- }
|
|
|
- } else {
|
|
|
- args[arg_index++] = a;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- if (param_count > 0) {
|
|
|
- GB_ASSERT_MSG(pt->params != nullptr, "%s %td", expr_to_string(expr), pt->param_count);
|
|
|
- GB_ASSERT(param_count < 1000000);
|
|
|
-
|
|
|
- if (arg_count < param_count) {
|
|
|
- isize end = cast(isize)param_count;
|
|
|
- if (variadic) {
|
|
|
- end = variadic_index;
|
|
|
- }
|
|
|
- while (arg_index < end) {
|
|
|
- Entity *e = param_tuple->variables[arg_index];
|
|
|
- GB_ASSERT(e->kind == Entity_Variable);
|
|
|
- args[arg_index++] = ir_handle_param_value(proc, e->type, e->Variable.param_value, ast_token(expr).pos);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (is_c_vararg) {
|
|
|
- GB_ASSERT(variadic);
|
|
|
- GB_ASSERT(!vari_expand);
|
|
|
- isize i = 0;
|
|
|
- for (; i < variadic_index; i++) {
|
|
|
- Entity *e = param_tuple->variables[i];
|
|
|
- if (e->kind == Entity_Variable) {
|
|
|
- args[i] = ir_emit_conv(proc, args[i], e->type);
|
|
|
- }
|
|
|
- }
|
|
|
- Type *variadic_type = param_tuple->variables[i]->type;
|
|
|
- GB_ASSERT(is_type_slice(variadic_type));
|
|
|
- variadic_type = base_type(variadic_type)->Slice.elem;
|
|
|
- if (!is_type_any(variadic_type)) {
|
|
|
- for (; i < arg_count; i++) {
|
|
|
- args[i] = ir_emit_conv(proc, args[i], variadic_type);
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (; i < arg_count; i++) {
|
|
|
- args[i] = ir_emit_conv(proc, args[i], default_type(ir_type(args[i])));
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (variadic) {
|
|
|
- isize i = 0;
|
|
|
- for (; i < variadic_index; i++) {
|
|
|
- Entity *e = param_tuple->variables[i];
|
|
|
- if (e->kind == Entity_Variable) {
|
|
|
- args[i] = ir_emit_conv(proc, args[i], e->type);
|
|
|
- }
|
|
|
- }
|
|
|
- if (!vari_expand) {
|
|
|
- Type *variadic_type = param_tuple->variables[i]->type;
|
|
|
- GB_ASSERT(is_type_slice(variadic_type));
|
|
|
- variadic_type = base_type(variadic_type)->Slice.elem;
|
|
|
- for (; i < arg_count; i++) {
|
|
|
- args[i] = ir_emit_conv(proc, args[i], variadic_type);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (isize i = 0; i < param_count; i++) {
|
|
|
- Entity *e = param_tuple->variables[i];
|
|
|
- if (e->kind == Entity_Variable) {
|
|
|
- GB_ASSERT(args[i] != nullptr);
|
|
|
- args[i] = ir_emit_conv(proc, args[i], e->type);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (variadic && !vari_expand && !is_c_vararg) {
|
|
|
- ir_emit_comment(proc, str_lit("variadic call argument generation"));
|
|
|
- gbAllocator allocator = ir_allocator();
|
|
|
- Type *slice_type = param_tuple->variables[variadic_index]->type;
|
|
|
- Type *elem_type = base_type(slice_type)->Slice.elem;
|
|
|
- irValue *slice = ir_add_local_generated(proc, slice_type, true);
|
|
|
- isize slice_len = arg_count+1 - (variadic_index+1);
|
|
|
-
|
|
|
- if (slice_len > 0) {
|
|
|
- irValue *base_array = ir_add_local_generated(proc, alloc_type_array(elem_type, slice_len), true);
|
|
|
-
|
|
|
- for (isize i = variadic_index, j = 0; i < arg_count; i++, j++) {
|
|
|
- irValue *addr = ir_emit_array_epi(proc, base_array, cast(i32)j);
|
|
|
- ir_emit_store(proc, addr, args[i]);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *base_elem = ir_emit_array_epi(proc, base_array, 0);
|
|
|
- irValue *len = ir_const_int(slice_len);
|
|
|
- ir_fill_slice(proc, slice, base_elem, len);
|
|
|
- }
|
|
|
-
|
|
|
- arg_count = param_count;
|
|
|
- args[variadic_index] = ir_emit_load(proc, slice);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (variadic && variadic_index+1 < param_count) {
|
|
|
- for (isize i = variadic_index+1; i < param_count; i++) {
|
|
|
- Entity *e = param_tuple->variables[i];
|
|
|
- args[i] = ir_handle_param_value(proc, e->type, e->Variable.param_value, ast_token(expr).pos);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- isize final_count = param_count;
|
|
|
- if (is_c_vararg) {
|
|
|
- final_count = arg_count;
|
|
|
- }
|
|
|
-
|
|
|
- auto call_args = array_slice(args, 0, final_count);
|
|
|
- return ir_emit_call(proc, value, call_args, ce->inlining, proc->return_ptr_hint_ast == expr);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-irValue *ir_build_expr_internal(irProcedure *proc, Ast *expr) {
|
|
|
- Ast *original_expr = expr;
|
|
|
- expr = unparen_expr(expr);
|
|
|
-
|
|
|
- TokenPos expr_pos = ast_token(expr).pos;
|
|
|
-
|
|
|
- TypeAndValue tv = type_and_value_of_expr(expr);
|
|
|
- GB_ASSERT_MSG(tv.mode != Addressing_Invalid, "invalid expression '%s' @ %s", expr_to_string(expr), token_pos_to_string(expr_pos));
|
|
|
- if (tv.mode == Addressing_Type) {
|
|
|
- // HACK TODO(bill): This is hack but it should be safe in virtually all cases
|
|
|
- irValue *v = ir_typeid(proc->module, tv.type);
|
|
|
- return ir_emit_conv(proc, v, t_typeid);
|
|
|
- }
|
|
|
-
|
|
|
- if (tv.value.kind != ExactValue_Invalid) {
|
|
|
- // NOTE(bill): Edge case
|
|
|
- if (is_type_u8_array(tv.type) && tv.value.kind == ExactValue_String) {
|
|
|
- return ir_add_module_constant(proc->module, tv.type, tv.value);
|
|
|
- } else if (is_type_rune_array(tv.type) && tv.value.kind == ExactValue_String) {
|
|
|
- return ir_add_module_constant(proc->module, tv.type, tv.value);
|
|
|
- } else if (tv.value.kind != ExactValue_Compound &&
|
|
|
- is_type_array(tv.type)) {
|
|
|
- Type *elem = core_array_type(tv.type);
|
|
|
- ExactValue value = convert_exact_value_for_type(tv.value, elem);
|
|
|
- irValue *x = ir_add_module_constant(proc->module, elem, value);
|
|
|
- return ir_emit_conv(proc, x, tv.type);
|
|
|
- }
|
|
|
-
|
|
|
- if (tv.value.kind == ExactValue_Typeid) {
|
|
|
- irValue *v = ir_typeid(proc->module, tv.value.value_typeid);
|
|
|
- return ir_emit_conv(proc, v, tv.type);
|
|
|
- }
|
|
|
-
|
|
|
- if (tv.value.kind == ExactValue_Procedure) {
|
|
|
- Ast *expr = tv.value.value_procedure;
|
|
|
- if (expr->kind == Ast_ProcLit) {
|
|
|
- return ir_gen_anonymous_proc_lit(proc->module, str_lit("_proclit"), expr);
|
|
|
- }
|
|
|
- Entity *e = entity_from_expr(expr);
|
|
|
- e = strip_entity_wrapping(e);
|
|
|
- GB_ASSERT(e != nullptr);
|
|
|
- if (e->kind == Entity_Procedure && e->Procedure.is_foreign) {
|
|
|
- // NOTE(bill): There can be duplicates of the foreign procedure; get the main one
|
|
|
- String link_name = e->token.string;
|
|
|
- if (e->Procedure.link_name.len != 0) {
|
|
|
- link_name = e->Procedure.link_name;
|
|
|
- }
|
|
|
- auto *found = string_map_get(&proc->module->members, link_name);
|
|
|
- if (found) {
|
|
|
- return *found;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- auto *found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- if (found) {
|
|
|
- auto v = *found;
|
|
|
- // NOTE(bill): This is because pointers are already pointers in LLVM
|
|
|
- if (is_type_proc(ir_type(v))) {
|
|
|
- return v;
|
|
|
- }
|
|
|
- return ir_emit_load(proc, v);
|
|
|
- } else if (e != nullptr && e->kind == Entity_Variable) {
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Error in: %s %s\n", LIT(proc->name), token_pos_to_string(e->token.pos));
|
|
|
- }
|
|
|
-
|
|
|
- return ir_add_module_constant(proc->module, tv.type, tv.value);
|
|
|
- }
|
|
|
-
|
|
|
- if (tv.mode == Addressing_Variable) {
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- }
|
|
|
-
|
|
|
- if (tv.mode == Addressing_Constant) {
|
|
|
- GB_ASSERT(tv.value.kind == ExactValue_Invalid);
|
|
|
- // NOTE(bill): Zero value constant
|
|
|
- return ir_add_module_constant(proc->module, tv.type, tv.value);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- switch (expr->kind) {
|
|
|
- case_ast_node(bl, BasicLit, expr);
|
|
|
- TokenPos pos = bl->token.pos;
|
|
|
- GB_PANIC("Non-constant basic literal %s - %.*s", token_pos_to_string(pos), LIT(token_strings[bl->token.kind]));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(bd, BasicDirective, expr);
|
|
|
- TokenPos pos = bd->token.pos;
|
|
|
- GB_PANIC("Non-constant basic literal %s - %.*s", token_pos_to_string(pos), LIT(bd->name));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(i, Implicit, expr);
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(u, Undef, expr);
|
|
|
- return ir_value_undef(tv.type);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(i, Ident, expr);
|
|
|
- Entity *e = entity_of_node(expr);
|
|
|
- e = strip_entity_wrapping(e);
|
|
|
-
|
|
|
- GB_ASSERT_MSG(e != nullptr, "%s", expr_to_string(expr));
|
|
|
- if (e->kind == Entity_Builtin) {
|
|
|
- Token token = ast_token(expr);
|
|
|
- GB_PANIC("TODO(bill): ir_build_expr Entity_Builtin '%.*s'\n"
|
|
|
- "\t at %s", LIT(builtin_procs[e->Builtin.id].name),
|
|
|
- token_pos_to_string(token.pos));
|
|
|
- return nullptr;
|
|
|
- } else if (e->kind == Entity_Nil) {
|
|
|
- return ir_value_nil(tv.type);
|
|
|
- }
|
|
|
-
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- if (found) {
|
|
|
- irValue *v = *found;
|
|
|
- if (v->kind == irValue_Proc) {
|
|
|
- return v;
|
|
|
- }
|
|
|
- // if (e->kind == Entity_Variable && e->Variable.param) {
|
|
|
- // return v;
|
|
|
- // }
|
|
|
- return ir_emit_load(proc, v);
|
|
|
- } else if (e != nullptr && e->kind == Entity_Variable) {
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- }
|
|
|
- GB_PANIC("nullptr value for expression from identifier: %.*s : %s @ %p", LIT(i->token.string), type_to_string(e->type), expr);
|
|
|
- return nullptr;
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(de, DerefExpr, expr);
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(se, SelectorExpr, expr);
|
|
|
- TypeAndValue tav = type_and_value_of_expr(expr);
|
|
|
- GB_ASSERT(tav.mode != Addressing_Invalid);
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ise, ImplicitSelectorExpr, expr);
|
|
|
- TypeAndValue tav = type_and_value_of_expr(expr);
|
|
|
- GB_ASSERT(tav.mode == Addressing_Constant);
|
|
|
-
|
|
|
- return ir_add_module_constant(proc->module, tv.type, tv.value);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(se, SelectorCallExpr, expr);
|
|
|
- GB_ASSERT(se->modified_call);
|
|
|
- TypeAndValue tav = type_and_value_of_expr(expr);
|
|
|
- GB_ASSERT(tav.mode != Addressing_Invalid);
|
|
|
- return ir_build_expr(proc, se->call);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(te, TernaryExpr, expr);
|
|
|
- ir_emit_comment(proc, str_lit("TernaryExpr"));
|
|
|
-
|
|
|
- auto edges = array_make<irValue *>(ir_allocator(), 0, 2);
|
|
|
-
|
|
|
- GB_ASSERT(te->y != nullptr);
|
|
|
- irBlock *then = ir_new_block(proc, nullptr, "if.then");
|
|
|
- irBlock *done = ir_new_block(proc, nullptr, "if.done"); // NOTE(bill): Append later
|
|
|
- irBlock *else_ = ir_new_block(proc, nullptr, "if.else");
|
|
|
-
|
|
|
- irValue *cond = ir_build_cond(proc, te->cond, then, else_);
|
|
|
- ir_start_block(proc, then);
|
|
|
-
|
|
|
- Type *type = default_type(type_of_expr(expr));
|
|
|
-
|
|
|
- ir_open_scope(proc);
|
|
|
- array_add(&edges, ir_emit_conv(proc, ir_build_expr(proc, te->x), type));
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, else_);
|
|
|
-
|
|
|
- ir_open_scope(proc);
|
|
|
- array_add(&edges, ir_emit_conv(proc, ir_build_expr(proc, te->y), type));
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_phi(proc, edges, type));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(te, TernaryIfExpr, expr);
|
|
|
- ir_emit_comment(proc, str_lit("TernaryIfExpr"));
|
|
|
-
|
|
|
- auto edges = array_make<irValue *>(ir_allocator(), 0, 2);
|
|
|
-
|
|
|
- GB_ASSERT(te->y != nullptr);
|
|
|
- irBlock *then = ir_new_block(proc, nullptr, "if.then");
|
|
|
- irBlock *done = ir_new_block(proc, nullptr, "if.done"); // NOTE(bill): Append later
|
|
|
- irBlock *else_ = ir_new_block(proc, nullptr, "if.else");
|
|
|
-
|
|
|
- irValue *cond = ir_build_cond(proc, te->cond, then, else_);
|
|
|
- ir_start_block(proc, then);
|
|
|
-
|
|
|
- Type *type = default_type(type_of_expr(expr));
|
|
|
-
|
|
|
- ir_open_scope(proc);
|
|
|
- array_add(&edges, ir_emit_conv(proc, ir_build_expr(proc, te->x), type));
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, else_);
|
|
|
-
|
|
|
- ir_open_scope(proc);
|
|
|
- array_add(&edges, ir_emit_conv(proc, ir_build_expr(proc, te->y), type));
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
-
|
|
|
- return ir_emit(proc, ir_instr_phi(proc, edges, type));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(te, TernaryWhenExpr, expr);
|
|
|
- TypeAndValue tav = type_and_value_of_expr(te->cond);
|
|
|
- GB_ASSERT(tav.mode == Addressing_Constant);
|
|
|
- GB_ASSERT(tav.value.kind == ExactValue_Bool);
|
|
|
- if (tav.value.value_bool) {
|
|
|
- return ir_build_expr(proc, te->x);
|
|
|
- } else {
|
|
|
- return ir_build_expr(proc, te->y);
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ta, TypeAssertion, expr);
|
|
|
- TokenPos pos = ast_token(expr).pos;
|
|
|
- Type *type = tv.type;
|
|
|
- irValue *e = ir_build_expr(proc, ta->expr);
|
|
|
- Type *t = type_deref(ir_type(e));
|
|
|
- if (is_type_union(t)) {
|
|
|
- ir_emit_comment(proc, str_lit("cast - union_cast"));
|
|
|
- return ir_emit_union_cast(proc, e, type, pos);
|
|
|
- } else if (is_type_any(t)) {
|
|
|
- ir_emit_comment(proc, str_lit("cast - any_cast"));
|
|
|
- return ir_emit_any_cast(proc, e, type, pos);
|
|
|
- } else {
|
|
|
- GB_PANIC("TODO(bill): type assertion %s", type_to_string(ir_type(e)));
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(tc, TypeCast, expr);
|
|
|
- irValue *e = ir_build_expr(proc, tc->expr);
|
|
|
- switch (tc->token.kind) {
|
|
|
- case Token_cast:
|
|
|
- return ir_emit_conv(proc, e, tv.type);
|
|
|
- case Token_transmute:
|
|
|
- return ir_emit_transmute(proc, e, tv.type);
|
|
|
- }
|
|
|
- GB_PANIC("Invalid AST TypeCast");
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ac, AutoCast, expr);
|
|
|
- irValue *value = ir_build_expr(proc, ac->expr);
|
|
|
- return ir_emit_conv(proc, value, tv.type);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ue, UnaryExpr, expr);
|
|
|
- switch (ue->op.kind) {
|
|
|
- case Token_And: {
|
|
|
- Ast *ue_expr = unparen_expr(ue->expr);
|
|
|
- if (ue_expr->kind == Ast_CompoundLit) {
|
|
|
- irValue *v = ir_build_expr(proc, ue->expr);
|
|
|
-
|
|
|
- Type *type = ir_type(v);
|
|
|
- irValue *ptr = nullptr;
|
|
|
- if (proc->is_startup) {
|
|
|
- ptr = ir_add_global_generated(proc->module, type, v);
|
|
|
- } else {
|
|
|
- ptr = ir_add_local_generated(proc, type, false);
|
|
|
- }
|
|
|
- ir_emit_store(proc, ptr, v);
|
|
|
- return ptr;
|
|
|
-
|
|
|
- } else if (ue_expr->kind == Ast_TypeAssertion) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- GB_ASSERT(is_type_pointer(tv.type));
|
|
|
-
|
|
|
- ast_node(ta, TypeAssertion, ue_expr);
|
|
|
- TokenPos pos = ast_token(expr).pos;
|
|
|
- Type *type = type_of_expr(ue_expr);
|
|
|
- GB_ASSERT(!is_type_tuple(type));
|
|
|
-
|
|
|
- irValue *e = ir_build_expr(proc, ta->expr);
|
|
|
- Type *t = type_deref(ir_type(e));
|
|
|
- if (is_type_union(t)) {
|
|
|
- irValue *v = e;
|
|
|
- if (!is_type_pointer(ir_type(v))) {
|
|
|
- v = ir_address_from_load_or_generate_local(proc, v);
|
|
|
- }
|
|
|
- Type *src_type = type_deref(ir_type(v));
|
|
|
- Type *dst_type = type;
|
|
|
-
|
|
|
- irValue *src_tag = ir_emit_load(proc, ir_emit_union_tag_ptr(proc, v));
|
|
|
- irValue *dst_tag = ir_const_union_tag(src_type, dst_type);
|
|
|
-
|
|
|
- irValue *ok = ir_emit_comp(proc, Token_CmpEq, src_tag, dst_tag);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 6);
|
|
|
- args[0] = ok;
|
|
|
-
|
|
|
- args[1] = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
|
|
|
- args[2] = ir_const_i32(pos.line);
|
|
|
- args[3] = ir_const_i32(pos.column);
|
|
|
-
|
|
|
- args[4] = ir_typeid(proc->module, src_type);
|
|
|
- args[5] = ir_typeid(proc->module, dst_type);
|
|
|
- ir_emit_runtime_call(proc, "type_assertion_check", args);
|
|
|
-
|
|
|
- irValue *data_ptr = v;
|
|
|
- return ir_emit_conv(proc, data_ptr, tv.type);
|
|
|
- } else if (is_type_any(t)) {
|
|
|
- irValue *v = e;
|
|
|
- if (is_type_pointer(ir_type(v))) {
|
|
|
- v = ir_emit_load(proc, v);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *data_ptr = ir_emit_struct_ev(proc, v, 0);
|
|
|
- irValue *any_id = ir_emit_struct_ev(proc, v, 1);
|
|
|
- irValue *id = ir_typeid(proc->module, type);
|
|
|
-
|
|
|
-
|
|
|
- irValue *ok = ir_emit_comp(proc, Token_CmpEq, any_id, id);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 6);
|
|
|
- args[0] = ok;
|
|
|
-
|
|
|
- args[1] = ir_find_or_add_entity_string(proc->module, get_file_path_string(pos.file_id));
|
|
|
- args[2] = ir_const_i32(pos.line);
|
|
|
- args[3] = ir_const_i32(pos.column);
|
|
|
-
|
|
|
- args[4] = any_id;
|
|
|
- args[5] = id;
|
|
|
- ir_emit_runtime_call(proc, "type_assertion_check", args);
|
|
|
-
|
|
|
- return ir_emit_conv(proc, data_ptr, tv.type);
|
|
|
- } else {
|
|
|
- GB_PANIC("TODO(bill): type assertion %s", type_to_string(type));
|
|
|
- }
|
|
|
- } else if (ue_expr->kind == Ast_IndexExpr) {
|
|
|
- #if 0
|
|
|
- ast_node(ie, IndexExpr, ue_expr);
|
|
|
- if (is_type_slice(ie->expr->tav.type)) {
|
|
|
- auto tav = ie->index->tav;
|
|
|
- if (tav.mode == Addressing_Constant) {
|
|
|
- if (exact_value_to_i64(tav.value) == 0) {
|
|
|
- irValue *s = ir_build_expr(proc, ie->expr);
|
|
|
- if (is_type_pointer(ir_type(s))) {
|
|
|
- s = ir_emit_load(proc, s);
|
|
|
- }
|
|
|
- return ir_slice_elem(proc, s);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- #endif
|
|
|
- }
|
|
|
-
|
|
|
- bool allow_reference = true;
|
|
|
- irAddr addr = ir_build_addr(proc, ue->expr);
|
|
|
- return ir_addr_get_ptr(proc, addr, allow_reference);
|
|
|
- }
|
|
|
- default:
|
|
|
- return ir_emit_unary_arith(proc, ue->op.kind, ir_build_expr(proc, ue->expr), tv.type);
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(be, BinaryExpr, expr);
|
|
|
- switch (be->op.kind) {
|
|
|
- case Token_Add:
|
|
|
- case Token_Sub:
|
|
|
- case Token_Mul:
|
|
|
- case Token_Quo:
|
|
|
- case Token_Mod:
|
|
|
- case Token_ModMod:
|
|
|
- case Token_And:
|
|
|
- case Token_Or:
|
|
|
- case Token_Xor:
|
|
|
- case Token_AndNot:
|
|
|
- case Token_Shl:
|
|
|
- case Token_Shr: {
|
|
|
- irValue *left = ir_build_expr(proc, be->left);
|
|
|
- Type *type = default_type(tv.type);
|
|
|
- irValue *right = ir_build_expr(proc, be->right);
|
|
|
- return ir_emit_arith(proc, be->op.kind, left, right, type);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- case Token_CmpEq:
|
|
|
- case Token_NotEq:
|
|
|
- case Token_Lt:
|
|
|
- case Token_LtEq:
|
|
|
- case Token_Gt:
|
|
|
- case Token_GtEq: {
|
|
|
- irValue *left = ir_build_expr(proc, be->left);
|
|
|
- Type *type = default_type(tv.type);
|
|
|
- irValue *right = ir_build_expr(proc, be->right);
|
|
|
- irValue *cmp = ir_emit_comp(proc, be->op.kind, left, right);
|
|
|
- return ir_emit_conv(proc, cmp, type);
|
|
|
- }
|
|
|
-
|
|
|
- case Token_CmpAnd:
|
|
|
- case Token_CmpOr:
|
|
|
- return ir_emit_logical_binary_expr(proc, expr);
|
|
|
-
|
|
|
-
|
|
|
- case Token_in:
|
|
|
- case Token_not_in: {
|
|
|
- irValue *left = ir_build_expr(proc, be->left);
|
|
|
- Type *type = default_type(tv.type);
|
|
|
- irValue *right = ir_build_expr(proc, be->right);
|
|
|
- Type *rt = base_type(ir_type(right));
|
|
|
- switch (rt->kind) {
|
|
|
- case Type_Map:
|
|
|
- {
|
|
|
- if (be->op.kind == Token_in) {
|
|
|
- ir_emit_comment(proc, str_lit("map in"));
|
|
|
- } else {
|
|
|
- ir_emit_comment(proc, str_lit("map not_in"));
|
|
|
- }
|
|
|
-
|
|
|
- irValue *addr = ir_address_from_load_or_generate_local(proc, right);
|
|
|
- irValue *h = ir_gen_map_header(proc, addr, rt);
|
|
|
- irValue *key = ir_gen_map_hash(proc, left, rt->Map.key);
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 2);
|
|
|
- args[0] = h;
|
|
|
- args[1] = key;
|
|
|
-
|
|
|
- irValue *ptr = ir_emit_runtime_call(proc, "__dynamic_map_get", args);
|
|
|
- if (be->op.kind == Token_in) {
|
|
|
- return ir_emit_conv(proc, ir_emit_comp(proc, Token_NotEq, ptr, v_raw_nil), t_bool);
|
|
|
- } else {
|
|
|
- return ir_emit_conv(proc, ir_emit_comp(proc, Token_CmpEq, ptr, v_raw_nil), t_bool);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- case Type_BitSet:
|
|
|
- {
|
|
|
- if (be->op.kind == Token_in) {
|
|
|
- ir_emit_comment(proc, str_lit("bit_set in"));
|
|
|
- } else {
|
|
|
- ir_emit_comment(proc, str_lit("bit_set not_in"));
|
|
|
- }
|
|
|
-
|
|
|
- Type *key_type = rt->BitSet.elem;
|
|
|
- GB_ASSERT(are_types_identical(ir_type(left), key_type));
|
|
|
-
|
|
|
- Type *it = bit_set_to_int(rt);
|
|
|
- left = ir_emit_conv(proc, left, it);
|
|
|
-
|
|
|
- irValue *lower = ir_value_constant(it, exact_value_i64(rt->BitSet.lower));
|
|
|
- irValue *key = ir_emit_arith(proc, Token_Sub, left, lower, it);
|
|
|
- irValue *bit = ir_emit_arith(proc, Token_Shl, v_one, key, it);
|
|
|
- bit = ir_emit_conv(proc, bit, it);
|
|
|
-
|
|
|
- irValue *old_value = ir_emit_bitcast(proc, right, it);
|
|
|
- irValue *new_value = ir_emit_arith(proc, Token_And, old_value, bit, it);
|
|
|
-
|
|
|
- if (be->op.kind == Token_in) {
|
|
|
- return ir_emit_conv(proc, ir_emit_comp(proc, Token_NotEq, new_value, v_zero), t_bool);
|
|
|
- } else {
|
|
|
- return ir_emit_conv(proc, ir_emit_comp(proc, Token_CmpEq, new_value, v_zero), t_bool);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- default:
|
|
|
- GB_PANIC("Invalid 'in' type");
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- default:
|
|
|
- GB_PANIC("Invalid binary expression");
|
|
|
- break;
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(pl, ProcLit, expr);
|
|
|
- return ir_gen_anonymous_proc_lit(proc->module, proc->name, expr, proc);
|
|
|
- case_end;
|
|
|
-
|
|
|
-
|
|
|
- case_ast_node(cl, CompoundLit, expr);
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- case_end;
|
|
|
-
|
|
|
-
|
|
|
- case_ast_node(ce, CallExpr, expr);
|
|
|
- irValue *res = ir_build_call_expr(proc, expr);
|
|
|
- if (ce->optional_ok_one) { // TODO(bill): Minor hack for #optional_ok procedures
|
|
|
- GB_ASSERT(is_type_tuple(ir_type(res)));
|
|
|
- GB_ASSERT(ir_type(res)->Tuple.variables.count == 2);
|
|
|
- return ir_emit_struct_ev(proc, res, 0);
|
|
|
- }
|
|
|
- return res;
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(se, SliceExpr, expr);
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ie, IndexExpr, expr);
|
|
|
- return ir_addr_load(proc, ir_build_addr(proc, expr));
|
|
|
- case_end;
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unexpected expression: %.*s", LIT(ast_strings[expr->kind]));
|
|
|
- return nullptr;
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_get_using_variable(irProcedure *proc, Entity *e) {
|
|
|
- GB_ASSERT(e->kind == Entity_Variable && e->flags & EntityFlag_Using);
|
|
|
- String name = e->token.string;
|
|
|
- Entity *parent = e->using_parent;
|
|
|
- Selection sel = lookup_field(parent->type, name, false);
|
|
|
- GB_ASSERT(sel.entity != nullptr);
|
|
|
- irValue **pv = map_get(&proc->module->values, hash_entity(parent));
|
|
|
- irValue *v = nullptr;
|
|
|
- if (pv != nullptr) {
|
|
|
- v = *pv;
|
|
|
- } else {
|
|
|
- GB_ASSERT_MSG(e->using_expr != nullptr, "%.*s", LIT(name));
|
|
|
- v = ir_build_addr_ptr(proc, e->using_expr);
|
|
|
- }
|
|
|
- GB_ASSERT(v != nullptr);
|
|
|
- GB_ASSERT(parent->type == type_deref(ir_type(v)));
|
|
|
- return ir_emit_deep_field_gep(proc, v, sel);
|
|
|
-}
|
|
|
-
|
|
|
-bool ir_is_elem_const(irModule *m, Ast *elem, Type *elem_type) {
|
|
|
- if (!elem_type_can_be_constant(elem_type)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (elem->kind == Ast_FieldValue) {
|
|
|
- elem = elem->FieldValue.value;
|
|
|
- }
|
|
|
- TypeAndValue tav = type_and_value_of_expr(elem);
|
|
|
- GB_ASSERT_MSG(tav.mode != Addressing_Invalid, "%s %s", expr_to_string(elem), type_to_string(tav.type));
|
|
|
- return tav.value.kind != ExactValue_Invalid && tav.value.kind != ExactValue_Procedure;
|
|
|
-}
|
|
|
-
|
|
|
-irAddr ir_build_addr_from_entity(irProcedure *proc, Entity *e, Ast *expr) {
|
|
|
- GB_ASSERT(e != nullptr);
|
|
|
- if (e->kind == Entity_Constant) {
|
|
|
- Type *t = default_type(type_of_expr(expr));
|
|
|
- irValue *v = ir_add_module_constant(proc->module, t, e->Constant.value);
|
|
|
- irValue *g = ir_add_global_generated(proc->module, ir_type(v), v);
|
|
|
- return ir_addr(g);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- irValue *v = nullptr;
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- if (found) {
|
|
|
- v = *found;
|
|
|
- } else if (e->kind == Entity_Variable && e->flags & EntityFlag_Using) {
|
|
|
- // NOTE(bill): Calculate the using variable every time
|
|
|
- v = ir_get_using_variable(proc, e);
|
|
|
- }
|
|
|
-
|
|
|
- if (v == nullptr) {
|
|
|
- error(expr, "%.*s Unknown value: %.*s, entity: %p %.*s",
|
|
|
- LIT(proc->name),
|
|
|
- LIT(e->token.string), e, LIT(entity_strings[e->kind]));
|
|
|
- GB_PANIC("Unknown value");
|
|
|
- }
|
|
|
-
|
|
|
- return ir_addr(v);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-struct irCompoundLitElemTempData {
|
|
|
- Ast *expr;
|
|
|
- irValue *value;
|
|
|
- i32 elem_index;
|
|
|
- irValue *gep;
|
|
|
-};
|
|
|
-
|
|
|
-irAddr ir_build_addr(irProcedure *proc, Ast *expr) {
|
|
|
- switch (expr->kind) {
|
|
|
- case_ast_node(i, Implicit, expr);
|
|
|
- irValue *v = nullptr;
|
|
|
- switch (i->kind) {
|
|
|
- case Token_context:
|
|
|
- v = ir_find_or_generate_context_ptr(proc);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(v != nullptr);
|
|
|
- return ir_addr_context(v);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(i, Ident, expr);
|
|
|
- if (is_blank_ident(expr)) {
|
|
|
- irAddr val = {};
|
|
|
- return val;
|
|
|
- }
|
|
|
- String name = i->token.string;
|
|
|
- Entity *e = entity_of_node(expr);
|
|
|
- // GB_ASSERT(name == e->token.string);
|
|
|
- return ir_build_addr_from_entity(proc, e, expr);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(pe, ParenExpr, expr);
|
|
|
- return ir_build_addr(proc, unparen_expr(expr));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(se, SelectorExpr, expr);
|
|
|
- ir_emit_comment(proc, str_lit("SelectorExpr"));
|
|
|
- Ast *sel = unparen_expr(se->selector);
|
|
|
- if (sel->kind == Ast_Ident) {
|
|
|
- String selector = sel->Ident.token.string;
|
|
|
- TypeAndValue tav = type_and_value_of_expr(se->expr);
|
|
|
-
|
|
|
- if (tav.mode == Addressing_Invalid) {
|
|
|
- // NOTE(bill): Imports
|
|
|
- Entity *imp = entity_of_node(se->expr);
|
|
|
- if (imp != nullptr) {
|
|
|
- GB_ASSERT(imp->kind == Entity_ImportName);
|
|
|
- }
|
|
|
- return ir_build_addr(proc, unparen_expr(se->selector));
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- Type *type = base_type(tav.type);
|
|
|
- if (tav.mode == Addressing_Type) { // Addressing_Type
|
|
|
- Selection sel = lookup_field(type, selector, true);
|
|
|
- Entity *e = sel.entity;
|
|
|
- GB_ASSERT(e->kind == Entity_Variable);
|
|
|
- GB_ASSERT(e->flags & EntityFlag_TypeField);
|
|
|
- String name = e->token.string;
|
|
|
- if (name == "names") {
|
|
|
- irValue *ti_ptr = ir_type_info(proc, type);
|
|
|
- irValue *variant = ir_emit_struct_ep(proc, ti_ptr, 2);
|
|
|
-
|
|
|
- irValue *names_ptr = nullptr;
|
|
|
-
|
|
|
- if (is_type_enum(type)) {
|
|
|
- irValue *enum_info = ir_emit_conv(proc, variant, t_type_info_enum_ptr);
|
|
|
- names_ptr = ir_emit_struct_ep(proc, enum_info, 1);
|
|
|
- } else if (type->kind == Type_Struct) {
|
|
|
- irValue *struct_info = ir_emit_conv(proc, variant, t_type_info_struct_ptr);
|
|
|
- names_ptr = ir_emit_struct_ep(proc, struct_info, 1);
|
|
|
- }
|
|
|
- return ir_addr(names_ptr);
|
|
|
- } else {
|
|
|
- GB_PANIC("Unhandled TypeField %.*s", LIT(name));
|
|
|
- }
|
|
|
- GB_PANIC("Unreachable");
|
|
|
- }
|
|
|
-
|
|
|
- Selection sel = lookup_field(type, selector, false);
|
|
|
- GB_ASSERT(sel.entity != nullptr);
|
|
|
-
|
|
|
-
|
|
|
- {
|
|
|
- irAddr addr = ir_build_addr(proc, se->expr);
|
|
|
- if (addr.kind == irAddr_Context) {
|
|
|
- GB_ASSERT(sel.index.count > 0);
|
|
|
- if (addr.ctx.sel.index.count >= 0) {
|
|
|
- sel = selection_combine(addr.ctx.sel, sel);
|
|
|
- }
|
|
|
- addr.ctx.sel = sel;
|
|
|
-
|
|
|
- return addr;
|
|
|
- } else if (addr.kind == irAddr_SoaVariable) {
|
|
|
- irValue *index = addr.soa.index;
|
|
|
- i32 first_index = sel.index[0];
|
|
|
- Selection sub_sel = sel;
|
|
|
- sub_sel.index.data += 1;
|
|
|
- sub_sel.index.count -= 1;
|
|
|
-
|
|
|
- irValue *arr = ir_emit_struct_ep(proc, addr.addr, first_index);
|
|
|
-
|
|
|
- Type *t = base_type(type_deref(ir_type(addr.addr)));
|
|
|
- GB_ASSERT(is_type_soa_struct(t));
|
|
|
-
|
|
|
- if (addr.soa.index->kind != irValue_Constant || t->Struct.soa_kind != StructSoa_Fixed) {
|
|
|
- irValue *len = ir_soa_struct_len(proc, addr.addr);
|
|
|
- ir_emit_bounds_check(proc, ast_token(addr.soa.index_expr), addr.soa.index, len);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *item = nullptr;
|
|
|
-
|
|
|
- if (t->Struct.soa_kind == StructSoa_Fixed) {
|
|
|
- item = ir_emit_array_ep(proc, arr, index);
|
|
|
- } else {
|
|
|
- item = ir_emit_load(proc, ir_emit_ptr_offset(proc, arr, index));
|
|
|
- }
|
|
|
- if (sub_sel.index.count > 0) {
|
|
|
- item = ir_emit_deep_field_gep(proc, item, sub_sel);
|
|
|
- }
|
|
|
- return ir_addr(item);
|
|
|
- }
|
|
|
- irValue *a = ir_addr_get_ptr(proc, addr);
|
|
|
- a = ir_emit_deep_field_gep(proc, a, sel);
|
|
|
- return ir_addr(a);
|
|
|
- }
|
|
|
- } else {
|
|
|
- GB_PANIC("Unsupported selector expression");
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(se, SelectorCallExpr, expr);
|
|
|
- GB_ASSERT(se->modified_call);
|
|
|
- TypeAndValue tav = type_and_value_of_expr(expr);
|
|
|
- GB_ASSERT(tav.mode != Addressing_Invalid);
|
|
|
- return ir_build_addr(proc, se->call);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ta, TypeAssertion, expr);
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- TokenPos pos = ast_token(expr).pos;
|
|
|
- irValue *e = ir_build_expr(proc, ta->expr);
|
|
|
- Type *t = type_deref(ir_type(e));
|
|
|
- if (is_type_union(t)) {
|
|
|
- Type *type = type_of_expr(expr);
|
|
|
- irValue *v = ir_add_local_generated(proc, type, false);
|
|
|
- ir_emit_comment(proc, str_lit("cast - union_cast"));
|
|
|
- ir_emit_store(proc, v, ir_emit_union_cast(proc, ir_build_expr(proc, ta->expr), type, pos));
|
|
|
- return ir_addr(v);
|
|
|
- } else if (is_type_any(t)) {
|
|
|
- ir_emit_comment(proc, str_lit("cast - any_cast"));
|
|
|
- Type *type = type_of_expr(expr);
|
|
|
- return ir_emit_any_cast_addr(proc, ir_build_expr(proc, ta->expr), type, pos);
|
|
|
- } else {
|
|
|
- GB_PANIC("TODO(bill): type assertion %s", type_to_string(ir_type(e)));
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ue, UnaryExpr, expr);
|
|
|
- switch (ue->op.kind) {
|
|
|
- case Token_And: {
|
|
|
- return ir_build_addr(proc, ue->expr);
|
|
|
- }
|
|
|
- default:
|
|
|
- GB_PANIC("Invalid unary expression for ir_build_addr");
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(be, BinaryExpr, expr);
|
|
|
- irValue *v = ir_build_expr(proc, expr);
|
|
|
- Type *t = ir_type(v);
|
|
|
- if (is_type_pointer(t)) {
|
|
|
- return ir_addr(v);
|
|
|
- }
|
|
|
- return ir_addr(ir_address_from_load_or_generate_local(proc, v));
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ie, IndexExpr, expr);
|
|
|
- ir_emit_comment(proc, str_lit("IndexExpr"));
|
|
|
- Type *t = base_type(type_of_expr(ie->expr));
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
-
|
|
|
- bool deref = is_type_pointer(t);
|
|
|
- t = base_type(type_deref(t));
|
|
|
- if (is_type_soa_struct(t)) {
|
|
|
- // SOA STRUCTURES!!!!
|
|
|
- irValue *val = ir_build_addr_ptr(proc, ie->expr);
|
|
|
- if (deref) {
|
|
|
- val = ir_emit_load(proc, val);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *index = ir_build_expr(proc, ie->index);
|
|
|
- return ir_addr_soa_variable(val, index, ie->index);
|
|
|
- }
|
|
|
-
|
|
|
- if (ie->expr->tav.mode == Addressing_SoaVariable) {
|
|
|
- // SOA Structures for slices/dynamic arrays
|
|
|
- GB_ASSERT(is_type_pointer(type_of_expr(ie->expr)));
|
|
|
-
|
|
|
- irValue *field = ir_build_expr(proc, ie->expr);
|
|
|
- irValue *index = ir_build_expr(proc, ie->index);
|
|
|
-
|
|
|
-
|
|
|
- if (!build_context.no_bounds_check) {
|
|
|
- // TODO HACK(bill): Clean up this hack to get the length for bounds checking
|
|
|
- GB_ASSERT(field->kind == irValue_Instr);
|
|
|
- irInstr *instr = &field->Instr;
|
|
|
-
|
|
|
- GB_ASSERT(instr->kind == irInstr_Load);
|
|
|
- irValue *a = instr->Load.address;
|
|
|
-
|
|
|
- GB_ASSERT(a->kind == irValue_Instr);
|
|
|
- irInstr *b = &a->Instr;
|
|
|
- GB_ASSERT(b->kind == irInstr_StructElementPtr);
|
|
|
- irValue *base_struct = b->StructElementPtr.address;
|
|
|
-
|
|
|
- GB_ASSERT(is_type_soa_struct(type_deref(ir_type(base_struct))));
|
|
|
- irValue *len = ir_soa_struct_len(proc, base_struct);
|
|
|
- ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *val = ir_emit_ptr_offset(proc, field, index);
|
|
|
- return ir_addr(val);
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT_MSG(is_type_indexable(t), "%s %s", type_to_string(t), expr_to_string(expr));
|
|
|
-
|
|
|
- if (is_type_map(t)) {
|
|
|
- irValue *map_val = ir_build_addr_ptr(proc, ie->expr);
|
|
|
- if (deref) {
|
|
|
- map_val = ir_emit_load(proc, map_val);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *key = ir_build_expr(proc, ie->index);
|
|
|
- key = ir_emit_conv(proc, key, t->Map.key);
|
|
|
-
|
|
|
- Type *result_type = type_of_expr(expr);
|
|
|
- return ir_addr_map(map_val, key, t, result_type);
|
|
|
- }
|
|
|
-
|
|
|
- switch (t->kind) {
|
|
|
- case Type_Array: {
|
|
|
- irValue *array = nullptr;
|
|
|
- array = ir_build_addr_ptr(proc, ie->expr);
|
|
|
- if (deref) {
|
|
|
- array = ir_emit_load(proc, array);
|
|
|
- }
|
|
|
- irValue *index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
|
|
|
- irValue *elem = ir_emit_array_ep(proc, array, index);
|
|
|
-
|
|
|
- auto index_tv = type_and_value_of_expr(ie->index);
|
|
|
- if (index_tv.mode != Addressing_Constant) {
|
|
|
- irValue *len = ir_const_int(t->Array.count);
|
|
|
- ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
|
|
|
- }
|
|
|
- return ir_addr(elem);
|
|
|
- }
|
|
|
-
|
|
|
- case Type_EnumeratedArray: {
|
|
|
- irValue *array = nullptr;
|
|
|
- array = ir_build_addr_ptr(proc, ie->expr);
|
|
|
- if (deref) {
|
|
|
- array = ir_emit_load(proc, array);
|
|
|
- }
|
|
|
- Type *index_type = t->EnumeratedArray.index;
|
|
|
-
|
|
|
- auto index_tv = type_and_value_of_expr(ie->index);
|
|
|
-
|
|
|
- irValue *index = nullptr;
|
|
|
- if (compare_exact_values(Token_NotEq, t->EnumeratedArray.min_value, exact_value_i64(0))) {
|
|
|
- if (index_tv.mode == Addressing_Constant) {
|
|
|
- ExactValue idx = exact_value_sub(index_tv.value, t->EnumeratedArray.min_value);
|
|
|
- index = ir_value_constant(index_type, idx);
|
|
|
- } else {
|
|
|
- index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
|
|
|
- index = ir_emit_arith(proc, Token_Sub, index, ir_value_constant(index_type, t->EnumeratedArray.min_value), index_type);
|
|
|
- }
|
|
|
- } else {
|
|
|
- index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *elem = ir_emit_array_ep(proc, array, index);
|
|
|
-
|
|
|
- if (index_tv.mode != Addressing_Constant) {
|
|
|
- irValue *len = ir_const_int(t->EnumeratedArray.count);
|
|
|
- ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
|
|
|
- }
|
|
|
- return ir_addr(elem);
|
|
|
- }
|
|
|
-
|
|
|
- case Type_Slice: {
|
|
|
- irValue *slice = nullptr;
|
|
|
- slice = ir_build_expr(proc, ie->expr);
|
|
|
- if (deref) {
|
|
|
- slice = ir_emit_load(proc, slice);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *elem = ir_slice_elem(proc, slice);
|
|
|
- irValue *index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
|
|
|
- irValue *len = ir_slice_len(proc, slice);
|
|
|
- ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
|
|
|
- irValue *v = ir_emit_ptr_offset(proc, elem, index);
|
|
|
- return ir_addr(v);
|
|
|
- }
|
|
|
-
|
|
|
- case Type_RelativeSlice: {
|
|
|
- irAddr addr = ir_build_addr(proc, ie->expr);
|
|
|
- if (deref) {
|
|
|
- addr = ir_addr(ir_addr_load(proc, addr));
|
|
|
- }
|
|
|
- irValue *slice = ir_addr_load(proc, addr);
|
|
|
-
|
|
|
- irValue *elem = ir_slice_elem(proc, slice);
|
|
|
- irValue *index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
|
|
|
- irValue *len = ir_slice_len(proc, slice);
|
|
|
- ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
|
|
|
- irValue *v = ir_emit_ptr_offset(proc, elem, index);
|
|
|
- return ir_addr(v);
|
|
|
- }
|
|
|
-
|
|
|
- case Type_DynamicArray: {
|
|
|
- irValue *dynamic_array = nullptr;
|
|
|
- dynamic_array = ir_build_expr(proc, ie->expr);
|
|
|
- if (deref) {
|
|
|
- dynamic_array = ir_emit_load(proc, dynamic_array);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *elem = ir_dynamic_array_elem(proc, dynamic_array);
|
|
|
- irValue *len = ir_dynamic_array_len(proc, dynamic_array);
|
|
|
- irValue *index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
|
|
|
- ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
|
|
|
- irValue *v = ir_emit_ptr_offset(proc, elem, index);
|
|
|
- return ir_addr(v);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- case Type_Basic: { // Basic_string
|
|
|
- irValue *str;
|
|
|
- irValue *elem;
|
|
|
- irValue *len;
|
|
|
- irValue *index;
|
|
|
-
|
|
|
- str = ir_build_expr(proc, ie->expr);
|
|
|
- if (deref) {
|
|
|
- str = ir_emit_load(proc, str);
|
|
|
- }
|
|
|
-
|
|
|
- elem = ir_string_elem(proc, str);
|
|
|
- len = ir_string_len(proc, str);
|
|
|
-
|
|
|
- index = ir_emit_conv(proc, ir_build_expr(proc, ie->index), t_int);
|
|
|
- ir_emit_bounds_check(proc, ast_token(ie->index), index, len);
|
|
|
-
|
|
|
- return ir_addr(ir_emit_ptr_offset(proc, elem, index));
|
|
|
- }
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(se, SliceExpr, expr);
|
|
|
- ir_emit_comment(proc, str_lit("SliceExpr"));
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *low = v_zero;
|
|
|
- irValue *high = nullptr;
|
|
|
-
|
|
|
- if (se->low != nullptr) low = ir_build_expr(proc, se->low);
|
|
|
- if (se->high != nullptr) high = ir_build_expr(proc, se->high);
|
|
|
-
|
|
|
- bool no_indices = se->low == nullptr && se->high == nullptr;
|
|
|
-
|
|
|
- irAddr addr = ir_build_addr(proc, se->expr);
|
|
|
- irValue *base = ir_addr_load(proc, addr);
|
|
|
- Type *type = base_type(ir_type(base));
|
|
|
-
|
|
|
- if (is_type_pointer(type)) {
|
|
|
- type = base_type(type_deref(type));
|
|
|
- addr = ir_addr(base);
|
|
|
- base = ir_addr_load(proc, addr);
|
|
|
- }
|
|
|
- // TODO(bill): Cleanup like mad!
|
|
|
-
|
|
|
- switch (type->kind) {
|
|
|
- case Type_Slice: {
|
|
|
- Type *slice_type = type;
|
|
|
- irValue *len = ir_slice_len(proc, base);
|
|
|
- if (high == nullptr) high = len;
|
|
|
-
|
|
|
- if (!no_indices) {
|
|
|
- ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *elem = ir_emit_ptr_offset(proc, ir_slice_elem(proc, base), low);
|
|
|
- irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
|
|
|
-
|
|
|
- irValue *slice = ir_add_local_generated(proc, slice_type, false);
|
|
|
- ir_fill_slice(proc, slice, elem, new_len);
|
|
|
- return ir_addr(slice);
|
|
|
- }
|
|
|
-
|
|
|
- case Type_DynamicArray: {
|
|
|
- Type *elem_type = type->DynamicArray.elem;
|
|
|
- Type *slice_type = alloc_type_slice(elem_type);
|
|
|
-
|
|
|
- irValue *len = ir_dynamic_array_len(proc, base);
|
|
|
- if (high == nullptr) high = len;
|
|
|
-
|
|
|
- if (!no_indices) {
|
|
|
- ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *elem = ir_emit_ptr_offset(proc, ir_dynamic_array_elem(proc, base), low);
|
|
|
- irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
|
|
|
-
|
|
|
- irValue *slice = ir_add_local_generated(proc, slice_type, false);
|
|
|
- ir_fill_slice(proc, slice, elem, new_len);
|
|
|
- return ir_addr(slice);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- case Type_Array: {
|
|
|
- Type *slice_type = alloc_type_slice(type->Array.elem);
|
|
|
- irValue *len = ir_array_len(proc, base);
|
|
|
-
|
|
|
- if (high == nullptr) high = len;
|
|
|
-
|
|
|
- bool low_const = type_and_value_of_expr(se->low).mode == Addressing_Constant;
|
|
|
- bool high_const = type_and_value_of_expr(se->high).mode == Addressing_Constant;
|
|
|
-
|
|
|
- if (!low_const || !high_const) {
|
|
|
- if (!no_indices) {
|
|
|
- ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
|
|
|
- }
|
|
|
- }
|
|
|
- irValue *elem = ir_emit_ptr_offset(proc, ir_array_elem(proc, ir_addr_get_ptr(proc, addr)), low);
|
|
|
- irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
|
|
|
-
|
|
|
- irValue *slice = ir_add_local_generated(proc, slice_type, false);
|
|
|
- ir_fill_slice(proc, slice, elem, new_len);
|
|
|
- return ir_addr(slice);
|
|
|
- }
|
|
|
-
|
|
|
- case Type_Basic: {
|
|
|
- GB_ASSERT(type == t_string);
|
|
|
- irValue *len = ir_string_len(proc, base);
|
|
|
- if (high == nullptr) high = len;
|
|
|
-
|
|
|
- if (!no_indices) {
|
|
|
- ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *elem = ir_emit_ptr_offset(proc, ir_string_elem(proc, base), low);
|
|
|
- irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
|
|
|
-
|
|
|
- irValue *str = ir_add_local_generated(proc, t_string, false);
|
|
|
- ir_fill_string(proc, str, elem, new_len);
|
|
|
- return ir_addr(str);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- case Type_Struct:
|
|
|
- if (is_type_soa_struct(type)) {
|
|
|
- irValue *len = ir_soa_struct_len(proc, ir_addr_get_ptr(proc, addr));
|
|
|
- if (high == nullptr) high = len;
|
|
|
-
|
|
|
- if (!no_indices) {
|
|
|
- ir_emit_slice_bounds_check(proc, se->open, low, high, len, se->low != nullptr);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *dst = ir_add_local_generated(proc, type_of_expr(expr), true);
|
|
|
- if (type->Struct.soa_kind == StructSoa_Fixed) {
|
|
|
- i32 field_count = cast(i32)type->Struct.fields.count;
|
|
|
- for (i32 i = 0; i < field_count; i++) {
|
|
|
- irValue *field_dst = ir_emit_struct_ep(proc, dst, i);
|
|
|
- irValue *field_src = ir_emit_struct_ep(proc, ir_addr_get_ptr(proc, addr), i);
|
|
|
- field_src = ir_emit_array_ep(proc, field_src, low);
|
|
|
- ir_emit_store(proc, field_dst, field_src);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *len_dst = ir_emit_struct_ep(proc, dst, field_count);
|
|
|
- irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
|
|
|
- ir_emit_store(proc, len_dst, new_len);
|
|
|
- } else if (type->Struct.soa_kind == StructSoa_Slice) {
|
|
|
- if (no_indices) {
|
|
|
- ir_emit_store(proc, dst, base);
|
|
|
- } else {
|
|
|
- i32 field_count = cast(i32)type->Struct.fields.count - 1;
|
|
|
- for (i32 i = 0; i < field_count; i++) {
|
|
|
- irValue *field_dst = ir_emit_struct_ep(proc, dst, i);
|
|
|
- irValue *field_src = ir_emit_struct_ev(proc, base, i);
|
|
|
- field_src = ir_emit_ptr_offset(proc, field_src, low);
|
|
|
- ir_emit_store(proc, field_dst, field_src);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- irValue *len_dst = ir_emit_struct_ep(proc, dst, field_count);
|
|
|
- irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
|
|
|
- ir_emit_store(proc, len_dst, new_len);
|
|
|
- }
|
|
|
- } else if (type->Struct.soa_kind == StructSoa_Dynamic) {
|
|
|
- i32 field_count = cast(i32)type->Struct.fields.count - 3;
|
|
|
- for (i32 i = 0; i < field_count; i++) {
|
|
|
- irValue *field_dst = ir_emit_struct_ep(proc, dst, i);
|
|
|
- irValue *field_src = ir_emit_struct_ev(proc, base, i);
|
|
|
- field_src = ir_emit_ptr_offset(proc, field_src, low);
|
|
|
- ir_emit_store(proc, field_dst, field_src);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- irValue *len_dst = ir_emit_struct_ep(proc, dst, field_count);
|
|
|
- irValue *new_len = ir_emit_arith(proc, Token_Sub, high, low, t_int);
|
|
|
- ir_emit_store(proc, len_dst, new_len);
|
|
|
- }
|
|
|
-
|
|
|
- return ir_addr(dst);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- GB_PANIC("Unknown slicable type");
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(de, DerefExpr, expr);
|
|
|
- if (is_type_relative_pointer(type_of_expr(de->expr))) {
|
|
|
- irAddr addr = ir_build_addr(proc, de->expr);
|
|
|
- addr.relative.deref = true;
|
|
|
- return addr;
|
|
|
- }
|
|
|
-
|
|
|
- // TODO(bill): Is a ptr copy needed?
|
|
|
- irValue *addr = ir_build_expr(proc, de->expr);
|
|
|
- addr = ir_emit_ptr_offset(proc, addr, v_zero);
|
|
|
- return ir_addr(addr);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ce, CallExpr, expr);
|
|
|
- // NOTE(bill): This is make sure you never need to have an 'array_ev'
|
|
|
- irValue *e = ir_build_expr(proc, expr);
|
|
|
- irValue *v = ir_add_local_generated(proc, ir_type(e), false);
|
|
|
- ir_emit_store(proc, v, e);
|
|
|
- return ir_addr(v);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(cl, CompoundLit, expr);
|
|
|
- ir_emit_comment(proc, str_lit("CompoundLit"));
|
|
|
- Type *type = type_of_expr(expr);
|
|
|
- Type *bt = base_type(type);
|
|
|
-
|
|
|
- irValue *v = ir_add_local_generated(proc, type, true);
|
|
|
-
|
|
|
- Type *et = nullptr;
|
|
|
- switch (bt->kind) {
|
|
|
- case Type_Array: et = bt->Array.elem; break;
|
|
|
- case Type_EnumeratedArray: et = bt->EnumeratedArray.elem; break;
|
|
|
- case Type_Slice: et = bt->Slice.elem; break;
|
|
|
- case Type_BitSet: et = bt->BitSet.elem; break;
|
|
|
- case Type_SimdVector: et = bt->SimdVector.elem; break;
|
|
|
- }
|
|
|
-
|
|
|
- String proc_name = {};
|
|
|
- if (proc->entity) {
|
|
|
- proc_name = proc->entity->token.string;
|
|
|
- }
|
|
|
- TokenPos pos = ast_token(expr).pos;
|
|
|
-
|
|
|
- switch (bt->kind) {
|
|
|
- default: GB_PANIC("Unknown CompoundLit type: %s", type_to_string(type)); break;
|
|
|
-
|
|
|
- case Type_Struct: {
|
|
|
-
|
|
|
- // TODO(bill): "constant" '#raw_union's are not initialized constantly at the moment.
|
|
|
- // NOTE(bill): This is due to the layout of the unions when printed to LLVM-IR
|
|
|
- bool is_raw_union = is_type_raw_union(bt);
|
|
|
- GB_ASSERT(is_type_struct(bt) || is_raw_union);
|
|
|
- TypeStruct *st = &bt->Struct;
|
|
|
- if (cl->elems.count > 0) {
|
|
|
- ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
|
|
|
- for_array(field_index, cl->elems) {
|
|
|
- Ast *elem = cl->elems[field_index];
|
|
|
-
|
|
|
- irValue *field_expr = nullptr;
|
|
|
- Entity *field = nullptr;
|
|
|
- isize index = field_index;
|
|
|
-
|
|
|
- if (elem->kind == Ast_FieldValue) {
|
|
|
- ast_node(fv, FieldValue, elem);
|
|
|
- String name = fv->field->Ident.token.string;
|
|
|
- Selection sel = lookup_field(bt, name, false);
|
|
|
- index = sel.index[0];
|
|
|
- elem = fv->value;
|
|
|
- TypeAndValue tav = type_and_value_of_expr(elem);
|
|
|
- } else {
|
|
|
- TypeAndValue tav = type_and_value_of_expr(elem);
|
|
|
- Selection sel = lookup_field_from_index(bt, st->fields[field_index]->Variable.field_src_index);
|
|
|
- index = sel.index[0];
|
|
|
- }
|
|
|
-
|
|
|
- field = st->fields[index];
|
|
|
- Type *ft = field->type;
|
|
|
- if (!is_raw_union && !is_type_typeid(ft) && ir_is_elem_const(proc->module, elem, ft)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- field_expr = ir_build_expr(proc, elem);
|
|
|
-
|
|
|
-
|
|
|
- GB_ASSERT(ir_type(field_expr)->kind != Type_Tuple);
|
|
|
-
|
|
|
- Type *fet = ir_type(field_expr);
|
|
|
- // HACK TODO(bill): THIS IS A MASSIVE HACK!!!!
|
|
|
- if (is_type_union(ft) && !are_types_identical(fet, ft) && !is_type_untyped(fet)) {
|
|
|
- GB_ASSERT_MSG(union_variant_index(ft, fet) > 0, "%s", type_to_string(fet));
|
|
|
-
|
|
|
- irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index);
|
|
|
- ir_emit_store_union_variant(proc, gep, field_expr, fet);
|
|
|
- } else {
|
|
|
- irValue *fv = ir_emit_conv(proc, field_expr, ft);
|
|
|
- irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index);
|
|
|
- ir_emit_store(proc, gep, fv);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Type_Map: {
|
|
|
- if (cl->elems.count == 0) {
|
|
|
- break;
|
|
|
- }
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- {
|
|
|
- auto args = array_make<irValue *>(a, 3);
|
|
|
- args[0] = ir_gen_map_header(proc, v, type);
|
|
|
- args[1] = ir_const_int(2*cl->elems.count);
|
|
|
- args[2] = ir_emit_source_code_location(proc, proc_name, pos);
|
|
|
- ir_emit_runtime_call(proc, "__dynamic_map_reserve", args);
|
|
|
- }
|
|
|
- for_array(field_index, cl->elems) {
|
|
|
- Ast *elem = cl->elems[field_index];
|
|
|
- ast_node(fv, FieldValue, elem);
|
|
|
-
|
|
|
- irValue *key = ir_build_expr(proc, fv->field);
|
|
|
- irValue *value = ir_build_expr(proc, fv->value);
|
|
|
- ir_insert_dynamic_map_key_and_value(proc, v, type, key, value, elem);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Type_Array: {
|
|
|
- if (cl->elems.count > 0) {
|
|
|
- ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
|
|
|
-
|
|
|
- auto temp_data = array_make<irCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
|
|
|
-
|
|
|
- // NOTE(bill): Separate value, gep, store into their own chunks
|
|
|
- for_array(i, cl->elems) {
|
|
|
- Ast *elem = cl->elems[i];
|
|
|
- if (elem->kind == Ast_FieldValue) {
|
|
|
- ast_node(fv, FieldValue, elem);
|
|
|
- if (ir_is_elem_const(proc->module, fv->value, et)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (is_ast_range(fv->field)) {
|
|
|
- ast_node(ie, BinaryExpr, fv->field);
|
|
|
- TypeAndValue lo_tav = ie->left->tav;
|
|
|
- TypeAndValue hi_tav = ie->right->tav;
|
|
|
- GB_ASSERT(lo_tav.mode == Addressing_Constant);
|
|
|
- GB_ASSERT(hi_tav.mode == Addressing_Constant);
|
|
|
-
|
|
|
- TokenKind op = ie->op.kind;
|
|
|
- i64 lo = exact_value_to_i64(lo_tav.value);
|
|
|
- i64 hi = exact_value_to_i64(hi_tav.value);
|
|
|
- if (op == Token_Ellipsis) {
|
|
|
- hi += 1;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *value = ir_build_expr(proc, fv->value);
|
|
|
-
|
|
|
- for (i64 k = lo; k < hi; k++) {
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.value = value;
|
|
|
- data.elem_index = cast(i32)k;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
-
|
|
|
- } else {
|
|
|
- auto tav = fv->field->tav;
|
|
|
- GB_ASSERT(tav.mode == Addressing_Constant);
|
|
|
- i64 index = exact_value_to_i64(tav.value);
|
|
|
-
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.value = ir_emit_conv(proc, ir_build_expr(proc, fv->value), et);
|
|
|
- data.expr = fv->value;
|
|
|
- data.elem_index = cast(i32)index;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
-
|
|
|
- } else {
|
|
|
- if (ir_is_elem_const(proc->module, elem, et)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.expr = elem;
|
|
|
- data.elem_index = cast(i32)i;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, temp_data) {
|
|
|
- temp_data[i].gep = ir_emit_array_epi(proc, v, temp_data[i].elem_index);
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, temp_data) {
|
|
|
- auto return_ptr_hint_ast = proc->return_ptr_hint_ast;
|
|
|
- auto return_ptr_hint_value = proc->return_ptr_hint_value;
|
|
|
- auto return_ptr_hint_used = proc->return_ptr_hint_used;
|
|
|
- defer (proc->return_ptr_hint_ast = return_ptr_hint_ast);
|
|
|
- defer (proc->return_ptr_hint_value = return_ptr_hint_value);
|
|
|
- defer (proc->return_ptr_hint_used = return_ptr_hint_used);
|
|
|
-
|
|
|
- irValue *field_expr = temp_data[i].value;
|
|
|
- Ast *expr = temp_data[i].expr;
|
|
|
-
|
|
|
- proc->return_ptr_hint_value = temp_data[i].gep;
|
|
|
- proc->return_ptr_hint_ast = unparen_expr(expr);
|
|
|
-
|
|
|
- if (field_expr == nullptr) {
|
|
|
- field_expr = ir_build_expr(proc, expr);
|
|
|
- }
|
|
|
- Type *t = ir_type(field_expr);
|
|
|
- GB_ASSERT(t->kind != Type_Tuple);
|
|
|
- irValue *ev = ir_emit_conv(proc, field_expr, et);
|
|
|
-
|
|
|
- if (!proc->return_ptr_hint_used) {
|
|
|
- temp_data[i].value = ev;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, temp_data) {
|
|
|
- if (temp_data[i].value != nullptr) {
|
|
|
- ir_emit_store(proc, temp_data[i].gep, temp_data[i].value, false);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_EnumeratedArray: {
|
|
|
- if (cl->elems.count > 0) {
|
|
|
- ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
|
|
|
-
|
|
|
- auto temp_data = array_make<irCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
|
|
|
-
|
|
|
- // NOTE(bill): Separate value, gep, store into their own chunks
|
|
|
- for_array(i, cl->elems) {
|
|
|
- Ast *elem = cl->elems[i];
|
|
|
- if (elem->kind == Ast_FieldValue) {
|
|
|
- ast_node(fv, FieldValue, elem);
|
|
|
- if (ir_is_elem_const(proc->module, fv->value, et)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (is_ast_range(fv->field)) {
|
|
|
- ast_node(ie, BinaryExpr, fv->field);
|
|
|
- TypeAndValue lo_tav = ie->left->tav;
|
|
|
- TypeAndValue hi_tav = ie->right->tav;
|
|
|
- GB_ASSERT(lo_tav.mode == Addressing_Constant);
|
|
|
- GB_ASSERT(hi_tav.mode == Addressing_Constant);
|
|
|
-
|
|
|
- TokenKind op = ie->op.kind;
|
|
|
- i64 lo = exact_value_to_i64(lo_tav.value);
|
|
|
- i64 hi = exact_value_to_i64(hi_tav.value);
|
|
|
- if (op == Token_Ellipsis) {
|
|
|
- hi += 1;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *value = ir_build_expr(proc, fv->value);
|
|
|
-
|
|
|
- for (i64 k = lo; k < hi; k++) {
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.value = value;
|
|
|
- data.elem_index = cast(i32)k;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
-
|
|
|
- } else {
|
|
|
- auto tav = fv->field->tav;
|
|
|
- GB_ASSERT(tav.mode == Addressing_Constant);
|
|
|
- i64 index = exact_value_to_i64(tav.value);
|
|
|
-
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.value = ir_emit_conv(proc, ir_build_expr(proc, fv->value), et);
|
|
|
- data.expr = fv->value;
|
|
|
- data.elem_index = cast(i32)index;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
-
|
|
|
- } else {
|
|
|
- if (ir_is_elem_const(proc->module, elem, et)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.expr = elem;
|
|
|
- data.elem_index = cast(i32)i;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- i32 index_offset = cast(i32)exact_value_to_i64(bt->EnumeratedArray.min_value);
|
|
|
-
|
|
|
- for_array(i, temp_data) {
|
|
|
- i32 index = temp_data[i].elem_index - index_offset;
|
|
|
- temp_data[i].gep = ir_emit_array_epi(proc, v, index);
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, temp_data) {
|
|
|
- auto return_ptr_hint_ast = proc->return_ptr_hint_ast;
|
|
|
- auto return_ptr_hint_value = proc->return_ptr_hint_value;
|
|
|
- auto return_ptr_hint_used = proc->return_ptr_hint_used;
|
|
|
- defer (proc->return_ptr_hint_ast = return_ptr_hint_ast);
|
|
|
- defer (proc->return_ptr_hint_value = return_ptr_hint_value);
|
|
|
- defer (proc->return_ptr_hint_used = return_ptr_hint_used);
|
|
|
-
|
|
|
- irValue *field_expr = temp_data[i].value;
|
|
|
- Ast *expr = temp_data[i].expr;
|
|
|
-
|
|
|
- proc->return_ptr_hint_value = temp_data[i].gep;
|
|
|
- proc->return_ptr_hint_ast = unparen_expr(expr);
|
|
|
-
|
|
|
- if (field_expr == nullptr) {
|
|
|
- field_expr = ir_build_expr(proc, expr);
|
|
|
- }
|
|
|
- Type *t = ir_type(field_expr);
|
|
|
- GB_ASSERT(t->kind != Type_Tuple);
|
|
|
- irValue *ev = ir_emit_conv(proc, field_expr, et);
|
|
|
-
|
|
|
- if (!proc->return_ptr_hint_used) {
|
|
|
- temp_data[i].value = ev;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, temp_data) {
|
|
|
- if (temp_data[i].value != nullptr) {
|
|
|
- ir_emit_store(proc, temp_data[i].gep, temp_data[i].value, false);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Slice: {
|
|
|
- if (cl->elems.count > 0) {
|
|
|
- Type *elem_type = bt->Slice.elem;
|
|
|
- Type *elem_ptr_type = alloc_type_pointer(elem_type);
|
|
|
- Type *elem_ptr_ptr_type = alloc_type_pointer(elem_ptr_type);
|
|
|
- irValue *slice = ir_add_module_constant(proc->module, type, exact_value_compound(expr));
|
|
|
- GB_ASSERT(slice->kind == irValue_ConstantSlice);
|
|
|
-
|
|
|
- irValue *data = ir_emit_array_ep(proc, slice->ConstantSlice.backing_array, v_zero32);
|
|
|
-
|
|
|
- auto temp_data = array_make<irCompoundLitElemTempData>(temporary_allocator(), 0, cl->elems.count);
|
|
|
-
|
|
|
- for_array(i, cl->elems) {
|
|
|
- Ast *elem = cl->elems[i];
|
|
|
- if (elem->kind == Ast_FieldValue) {
|
|
|
- ast_node(fv, FieldValue, elem);
|
|
|
-
|
|
|
- if (ir_is_elem_const(proc->module, fv->value, et)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (is_ast_range(fv->field)) {
|
|
|
- ast_node(ie, BinaryExpr, fv->field);
|
|
|
- TypeAndValue lo_tav = ie->left->tav;
|
|
|
- TypeAndValue hi_tav = ie->right->tav;
|
|
|
- GB_ASSERT(lo_tav.mode == Addressing_Constant);
|
|
|
- GB_ASSERT(hi_tav.mode == Addressing_Constant);
|
|
|
-
|
|
|
- TokenKind op = ie->op.kind;
|
|
|
- i64 lo = exact_value_to_i64(lo_tav.value);
|
|
|
- i64 hi = exact_value_to_i64(hi_tav.value);
|
|
|
- if (op == Token_Ellipsis) {
|
|
|
- hi += 1;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *value = ir_emit_conv(proc, ir_build_expr(proc, fv->value), et);
|
|
|
-
|
|
|
- for (i64 k = lo; k < hi; k++) {
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.value = value;
|
|
|
- data.elem_index = cast(i32)k;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
-
|
|
|
- } else {
|
|
|
- GB_ASSERT(fv->field->tav.mode == Addressing_Constant);
|
|
|
- i64 index = exact_value_to_i64(fv->field->tav.value);
|
|
|
-
|
|
|
- irValue *field_expr = ir_build_expr(proc, fv->value);
|
|
|
- GB_ASSERT(!is_type_tuple(ir_type(field_expr)));
|
|
|
-
|
|
|
- irValue *ev = ir_emit_conv(proc, field_expr, et);
|
|
|
-
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.value = ev;
|
|
|
- data.elem_index = cast(i32)index;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (ir_is_elem_const(proc->module, elem, et)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- irValue *field_expr = ir_build_expr(proc, elem);
|
|
|
- GB_ASSERT(!is_type_tuple(ir_type(field_expr)));
|
|
|
-
|
|
|
- irValue *ev = ir_emit_conv(proc, field_expr, et);
|
|
|
-
|
|
|
- irCompoundLitElemTempData data = {};
|
|
|
- data.value = ev;
|
|
|
- data.elem_index = cast(i32)i;
|
|
|
- array_add(&temp_data, data);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, temp_data) {
|
|
|
- temp_data[i].gep = ir_emit_ptr_offset(proc, data, ir_const_int(temp_data[i].elem_index));
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, temp_data) {
|
|
|
- ir_emit_store(proc, temp_data[i].gep, temp_data[i].value);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *count = ir_const_int(slice->ConstantSlice.count);
|
|
|
- ir_fill_slice(proc, v, data, count);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Type_DynamicArray: {
|
|
|
- if (cl->elems.count == 0) {
|
|
|
- break;
|
|
|
- }
|
|
|
- Type *et = bt->DynamicArray.elem;
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irValue *size = ir_const_int(type_size_of(et));
|
|
|
- irValue *align = ir_const_int(type_align_of(et));
|
|
|
-
|
|
|
- i64 item_count = gb_max(cl->max_count, cl->elems.count);
|
|
|
- {
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(a, 5);
|
|
|
- args[0] = ir_emit_conv(proc, v, t_rawptr);
|
|
|
- args[1] = size;
|
|
|
- args[2] = align;
|
|
|
- args[3] = ir_const_int(2*item_count); // TODO(bill): Is this too much waste?
|
|
|
- args[4] = ir_emit_source_code_location(proc, proc_name, pos);
|
|
|
- ir_emit_runtime_call(proc, "__dynamic_array_reserve", args);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *items = ir_generate_array(proc->module, et, item_count, str_lit("dacl$"), cast(i64)cast(intptr)expr);
|
|
|
-
|
|
|
- for_array(i, cl->elems) {
|
|
|
- Ast *elem = cl->elems[i];
|
|
|
- if (elem->kind == Ast_FieldValue) {
|
|
|
- ast_node(fv, FieldValue, elem);
|
|
|
- if (is_ast_range(fv->field)) {
|
|
|
- ast_node(ie, BinaryExpr, fv->field);
|
|
|
- TypeAndValue lo_tav = ie->left->tav;
|
|
|
- TypeAndValue hi_tav = ie->right->tav;
|
|
|
- GB_ASSERT(lo_tav.mode == Addressing_Constant);
|
|
|
- GB_ASSERT(hi_tav.mode == Addressing_Constant);
|
|
|
-
|
|
|
- TokenKind op = ie->op.kind;
|
|
|
- i64 lo = exact_value_to_i64(lo_tav.value);
|
|
|
- i64 hi = exact_value_to_i64(hi_tav.value);
|
|
|
- if (op == Token_Ellipsis) {
|
|
|
- hi += 1;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *value = ir_emit_conv(proc, ir_build_expr(proc, fv->value), et);
|
|
|
-
|
|
|
- for (i64 k = lo; k < hi; k++) {
|
|
|
- irValue *ep = ir_emit_array_epi(proc, items, cast(i32)k);
|
|
|
- ir_emit_store(proc, ep, value);
|
|
|
- }
|
|
|
- } else {
|
|
|
- GB_ASSERT(fv->field->tav.mode == Addressing_Constant);
|
|
|
-
|
|
|
- i64 field_index = exact_value_to_i64(fv->field->tav.value);
|
|
|
-
|
|
|
- irValue *ev = ir_build_expr(proc, fv->value);
|
|
|
- irValue *value = ir_emit_conv(proc, ev, et);
|
|
|
- irValue *ep = ir_emit_array_epi(proc, items, cast(i32)field_index);
|
|
|
- ir_emit_store(proc, ep, value);
|
|
|
- }
|
|
|
- } else {
|
|
|
- irValue *value = ir_emit_conv(proc, ir_build_expr(proc, elem), et);
|
|
|
- irValue *ep = ir_emit_array_epi(proc, items, cast(i32)i);
|
|
|
- ir_emit_store(proc, ep, value);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- auto args = array_make<irValue *>(a, 6);
|
|
|
- args[0] = ir_emit_conv(proc, v, t_rawptr);
|
|
|
- args[1] = size;
|
|
|
- args[2] = align;
|
|
|
- args[3] = ir_emit_conv(proc, items, t_rawptr);
|
|
|
- args[4] = ir_const_int(item_count);
|
|
|
- args[5] = ir_emit_source_code_location(proc, proc_name, pos);
|
|
|
- ir_emit_runtime_call(proc, "__dynamic_array_append", args);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Type_Basic: {
|
|
|
- GB_ASSERT(is_type_any(bt));
|
|
|
- if (cl->elems.count > 0) {
|
|
|
- ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
|
|
|
- String field_names[2] = {
|
|
|
- str_lit("data"),
|
|
|
- str_lit("id"),
|
|
|
- };
|
|
|
- Type *field_types[2] = {
|
|
|
- t_rawptr,
|
|
|
- t_typeid,
|
|
|
- };
|
|
|
-
|
|
|
- for_array(field_index, cl->elems) {
|
|
|
- Ast *elem = cl->elems[field_index];
|
|
|
-
|
|
|
- irValue *field_expr = nullptr;
|
|
|
- isize index = field_index;
|
|
|
-
|
|
|
- if (elem->kind == Ast_FieldValue) {
|
|
|
- ast_node(fv, FieldValue, elem);
|
|
|
- Selection sel = lookup_field(bt, fv->field->Ident.token.string, false);
|
|
|
- index = sel.index[0];
|
|
|
- elem = fv->value;
|
|
|
- } else {
|
|
|
- TypeAndValue tav = type_and_value_of_expr(elem);
|
|
|
- Selection sel = lookup_field(bt, field_names[field_index], false);
|
|
|
- index = sel.index[0];
|
|
|
- }
|
|
|
-
|
|
|
- field_expr = ir_build_expr(proc, elem);
|
|
|
-
|
|
|
- GB_ASSERT(ir_type(field_expr)->kind != Type_Tuple);
|
|
|
-
|
|
|
- Type *ft = field_types[index];
|
|
|
- irValue *fv = ir_emit_conv(proc, field_expr, ft);
|
|
|
- irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index);
|
|
|
- ir_emit_store(proc, gep, fv);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Type_BitSet: {
|
|
|
- i64 sz = type_size_of(type);
|
|
|
- if (cl->elems.count > 0 && sz > 0) {
|
|
|
- ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
|
|
|
-
|
|
|
- irValue *lower = ir_value_constant(t_int, exact_value_i64(bt->BitSet.lower));
|
|
|
- for_array(i, cl->elems) {
|
|
|
- Ast *elem = cl->elems[i];
|
|
|
- GB_ASSERT(elem->kind != Ast_FieldValue);
|
|
|
-
|
|
|
- if (ir_is_elem_const(proc->module, elem, et)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *expr = ir_build_expr(proc, elem);
|
|
|
- GB_ASSERT(ir_type(expr)->kind != Type_Tuple);
|
|
|
-
|
|
|
- Type *it = bit_set_to_int(bt);
|
|
|
- irValue *e = ir_emit_conv(proc, expr, it);
|
|
|
- e = ir_emit_arith(proc, Token_Sub, e, lower, it);
|
|
|
- e = ir_emit_arith(proc, Token_Shl, v_one, e, it);
|
|
|
-
|
|
|
- irValue *old_value = ir_emit_bitcast(proc, ir_emit_load(proc, v), it);
|
|
|
- irValue *new_value = ir_emit_arith(proc, Token_Or, old_value, e, it);
|
|
|
- new_value = ir_emit_bitcast(proc, new_value, type);
|
|
|
- ir_emit_store(proc, v, new_value);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- return ir_addr(v);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(tc, TypeCast, expr);
|
|
|
- Type *type = type_of_expr(expr);
|
|
|
- irValue *x = ir_build_expr(proc, tc->expr);
|
|
|
- irValue *e = nullptr;
|
|
|
- switch (tc->token.kind) {
|
|
|
- case Token_cast:
|
|
|
- e = ir_emit_conv(proc, x, type);
|
|
|
- break;
|
|
|
- case Token_transmute:
|
|
|
- e = ir_emit_transmute(proc, x, type);
|
|
|
- break;
|
|
|
- default:
|
|
|
- GB_PANIC("Invalid AST TypeCast");
|
|
|
- }
|
|
|
- irValue *v = ir_add_local_generated(proc, type, false);
|
|
|
- ir_emit_store(proc, v, e);
|
|
|
- return ir_addr(v);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ac, AutoCast, expr);
|
|
|
- return ir_build_addr(proc, ac->expr);
|
|
|
- case_end;
|
|
|
- }
|
|
|
-
|
|
|
- TokenPos token_pos = ast_token(expr).pos;
|
|
|
- GB_PANIC("Unexpected address expression\n"
|
|
|
- "\tAst: %.*s @ "
|
|
|
- "%s\n",
|
|
|
- LIT(ast_strings[expr->kind]),
|
|
|
- token_pos_to_string(token_pos));
|
|
|
-
|
|
|
-
|
|
|
- return ir_addr(nullptr);
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_assign_op(irProcedure *proc, irAddr const &lhs, irValue *value, TokenKind op) {
|
|
|
- irValue *old_value = ir_addr_load(proc, lhs);
|
|
|
- Type *type = ir_type(old_value);
|
|
|
-
|
|
|
- irValue *change = value;
|
|
|
- if (is_type_pointer(type) && is_type_integer(ir_type(value))) {
|
|
|
- change = ir_emit_conv(proc, value, default_type(ir_type(value)));
|
|
|
- } else {
|
|
|
- change = ir_emit_conv(proc, value, type);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *new_value = ir_emit_arith(proc, op, old_value, change, type);
|
|
|
- ir_addr_store(proc, lhs, new_value);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_build_cond(irProcedure *proc, Ast *cond, irBlock *true_block, irBlock *false_block) {
|
|
|
- switch (cond->kind) {
|
|
|
- case_ast_node(pe, ParenExpr, cond);
|
|
|
- return ir_build_cond(proc, pe->expr, true_block, false_block);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ue, UnaryExpr, cond);
|
|
|
- if (ue->op.kind == Token_Not) {
|
|
|
- return ir_build_cond(proc, ue->expr, false_block, true_block);
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(be, BinaryExpr, cond);
|
|
|
- if (be->op.kind == Token_CmpAnd) {
|
|
|
- irBlock *block = ir_new_block(proc, nullptr, "cmp.and");
|
|
|
- ir_build_cond(proc, be->left, block, false_block);
|
|
|
- ir_start_block(proc, block);
|
|
|
- return ir_build_cond(proc, be->right, true_block, false_block);
|
|
|
- } else if (be->op.kind == Token_CmpOr) {
|
|
|
- irBlock *block = ir_new_block(proc, nullptr, "cmp.or");
|
|
|
- ir_build_cond(proc, be->left, true_block, block);
|
|
|
- ir_start_block(proc, block);
|
|
|
- return ir_build_cond(proc, be->right, true_block, false_block);
|
|
|
- }
|
|
|
- case_end;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *v = ir_build_expr(proc, cond);
|
|
|
- v = ir_emit_conv(proc, v, t_bool);
|
|
|
- ir_emit_if(proc, v, true_block, false_block);
|
|
|
- return v;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_nested_proc(irProcedure *proc, AstProcLit *pd, Entity *e) {
|
|
|
- GB_ASSERT(pd->body != nullptr);
|
|
|
-
|
|
|
- if (ir_min_dep_entity(proc->module, e) == false) {
|
|
|
- // NOTE(bill): Nothing depends upon it so doesn't need to be built
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(bill): Generate a new name
|
|
|
- // parent.name-guid
|
|
|
- String original_name = e->token.string;
|
|
|
- String pd_name = original_name;
|
|
|
- if (e->Procedure.link_name.len > 0) {
|
|
|
- pd_name = e->Procedure.link_name;
|
|
|
- }
|
|
|
-
|
|
|
- isize name_len = proc->name.len + 1 + pd_name.len + 1 + 10 + 1;
|
|
|
- u8 *name_text = gb_alloc_array(ir_allocator(), u8, name_len);
|
|
|
-
|
|
|
- i32 guid = cast(i32)proc->children.count;
|
|
|
- name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s.%.*s-%d", LIT(proc->name), LIT(pd_name), guid);
|
|
|
- String name = make_string(name_text, name_len-1);
|
|
|
-
|
|
|
- set_procedure_abi_types(e->type);
|
|
|
- irValue *value = ir_value_procedure(proc->module, e, e->type, pd->type, pd->body, name);
|
|
|
-
|
|
|
- value->Proc.tags = pd->tags;
|
|
|
- value->Proc.inlining = pd->inlining;
|
|
|
- value->Proc.parent = proc;
|
|
|
-
|
|
|
- ir_module_add_value(proc->module, e, value);
|
|
|
- array_add(&proc->children, &value->Proc);
|
|
|
- array_add(&proc->module->procs_to_generate, value);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_build_constant_value_decl(irProcedure *proc, AstValueDecl *vd) {
|
|
|
- if (vd == nullptr || vd->is_mutable) {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, vd->names) {
|
|
|
- Ast *ident = vd->names[i];
|
|
|
- GB_ASSERT(ident->kind == Ast_Ident);
|
|
|
- Entity *e = entity_of_node(ident);
|
|
|
- GB_ASSERT(e != nullptr);
|
|
|
- switch (e->kind) {
|
|
|
- case Entity_TypeName:
|
|
|
- case Entity_Procedure:
|
|
|
- break;
|
|
|
- default:
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (e->kind == Entity_TypeName) {
|
|
|
- bool polymorphic_struct = false;
|
|
|
- if (e->type != nullptr && e->kind == Entity_TypeName) {
|
|
|
- Type *bt = base_type(e->type);
|
|
|
- if (bt->kind == Type_Struct) {
|
|
|
- polymorphic_struct = bt->Struct.is_polymorphic;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!polymorphic_struct && !ir_min_dep_entity(proc->module, e)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(bill): Generate a new name
|
|
|
- // parent_proc.name-guid
|
|
|
- String ts_name = e->token.string;
|
|
|
-
|
|
|
- irModule *m = proc->module;
|
|
|
- isize name_len = proc->name.len + 1 + ts_name.len + 1 + 10 + 1;
|
|
|
- u8 *name_text = gb_alloc_array(ir_allocator(), u8, name_len);
|
|
|
- i32 guid = cast(i32)m->members.entries.count;
|
|
|
- name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s.%.*s-%d", LIT(proc->name), LIT(ts_name), guid);
|
|
|
-
|
|
|
- String name = make_string(name_text, name_len-1);
|
|
|
-
|
|
|
- irValue *value = ir_value_type_name(name, e->type);
|
|
|
- ir_add_entity_name(m, e, name);
|
|
|
- ir_gen_global_type_name(m, e, name);
|
|
|
- } else if (e->kind == Entity_Procedure) {
|
|
|
- CheckerInfo *info = proc->module->info;
|
|
|
- DeclInfo *decl = decl_info_of_entity(e);
|
|
|
- ast_node(pl, ProcLit, decl->proc_lit);
|
|
|
- if (pl->body != nullptr) {
|
|
|
- auto *found = map_get(&info->gen_procs, hash_pointer(ident));
|
|
|
- if (found) {
|
|
|
- auto procs = *found;
|
|
|
- for_array(i, procs) {
|
|
|
- Entity *e = procs[i];
|
|
|
- if (!ir_min_dep_entity(proc->module, e)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- DeclInfo *d = decl_info_of_entity(e);
|
|
|
- ir_build_nested_proc(proc, &d->proc_lit->ProcLit, e);
|
|
|
- }
|
|
|
- } else {
|
|
|
- ir_build_nested_proc(proc, pl, e);
|
|
|
- }
|
|
|
- } else {
|
|
|
-
|
|
|
- // FFI - Foreign function interace
|
|
|
- String original_name = e->token.string;
|
|
|
- String name = original_name;
|
|
|
-
|
|
|
- if (e->Procedure.is_foreign) {
|
|
|
- ir_add_foreign_library_path(proc->module, e->Procedure.foreign_library);
|
|
|
- }
|
|
|
-
|
|
|
- if (e->Procedure.link_name.len > 0) {
|
|
|
- name = e->Procedure.link_name;
|
|
|
- }
|
|
|
-
|
|
|
- StringHashKey key = string_hash_string(name);
|
|
|
- irValue **prev_value = string_map_get(&proc->module->members, key);
|
|
|
- if (prev_value != nullptr) {
|
|
|
- // NOTE(bill): Don't do mutliple declarations in the IR
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- set_procedure_abi_types(e->type);
|
|
|
- irValue *value = ir_value_procedure(proc->module, e, e->type, pl->type, pl->body, name);
|
|
|
-
|
|
|
- value->Proc.tags = pl->tags;
|
|
|
- value->Proc.inlining = pl->inlining;
|
|
|
-
|
|
|
- if (value->Proc.is_foreign || value->Proc.is_export) {
|
|
|
- string_map_set(&proc->module->members, key, value);
|
|
|
- } else {
|
|
|
- array_add(&proc->children, &value->Proc);
|
|
|
- }
|
|
|
-
|
|
|
- ir_module_add_value(proc->module, e, value);
|
|
|
- ir_build_proc(value, proc);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_stmt_list(irProcedure *proc, Slice<Ast *> stmts) {
|
|
|
- // NOTE(bill): Precollect constant entities
|
|
|
- for_array(i, stmts) {
|
|
|
- Ast *stmt = stmts[i];
|
|
|
- switch (stmt->kind) {
|
|
|
- case_ast_node(vd, ValueDecl, stmt);
|
|
|
- ir_build_constant_value_decl(proc, vd);
|
|
|
- case_end;
|
|
|
- case_ast_node(fb, ForeignBlockDecl, stmt);
|
|
|
- ast_node(block, BlockStmt, fb->body);
|
|
|
- ir_build_stmt_list(proc, block->stmts);
|
|
|
- case_end;
|
|
|
- }
|
|
|
- }
|
|
|
- for_array(i, stmts) {
|
|
|
- ir_build_stmt(proc, stmts[i]);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_stmt_internal(irProcedure *proc, Ast *node);
|
|
|
-void ir_build_stmt(irProcedure *proc, Ast *node) {
|
|
|
- Ast *prev_stmt = proc->curr_stmt;
|
|
|
- proc->curr_stmt = node;
|
|
|
- u64 prev_state_flags = proc->module->state_flags;
|
|
|
- defer (proc->module->state_flags = prev_state_flags);
|
|
|
-
|
|
|
- if (node->state_flags != 0) {
|
|
|
- u64 in = node->state_flags;
|
|
|
- u64 out = proc->module->state_flags;
|
|
|
-
|
|
|
- if (in & StateFlag_bounds_check) {
|
|
|
- out |= StateFlag_bounds_check;
|
|
|
- out &= ~StateFlag_no_bounds_check;
|
|
|
- } else if (in & StateFlag_no_bounds_check) {
|
|
|
- out |= StateFlag_no_bounds_check;
|
|
|
- out &= ~StateFlag_bounds_check;
|
|
|
- }
|
|
|
-
|
|
|
- proc->module->state_flags = out;
|
|
|
- }
|
|
|
-
|
|
|
- ir_push_debug_location(proc->module, node, proc->debug_scope);
|
|
|
- ir_build_stmt_internal(proc, node);
|
|
|
- ir_pop_debug_location(proc->module);
|
|
|
-
|
|
|
- proc->curr_stmt = prev_stmt;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_when_stmt(irProcedure *proc, AstWhenStmt *ws) {
|
|
|
- irValue *cond = ir_build_expr(proc, ws->cond);
|
|
|
- GB_ASSERT(cond->kind == irValue_Constant &&
|
|
|
- is_type_boolean(ir_type(cond)));
|
|
|
-
|
|
|
- GB_ASSERT(cond->Constant.value.kind == ExactValue_Bool);
|
|
|
- if (cond->Constant.value.value_bool) {
|
|
|
- ir_build_stmt_list(proc, ws->body->BlockStmt.stmts);
|
|
|
- } else if (ws->else_stmt) {
|
|
|
- switch (ws->else_stmt->kind) {
|
|
|
- case Ast_BlockStmt:
|
|
|
- ir_build_stmt_list(proc, ws->else_stmt->BlockStmt.stmts);
|
|
|
- break;
|
|
|
- case Ast_WhenStmt:
|
|
|
- ir_build_when_stmt(proc, &ws->else_stmt->WhenStmt);
|
|
|
- break;
|
|
|
- default:
|
|
|
- GB_PANIC("Invalid 'else' statement in 'when' statement");
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void ir_build_range_indexed(irProcedure *proc, irValue *expr, Type *val_type, irValue *count_ptr,
|
|
|
- irValue **val_, irValue **idx_, irBlock **loop_, irBlock **done_) {
|
|
|
- irValue *count = nullptr;
|
|
|
- Type *expr_type = base_type(type_deref(ir_type(expr)));
|
|
|
- switch (expr_type->kind) {
|
|
|
- case Type_Array:
|
|
|
- count = ir_const_int(expr_type->Array.count);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *val = nullptr;
|
|
|
- irValue *idx = nullptr;
|
|
|
- irBlock *loop = nullptr;
|
|
|
- irBlock *done = nullptr;
|
|
|
- irBlock *body = nullptr;
|
|
|
-
|
|
|
-
|
|
|
- irValue *index = ir_add_local_generated(proc, t_int, false);
|
|
|
- ir_emit_store(proc, index, ir_const_int(-1));
|
|
|
-
|
|
|
- loop = ir_new_block(proc, nullptr, "for.index.loop");
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, loop);
|
|
|
-
|
|
|
- irValue *incr = ir_emit_arith(proc, Token_Add, ir_emit_load(proc, index), v_one, t_int);
|
|
|
- ir_emit_store(proc, index, incr);
|
|
|
-
|
|
|
- body = ir_new_block(proc, nullptr, "for.index.body");
|
|
|
- done = ir_new_block(proc, nullptr, "for.index.done");
|
|
|
- if (count == nullptr) {
|
|
|
- GB_ASSERT(count_ptr != nullptr);
|
|
|
- count = ir_emit_load(proc, count_ptr);
|
|
|
- }
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_Lt, incr, count);
|
|
|
- ir_emit_if(proc, cond, body, done);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- idx = ir_emit_load(proc, index);
|
|
|
- switch (expr_type->kind) {
|
|
|
- case Type_Array: {
|
|
|
- if (val_type != nullptr) {
|
|
|
- val = ir_emit_load(proc, ir_emit_array_ep(proc, expr, idx));
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_EnumeratedArray: {
|
|
|
- if (val_type != nullptr) {
|
|
|
- val = ir_emit_load(proc, ir_emit_array_ep(proc, expr, idx));
|
|
|
- }
|
|
|
- // NOTE(bill): Override the idx value for the enumeration
|
|
|
- Type *index_type =expr_type->EnumeratedArray.index;
|
|
|
- if (compare_exact_values(Token_NotEq, expr_type->EnumeratedArray.min_value, exact_value_u64(0))) {
|
|
|
- idx = ir_emit_arith(proc, Token_Add, idx, ir_value_constant(index_type, expr_type->EnumeratedArray.min_value), index_type);
|
|
|
- }
|
|
|
-
|
|
|
- idx = ir_emit_conv(proc, idx, expr_type->EnumeratedArray.index);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Slice: {
|
|
|
- if (val_type != nullptr) {
|
|
|
- irValue *elem = ir_slice_elem(proc, expr);
|
|
|
- val = ir_emit_load(proc, ir_emit_ptr_offset(proc, elem, idx));
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_DynamicArray: {
|
|
|
- if (val_type != nullptr) {
|
|
|
- irValue *elem = ir_emit_struct_ep(proc, expr, 0);
|
|
|
- elem = ir_emit_load(proc, elem);
|
|
|
- val = ir_emit_load(proc, ir_emit_ptr_offset(proc, elem, idx));
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Map: {
|
|
|
- irValue *entries = ir_map_entries_ptr(proc, expr);
|
|
|
- irValue *elem = ir_emit_struct_ep(proc, entries, 0);
|
|
|
- elem = ir_emit_load(proc, elem);
|
|
|
-
|
|
|
- irValue *entry = ir_emit_ptr_offset(proc, elem, idx);
|
|
|
- idx = ir_emit_load(proc, ir_emit_struct_ep(proc, entry, 2));
|
|
|
- val = ir_emit_load(proc, ir_emit_struct_ep(proc, entry, 3));
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
- default:
|
|
|
- GB_PANIC("Cannot do range_indexed of %s", type_to_string(expr_type));
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if (val_) *val_ = val;
|
|
|
- if (idx_) *idx_ = idx;
|
|
|
- if (loop_) *loop_ = loop;
|
|
|
- if (done_) *done_ = done;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_build_range_string(irProcedure *proc, irValue *expr, Type *val_type,
|
|
|
- irValue **val_, irValue **idx_, irBlock **loop_, irBlock **done_) {
|
|
|
- irValue *count = v_zero;
|
|
|
- Type *expr_type = base_type(ir_type(expr));
|
|
|
- switch (expr_type->kind) {
|
|
|
- case Type_Basic:
|
|
|
- count = ir_string_len(proc, expr);
|
|
|
- break;
|
|
|
- default:
|
|
|
- GB_PANIC("Cannot do range_string of %s", type_to_string(expr_type));
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *val = nullptr;
|
|
|
- irValue *idx = nullptr;
|
|
|
- irBlock *loop = nullptr;
|
|
|
- irBlock *done = nullptr;
|
|
|
- irBlock *body = nullptr;
|
|
|
-
|
|
|
-
|
|
|
- irValue *offset_ = ir_add_local_generated(proc, t_int, false);
|
|
|
- ir_emit_store(proc, offset_, v_zero);
|
|
|
-
|
|
|
- loop = ir_new_block(proc, nullptr, "for.string.loop");
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, loop);
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- body = ir_new_block(proc, nullptr, "for.string.body");
|
|
|
- done = ir_new_block(proc, nullptr, "for.string.done");
|
|
|
-
|
|
|
- irValue *offset = ir_emit_load(proc, offset_);
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_Lt, offset, count);
|
|
|
- ir_emit_if(proc, cond, body, done);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
-
|
|
|
- irValue *str_elem = ir_emit_ptr_offset(proc, ir_string_elem(proc, expr), offset);
|
|
|
- irValue *str_len = ir_emit_arith(proc, Token_Sub, count, offset, t_int);
|
|
|
- auto args = array_make<irValue *>(ir_allocator(), 1);
|
|
|
- args[0] = ir_emit_string(proc, str_elem, str_len);
|
|
|
- irValue *rune_and_len = ir_emit_runtime_call(proc, "string_decode_rune", args);
|
|
|
- irValue *len = ir_emit_struct_ev(proc, rune_and_len, 1);
|
|
|
- ir_emit_store(proc, offset_, ir_emit_arith(proc, Token_Add, offset, len, t_int));
|
|
|
-
|
|
|
-
|
|
|
- idx = offset;
|
|
|
- if (val_type != nullptr) {
|
|
|
- val = ir_emit_struct_ev(proc, rune_and_len, 0);
|
|
|
- }
|
|
|
-
|
|
|
- if (val_) *val_ = val;
|
|
|
- if (idx_) *idx_ = idx;
|
|
|
- if (loop_) *loop_ = loop;
|
|
|
- if (done_) *done_ = done;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_build_range_interval(irProcedure *proc, AstBinaryExpr *node, Type *val_type,
|
|
|
- irValue **val_, irValue **idx_, irBlock **loop_, irBlock **done_) {
|
|
|
- // TODO(bill): How should the behaviour work for lower and upper bounds checking for iteration?
|
|
|
- // If 'lower' is changed, should 'val' do so or is that not typical behaviour?
|
|
|
-
|
|
|
- irValue *lower = ir_build_expr(proc, node->left);
|
|
|
- irValue *upper = nullptr;
|
|
|
-
|
|
|
- irValue *val = nullptr;
|
|
|
- irValue *idx = nullptr;
|
|
|
- irBlock *loop = nullptr;
|
|
|
- irBlock *done = nullptr;
|
|
|
- irBlock *body = nullptr;
|
|
|
-
|
|
|
- if (val_type == nullptr) {
|
|
|
- val_type = ir_type(lower);
|
|
|
- }
|
|
|
- irValue *value = ir_add_local_generated(proc, val_type, false);
|
|
|
- ir_emit_store(proc, value, lower);
|
|
|
-
|
|
|
- irValue *index = ir_add_local_generated(proc, t_int, false);
|
|
|
- ir_emit_store(proc, index, ir_const_int(0));
|
|
|
-
|
|
|
- loop = ir_new_block(proc, nullptr, "for.interval.loop");
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, loop);
|
|
|
-
|
|
|
- body = ir_new_block(proc, nullptr, "for.interval.body");
|
|
|
- done = ir_new_block(proc, nullptr, "for.interval.done");
|
|
|
-
|
|
|
-
|
|
|
- TokenKind op = Token_Lt;
|
|
|
- switch (node->op.kind) {
|
|
|
- case Token_Ellipsis: op = Token_LtEq; break;
|
|
|
- case Token_RangeHalf: op = Token_Lt; break;
|
|
|
- default: GB_PANIC("Invalid interval operator"); break;
|
|
|
- }
|
|
|
-
|
|
|
- upper = ir_build_expr(proc, node->right);
|
|
|
-
|
|
|
- irValue *curr_value = ir_emit_load(proc, value);
|
|
|
- irValue *cond = ir_emit_comp(proc, op, curr_value, upper);
|
|
|
- ir_emit_if(proc, cond, body, done);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- if (value != nullptr) {
|
|
|
- val = ir_emit_load(proc, value);
|
|
|
- }
|
|
|
- idx = ir_emit_load(proc, index);
|
|
|
-
|
|
|
- ir_emit_increment(proc, value);
|
|
|
- ir_emit_increment(proc, index);
|
|
|
-
|
|
|
- if (val_) *val_ = val;
|
|
|
- if (idx_) *idx_ = idx;
|
|
|
- if (loop_) *loop_ = loop;
|
|
|
- if (done_) *done_ = done;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_range_enum(irProcedure *proc, Type *enum_type, Type *val_type, irValue **val_, irValue **idx_, irBlock **loop_, irBlock **done_) {
|
|
|
- Type *t = enum_type;
|
|
|
- GB_ASSERT(is_type_enum(t));
|
|
|
- Type *enum_ptr = alloc_type_pointer(t);
|
|
|
- t = base_type(t);
|
|
|
- Type *core_elem = core_type(t);
|
|
|
- GB_ASSERT(t->kind == Type_Enum);
|
|
|
- i64 enum_count = t->Enum.fields.count;
|
|
|
- irValue *max_count = ir_const_int(enum_count);
|
|
|
-
|
|
|
- irValue *ti = ir_type_info(proc, t);
|
|
|
- irValue *variant = ir_emit_struct_ep(proc, ti, 4);
|
|
|
- irValue *eti_ptr = ir_emit_conv(proc, variant, t_type_info_enum_ptr);
|
|
|
- irValue *values = ir_emit_load(proc, ir_emit_struct_ep(proc, eti_ptr, 2));
|
|
|
- irValue *values_data = ir_slice_elem(proc, values);
|
|
|
-
|
|
|
- irValue *offset_ = ir_add_local_generated(proc, t_int, false);
|
|
|
- ir_emit_store(proc, offset_, v_zero);
|
|
|
-
|
|
|
- irBlock *loop = ir_new_block(proc, nullptr, "for.enum.loop");
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, loop);
|
|
|
-
|
|
|
- irBlock *body = ir_new_block(proc, nullptr, "for.enum.body");
|
|
|
- irBlock *done = ir_new_block(proc, nullptr, "for.enum.done");
|
|
|
-
|
|
|
- irValue *offset = ir_emit_load(proc, offset_);
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_Lt, offset, max_count);
|
|
|
- ir_emit_if(proc, cond, body, done);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- irValue *val_ptr = ir_emit_ptr_offset(proc, values_data, offset);
|
|
|
- ir_emit_increment(proc, offset_);
|
|
|
-
|
|
|
- irValue *val = nullptr;
|
|
|
- if (val_type != nullptr) {
|
|
|
- GB_ASSERT(are_types_identical(enum_type, val_type));
|
|
|
-
|
|
|
- if (is_type_integer(core_elem)) {
|
|
|
- irValue *i = ir_emit_load(proc, val_ptr);
|
|
|
- val = ir_emit_conv(proc, i, t);
|
|
|
- } else {
|
|
|
- GB_PANIC("TODO(bill): enum core type %s", type_to_string(core_elem));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (val_) *val_ = val;
|
|
|
- if (idx_) *idx_ = offset;
|
|
|
- if (loop_) *loop_ = loop;
|
|
|
- if (done_) *done_ = done;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_range_tuple(irProcedure *proc, Ast *expr, Type *val0_type, Type *val1_type,
|
|
|
- irValue **val0_, irValue **val1_, irBlock **loop_, irBlock **done_) {
|
|
|
- irBlock *loop = ir_new_block(proc, nullptr, "for.tuple.loop");
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, loop);
|
|
|
-
|
|
|
- irBlock *body = ir_new_block(proc, nullptr, "for.tuple.body");
|
|
|
- irBlock *done = ir_new_block(proc, nullptr, "for.tuple.done");
|
|
|
-
|
|
|
- irValue *tuple_value = ir_build_expr(proc, expr);
|
|
|
- Type *tuple = ir_type(tuple_value);
|
|
|
- GB_ASSERT(tuple->kind == Type_Tuple);
|
|
|
- i32 tuple_count = cast(i32)tuple->Tuple.variables.count;
|
|
|
- i32 cond_index = tuple_count-1;
|
|
|
-
|
|
|
- irValue *cond = ir_emit_struct_ev(proc, tuple_value, cond_index);
|
|
|
- ir_emit_if(proc, cond, body, done);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- irValue *val0 = nullptr;
|
|
|
-
|
|
|
-
|
|
|
- if (val0_) *val0_ = ir_emit_struct_ev(proc, tuple_value, 0);
|
|
|
- if (val1_) *val1_ = ir_emit_struct_ev(proc, tuple_value, 1);
|
|
|
- if (loop_) *loop_ = loop;
|
|
|
- if (done_) *done_ = done;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_store_type_case_implicit(irProcedure *proc, Ast *clause, irValue *value) {
|
|
|
- Entity *e = implicit_entity_of_node(clause);
|
|
|
- GB_ASSERT(e != nullptr);
|
|
|
-
|
|
|
- if (e->flags & EntityFlag_Value) {
|
|
|
- // by value
|
|
|
- irValue *x = ir_add_local(proc, e, nullptr, false);
|
|
|
- GB_ASSERT(are_types_identical(ir_type(value), e->type));
|
|
|
- ir_emit_store(proc, x, value);
|
|
|
- } else {
|
|
|
- // by reference
|
|
|
- ir_module_add_value(proc->module, e, value);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-irAddr ir_store_range_stmt_val(irProcedure *proc, Ast *stmt_val, irValue *value) {
|
|
|
- Entity *e = entity_of_node(stmt_val);
|
|
|
- if (e == nullptr) {
|
|
|
- return {};
|
|
|
- }
|
|
|
-
|
|
|
- if ((e->flags & EntityFlag_Value) == 0) {
|
|
|
- if (value->kind == irValue_Instr) {
|
|
|
- if (value->Instr.kind == irInstr_Load) {
|
|
|
- irValue *ptr = value->Instr.Load.address;
|
|
|
- Type *vt = type_deref(ir_type(ptr));
|
|
|
- if (!are_types_identical(vt, e->type)) {
|
|
|
- GB_ASSERT(are_types_identical(base_type(vt), base_type(e->type)));
|
|
|
- ptr = ir_emit_conv(proc, ptr, alloc_type_pointer(e->type));
|
|
|
- }
|
|
|
-
|
|
|
- ir_module_add_value(proc->module, e, ptr);
|
|
|
- return ir_addr(ptr);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // by value
|
|
|
- irAddr addr = ir_addr(ir_add_local(proc, e, nullptr, false));
|
|
|
- Type *vt = ir_type(value);
|
|
|
- Type *base_et = base_type(e->type);
|
|
|
- Type *base_vt = base_type(vt);
|
|
|
- if (!are_types_identical(e->type, vt)) {
|
|
|
- if (are_types_identical(base_et, base_vt)) {
|
|
|
- value = ir_emit_conv(proc, value, e->type);
|
|
|
- } else {
|
|
|
- // gb_printf_err("%s\n", expr_to_string(stmt_val));
|
|
|
- // gb_printf_err("Entity: %s -> Value: %s\n", type_to_string(e->type), type_to_string(vt));
|
|
|
- // Token tok = ast_token(stmt_val);
|
|
|
- }
|
|
|
- }
|
|
|
- ir_addr_store(proc, addr, value);
|
|
|
- return addr;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_type_case_body(irProcedure *proc, Ast *label, Ast *clause, irBlock *body, irBlock *done) {
|
|
|
- ast_node(cc, CaseClause, clause);
|
|
|
-
|
|
|
- ir_push_target_list(proc, label, done, nullptr, nullptr);
|
|
|
- ir_open_scope(proc);
|
|
|
- ir_build_stmt_list(proc, cc->stmts);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, body);
|
|
|
- ir_pop_target_list(proc);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_build_stmt_internal(irProcedure *proc, Ast *node) {
|
|
|
- switch (node->kind) {
|
|
|
- case_ast_node(bs, EmptyStmt, node);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(us, UsingStmt, node);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ws, WhenStmt, node);
|
|
|
- ir_build_when_stmt(proc, ws);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(vd, ValueDecl, node);
|
|
|
- if (vd->is_mutable) {
|
|
|
- irModule *m = proc->module;
|
|
|
-
|
|
|
- bool is_static = false;
|
|
|
- if (vd->names.count > 0) {
|
|
|
- Entity *e = entity_of_node(vd->names[0]);
|
|
|
- if (e->flags & EntityFlag_Static) {
|
|
|
- // NOTE(bill): If one of the entities is static, they all are
|
|
|
- is_static = true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (is_static) {
|
|
|
- for_array(i, vd->names) {
|
|
|
- irValue *value = nullptr;
|
|
|
- if (vd->values.count > 0) {
|
|
|
- GB_ASSERT(vd->names.count == vd->values.count);
|
|
|
- Ast *ast_value = vd->values[i];
|
|
|
- GB_ASSERT(ast_value->tav.mode == Addressing_Constant ||
|
|
|
- ast_value->tav.mode == Addressing_Invalid);
|
|
|
-
|
|
|
- value = ir_add_module_constant(m, ast_value->tav.type, ast_value->tav.value);
|
|
|
- }
|
|
|
-
|
|
|
- Ast *ident = vd->names[i];
|
|
|
- GB_ASSERT(!is_blank_ident(ident));
|
|
|
- Entity *e = entity_of_node(ident);
|
|
|
- GB_ASSERT(e->flags & EntityFlag_Static);
|
|
|
- String name = e->token.string;
|
|
|
-
|
|
|
- String mangled_name = {};
|
|
|
- {
|
|
|
- gbString str = gb_string_make_length(permanent_allocator(), proc->name.text, proc->name.len);
|
|
|
- str = gb_string_appendc(str, "-");
|
|
|
- str = gb_string_append_fmt(str, ".%.*s-%llu", LIT(name), cast(long long)e->id);
|
|
|
- mangled_name.text = cast(u8 *)str;
|
|
|
- mangled_name.len = gb_string_length(str);
|
|
|
- }
|
|
|
-
|
|
|
- ir_add_entity_name(m, e, mangled_name);
|
|
|
-
|
|
|
- irValue *g = ir_value_global(e, value);
|
|
|
- g->Global.name = mangled_name;
|
|
|
- g->Global.is_private = true;
|
|
|
- if (e->Variable.thread_local_model != "") {
|
|
|
- g->Global.thread_local_model = e->Variable.thread_local_model;
|
|
|
- } else {
|
|
|
- g->Global.is_internal = true;
|
|
|
- }
|
|
|
- ir_module_add_value(proc->module, e, g);
|
|
|
- string_map_set(&proc->module->members, mangled_name, g);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena);
|
|
|
- defer (gb_temp_arena_memory_end(tmp));
|
|
|
-
|
|
|
- if (vd->values.count == 0) { // declared and zero-initialized
|
|
|
- for_array(i, vd->names) {
|
|
|
- Ast *name = vd->names[i];
|
|
|
- if (!is_blank_ident(name)) {
|
|
|
- ir_add_local_for_identifier(proc, name, true);
|
|
|
- }
|
|
|
- }
|
|
|
- } else { // Tuple(s)
|
|
|
- auto lvals = array_make<irAddr>(m->tmp_allocator, 0, vd->names.count);
|
|
|
- auto inits = array_make<irValue *>(m->tmp_allocator, 0, vd->names.count);
|
|
|
-
|
|
|
- for_array(i, vd->names) {
|
|
|
- Ast *name = vd->names[i];
|
|
|
- irAddr lval = ir_addr(nullptr);
|
|
|
- if (!is_blank_ident(name)) {
|
|
|
- // NOTE(bill, 2020-06-10): This must be zero initialize because of weird LLVM optimization behaviours
|
|
|
- ir_add_local_for_identifier(proc, name, true);
|
|
|
- lval = ir_build_addr(proc, name);
|
|
|
- }
|
|
|
- array_add(&lvals, lval);
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, vd->values) {
|
|
|
- irValue *init = ir_build_expr(proc, vd->values[i]);
|
|
|
- Type *t = ir_type(init);
|
|
|
- if (t->kind == Type_Tuple) {
|
|
|
- for_array(i, t->Tuple.variables) {
|
|
|
- Entity *e = t->Tuple.variables[i];
|
|
|
- irValue *v = ir_emit_struct_ev(proc, init, cast(i32)i);
|
|
|
- array_add(&inits, v);
|
|
|
- }
|
|
|
- } else {
|
|
|
- array_add(&inits, init);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- for_array(i, inits) {
|
|
|
- ir_addr_store(proc, lvals[i], inits[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(as, AssignStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("AssignStmt"));
|
|
|
-
|
|
|
- irModule *m = proc->module;
|
|
|
- gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena);
|
|
|
-
|
|
|
- switch (as->op.kind) {
|
|
|
- case Token_Eq: {
|
|
|
- auto lvals = array_make<irAddr>(m->tmp_allocator, 0, as->lhs.count);
|
|
|
-
|
|
|
- for_array(i, as->lhs) {
|
|
|
- Ast *lhs = as->lhs[i];
|
|
|
- irAddr lval = {};
|
|
|
- if (!is_blank_ident(lhs)) {
|
|
|
- lval = ir_build_addr(proc, lhs);
|
|
|
- }
|
|
|
- array_add(&lvals, lval);
|
|
|
- }
|
|
|
-
|
|
|
- if (as->lhs.count == as->rhs.count) {
|
|
|
- if (as->lhs.count == 1) {
|
|
|
- Ast *rhs = as->rhs[0];
|
|
|
- irValue *init = ir_build_expr(proc, rhs);
|
|
|
- ir_addr_store(proc, lvals[0], init);
|
|
|
- } else {
|
|
|
- auto inits = array_make<irValue *>(m->tmp_allocator, 0, lvals.count);
|
|
|
-
|
|
|
- for_array(i, as->rhs) {
|
|
|
- irValue *init = ir_build_expr(proc, as->rhs[i]);
|
|
|
- array_add(&inits, init);
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, inits) {
|
|
|
- auto lval = lvals[i];
|
|
|
- ir_addr_store(proc, lval, inits[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- auto inits = array_make<irValue *>(m->tmp_allocator, 0, lvals.count);
|
|
|
-
|
|
|
- for_array(i, as->rhs) {
|
|
|
- irValue *init = ir_build_expr(proc, as->rhs[i]);
|
|
|
- Type *t = ir_type(init);
|
|
|
- // TODO(bill): refactor for code reuse as this is repeated a bit
|
|
|
- if (t->kind == Type_Tuple) {
|
|
|
- for_array(i, t->Tuple.variables) {
|
|
|
- Entity *e = t->Tuple.variables[i];
|
|
|
- irValue *v = ir_emit_struct_ev(proc, init, cast(i32)i);
|
|
|
- array_add(&inits, v);
|
|
|
- }
|
|
|
- } else {
|
|
|
- array_add(&inits, init);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, inits) {
|
|
|
- ir_addr_store(proc, lvals[i], inits[i]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- default: {
|
|
|
- // NOTE(bill): Only 1 += 1 is allowed, no tuples
|
|
|
- // +=, -=, etc
|
|
|
- i32 op = cast(i32)as->op.kind;
|
|
|
- op += Token_Add - Token_AddEq; // Convert += to +
|
|
|
- if (op == Token_CmpAnd || op == Token_CmpOr) {
|
|
|
- Type *type = as->lhs[0]->tav.type;
|
|
|
- irValue *new_value = ir_emit_logical_binary_expr(proc, cast(TokenKind)op, as->lhs[0], as->rhs[0], type);
|
|
|
-
|
|
|
- irAddr lhs = ir_build_addr(proc, as->lhs[0]);
|
|
|
- ir_addr_store(proc, lhs, new_value);
|
|
|
- } else {
|
|
|
- irAddr lhs = ir_build_addr(proc, as->lhs[0]);
|
|
|
- irValue *value = ir_build_expr(proc, as->rhs[0]);
|
|
|
- ir_build_assign_op(proc, lhs, value, cast(TokenKind)op);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(es, ExprStmt, node);
|
|
|
- // NOTE(bill): No need to use return value
|
|
|
- ir_build_expr(proc, es->expr);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(bs, BlockStmt, node);
|
|
|
- if (bs->label != nullptr) {
|
|
|
- irBlock *done = ir_new_block(proc, node, "block.done");
|
|
|
- irTargetList *tl = ir_push_target_list(proc, bs->label, done, nullptr, nullptr);
|
|
|
- tl->is_block = true;
|
|
|
-
|
|
|
- ir_open_scope(proc);
|
|
|
- ir_build_stmt_list(proc, bs->stmts);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
-
|
|
|
- } else {
|
|
|
- ir_open_scope(proc);
|
|
|
- ir_build_stmt_list(proc, bs->stmts);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
- }
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ds, DeferStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("DeferStmt"));
|
|
|
- isize scope_index = proc->scope_index;
|
|
|
- // TODO(bill): What was the original rationale behind this line?
|
|
|
- // if (ds->stmt->kind == Ast_BlockStmt) scope_index--;
|
|
|
- ir_add_defer_node(proc, scope_index, ds->stmt);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(rs, ReturnStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("ReturnStmt"));
|
|
|
- irValue *v = nullptr;
|
|
|
- TypeTuple *tuple = &proc->type->Proc.results->Tuple;
|
|
|
- isize return_count = proc->type->Proc.result_count;
|
|
|
- isize res_count = rs->results.count;
|
|
|
-
|
|
|
- if (return_count == 0) {
|
|
|
- // No return values
|
|
|
- } else if (return_count == 1) {
|
|
|
- Entity *e = tuple->variables[0];
|
|
|
- if (res_count == 0) {
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- GB_ASSERT(found);
|
|
|
- v = ir_emit_load(proc, *found);
|
|
|
- } else {
|
|
|
- v = ir_build_expr(proc, rs->results[0]);
|
|
|
- v = ir_emit_conv(proc, v, e->type);
|
|
|
- }
|
|
|
- if (proc->type->Proc.has_named_results) {
|
|
|
- // NOTE(bill): store the named values before returning
|
|
|
- if (e->token.string != "") {
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- GB_ASSERT(found != nullptr);
|
|
|
- ir_emit_store(proc, *found, v);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);
|
|
|
- defer (gb_temp_arena_memory_end(tmp));
|
|
|
-
|
|
|
- auto results = array_make<irValue *>(proc->module->tmp_allocator, 0, return_count);
|
|
|
-
|
|
|
- if (res_count != 0) {
|
|
|
- for (isize res_index = 0; res_index < res_count; res_index++) {
|
|
|
- irValue *res = ir_build_expr(proc, rs->results[res_index]);
|
|
|
- Type *t = ir_type(res);
|
|
|
- if (t->kind == Type_Tuple) {
|
|
|
- for_array(i, t->Tuple.variables) {
|
|
|
- Entity *e = t->Tuple.variables[i];
|
|
|
- irValue *v = ir_emit_struct_ev(proc, res, cast(i32)i);
|
|
|
- array_add(&results, v);
|
|
|
- }
|
|
|
- } else {
|
|
|
- array_add(&results, res);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (isize res_index = 0; res_index < return_count; res_index++) {
|
|
|
- Entity *e = tuple->variables[res_index];
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- GB_ASSERT(found);
|
|
|
- irValue *res = ir_emit_load(proc, *found);
|
|
|
- array_add(&results, res);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(results.count == return_count);
|
|
|
-
|
|
|
- if (proc->type->Proc.has_named_results) {
|
|
|
- // NOTE(bill): store the named values before returning
|
|
|
- for_array(i, tuple->variables) {
|
|
|
- Entity *e = tuple->variables[i];
|
|
|
- if (e->kind != Entity_Variable) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (e->token.string == "") {
|
|
|
- continue;
|
|
|
- }
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(e));
|
|
|
- GB_ASSERT(found != nullptr);
|
|
|
- ir_emit_store(proc, *found, ir_emit_conv(proc, results[i], e->type));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- Type *ret_type = proc->type->Proc.results;
|
|
|
- // NOTE(bill): Doesn't need to be zero because it will be initialized in the loops
|
|
|
- v = ir_add_local_generated(proc, ret_type, false);
|
|
|
- for_array(i, results) {
|
|
|
- Entity *e = tuple->variables[i];
|
|
|
- irValue *res = ir_emit_conv(proc, results[i], e->type);
|
|
|
- irValue *field = ir_emit_struct_ep(proc, v, cast(i32)i);
|
|
|
- ir_emit_store(proc, field, res);
|
|
|
- }
|
|
|
-
|
|
|
- v = ir_emit_load(proc, v);
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit_return(proc, v);
|
|
|
-
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(is, IfStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("IfStmt"));
|
|
|
- ir_open_scope(proc); // Scope #1
|
|
|
-
|
|
|
- if (is->init != nullptr) {
|
|
|
- // TODO(bill): Should this have a separate block to begin with?
|
|
|
- #if 1
|
|
|
- irBlock *init = ir_new_block(proc, node, "if.init");
|
|
|
- ir_emit_jump(proc, init);
|
|
|
- ir_start_block(proc, init);
|
|
|
- #endif
|
|
|
- ir_build_stmt(proc, is->init);
|
|
|
- }
|
|
|
- irBlock *then = ir_new_block(proc, node, "if.then");
|
|
|
- irBlock *done = ir_new_block(proc, node, "if.done");
|
|
|
- irBlock *else_ = done;
|
|
|
- if (is->else_stmt != nullptr) {
|
|
|
- else_ = ir_new_block(proc, is->else_stmt, "if.else");
|
|
|
- }
|
|
|
-
|
|
|
- ir_build_cond(proc, is->cond, then, else_);
|
|
|
- ir_start_block(proc, then);
|
|
|
-
|
|
|
- if (is->label != nullptr) {
|
|
|
- irTargetList *tl = ir_push_target_list(proc, is->label, done, nullptr, nullptr);
|
|
|
- tl->is_block = true;
|
|
|
- }
|
|
|
-
|
|
|
- // ir_open_scope(proc);
|
|
|
- ir_build_stmt(proc, is->body);
|
|
|
- // ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
-
|
|
|
- if (is->else_stmt != nullptr) {
|
|
|
- ir_start_block(proc, else_);
|
|
|
-
|
|
|
- ir_open_scope(proc);
|
|
|
- ir_build_stmt(proc, is->else_stmt);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- ir_start_block(proc, done);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(fs, ForStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("ForStmt"));
|
|
|
- ir_open_scope(proc); // Open Scope here
|
|
|
-
|
|
|
- if (fs->init != nullptr) {
|
|
|
- #if 1
|
|
|
- irBlock *init = ir_new_block(proc, node, "for.init");
|
|
|
- ir_emit_jump(proc, init);
|
|
|
- ir_start_block(proc, init);
|
|
|
- #endif
|
|
|
- ir_build_stmt(proc, fs->init);
|
|
|
- }
|
|
|
- irBlock *body = ir_new_block(proc, node, "for.body");
|
|
|
- irBlock *done = ir_new_block(proc, node, "for.done"); // NOTE(bill): Append later
|
|
|
- irBlock *loop = body;
|
|
|
- if (fs->cond != nullptr) {
|
|
|
- loop = ir_new_block(proc, node, "for.loop");
|
|
|
- }
|
|
|
- irBlock *post = loop;
|
|
|
- if (fs->post != nullptr) {
|
|
|
- post = ir_new_block(proc, node, "for.post");
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, loop);
|
|
|
-
|
|
|
- if (loop != body) {
|
|
|
- ir_build_cond(proc, fs->cond, body, done);
|
|
|
- ir_start_block(proc, body);
|
|
|
- }
|
|
|
-
|
|
|
- ir_push_target_list(proc, fs->label, done, post, nullptr);
|
|
|
-
|
|
|
- ir_build_stmt(proc, fs->body);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_pop_target_list(proc);
|
|
|
-
|
|
|
- ir_emit_jump(proc, post);
|
|
|
-
|
|
|
- if (fs->post != nullptr) {
|
|
|
- ir_start_block(proc, post);
|
|
|
- ir_build_stmt(proc, fs->post);
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- }
|
|
|
-
|
|
|
- ir_start_block(proc, done);
|
|
|
- case_end;
|
|
|
-
|
|
|
-
|
|
|
- case_ast_node(rs, RangeStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("RangeStmt"));
|
|
|
- ir_open_scope(proc); // Open scope here
|
|
|
-
|
|
|
- Type *val0_type = nullptr;
|
|
|
- Type *val1_type = nullptr;
|
|
|
- if (rs->vals.count > 0 && rs->vals[0] != nullptr && !is_blank_ident(rs->vals[0])) {
|
|
|
- val0_type = type_of_expr(rs->vals[0]);
|
|
|
- }
|
|
|
- if (rs->vals.count > 1 && rs->vals[1] != nullptr && !is_blank_ident(rs->vals[1])) {
|
|
|
- val1_type = type_of_expr(rs->vals[1]);
|
|
|
- }
|
|
|
-
|
|
|
- if (val0_type != nullptr) {
|
|
|
- ir_add_local_for_identifier(proc, rs->vals[0], true);
|
|
|
- }
|
|
|
- if (val1_type != nullptr) {
|
|
|
- ir_add_local_for_identifier(proc, rs->vals[1], true);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *val = nullptr;
|
|
|
- irValue *key = nullptr;
|
|
|
- irBlock *loop = nullptr;
|
|
|
- irBlock *done = nullptr;
|
|
|
- Ast *expr = unparen_expr(rs->expr);
|
|
|
- bool is_map = false;
|
|
|
-
|
|
|
- TypeAndValue tav = type_and_value_of_expr(expr);
|
|
|
-
|
|
|
- if (is_ast_range(expr)) {
|
|
|
- ir_build_range_interval(proc, &expr->BinaryExpr, val0_type, &val, &key, &loop, &done);
|
|
|
- } else if (tav.mode == Addressing_Type) {
|
|
|
- ir_build_range_enum(proc, type_deref(tav.type), val0_type, &val, &key, &loop, &done);
|
|
|
- } else {
|
|
|
- Type *expr_type = type_of_expr(expr);
|
|
|
- Type *et = base_type(type_deref(expr_type));
|
|
|
- switch (et->kind) {
|
|
|
- case Type_Map: {
|
|
|
- is_map = true;
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- irAddr addr = ir_build_addr(proc, expr);
|
|
|
- bool allow_reference = true;
|
|
|
- irValue *map = ir_addr_get_ptr(proc, addr, allow_reference);
|
|
|
- if (is_type_pointer(ir_addr_type(addr))) {
|
|
|
- map = ir_addr_load(proc, addr);
|
|
|
- }
|
|
|
- irValue *entries_ptr = ir_map_entries_ptr(proc, map);
|
|
|
- irValue *count_ptr = ir_emit_struct_ep(proc, entries_ptr, 1);
|
|
|
- ir_build_range_indexed(proc, map, val1_type, count_ptr, &val, &key, &loop, &done);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Array: {
|
|
|
- irValue *count_ptr = nullptr;
|
|
|
- irValue *array = ir_build_addr_ptr(proc, expr);
|
|
|
- if (is_type_pointer(type_deref(ir_type(array)))) {
|
|
|
- array = ir_emit_load(proc, array);
|
|
|
- }
|
|
|
- count_ptr = ir_add_local_generated(proc, t_int, false);
|
|
|
- ir_emit_store(proc, count_ptr, ir_const_int(et->Array.count));
|
|
|
- ir_build_range_indexed(proc, array, val0_type, count_ptr, &val, &key, &loop, &done);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_EnumeratedArray: {
|
|
|
- irValue *count_ptr = nullptr;
|
|
|
- irValue *array = ir_build_addr_ptr(proc, expr);
|
|
|
- if (is_type_pointer(type_deref(ir_type(array)))) {
|
|
|
- array = ir_emit_load(proc, array);
|
|
|
- }
|
|
|
- count_ptr = ir_add_local_generated(proc, t_int, false);
|
|
|
- ir_emit_store(proc, count_ptr, ir_const_int(et->EnumeratedArray.count));
|
|
|
- ir_build_range_indexed(proc, array, val0_type, count_ptr, &val, &key, &loop, &done);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_DynamicArray: {
|
|
|
- irValue *count_ptr = nullptr;
|
|
|
- irValue *array = ir_build_addr_ptr(proc, expr);
|
|
|
- if (is_type_pointer(type_deref(ir_type(array)))) {
|
|
|
- array = ir_emit_load(proc, array);
|
|
|
- }
|
|
|
- count_ptr = ir_emit_struct_ep(proc, array, 1);
|
|
|
- ir_build_range_indexed(proc, array, val0_type, count_ptr, &val, &key, &loop, &done);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Slice: {
|
|
|
- irValue *count_ptr = nullptr;
|
|
|
- irValue *slice = ir_build_expr(proc, expr);
|
|
|
- if (is_type_pointer(ir_type(slice))) {
|
|
|
- count_ptr = ir_emit_struct_ep(proc, slice, 1);
|
|
|
- slice = ir_emit_load(proc, slice);
|
|
|
- } else {
|
|
|
- count_ptr = ir_add_local_generated(proc, t_int, false);
|
|
|
- ir_emit_store(proc, count_ptr, ir_slice_len(proc, slice));
|
|
|
- }
|
|
|
- ir_build_range_indexed(proc, slice, val0_type, count_ptr, &val, &key, &loop, &done);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Basic: {
|
|
|
- irValue *string = ir_build_expr(proc, expr);
|
|
|
- if (is_type_pointer(ir_type(string))) {
|
|
|
- string = ir_emit_load(proc, string);
|
|
|
- }
|
|
|
- if (is_type_untyped(expr_type)) {
|
|
|
- irValue *s = ir_add_local_generated(proc, default_type(ir_type(string)), false);
|
|
|
- ir_emit_store(proc, s, string);
|
|
|
- string = ir_emit_load(proc, s);
|
|
|
- }
|
|
|
- Type *t = base_type(ir_type(string));
|
|
|
- GB_ASSERT(!is_type_cstring(t));
|
|
|
- ir_build_range_string(proc, string, val0_type, &val, &key, &loop, &done);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Tuple:
|
|
|
- ir_build_range_tuple(proc, expr, val0_type, val1_type, &val, &key, &loop, &done);
|
|
|
- break;
|
|
|
- default:
|
|
|
- GB_PANIC("Cannot range over %s", type_to_string(expr_type));
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- if (is_map) {
|
|
|
- if (val0_type) ir_store_range_stmt_val(proc, rs->vals[0], key);
|
|
|
- if (val1_type) ir_store_range_stmt_val(proc, rs->vals[1], val);
|
|
|
- } else {
|
|
|
- if (val0_type) ir_store_range_stmt_val(proc, rs->vals[0], val);
|
|
|
- if (val1_type) ir_store_range_stmt_val(proc, rs->vals[1], key);
|
|
|
- }
|
|
|
-
|
|
|
- ir_push_target_list(proc, rs->label, done, loop, nullptr);
|
|
|
-
|
|
|
- ir_build_stmt(proc, rs->body);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
-
|
|
|
- ir_pop_target_list(proc);
|
|
|
- ir_emit_jump(proc, loop);
|
|
|
- ir_start_block(proc, done);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(rs, UnrollRangeStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("UnrollRangeStmt"));
|
|
|
- ir_open_scope(proc); // Open scope here
|
|
|
-
|
|
|
- irBlock *done = ir_new_block(proc, node, "inline.for.done");
|
|
|
-
|
|
|
- Type *val0_type = nullptr;
|
|
|
- Type *val1_type = nullptr;
|
|
|
- if (rs->val0 != nullptr && !is_blank_ident(rs->val0)) {
|
|
|
- val0_type = type_of_expr(rs->val0);
|
|
|
- }
|
|
|
- if (rs->val1 != nullptr && !is_blank_ident(rs->val1)) {
|
|
|
- val1_type = type_of_expr(rs->val1);
|
|
|
- }
|
|
|
-
|
|
|
- if (val0_type != nullptr) {
|
|
|
- ir_add_local_for_identifier(proc, rs->val0, true);
|
|
|
- }
|
|
|
- if (val1_type != nullptr) {
|
|
|
- ir_add_local_for_identifier(proc, rs->val1, true);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *val = nullptr;
|
|
|
- irValue *key = nullptr;
|
|
|
- Ast *expr = unparen_expr(rs->expr);
|
|
|
-
|
|
|
- TypeAndValue tav = type_and_value_of_expr(expr);
|
|
|
-
|
|
|
- if (is_ast_range(expr)) {
|
|
|
-
|
|
|
- irAddr val0_addr = {};
|
|
|
- irAddr val1_addr = {};
|
|
|
- if (val0_type) val0_addr = ir_build_addr(proc, rs->val0);
|
|
|
- if (val1_type) val1_addr = ir_build_addr(proc, rs->val1);
|
|
|
-
|
|
|
- TokenKind op = expr->BinaryExpr.op.kind;
|
|
|
- Ast *start_expr = expr->BinaryExpr.left;
|
|
|
- Ast *end_expr = expr->BinaryExpr.right;
|
|
|
- GB_ASSERT(start_expr->tav.mode == Addressing_Constant);
|
|
|
- GB_ASSERT(end_expr->tav.mode == Addressing_Constant);
|
|
|
-
|
|
|
- ExactValue start = start_expr->tav.value;
|
|
|
- ExactValue end = end_expr->tav.value;
|
|
|
- if (op == Token_Ellipsis) { // .. [start, end]
|
|
|
- ExactValue index = exact_value_i64(0);
|
|
|
- for (ExactValue val = start;
|
|
|
- compare_exact_values(Token_LtEq, val, end);
|
|
|
- val = exact_value_increment_one(val), index = exact_value_increment_one(index)) {
|
|
|
-
|
|
|
- irBlock *body = ir_new_block(proc, node, "inline.for.body");
|
|
|
- ir_emit_jump(proc, body);
|
|
|
-
|
|
|
- if (val0_type) ir_addr_store(proc, val0_addr, ir_value_constant(val0_type, val));
|
|
|
- if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, index));
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- ir_build_stmt(proc, rs->body);
|
|
|
- }
|
|
|
- } else if (op == Token_RangeHalf) { // ..< [start, end)
|
|
|
- ExactValue index = exact_value_i64(0);
|
|
|
- for (ExactValue val = start;
|
|
|
- compare_exact_values(Token_Lt, val, end);
|
|
|
- val = exact_value_increment_one(val), index = exact_value_increment_one(index)) {
|
|
|
-
|
|
|
- irBlock *body = ir_new_block(proc, node, "inline.for.body");
|
|
|
- ir_emit_jump(proc, body);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- if (val0_type) ir_addr_store(proc, val0_addr, ir_value_constant(val0_type, val));
|
|
|
- if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, index));
|
|
|
-
|
|
|
-
|
|
|
- ir_build_stmt(proc, rs->body);
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (tav.mode == Addressing_Type) {
|
|
|
- GB_ASSERT(is_type_enum(type_deref(tav.type)));
|
|
|
- Type *et = type_deref(tav.type);
|
|
|
- Type *bet = base_type(et);
|
|
|
-
|
|
|
- irAddr val0_addr = {};
|
|
|
- irAddr val1_addr = {};
|
|
|
- if (val0_type) val0_addr = ir_build_addr(proc, rs->val0);
|
|
|
- if (val1_type) val1_addr = ir_build_addr(proc, rs->val1);
|
|
|
-
|
|
|
- for_array(i, bet->Enum.fields) {
|
|
|
- irBlock *body = ir_new_block(proc, node, "inline.for.body");
|
|
|
- ir_emit_jump(proc, body);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- Entity *field = bet->Enum.fields[i];
|
|
|
- GB_ASSERT(field->kind == Entity_Constant);
|
|
|
- if (val0_type) ir_addr_store(proc, val0_addr, ir_value_constant(val0_type, field->Constant.value));
|
|
|
- if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, exact_value_i64(i)));
|
|
|
-
|
|
|
- ir_build_stmt(proc, rs->body);
|
|
|
- }
|
|
|
- } else {
|
|
|
- irAddr val0_addr = {};
|
|
|
- irAddr val1_addr = {};
|
|
|
- if (val0_type) val0_addr = ir_build_addr(proc, rs->val0);
|
|
|
- if (val1_type) val1_addr = ir_build_addr(proc, rs->val1);
|
|
|
-
|
|
|
- GB_ASSERT(expr->tav.mode == Addressing_Constant);
|
|
|
-
|
|
|
- Type *t = base_type(expr->tav.type);
|
|
|
-
|
|
|
-
|
|
|
- switch (t->kind) {
|
|
|
- case Type_Basic:
|
|
|
- GB_ASSERT(is_type_string(t));
|
|
|
- {
|
|
|
- ExactValue value = expr->tav.value;
|
|
|
- GB_ASSERT(value.kind == ExactValue_String);
|
|
|
- String str = value.value_string;
|
|
|
- Rune codepoint = 0;
|
|
|
- isize offset = 0;
|
|
|
- do {
|
|
|
- irBlock *body = ir_new_block(proc, node, "inline.for.body");
|
|
|
- ir_emit_jump(proc, body);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- isize width = gb_utf8_decode(str.text+offset, str.len-offset, &codepoint);
|
|
|
- if (val0_type) ir_addr_store(proc, val0_addr, ir_value_constant(val0_type, exact_value_i64(codepoint)));
|
|
|
- if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, exact_value_i64(offset)));
|
|
|
- ir_build_stmt(proc, rs->body);
|
|
|
-
|
|
|
- offset += width;
|
|
|
- } while (offset < str.len);
|
|
|
- }
|
|
|
- break;
|
|
|
- case Type_Array:
|
|
|
- if (t->Array.count > 0) {
|
|
|
- irValue *val = ir_build_expr(proc, expr);
|
|
|
- irValue *val_addr = ir_address_from_load_or_generate_local(proc, val);
|
|
|
-
|
|
|
- for (i64 i = 0; i < t->Array.count; i++) {
|
|
|
- irBlock *body = ir_new_block(proc, node, "inline.for.body");
|
|
|
- ir_emit_jump(proc, body);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- if (val0_type) {
|
|
|
- // NOTE(bill): Due to weird legacy issues in LLVM, this needs to be an i32
|
|
|
- irValue *elem = ir_emit_array_epi(proc, val_addr, cast(i32)i);
|
|
|
- ir_addr_store(proc, val0_addr, ir_emit_load(proc, elem));
|
|
|
- }
|
|
|
- if (val1_type) ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, exact_value_i64(i)));
|
|
|
-
|
|
|
- ir_build_stmt(proc, rs->body);
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- break;
|
|
|
- case Type_EnumeratedArray:
|
|
|
- if (t->EnumeratedArray.count > 0) {
|
|
|
- irValue *val = ir_build_expr(proc, expr);
|
|
|
- irValue *val_addr = ir_address_from_load_or_generate_local(proc, val);
|
|
|
-
|
|
|
- for (i64 i = 0; i < t->EnumeratedArray.count; i++) {
|
|
|
- irBlock *body = ir_new_block(proc, node, "inline.for.body");
|
|
|
- ir_emit_jump(proc, body);
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- if (val0_type) {
|
|
|
- // NOTE(bill): Due to weird legacy issues in LLVM, this needs to be an i32
|
|
|
- irValue *elem = ir_emit_array_epi(proc, val_addr, cast(i32)i);
|
|
|
- ir_addr_store(proc, val0_addr, ir_emit_load(proc, elem));
|
|
|
- }
|
|
|
- if (val1_type) {
|
|
|
- ExactValue idx = exact_value_add(exact_value_i64(i), t->EnumeratedArray.min_value);
|
|
|
- ir_addr_store(proc, val1_addr, ir_value_constant(val1_type, idx));
|
|
|
- }
|
|
|
-
|
|
|
- ir_build_stmt(proc, rs->body);
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- break;
|
|
|
- default:
|
|
|
- GB_PANIC("Invalid '#unroll for' type");
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
-
|
|
|
- ir_close_scope(proc, irDeferExit_Default, nullptr);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(ss, SwitchStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("SwitchStmt"));
|
|
|
- if (ss->init != nullptr) {
|
|
|
- ir_build_stmt(proc, ss->init);
|
|
|
- }
|
|
|
- irValue *tag = v_true;
|
|
|
- if (ss->tag != nullptr) {
|
|
|
- tag = ir_build_expr(proc, ss->tag);
|
|
|
- }
|
|
|
- irBlock *done = ir_new_block(proc, node, "switch.done"); // NOTE(bill): Append later
|
|
|
-
|
|
|
- ast_node(body, BlockStmt, ss->body);
|
|
|
-
|
|
|
- Slice<Ast *> default_stmts = {};
|
|
|
- irBlock *default_fall = nullptr;
|
|
|
- irBlock *default_block = nullptr;
|
|
|
-
|
|
|
- irBlock *fall = nullptr;
|
|
|
- bool append_fall = false;
|
|
|
-
|
|
|
- isize case_count = body->stmts.count;
|
|
|
- for_array(i, body->stmts) {
|
|
|
- Ast *clause = body->stmts[i];
|
|
|
- irBlock *body = fall;
|
|
|
-
|
|
|
- ast_node(cc, CaseClause, clause);
|
|
|
-
|
|
|
- if (body == nullptr) {
|
|
|
- if (cc->list.count == 0) {
|
|
|
- body = ir_new_block(proc, clause, "switch.dflt.body");
|
|
|
- } else {
|
|
|
- body = ir_new_block(proc, clause, "switch.case.body");
|
|
|
- }
|
|
|
- }
|
|
|
- if (append_fall && body == fall) {
|
|
|
- append_fall = false;
|
|
|
- }
|
|
|
-
|
|
|
- fall = done;
|
|
|
- if (i+1 < case_count) {
|
|
|
- append_fall = true;
|
|
|
- fall = ir_new_block(proc, clause, "switch.fall.body");
|
|
|
- }
|
|
|
-
|
|
|
- if (cc->list.count == 0) {
|
|
|
- // default case
|
|
|
- default_stmts = cc->stmts;
|
|
|
- default_fall = fall;
|
|
|
- default_block = body;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- irBlock *next_cond = nullptr;
|
|
|
- for_array(j, cc->list) {
|
|
|
- Ast *expr = unparen_expr(cc->list[j]);
|
|
|
- next_cond = ir_new_block(proc, clause, "switch.case.next");
|
|
|
- irValue *cond = v_false;
|
|
|
- if (is_ast_range(expr)) {
|
|
|
- ast_node(ie, BinaryExpr, expr);
|
|
|
- TokenKind op = Token_Invalid;
|
|
|
- switch (ie->op.kind) {
|
|
|
- case Token_Ellipsis: op = Token_LtEq; break;
|
|
|
- case Token_RangeHalf: op = Token_Lt; break;
|
|
|
- default: GB_PANIC("Invalid interval operator"); break;
|
|
|
- }
|
|
|
- irValue *lhs = ir_build_expr(proc, ie->left);
|
|
|
- irValue *rhs = ir_build_expr(proc, ie->right);
|
|
|
- // TODO(bill): do short circuit here
|
|
|
- irValue *cond_lhs = ir_emit_comp(proc, Token_LtEq, lhs, tag);
|
|
|
- irValue *cond_rhs = ir_emit_comp(proc, op, tag, rhs);
|
|
|
- cond = ir_emit_arith(proc, Token_And, cond_lhs, cond_rhs, t_bool);
|
|
|
- } else {
|
|
|
- if (expr->tav.mode == Addressing_Type) {
|
|
|
- GB_ASSERT(is_type_typeid(ir_type(tag)));
|
|
|
- irValue *e = ir_typeid(proc->module, expr->tav.type);
|
|
|
- e = ir_emit_conv(proc, e, ir_type(tag));
|
|
|
- cond = ir_emit_comp(proc, Token_CmpEq, tag, e);
|
|
|
- } else {
|
|
|
- cond = ir_emit_comp(proc, Token_CmpEq, tag, ir_build_expr(proc, expr));
|
|
|
- }
|
|
|
- }
|
|
|
- ir_emit_if(proc, cond, body, next_cond);
|
|
|
- ir_start_block(proc, next_cond);
|
|
|
- }
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- ir_push_target_list(proc, ss->label, done, nullptr, fall);
|
|
|
- ir_open_scope(proc);
|
|
|
- ir_build_stmt_list(proc, cc->stmts);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, body);
|
|
|
- ir_pop_target_list(proc);
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- proc->curr_block = next_cond;
|
|
|
- // ir_start_block(proc, next_cond);
|
|
|
- }
|
|
|
-
|
|
|
- if (default_block != nullptr) {
|
|
|
- ir_emit_jump(proc, default_block);
|
|
|
- ir_start_block(proc, default_block);
|
|
|
-
|
|
|
- ir_push_target_list(proc, ss->label, done, nullptr, default_fall);
|
|
|
- ir_open_scope(proc);
|
|
|
- ir_build_stmt_list(proc, default_stmts);
|
|
|
- ir_close_scope(proc, irDeferExit_Default, default_block);
|
|
|
- ir_pop_target_list(proc);
|
|
|
- }
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
- case_end;
|
|
|
-
|
|
|
-
|
|
|
- case_ast_node(ss, TypeSwitchStmt, node);
|
|
|
- ir_emit_comment(proc, str_lit("TypeSwitchStmt"));
|
|
|
- gbAllocator allocator = ir_allocator();
|
|
|
-
|
|
|
- ast_node(as, AssignStmt, ss->tag);
|
|
|
- GB_ASSERT(as->lhs.count == 1);
|
|
|
- GB_ASSERT(as->rhs.count == 1);
|
|
|
-
|
|
|
- irValue *parent = ir_build_expr(proc, as->rhs[0]);
|
|
|
- Type *parent_type = ir_type(parent);
|
|
|
- bool is_parent_ptr = is_type_pointer(ir_type(parent));
|
|
|
-
|
|
|
- TypeSwitchKind switch_kind = check_valid_type_switch_type(ir_type(parent));
|
|
|
- GB_ASSERT(switch_kind != TypeSwitch_Invalid);
|
|
|
-
|
|
|
- irValue *parent_value = parent;
|
|
|
-
|
|
|
- irValue *parent_ptr = parent;
|
|
|
- if (!is_parent_ptr) {
|
|
|
- parent_ptr = ir_address_from_load_or_generate_local(proc, parent_ptr);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *tag_index = nullptr;
|
|
|
- irValue *union_data = nullptr;
|
|
|
- if (switch_kind == TypeSwitch_Union) {
|
|
|
- ir_emit_comment(proc, str_lit("get union's tag"));
|
|
|
- tag_index = ir_emit_load(proc, ir_emit_union_tag_ptr(proc, parent_ptr));
|
|
|
- union_data = ir_emit_conv(proc, parent_ptr, t_rawptr);
|
|
|
- }
|
|
|
-
|
|
|
- irBlock *start_block = ir_new_block(proc, node, "typeswitch.case.first");
|
|
|
- ir_emit_jump(proc, start_block);
|
|
|
- ir_start_block(proc, start_block);
|
|
|
-
|
|
|
- // NOTE(bill): Append this later
|
|
|
- irBlock *done = ir_new_block(proc, node, "typeswitch.done");
|
|
|
- Ast *default_ = nullptr;
|
|
|
-
|
|
|
- ast_node(body, BlockStmt, ss->body);
|
|
|
-
|
|
|
- gb_local_persist i32 weird_count = 0;
|
|
|
-
|
|
|
- for_array(i, body->stmts) {
|
|
|
- Ast *clause = body->stmts[i];
|
|
|
- ast_node(cc, CaseClause, clause);
|
|
|
- if (cc->list.count == 0) {
|
|
|
- default_ = clause;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- irBlock *body = ir_new_block(proc, clause, "typeswitch.body");
|
|
|
- irBlock *next = nullptr;
|
|
|
- Type *case_type = nullptr;
|
|
|
- for_array(type_index, cc->list) {
|
|
|
- next = ir_new_block(proc, nullptr, "typeswitch.next");
|
|
|
- case_type = type_of_expr(cc->list[type_index]);
|
|
|
- irValue *cond = nullptr;
|
|
|
- if (switch_kind == TypeSwitch_Union) {
|
|
|
- Type *ut = base_type(type_deref(parent_type));
|
|
|
- irValue *variant_tag = ir_const_union_tag(ut, case_type);
|
|
|
- cond = ir_emit_comp(proc, Token_CmpEq, tag_index, variant_tag);
|
|
|
- } else if (switch_kind == TypeSwitch_Any) {
|
|
|
- irValue *any_typeid = ir_emit_load(proc, ir_emit_struct_ep(proc, parent_ptr, 1));
|
|
|
- irValue *case_typeid = ir_typeid(proc->module, case_type);
|
|
|
- cond = ir_emit_comp(proc, Token_CmpEq, any_typeid, case_typeid);
|
|
|
- }
|
|
|
- GB_ASSERT(cond != nullptr);
|
|
|
-
|
|
|
- ir_emit_if(proc, cond, body, next);
|
|
|
- ir_start_block(proc, next);
|
|
|
- }
|
|
|
-
|
|
|
- Entity *case_entity = implicit_entity_of_node(clause);
|
|
|
-
|
|
|
- irValue *value = parent_value;
|
|
|
-
|
|
|
- ir_start_block(proc, body);
|
|
|
-
|
|
|
- // bool any_or_not_ptr = is_type_any(type_deref(parent_type)) || !is_parent_ptr;
|
|
|
- if (cc->list.count == 1) {
|
|
|
-
|
|
|
- irValue *data = nullptr;
|
|
|
- if (switch_kind == TypeSwitch_Union) {
|
|
|
- data = union_data;
|
|
|
- } else if (switch_kind == TypeSwitch_Any) {
|
|
|
- irValue *any_data = ir_emit_load(proc, ir_emit_struct_ep(proc, parent_ptr, 0));
|
|
|
- data = any_data;
|
|
|
- }
|
|
|
- Type *ct = case_entity->type;
|
|
|
- Type *ct_ptr = alloc_type_pointer(ct);
|
|
|
-
|
|
|
-
|
|
|
- value = ir_emit_conv(proc, data, ct_ptr);
|
|
|
-
|
|
|
- if (case_entity->flags & EntityFlag_Value) {
|
|
|
- // by value
|
|
|
- value = ir_emit_load(proc, value);
|
|
|
- } else {
|
|
|
- // by reference
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ir_store_type_case_implicit(proc, clause, value);
|
|
|
- ir_type_case_body(proc, ss->label, clause, body, done);
|
|
|
- ir_start_block(proc, next);
|
|
|
- }
|
|
|
-
|
|
|
- if (default_ != nullptr) {
|
|
|
- ir_store_type_case_implicit(proc, default_, parent_value);
|
|
|
- ir_type_case_body(proc, ss->label, default_, proc->curr_block, done);
|
|
|
- } else {
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- }
|
|
|
- ir_start_block(proc, done);
|
|
|
- case_end;
|
|
|
-
|
|
|
- case_ast_node(bs, BranchStmt, node);
|
|
|
- irBlock *block = nullptr;
|
|
|
-
|
|
|
- if (bs->label != nullptr) {
|
|
|
- irBranchBlocks bb = ir_lookup_branch_blocks(proc, bs->label);
|
|
|
- switch (bs->token.kind) {
|
|
|
- case Token_break: block = bb.break_; break;
|
|
|
- case Token_continue: block = bb.continue_; break;
|
|
|
- case Token_fallthrough:
|
|
|
- GB_PANIC("fallthrough cannot have a label");
|
|
|
- break;
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (irTargetList *t = proc->target_list; t != nullptr && block == nullptr; t = t->prev) {
|
|
|
- if (t->is_block) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- switch (bs->token.kind) {
|
|
|
- case Token_break: block = t->break_; break;
|
|
|
- case Token_continue: block = t->continue_; break;
|
|
|
- case Token_fallthrough: block = t->fallthrough_; break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (block != nullptr) {
|
|
|
- ir_emit_defer_stmts(proc, irDeferExit_Branch, block);
|
|
|
- }
|
|
|
- switch (bs->token.kind) {
|
|
|
- case Token_break: ir_emit_comment(proc, str_lit("break")); break;
|
|
|
- case Token_continue: ir_emit_comment(proc, str_lit("continue")); break;
|
|
|
- case Token_fallthrough: ir_emit_comment(proc, str_lit("fallthrough")); break;
|
|
|
- }
|
|
|
- ir_emit_jump(proc, block);
|
|
|
- ir_emit_unreachable(proc);
|
|
|
- case_end;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// @Procedure
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-void ir_number_proc_registers(irProcedure *proc) {
|
|
|
- // i32 reg_index = proc->parameter_count;
|
|
|
- i32 reg_index = 0;
|
|
|
- for_array(i, proc->blocks) {
|
|
|
- irBlock *b = proc->blocks[i];
|
|
|
- b->index = cast(i32)i;
|
|
|
- for_array(j, b->instrs) {
|
|
|
- irValue *value = b->instrs[j];
|
|
|
- GB_ASSERT_MSG(value->kind == irValue_Instr, "%.*s", LIT(proc->name));
|
|
|
- irInstr *instr = &value->Instr;
|
|
|
- if (ir_instr_type(instr) == nullptr) { // NOTE(bill): Ignore non-returning instructions
|
|
|
- value->index = -1;
|
|
|
- continue;
|
|
|
- }
|
|
|
- value->index = reg_index;
|
|
|
- value->index_set = true;
|
|
|
- reg_index++;
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_begin_procedure_body(irProcedure *proc) {
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- array_add(&proc->module->procs, proc);
|
|
|
-
|
|
|
- array_init(&proc->blocks, heap_allocator());
|
|
|
- array_init(&proc->defer_stmts, heap_allocator());
|
|
|
- array_init(&proc->children, heap_allocator());
|
|
|
- array_init(&proc->branch_blocks, heap_allocator());
|
|
|
- array_init(&proc->context_stack, heap_allocator());
|
|
|
-
|
|
|
- DeclInfo *decl = decl_info_of_entity(proc->entity);
|
|
|
- if (decl == nullptr && proc->proc_lit != nullptr) {
|
|
|
- GB_ASSERT(proc->proc_lit->kind == Ast_ProcLit);
|
|
|
- decl = proc->proc_lit->ProcLit.decl;
|
|
|
- }
|
|
|
- if (decl != nullptr) {
|
|
|
- for_array(i, decl->labels) {
|
|
|
- BlockLabel bl = decl->labels[i];
|
|
|
- irBranchBlocks bb = {bl.label, nullptr, nullptr};
|
|
|
- array_add(&proc->branch_blocks, bb);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(lachsinc): This is somewhat of a fallback/catch-all; We use the procedure's identifer as a debug location..
|
|
|
- // Additional debug locations should be pushed for the procedures statements/expressions themselves.
|
|
|
- if (proc->module->generate_debug_info && proc->entity && proc->entity->identifier) { // TODO(lachsinc): Better way to determine if these procs are main/runtime_startup.
|
|
|
- // TODO(lachsinc): Passing the file for the scope may not be correct for nested procedures? This should probably be
|
|
|
- // handled all inside push_debug_location, with just the Ast * we can pull out everything we need to construct scope/file debug info etc.
|
|
|
- ir_add_debug_info_proc(proc);
|
|
|
- ir_push_debug_location(proc->module, proc->entity->identifier, proc->debug_scope);
|
|
|
- GB_ASSERT_NOT_NULL(proc->debug_scope);
|
|
|
- } else {
|
|
|
- ir_push_debug_location(proc->module, nullptr, nullptr);
|
|
|
- }
|
|
|
-
|
|
|
- proc->decl_block = ir_new_block(proc, proc->type_expr, "decls");
|
|
|
- ir_start_block(proc, proc->decl_block);
|
|
|
- proc->entry_block = ir_new_block(proc, proc->type_expr, "entry");
|
|
|
- ir_start_block(proc, proc->entry_block);
|
|
|
-
|
|
|
- i32 parameter_index = 0;
|
|
|
-
|
|
|
- if (proc->type->Proc.return_by_pointer) {
|
|
|
- // NOTE(bill): this must be the first parameter stored
|
|
|
- Type *ptr_type = alloc_type_pointer(reduce_tuple_to_single_type(proc->type->Proc.results));
|
|
|
- Entity *e = alloc_entity_param(nullptr, make_token_ident(str_lit("agg.result")), ptr_type, false, false);
|
|
|
- e->flags |= EntityFlag_Sret | EntityFlag_NoAlias;
|
|
|
-
|
|
|
- irValue *param = ir_value_param(proc, e, ptr_type, -1);
|
|
|
- param->Param.kind = irParamPass_Pointer;
|
|
|
-
|
|
|
- ir_module_add_value(proc->module, e, param);
|
|
|
- proc->return_ptr = param;
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(proc->type != nullptr);
|
|
|
-
|
|
|
- if (proc->type->Proc.params != nullptr) {
|
|
|
- TypeTuple *params = &proc->type->Proc.params->Tuple;
|
|
|
- if (proc->type_expr != nullptr) {
|
|
|
- ast_node(pt, ProcType, proc->type_expr);
|
|
|
- isize param_index = 0;
|
|
|
- isize q_index = 0;
|
|
|
-
|
|
|
- for_array(i, params->variables) {
|
|
|
- ast_node(fl, FieldList, pt->params);
|
|
|
- GB_ASSERT(fl->list.count > 0);
|
|
|
- GB_ASSERT(fl->list[0]->kind == Ast_Field);
|
|
|
- if (q_index == fl->list[param_index]->Field.names.count) {
|
|
|
- q_index = 0;
|
|
|
- param_index++;
|
|
|
- }
|
|
|
- ast_node(field, Field, fl->list[param_index]);
|
|
|
- Ast *name = field->names[q_index++];
|
|
|
-
|
|
|
- Entity *e = params->variables[i];
|
|
|
- if (e->kind != Entity_Variable) {
|
|
|
- parameter_index += 1;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- Type *abi_type = proc->type->Proc.abi_compat_params[i];
|
|
|
- if (e->token.string != "") {
|
|
|
- ir_add_param(proc, e, name, abi_type, parameter_index);
|
|
|
- }
|
|
|
-
|
|
|
- if (is_type_tuple(abi_type)) {
|
|
|
- parameter_index += cast(i32)abi_type->Tuple.variables.count;
|
|
|
- } else {
|
|
|
- parameter_index += 1;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- auto abi_types = proc->type->Proc.abi_compat_params;
|
|
|
-
|
|
|
- for_array(i, params->variables) {
|
|
|
- Entity *e = params->variables[i];
|
|
|
- if (e->kind != Entity_Variable) {
|
|
|
- parameter_index += 1;
|
|
|
- continue;
|
|
|
- }
|
|
|
- Type *abi_type = e->type;
|
|
|
- if (abi_types.count > 0) {
|
|
|
- abi_type = abi_types[i];
|
|
|
- }
|
|
|
- if (e->token.string != "") {
|
|
|
- ir_add_param(proc, e, nullptr, abi_type, parameter_index);
|
|
|
- }
|
|
|
- if (is_type_tuple(abi_type)) {
|
|
|
- parameter_index += cast(i32)abi_type->Tuple.variables.count;
|
|
|
- } else {
|
|
|
- parameter_index += 1;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (proc->type->Proc.has_named_results) {
|
|
|
- GB_ASSERT(proc->type->Proc.result_count > 0);
|
|
|
- TypeTuple *results = &proc->type->Proc.results->Tuple;
|
|
|
-
|
|
|
- for_array(i, results->variables) {
|
|
|
- Entity *e = results->variables[i];
|
|
|
- GB_ASSERT(e->kind == Entity_Variable);
|
|
|
-
|
|
|
- if (e->token.string != "") {
|
|
|
- GB_ASSERT(!is_blank_ident(e->token));
|
|
|
-
|
|
|
- irAddr res = {};
|
|
|
- if (proc->type->Proc.return_by_pointer) {
|
|
|
- irValue *ptr = proc->return_ptr;
|
|
|
- if (results->variables.count != 1) {
|
|
|
- ptr = ir_emit_struct_ep(proc, ptr, cast(i32)i);
|
|
|
- }
|
|
|
-
|
|
|
- res = ir_addr(ptr);
|
|
|
- ir_module_add_value(proc->module, e, ptr);
|
|
|
- } else {
|
|
|
- res = ir_addr(ir_add_local(proc, e, e->identifier, true));
|
|
|
- }
|
|
|
-
|
|
|
- if (e->Variable.param_value.kind != ParameterValue_Invalid) {
|
|
|
- irValue *c = ir_handle_param_value(proc, e->type, e->Variable.param_value, e->token.pos);
|
|
|
- ir_addr_store(proc, res, c);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- if (proc->type->Proc.calling_convention == ProcCC_Odin) {
|
|
|
- Entity *e = alloc_entity_param(nullptr, make_token_ident(str_lit("__.context_ptr")), t_context_ptr, false, false);
|
|
|
- e->flags |= EntityFlag_NoAlias;
|
|
|
- irValue *param = ir_value_param(proc, e, e->type, -1);
|
|
|
- ir_module_add_value(proc->module, e, param);
|
|
|
- irContextData ctx = {param, proc->scope_index};
|
|
|
- array_add(&proc->context_stack, ctx);
|
|
|
- }
|
|
|
-
|
|
|
- proc->parameter_count = parameter_index;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-bool ir_remove_dead_instr(irProcedure *proc) {
|
|
|
- if (proc->ignore_dead_instr) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- isize elimination_count = 0;
|
|
|
-retry:
|
|
|
-#if 1
|
|
|
- for_array(i, proc->blocks) {
|
|
|
- irBlock *b = proc->blocks[i];
|
|
|
- b->index = cast(i32)i;
|
|
|
- for (isize j = 0; j < b->instrs.count; /**/) {
|
|
|
- irValue *value = b->instrs[j];
|
|
|
- GB_ASSERT_MSG(value->kind == irValue_Instr, "%.*s", LIT(proc->name));
|
|
|
- irInstr *instr = &value->Instr;
|
|
|
- if (value->uses == 0) {
|
|
|
- switch (instr->kind) {
|
|
|
- case irInstr_Load:
|
|
|
- instr->Load.address->uses -= 1;
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- case irInstr_Local:
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- case irInstr_AtomicLoad:
|
|
|
- instr->AtomicLoad.address->uses -= 1;
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- case irInstr_PtrOffset:
|
|
|
- instr->PtrOffset.address->uses -= 1;
|
|
|
- instr->PtrOffset.offset->uses -= 1;
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- case irInstr_ArrayElementPtr:
|
|
|
- instr->ArrayElementPtr.address->uses -= 1;
|
|
|
- instr->ArrayElementPtr.elem_index->uses -= 1;
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- case irInstr_StructElementPtr:
|
|
|
- instr->StructElementPtr.address->uses -= 1;
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- case irInstr_StructExtractValue:
|
|
|
- instr->StructExtractValue.address->uses -= 1;
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- case irInstr_UnionTagPtr:
|
|
|
- instr->UnionTagPtr.address->uses -= 1;
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- case irInstr_UnionTagValue:
|
|
|
- instr->UnionTagValue.address->uses -= 1;
|
|
|
- array_ordered_remove(&b->instrs, j);
|
|
|
- elimination_count += 1;
|
|
|
- continue;
|
|
|
- // case irInstr_Conv:
|
|
|
- // // instr->Conv.value->uses -= 1;
|
|
|
- // array_ordered_remove(&b->instrs, j);
|
|
|
- // elimination_count += 1;
|
|
|
- // continue;
|
|
|
- // case irInstr_UnaryOp:
|
|
|
- // // instr->UnaryOp.expr->uses -= 1;
|
|
|
- // array_ordered_remove(&b->instrs, j);
|
|
|
- // elimination_count += 1;
|
|
|
- // continue;
|
|
|
- // case irInstr_BinaryOp:
|
|
|
- // // instr->BinaryOp.left->uses -= 1;
|
|
|
- // // instr->BinaryOp.right->uses -= 1;
|
|
|
- // array_ordered_remove(&b->instrs, j);
|
|
|
- // elimination_count += 1;
|
|
|
- // continue;
|
|
|
- }
|
|
|
- }
|
|
|
- j += 1;
|
|
|
- }
|
|
|
- }
|
|
|
-#endif
|
|
|
- if (elimination_count > 0) {
|
|
|
- // gb_printf_err("Retry ir_remove_dead_instr, count: %td; %.*s\n", elimination_count, LIT(proc->name));
|
|
|
- elimination_count = 0;
|
|
|
- goto retry;
|
|
|
- }
|
|
|
- return elimination_count > 0;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_end_procedure_body(irProcedure *proc) {
|
|
|
- if (proc->type->Proc.result_count == 0) {
|
|
|
- ir_emit_return(proc, nullptr);
|
|
|
- }
|
|
|
-
|
|
|
- if (proc->curr_block->instrs.count == 0) {
|
|
|
- ir_emit_unreachable(proc);
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT(proc->scope_index == 0);
|
|
|
-
|
|
|
- proc->curr_block = proc->decl_block;
|
|
|
- ir_emit_jump(proc, proc->entry_block);
|
|
|
- proc->curr_block = nullptr;
|
|
|
-
|
|
|
- ir_remove_dead_instr(proc);
|
|
|
-
|
|
|
- ir_number_proc_registers(proc);
|
|
|
-
|
|
|
- ir_pop_debug_location(proc->module);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void ir_insert_code_before_proc(irProcedure* proc, irProcedure *parent) {
|
|
|
- // if (parent == nullptr) {
|
|
|
- // if (proc->name == "main") {
|
|
|
- // ir_emit_startup_runtime(proc);
|
|
|
- // }
|
|
|
- // }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_build_proc(irValue *value, irProcedure *parent) {
|
|
|
- irProcedure *proc = &value->Proc;
|
|
|
-
|
|
|
- set_procedure_abi_types(proc->type);
|
|
|
-
|
|
|
- proc->parent = parent;
|
|
|
-
|
|
|
- if (proc->body != nullptr && proc->body->kind != Ast_Invalid) {
|
|
|
- u64 prev_state_flags = proc->module->state_flags;
|
|
|
-
|
|
|
- if (proc->tags != 0) {
|
|
|
- u64 in = proc->tags;
|
|
|
- u64 out = proc->module->state_flags;
|
|
|
- if (in & ProcTag_bounds_check) {
|
|
|
- out |= StateFlag_bounds_check;
|
|
|
- out &= ~StateFlag_no_bounds_check;
|
|
|
- } else if (in & ProcTag_no_bounds_check) {
|
|
|
- out |= StateFlag_no_bounds_check;
|
|
|
- out &= ~StateFlag_bounds_check;
|
|
|
- }
|
|
|
- proc->module->state_flags = out;
|
|
|
- }
|
|
|
-
|
|
|
- ir_begin_procedure_body(proc);
|
|
|
- ir_insert_code_before_proc(proc, parent);
|
|
|
- ir_build_stmt(proc, proc->body);
|
|
|
- ir_end_procedure_body(proc);
|
|
|
-
|
|
|
- proc->module->state_flags = prev_state_flags;
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(lachsinc): For now we pop the debug location inside ir_end_procedure_body().
|
|
|
- // This may result in debug info being missing for below.
|
|
|
-
|
|
|
- if (proc->type->Proc.has_proc_default_values) {
|
|
|
- auto *p = &proc->type->Proc;
|
|
|
- if (p->params != nullptr) for_array(i, p->params->Tuple.variables) {
|
|
|
- Entity *f = p->params->Tuple.variables[i];
|
|
|
- if (f->kind == Entity_Variable) {
|
|
|
- ParameterValue pv = f->Variable.param_value;
|
|
|
- if (pv.kind == ParameterValue_Constant && pv.value.kind == ExactValue_Procedure) {
|
|
|
- Ast *expr = f->Variable.param_value.value.value_procedure;
|
|
|
- GB_ASSERT(expr != nullptr);
|
|
|
- if (expr->kind == Ast_ProcLit) {
|
|
|
- ir_gen_anonymous_proc_lit(proc->module, proc->name, expr, proc);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (p->results != nullptr) for_array(i, p->results->Tuple.variables) {
|
|
|
- Entity *f = p->results->Tuple.variables[i];
|
|
|
- if (f->kind == Entity_Variable) {
|
|
|
- ParameterValue pv = f->Variable.param_value;
|
|
|
- if (pv.kind == ParameterValue_Constant && pv.value.kind == ExactValue_Procedure) {
|
|
|
- Ast *expr = f->Variable.param_value.value.value_procedure;
|
|
|
- GB_ASSERT(expr != nullptr);
|
|
|
- if (expr->kind == Ast_ProcLit) {
|
|
|
- ir_gen_anonymous_proc_lit(proc->module, proc->name, expr, proc);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// @Module
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void ir_module_add_value(irModule *m, Entity *e, irValue *v) {
|
|
|
- map_set(&m->values, hash_entity(e), v);
|
|
|
- // TODO(lachsinc): This may not be the most sensible place to do this!
|
|
|
- // it may be more sensible to look for more specific locations that call ir_value_global and assign it a value? maybe?
|
|
|
- // ir_value_global itself doesn't have access to module though.
|
|
|
- if (v->kind == irValue_Global && v->Global.value != nullptr && e->state == EntityState_Resolved) {
|
|
|
- ir_add_debug_info_global(m, v);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_init_module(irModule *m, Checker *c) {
|
|
|
- // TODO(bill): Determine a decent size for the arena
|
|
|
- isize token_count = c->parser->total_token_count;
|
|
|
- isize arena_size = 4 * token_count * gb_size_of(irValue);
|
|
|
- gb_arena_init_from_allocator(&m->tmp_arena, heap_allocator(), arena_size);
|
|
|
- ir_allocator() = ir_allocator();
|
|
|
- m->tmp_allocator = gb_arena_allocator(&m->tmp_arena);
|
|
|
- m->info = &c->info;
|
|
|
-
|
|
|
- m->generate_debug_info = false;
|
|
|
- if (build_context.ODIN_DEBUG) {
|
|
|
- m->generate_debug_info = build_context.ODIN_OS == "windows" && build_context.word_size == 8;
|
|
|
- }
|
|
|
-
|
|
|
- map_init(&m->values, heap_allocator());
|
|
|
- string_map_init(&m->members, heap_allocator());
|
|
|
- map_init(&m->debug_info, heap_allocator());
|
|
|
- map_init(&m->entity_names, heap_allocator());
|
|
|
- map_init(&m->anonymous_proc_lits, heap_allocator());
|
|
|
- map_init(&m->equal_procs, heap_allocator());
|
|
|
- map_init(&m->hasher_procs, heap_allocator());
|
|
|
- array_init(&m->procs, heap_allocator());
|
|
|
- array_init(&m->procs_to_generate, heap_allocator());
|
|
|
- array_init(&m->foreign_library_paths, heap_allocator());
|
|
|
- string_map_init(&m->const_strings, heap_allocator());
|
|
|
- string_map_init(&m->const_string_byte_slices, heap_allocator());
|
|
|
- map_init(&m->constant_value_to_global, heap_allocator());
|
|
|
-
|
|
|
- // Default states
|
|
|
- m->state_flags = 0;
|
|
|
- m->state_flags |= StateFlag_bounds_check;
|
|
|
-
|
|
|
- {
|
|
|
- // Add type info data
|
|
|
- {
|
|
|
- isize max_type_info_count = ir_type_info_count(m->info);
|
|
|
-
|
|
|
- String name = str_lit(IR_TYPE_INFO_DATA_NAME);
|
|
|
- Entity *e = alloc_entity_variable(nullptr, make_token_ident(name), alloc_type_array(t_type_info, max_type_info_count));
|
|
|
- irValue *g = ir_value_global(e, nullptr);
|
|
|
- g->Global.is_private = true;
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
- ir_global_type_info_data = g;
|
|
|
- }
|
|
|
-
|
|
|
- // Type info member buffer
|
|
|
- {
|
|
|
- // NOTE(bill): Removes need for heap allocation by making it global memory
|
|
|
- isize count = 0;
|
|
|
-
|
|
|
- for_array(entry_index, m->info->type_info_types) {
|
|
|
- Type *t = m->info->type_info_types[entry_index];
|
|
|
-
|
|
|
- isize index = ir_type_info_index(m->info, t, false);
|
|
|
- if (index < 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- switch (t->kind) {
|
|
|
- case Type_Union:
|
|
|
- count += t->Union.variants.count;
|
|
|
- break;
|
|
|
- case Type_Struct:
|
|
|
- count += t->Struct.fields.count;
|
|
|
- break;
|
|
|
- case Type_Tuple:
|
|
|
- count += t->Tuple.variables.count;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (count > 0) {
|
|
|
- {
|
|
|
- String name = str_lit(IR_TYPE_INFO_TYPES_NAME);
|
|
|
- Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
|
|
|
- alloc_type_array(t_type_info_ptr, count));
|
|
|
- irValue *g = ir_value_global(e, nullptr);
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
- ir_global_type_info_member_types = g;
|
|
|
- }
|
|
|
- {
|
|
|
- String name = str_lit(IR_TYPE_INFO_NAMES_NAME);
|
|
|
- Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
|
|
|
- alloc_type_array(t_string, count));
|
|
|
- irValue *g = ir_value_global(e, nullptr);
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
- ir_global_type_info_member_names = g;
|
|
|
- }
|
|
|
- {
|
|
|
- String name = str_lit(IR_TYPE_INFO_OFFSETS_NAME);
|
|
|
- Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
|
|
|
- alloc_type_array(t_uintptr, count));
|
|
|
- irValue *g = ir_value_global(e, nullptr);
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
- ir_global_type_info_member_offsets = g;
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- String name = str_lit(IR_TYPE_INFO_USINGS_NAME);
|
|
|
- Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
|
|
|
- alloc_type_array(t_bool, count));
|
|
|
- irValue *g = ir_value_global(e, nullptr);
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
- ir_global_type_info_member_usings = g;
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- String name = str_lit(IR_TYPE_INFO_TAGS_NAME);
|
|
|
- Entity *e = alloc_entity_variable(nullptr, make_token_ident(name),
|
|
|
- alloc_type_array(t_string, count));
|
|
|
- irValue *g = ir_value_global(e, nullptr);
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
- ir_global_type_info_member_tags = g;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- irDebugInfo *di = ir_alloc_debug_info(irDebugInfo_CompileUnit);
|
|
|
-
|
|
|
- GB_ASSERT(m->info->files.entries.count > 0);
|
|
|
- AstFile *file = m->info->files.entries[0].value;
|
|
|
-
|
|
|
- di->CompileUnit.file = file; // Zeroth is the init file
|
|
|
- di->CompileUnit.producer = str_lit("odin");
|
|
|
-
|
|
|
- map_set(&m->debug_info, hash_pointer(m), di);
|
|
|
-
|
|
|
- m->debug_compile_unit = di;
|
|
|
-
|
|
|
- irDebugInfo *enums_di = ir_alloc_debug_info(irDebugInfo_DebugInfoArray);
|
|
|
- array_init(&enums_di->DebugInfoArray.elements, heap_allocator()); // TODO(lachsinc): ir_allocator() ??
|
|
|
- map_set(&m->debug_info, hash_pointer(enums_di), enums_di);
|
|
|
- m->debug_compile_unit->CompileUnit.enums = enums_di;
|
|
|
-
|
|
|
- irDebugInfo *globals_di = ir_alloc_debug_info(irDebugInfo_DebugInfoArray);
|
|
|
- array_init(&globals_di->DebugInfoArray.elements, heap_allocator()); // TODO(lachsinc): ir_allocator() ??
|
|
|
- map_set(&m->debug_info, hash_pointer(globals_di), globals_di);
|
|
|
- m->debug_compile_unit->CompileUnit.globals = globals_di;
|
|
|
-
|
|
|
- array_init(&m->debug_location_stack, heap_allocator()); // TODO(lachsinc): ir_allocator() ??
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- for_array(i, m->info->files.entries) {
|
|
|
- AstFile *file = m->info->files.entries[i].value;
|
|
|
- ir_add_debug_info_file(m, file);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_destroy_module(irModule *m) {
|
|
|
- map_destroy(&m->values);
|
|
|
- string_map_destroy(&m->members);
|
|
|
- map_destroy(&m->entity_names);
|
|
|
- map_destroy(&m->anonymous_proc_lits);
|
|
|
- map_destroy(&m->debug_info);
|
|
|
- string_map_destroy(&m->const_strings);
|
|
|
- string_map_destroy(&m->const_string_byte_slices);
|
|
|
- map_destroy(&m->constant_value_to_global);
|
|
|
- array_free(&m->procs);
|
|
|
- array_free(&m->procs_to_generate);
|
|
|
- array_free(&m->foreign_library_paths);
|
|
|
- array_free(&m->debug_location_stack);
|
|
|
- gb_arena_free(&m->tmp_arena);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// @Code Generation
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-
|
|
|
-bool ir_gen_init(irGen *s, Checker *c) {
|
|
|
- if (global_error_collector.count != 0) {
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- isize tc = c->parser->total_token_count;
|
|
|
- if (tc < 2) {
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- arena_init(&global_ir_arena, heap_allocator());
|
|
|
-
|
|
|
- ir_init_module(&s->module, c);
|
|
|
- // s->module.generate_debug_info = false;
|
|
|
-
|
|
|
- String init_fullpath = c->parser->init_fullpath;
|
|
|
-
|
|
|
- if (build_context.out_filepath.len == 0) {
|
|
|
- s->output_name = remove_directory_from_path(init_fullpath);
|
|
|
- s->output_name = remove_extension_from_path(s->output_name);
|
|
|
- s->output_name = string_trim_whitespace(s->output_name);
|
|
|
- if (s->output_name.len == 0) {
|
|
|
- s->output_name = c->info.init_scope->pkg->name;
|
|
|
- }
|
|
|
- s->output_base = s->output_name;
|
|
|
- } else {
|
|
|
- s->output_name = build_context.out_filepath;
|
|
|
- s->output_name = string_trim_whitespace(s->output_name);
|
|
|
- if (s->output_name.len == 0) {
|
|
|
- s->output_name = c->info.init_scope->pkg->name;
|
|
|
- }
|
|
|
- isize pos = string_extension_position(s->output_name);
|
|
|
- if (pos < 0) {
|
|
|
- s->output_base = s->output_name;
|
|
|
- } else {
|
|
|
- s->output_base = substring(s->output_name, 0, pos);
|
|
|
- }
|
|
|
- }
|
|
|
- gbAllocator ha = heap_allocator();
|
|
|
- s->output_base = path_to_full_path(ha, s->output_base);
|
|
|
-
|
|
|
- gbString output_file_path = gb_string_make_length(ha, s->output_base.text, s->output_base.len);
|
|
|
- output_file_path = gb_string_appendc(output_file_path, ".ll");
|
|
|
- defer (gb_string_free(output_file_path));
|
|
|
-
|
|
|
- gbFileError err = gb_file_create(&s->output_file, output_file_path);
|
|
|
- if (err != gbFileError_None) {
|
|
|
- gb_printf_err("Failed to create file %s\n", output_file_path);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-void ir_gen_destroy(irGen *s) {
|
|
|
- ir_destroy_module(&s->module);
|
|
|
- gb_file_close(&s->output_file);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-//
|
|
|
-// Type Info stuff
|
|
|
-//
|
|
|
-irValue *ir_get_type_info_ptr(irProcedure *proc, Type *type) {
|
|
|
- i32 index = cast(i32)ir_type_info_index(proc->module->info, type);
|
|
|
- // gb_printf_err("%d %s\n", index, type_to_string(type));
|
|
|
- irValue *ptr = ir_emit_array_epi(proc, ir_global_type_info_data, index);
|
|
|
- return ir_emit_bitcast(proc, ptr, t_type_info_ptr);
|
|
|
-}
|
|
|
-
|
|
|
-irValue *ir_type_info_member_types_offset(irProcedure *proc, isize count) {
|
|
|
- irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_types, ir_global_type_info_member_types_index);
|
|
|
- ir_global_type_info_member_types_index += cast(i32)count;
|
|
|
- return offset;
|
|
|
-}
|
|
|
-irValue *ir_type_info_member_names_offset(irProcedure *proc, isize count) {
|
|
|
- irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_names, ir_global_type_info_member_names_index);
|
|
|
- ir_global_type_info_member_names_index += cast(i32)count;
|
|
|
- return offset;
|
|
|
-}
|
|
|
-irValue *ir_type_info_member_offsets_offset(irProcedure *proc, isize count) {
|
|
|
- irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_offsets, ir_global_type_info_member_offsets_index);
|
|
|
- ir_global_type_info_member_offsets_index += cast(i32)count;
|
|
|
- return offset;
|
|
|
-}
|
|
|
-irValue *ir_type_info_member_usings_offset(irProcedure *proc, isize count) {
|
|
|
- irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_usings, ir_global_type_info_member_usings_index);
|
|
|
- ir_global_type_info_member_usings_index += cast(i32)count;
|
|
|
- return offset;
|
|
|
-}
|
|
|
-irValue *ir_type_info_member_tags_offset(irProcedure *proc, isize count) {
|
|
|
- irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_tags, ir_global_type_info_member_tags_index);
|
|
|
- ir_global_type_info_member_tags_index += cast(i32)count;
|
|
|
- return offset;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info data
|
|
|
- irModule *m = proc->module;
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
- CheckerInfo *info = m->info;
|
|
|
-
|
|
|
- if (true) {
|
|
|
- irValue *global_type_table = ir_find_global_variable(proc, str_lit("type_table"));
|
|
|
- Type *type = base_type(type_deref(ir_type(ir_global_type_info_data)));
|
|
|
- GB_ASSERT(is_type_array(type));
|
|
|
- irValue *len = ir_const_int(type->Array.count);
|
|
|
- ir_fill_slice(proc, global_type_table,
|
|
|
- ir_emit_array_epi(proc, ir_global_type_info_data, 0),
|
|
|
- len);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // Useful types
|
|
|
- Type *t_i64_slice_ptr = alloc_type_pointer(alloc_type_slice(t_i64));
|
|
|
- Type *t_string_slice_ptr = alloc_type_pointer(alloc_type_slice(t_string));
|
|
|
- Entity *type_info_flags_entity = find_core_entity(info->checker, str_lit("Type_Info_Flags"));
|
|
|
- Type *t_type_info_flags = type_info_flags_entity->type;
|
|
|
-
|
|
|
- i32 type_info_member_types_index = 0;
|
|
|
- i32 type_info_member_names_index = 0;
|
|
|
- i32 type_info_member_offsets_index = 0;
|
|
|
-
|
|
|
- for_array(type_info_type_index, info->type_info_types) {
|
|
|
- Type *t = info->type_info_types[type_info_type_index];
|
|
|
- t = default_type(t);
|
|
|
- if (t == t_invalid) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- isize entry_index = ir_type_info_index(info, t, false);
|
|
|
- if (entry_index <= 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- irValue *tag = nullptr;
|
|
|
- irValue *ti_ptr = ir_emit_array_epi(proc, ir_global_type_info_data, cast(i32)entry_index);
|
|
|
- irValue *variant_ptr = ir_emit_struct_ep(proc, ti_ptr, 4);
|
|
|
-
|
|
|
- irValue *type_info_flags = ir_value_constant(t_type_info_flags, exact_value_i64(type_info_flags_of_type(t)));
|
|
|
-
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 0), ir_const_int(type_size_of(t)));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 1), ir_const_int(type_align_of(t)));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 2), type_info_flags);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 3), ir_typeid(proc->module, t));
|
|
|
-
|
|
|
-
|
|
|
- switch (t->kind) {
|
|
|
- case Type_Named: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Named"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_named_ptr);
|
|
|
-
|
|
|
- // TODO(bill): Which is better? The mangled name or actual name?
|
|
|
- irValue *name = ir_const_string(proc->module, t->Named.type_name->token.string);
|
|
|
- irValue *gtip = ir_get_type_info_ptr(proc, t->Named.base);
|
|
|
-
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), name);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), gtip);
|
|
|
-
|
|
|
- if (t->Named.type_name->pkg) {
|
|
|
- irValue *name = ir_const_string(proc->module, t->Named.type_name->pkg->name);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), name);
|
|
|
- }
|
|
|
-
|
|
|
- String proc_name = {};
|
|
|
- if (t->Named.type_name->parent_proc_decl) {
|
|
|
- DeclInfo *decl = t->Named.type_name->parent_proc_decl;
|
|
|
- if (decl->entity && decl->entity->kind == Entity_Procedure) {
|
|
|
- proc_name = decl->entity->token.string;
|
|
|
- }
|
|
|
- }
|
|
|
- irValue *loc = ir_emit_source_code_location(proc, proc_name, t->Named.type_name->token.pos);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), loc);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Type_Basic:
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Basic"));
|
|
|
- switch (t->Basic.kind) {
|
|
|
- case Basic_bool:
|
|
|
- case Basic_b8:
|
|
|
- case Basic_b16:
|
|
|
- case Basic_b32:
|
|
|
- case Basic_b64:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_boolean_ptr);
|
|
|
- break;
|
|
|
-
|
|
|
- case Basic_i8:
|
|
|
- case Basic_u8:
|
|
|
- case Basic_i16:
|
|
|
- case Basic_u16:
|
|
|
- case Basic_i32:
|
|
|
- case Basic_u32:
|
|
|
- case Basic_i64:
|
|
|
- case Basic_u64:
|
|
|
- case Basic_i128:
|
|
|
- case Basic_u128:
|
|
|
-
|
|
|
- case Basic_i16le:
|
|
|
- case Basic_u16le:
|
|
|
- case Basic_i32le:
|
|
|
- case Basic_u32le:
|
|
|
- case Basic_i64le:
|
|
|
- case Basic_u64le:
|
|
|
- case Basic_i128le:
|
|
|
- case Basic_u128le:
|
|
|
- case Basic_i16be:
|
|
|
- case Basic_u16be:
|
|
|
- case Basic_i32be:
|
|
|
- case Basic_u32be:
|
|
|
- case Basic_i64be:
|
|
|
- case Basic_u64be:
|
|
|
- case Basic_i128be:
|
|
|
- case Basic_u128be:
|
|
|
-
|
|
|
- case Basic_int:
|
|
|
- case Basic_uint:
|
|
|
- case Basic_uintptr: {
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_integer_ptr);
|
|
|
- irValue *is_signed = ir_const_bool((t->Basic.flags & BasicFlag_Unsigned) == 0);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), is_signed);
|
|
|
- // NOTE(bill): This is matches the runtime layout
|
|
|
- u8 endianness_value = 0;
|
|
|
- if (t->Basic.flags & BasicFlag_EndianLittle) {
|
|
|
- endianness_value = 1;
|
|
|
- } else if (t->Basic.flags & BasicFlag_EndianBig) {
|
|
|
- endianness_value = 2;
|
|
|
- }
|
|
|
- irValue *endianness = ir_const_u8(endianness_value);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), endianness);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Basic_rune:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_rune_ptr);
|
|
|
- break;
|
|
|
-
|
|
|
- case Basic_f16:
|
|
|
- case Basic_f32:
|
|
|
- case Basic_f64:
|
|
|
- case Basic_f16le:
|
|
|
- case Basic_f32le:
|
|
|
- case Basic_f64le:
|
|
|
- case Basic_f16be:
|
|
|
- case Basic_f32be:
|
|
|
- case Basic_f64be:
|
|
|
- {
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_float_ptr);
|
|
|
-
|
|
|
- // NOTE(bill): This is matches the runtime layout
|
|
|
- u8 endianness_value = 0;
|
|
|
- if (t->Basic.flags & BasicFlag_EndianLittle) {
|
|
|
- endianness_value = 1;
|
|
|
- } else if (t->Basic.flags & BasicFlag_EndianBig) {
|
|
|
- endianness_value = 2;
|
|
|
- }
|
|
|
- irValue *endianness = ir_const_u8(endianness_value);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), endianness);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
-
|
|
|
- case Basic_complex32:
|
|
|
- case Basic_complex64:
|
|
|
- case Basic_complex128:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_complex_ptr);
|
|
|
- break;
|
|
|
-
|
|
|
- case Basic_quaternion64:
|
|
|
- case Basic_quaternion128:
|
|
|
- case Basic_quaternion256:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_quaternion_ptr);
|
|
|
- break;
|
|
|
-
|
|
|
- case Basic_rawptr:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_pointer_ptr);
|
|
|
- break;
|
|
|
-
|
|
|
- case Basic_string:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_string_ptr);
|
|
|
- break;
|
|
|
-
|
|
|
- case Basic_cstring:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_string_ptr);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), v_true); // is_cstring
|
|
|
- break;
|
|
|
-
|
|
|
- case Basic_any:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_any_ptr);
|
|
|
- break;
|
|
|
-
|
|
|
- case Basic_typeid:
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_typeid_ptr);
|
|
|
- break;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_Pointer: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Pointer"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_pointer_ptr);
|
|
|
- irValue *gep = ir_get_type_info_ptr(proc, t->Pointer.elem);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Array: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Array"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_array_ptr);
|
|
|
- irValue *gep = ir_get_type_info_ptr(proc, t->Array.elem);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
|
|
|
-
|
|
|
- i64 ez = type_size_of(t->Array.elem);
|
|
|
- irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
|
|
|
- ir_emit_store(proc, elem_size, ir_const_int(ez));
|
|
|
-
|
|
|
- irValue *count = ir_emit_struct_ep(proc, tag, 2);
|
|
|
- ir_emit_store(proc, count, ir_const_int(t->Array.count));
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_EnumeratedArray: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Enumerated_Array"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_enumerated_array_ptr);
|
|
|
- irValue *elem = ir_get_type_info_ptr(proc, t->EnumeratedArray.elem);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), elem);
|
|
|
-
|
|
|
- irValue *index = ir_get_type_info_ptr(proc, t->EnumeratedArray.index);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), index);
|
|
|
-
|
|
|
- i64 ez = type_size_of(t->EnumeratedArray.elem);
|
|
|
- irValue *elem_size = ir_emit_struct_ep(proc, tag, 2);
|
|
|
- ir_emit_store(proc, elem_size, ir_const_int(ez));
|
|
|
-
|
|
|
- irValue *count = ir_emit_struct_ep(proc, tag, 3);
|
|
|
- ir_emit_store(proc, count, ir_const_int(t->EnumeratedArray.count));
|
|
|
-
|
|
|
- irValue *min_value = ir_emit_struct_ep(proc, tag, 4);
|
|
|
- irValue *max_value = ir_emit_struct_ep(proc, tag, 5);
|
|
|
-
|
|
|
- irValue *min_v = ir_value_constant(t_i64, t->EnumeratedArray.min_value);
|
|
|
- irValue *max_v = ir_value_constant(t_i64, t->EnumeratedArray.max_value);
|
|
|
-
|
|
|
- ir_emit_store(proc, min_value, min_v);
|
|
|
- ir_emit_store(proc, max_value, max_v);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_DynamicArray: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Dynamic_Array"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_dynamic_array_ptr);
|
|
|
- irValue *gep = ir_get_type_info_ptr(proc, t->DynamicArray.elem);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
|
|
|
-
|
|
|
- i64 ez = type_size_of(t->DynamicArray.elem);
|
|
|
- irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
|
|
|
- ir_emit_store(proc, elem_size, ir_const_int(ez));
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Slice: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Slice"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_slice_ptr);
|
|
|
- irValue *gep = ir_get_type_info_ptr(proc, t->Slice.elem);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
|
|
|
-
|
|
|
- i64 ez = type_size_of(t->Slice.elem);
|
|
|
- irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
|
|
|
- ir_emit_store(proc, elem_size, ir_const_int(ez));
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Proc: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Proc"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_procedure_ptr);
|
|
|
-
|
|
|
- irValue *params = ir_emit_struct_ep(proc, tag, 0);
|
|
|
- irValue *results = ir_emit_struct_ep(proc, tag, 1);
|
|
|
- irValue *variadic = ir_emit_struct_ep(proc, tag, 2);
|
|
|
- irValue *convention = ir_emit_struct_ep(proc, tag, 3);
|
|
|
-
|
|
|
- if (t->Proc.params != nullptr) {
|
|
|
- ir_emit_store(proc, params, ir_get_type_info_ptr(proc, t->Proc.params));
|
|
|
- }
|
|
|
- if (t->Proc.results != nullptr) {
|
|
|
- ir_emit_store(proc, results, ir_get_type_info_ptr(proc, t->Proc.results));
|
|
|
- }
|
|
|
- ir_emit_store(proc, variadic, ir_const_bool(t->Proc.variadic));
|
|
|
- ir_emit_store(proc, convention, ir_const_u8(t->Proc.calling_convention));
|
|
|
-
|
|
|
- // TODO(bill): TypeInfo for procedures
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Tuple: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Tuple"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_tuple_ptr);
|
|
|
-
|
|
|
- irValue *memory_types = ir_type_info_member_types_offset(proc, t->Tuple.variables.count);
|
|
|
- irValue *memory_names = ir_type_info_member_names_offset(proc, t->Tuple.variables.count);
|
|
|
-
|
|
|
- for_array(i, t->Tuple.variables) {
|
|
|
- // NOTE(bill): offset is not used for tuples
|
|
|
- Entity *f = t->Tuple.variables[i];
|
|
|
-
|
|
|
- irValue *index = ir_const_int(i);
|
|
|
- irValue *type_info = ir_emit_ptr_offset(proc, memory_types, index);
|
|
|
-
|
|
|
- ir_emit_store(proc, type_info, ir_type_info(proc, f->type));
|
|
|
- if (f->token.string.len > 0) {
|
|
|
- irValue *name = ir_emit_ptr_offset(proc, memory_names, index);
|
|
|
- ir_emit_store(proc, name, ir_const_string(proc->module, f->token.string));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- irValue *count = ir_const_int(t->Tuple.variables.count);
|
|
|
- ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 0), memory_types, count);
|
|
|
- ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 1), memory_names, count);
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Enum:
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Enum"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_enum_ptr);
|
|
|
- {
|
|
|
- GB_ASSERT(t->Enum.base_type != nullptr);
|
|
|
- irValue *base = ir_type_info(proc, t->Enum.base_type);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), base);
|
|
|
-
|
|
|
- if (t->Enum.fields.count > 0) {
|
|
|
- auto fields = t->Enum.fields;
|
|
|
- irValue *name_array = ir_generate_array(m, t_string, fields.count,
|
|
|
- str_lit("$enum_names"), cast(i64)entry_index);
|
|
|
- irValue *value_array = ir_generate_array(m, t_type_info_enum_value, fields.count,
|
|
|
- str_lit("$enum_values"), cast(i64)entry_index);
|
|
|
-
|
|
|
- GB_ASSERT(is_type_integer(t->Enum.base_type));
|
|
|
-
|
|
|
- for_array(i, fields) {
|
|
|
- irValue *name_ep = ir_emit_array_epi(proc, name_array, cast(i32)i);
|
|
|
- irValue *value_ep = ir_emit_array_epi(proc, value_array, cast(i32)i);
|
|
|
-
|
|
|
- ExactValue value = fields[i]->Constant.value;
|
|
|
- irValue *v = ir_value_constant(t_i64, value);
|
|
|
-
|
|
|
- ir_emit_store(proc, value_ep, v);
|
|
|
- ir_emit_store(proc, name_ep, ir_const_string(proc->module, fields[i]->token.string));
|
|
|
- }
|
|
|
-
|
|
|
- irValue *v_count = ir_const_int(fields.count);
|
|
|
-
|
|
|
- irValue *names = ir_emit_struct_ep(proc, tag, 1);
|
|
|
- irValue *name_array_elem = ir_array_elem(proc, name_array);
|
|
|
- ir_fill_slice(proc, names, name_array_elem, v_count);
|
|
|
-
|
|
|
- irValue *values = ir_emit_struct_ep(proc, tag, 2);
|
|
|
- irValue *value_array_elem = ir_array_elem(proc, value_array);
|
|
|
- ir_fill_slice(proc, values, value_array_elem, v_count);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_Union: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Union"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_union_ptr);
|
|
|
-
|
|
|
- {
|
|
|
- irValue *variant_types = ir_emit_struct_ep(proc, tag, 0);
|
|
|
- irValue *tag_offset_ptr = ir_emit_struct_ep(proc, tag, 1);
|
|
|
- irValue *tag_type_ptr = ir_emit_struct_ep(proc, tag, 2);
|
|
|
- irValue *custom_align_ptr = ir_emit_struct_ep(proc, tag, 3);
|
|
|
- irValue *no_nil_ptr = ir_emit_struct_ep(proc, tag, 4);
|
|
|
- irValue *maybe_ptr = ir_emit_struct_ep(proc, tag, 5);
|
|
|
-
|
|
|
- isize variant_count = gb_max(0, t->Union.variants.count);
|
|
|
- irValue *memory_types = ir_type_info_member_types_offset(proc, variant_count);
|
|
|
-
|
|
|
- // NOTE(bill): Zeroth is nil so ignore it
|
|
|
- for (isize variant_index = 0; variant_index < variant_count; variant_index++) {
|
|
|
- Type *vt = t->Union.variants[variant_index];
|
|
|
- irValue *tip = ir_get_type_info_ptr(proc, vt);
|
|
|
-
|
|
|
- irValue *index = ir_const_int(variant_index);
|
|
|
- irValue *type_info = ir_emit_ptr_offset(proc, memory_types, index);
|
|
|
- ir_emit_store(proc, type_info, ir_type_info(proc, vt));
|
|
|
- }
|
|
|
-
|
|
|
- irValue *count = ir_const_int(variant_count);
|
|
|
- ir_fill_slice(proc, variant_types, memory_types, count);
|
|
|
-
|
|
|
- i64 tag_size = union_tag_size(t);
|
|
|
- i64 tag_offset = align_formula(t->Union.variant_block_size, tag_size);
|
|
|
-
|
|
|
- if (tag_size > 0) {
|
|
|
- ir_emit_store(proc, tag_offset_ptr, ir_const_uintptr(tag_offset));
|
|
|
- ir_emit_store(proc, tag_type_ptr, ir_type_info(proc, union_tag_type(t)));
|
|
|
- }
|
|
|
-
|
|
|
- irValue *is_custom_align = ir_const_bool(t->Union.custom_align != 0);
|
|
|
- ir_emit_store(proc, custom_align_ptr, is_custom_align);
|
|
|
-
|
|
|
- ir_emit_store(proc, no_nil_ptr, ir_const_bool(t->Union.no_nil));
|
|
|
- ir_emit_store(proc, maybe_ptr, ir_const_bool(t->Union.maybe));
|
|
|
- }
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Type_Struct: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Struct"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_struct_ptr);
|
|
|
-
|
|
|
- {
|
|
|
- irValue *is_packed = ir_const_bool(t->Struct.is_packed);
|
|
|
- irValue *is_raw_union = ir_const_bool(t->Struct.is_raw_union);
|
|
|
- irValue *is_custom_align = ir_const_bool(t->Struct.custom_align != 0);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 5), is_packed);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 6), is_raw_union);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 7), is_custom_align);
|
|
|
-
|
|
|
- if (is_type_comparable(t) && !is_type_simple_compare(t)) {
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 8), ir_get_equal_proc_for_type(proc->module, t));
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- if (t->Struct.soa_kind != StructSoa_None) {
|
|
|
- irValue *kind = ir_emit_struct_ep(proc, tag, 9);
|
|
|
- Type *kind_type = type_deref(ir_type(kind));
|
|
|
-
|
|
|
- irValue *soa_kind = ir_value_constant(kind_type, exact_value_i64(t->Struct.soa_kind));
|
|
|
- irValue *soa_type = ir_type_info(proc, t->Struct.soa_elem);
|
|
|
- irValue *soa_len = ir_const_int(t->Struct.soa_count);
|
|
|
-
|
|
|
-
|
|
|
- ir_emit_store(proc, kind, soa_kind);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 10), soa_type);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 11), soa_len);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- isize count = t->Struct.fields.count;
|
|
|
- if (count > 0) {
|
|
|
- irValue *memory_types = ir_type_info_member_types_offset (proc, count);
|
|
|
- irValue *memory_names = ir_type_info_member_names_offset (proc, count);
|
|
|
- irValue *memory_offsets = ir_type_info_member_offsets_offset(proc, count);
|
|
|
- irValue *memory_usings = ir_type_info_member_usings_offset (proc, count);
|
|
|
- irValue *memory_tags = ir_type_info_member_tags_offset (proc, count);
|
|
|
-
|
|
|
- type_set_offsets(t); // NOTE(bill): Just incase the offsets have not been set yet
|
|
|
- for (isize source_index = 0; source_index < count; source_index++) {
|
|
|
- // TODO(bill): Order fields in source order not layout order
|
|
|
- Entity *f = t->Struct.fields[source_index];
|
|
|
- irValue *tip = ir_get_type_info_ptr(proc, f->type);
|
|
|
- i64 foffset = 0;
|
|
|
- if (!t->Struct.is_raw_union) {
|
|
|
- foffset = t->Struct.offsets[f->Variable.field_index];
|
|
|
- }
|
|
|
- GB_ASSERT(f->kind == Entity_Variable && f->flags & EntityFlag_Field);
|
|
|
-
|
|
|
- irValue *index = ir_const_int(source_index);
|
|
|
- irValue *type_info = ir_emit_ptr_offset(proc, memory_types, index);
|
|
|
- irValue *offset = ir_emit_ptr_offset(proc, memory_offsets, index);
|
|
|
- irValue *is_using = ir_emit_ptr_offset(proc, memory_usings, index);
|
|
|
-
|
|
|
- ir_emit_store(proc, type_info, ir_type_info(proc, f->type));
|
|
|
- if (f->token.string.len > 0) {
|
|
|
- irValue *name = ir_emit_ptr_offset(proc, memory_names, index);
|
|
|
- ir_emit_store(proc, name, ir_const_string(proc->module, f->token.string));
|
|
|
- }
|
|
|
- ir_emit_store(proc, offset, ir_const_uintptr(foffset));
|
|
|
- ir_emit_store(proc, is_using, ir_const_bool((f->flags&EntityFlag_Using) != 0));
|
|
|
-
|
|
|
- if (t->Struct.tags.count > 0) {
|
|
|
- String tag_string = t->Struct.tags[source_index];
|
|
|
- if (tag_string.len > 0) {
|
|
|
- irValue *tag_ptr = ir_emit_ptr_offset(proc, memory_tags, index);
|
|
|
- ir_emit_store(proc, tag_ptr, ir_const_string(proc->module, tag_string));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- irValue *cv = ir_const_int(count);
|
|
|
- ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 0), memory_types, cv);
|
|
|
- ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 1), memory_names, cv);
|
|
|
- ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 2), memory_offsets, cv);
|
|
|
- ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 3), memory_usings, cv);
|
|
|
- ir_fill_slice(proc, ir_emit_struct_ep(proc, tag, 4), memory_tags, cv);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- case Type_Map: {
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Map"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_map_ptr);
|
|
|
- init_map_internal_types(t);
|
|
|
-
|
|
|
- irValue *key = ir_emit_struct_ep(proc, tag, 0);
|
|
|
- irValue *value = ir_emit_struct_ep(proc, tag, 1);
|
|
|
- irValue *generated_struct = ir_emit_struct_ep(proc, tag, 2);
|
|
|
- irValue *key_equal = ir_emit_struct_ep(proc, tag, 3);
|
|
|
- irValue *key_hasher = ir_emit_struct_ep(proc, tag, 4);
|
|
|
-
|
|
|
- ir_emit_store(proc, key, ir_get_type_info_ptr(proc, t->Map.key));
|
|
|
- ir_emit_store(proc, value, ir_get_type_info_ptr(proc, t->Map.value));
|
|
|
- ir_emit_store(proc, generated_struct, ir_get_type_info_ptr(proc, t->Map.generated_struct_type));
|
|
|
- ir_emit_store(proc, key_equal, ir_get_equal_proc_for_type(proc->module, t->Map.key));
|
|
|
- ir_emit_store(proc, key_hasher, ir_get_hasher_proc_for_type(proc->module, t->Map.key));
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case Type_BitSet:
|
|
|
- ir_emit_comment(proc, str_lit("Type_Info_Bit_Set"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_bit_set_ptr);
|
|
|
-
|
|
|
- GB_ASSERT(is_type_typed(t->BitSet.elem));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->BitSet.elem));
|
|
|
- if (t->BitSet.underlying != nullptr) {
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), ir_get_type_info_ptr(proc, t->BitSet.underlying));
|
|
|
- }
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), ir_const_i64(t->BitSet.lower));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), ir_const_i64(t->BitSet.upper));
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_SimdVector:
|
|
|
- ir_emit_comment(proc, str_lit("Type_SimdVector"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_simd_vector_ptr);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->SimdVector.elem));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 1), ir_const_int(type_size_of(t->SimdVector.elem)));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 2), ir_const_int(t->SimdVector.count));
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_RelativePointer:
|
|
|
- ir_emit_comment(proc, str_lit("Type_RelativePointer"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_relative_pointer_ptr);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->RelativePointer.pointer_type));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->RelativePointer.base_integer));
|
|
|
- break;
|
|
|
-
|
|
|
- case Type_RelativeSlice:
|
|
|
- ir_emit_comment(proc, str_lit("Type_RelativeSlice"));
|
|
|
- tag = ir_emit_conv(proc, variant_ptr, t_type_info_relative_slice_ptr);
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->RelativePointer.pointer_type));
|
|
|
- ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->RelativePointer.base_integer));
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- if (tag != nullptr) {
|
|
|
- Type *tag_type = type_deref(ir_type(tag));
|
|
|
- GB_ASSERT(is_type_named(tag_type));
|
|
|
- ir_emit_store_union_variant(proc, variant_ptr, ir_emit_load(proc, tag), tag_type);
|
|
|
- } else {
|
|
|
- if (t != t_llvm_bool) {
|
|
|
- GB_PANIC("Unhandled Type_Info variant: %s", type_to_string(t));
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void ir_gen_tree(irGen *s) {
|
|
|
- irModule *m = &s->module;
|
|
|
- CheckerInfo *info = m->info;
|
|
|
- gbAllocator a = ir_allocator();
|
|
|
-
|
|
|
- if (v_zero == nullptr) {
|
|
|
- v_zero = ir_const_int (0);
|
|
|
- v_one = ir_const_int (1);
|
|
|
- v_zero32 = ir_const_i32 (0);
|
|
|
- v_one32 = ir_const_i32 (1);
|
|
|
- v_two32 = ir_const_i32 (2);
|
|
|
- v_false = ir_const_bool(false);
|
|
|
- v_true = ir_const_bool(true);
|
|
|
- v_raw_nil = ir_value_constant(t_rawptr, exact_value_pointer(0));
|
|
|
- }
|
|
|
-
|
|
|
- isize global_variable_max_count = 0;
|
|
|
- Entity *entry_point = info->entry_point;
|
|
|
- bool has_dll_main = false;
|
|
|
- bool has_win_main = false;
|
|
|
-
|
|
|
- for_array(i, info->entities) {
|
|
|
- Entity *e = info->entities[i];
|
|
|
- String name = e->token.string;
|
|
|
-
|
|
|
- bool is_global = e->pkg != nullptr;
|
|
|
-
|
|
|
- if (e->kind == Entity_Variable) {
|
|
|
- global_variable_max_count++;
|
|
|
- } else if (e->kind == Entity_Procedure && !is_global) {
|
|
|
- if ((e->scope->flags&ScopeFlag_Init) && name == "main") {
|
|
|
- GB_ASSERT(e == entry_point);
|
|
|
- // entry_point = e;
|
|
|
- }
|
|
|
- if (e->Procedure.is_export ||
|
|
|
- (e->Procedure.link_name.len > 0) ||
|
|
|
- ((e->scope->flags&ScopeFlag_File) && e->Procedure.link_name.len > 0)) {
|
|
|
- if (!has_dll_main && name == "DllMain") {
|
|
|
- has_dll_main = true;
|
|
|
- } else if (!has_win_main && name == "WinMain") {
|
|
|
- has_win_main = true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- struct irGlobalVariable {
|
|
|
- irValue *var, *init;
|
|
|
- DeclInfo *decl;
|
|
|
- };
|
|
|
- auto global_variables = array_make<irGlobalVariable>(m->tmp_allocator, 0, global_variable_max_count);
|
|
|
-
|
|
|
- m->entry_point_entity = entry_point;
|
|
|
- m->min_dep_set = info->minimum_dependency_set;
|
|
|
-
|
|
|
- for_array(i, info->variable_init_order) {
|
|
|
- DeclInfo *d = info->variable_init_order[i];
|
|
|
-
|
|
|
- Entity *e = d->entity;
|
|
|
-
|
|
|
- if ((e->scope->flags & ScopeFlag_File) == 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (!ir_min_dep_entity(m, e)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- DeclInfo *decl = decl_info_of_entity(e);
|
|
|
- if (decl == nullptr) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- GB_ASSERT(e->kind == Entity_Variable);
|
|
|
-
|
|
|
- bool is_foreign = e->Variable.is_foreign;
|
|
|
- bool is_export = e->Variable.is_export;
|
|
|
- bool no_name_mangle = e->Variable.link_name.len > 0 || is_foreign || is_export;
|
|
|
-
|
|
|
- String name = e->token.string;
|
|
|
- if (e->Variable.link_name.len > 0) {
|
|
|
- name = e->Variable.link_name;
|
|
|
- }
|
|
|
- if (!no_name_mangle) {
|
|
|
- name = ir_mangle_name(s, e);
|
|
|
- }
|
|
|
- ir_add_entity_name(m, e, name);
|
|
|
-
|
|
|
- irValue *g = ir_value_global(e, nullptr);
|
|
|
- g->Global.name = name;
|
|
|
- g->Global.thread_local_model = e->Variable.thread_local_model;
|
|
|
- g->Global.is_foreign = is_foreign;
|
|
|
- g->Global.is_export = is_export;
|
|
|
-
|
|
|
- irGlobalVariable var = {};
|
|
|
- var.var = g;
|
|
|
- var.decl = decl;
|
|
|
-
|
|
|
- if (decl->init_expr != nullptr && !is_type_any(e->type)) {
|
|
|
- TypeAndValue tav = type_and_value_of_expr(decl->init_expr);
|
|
|
- if (tav.mode != Addressing_Invalid) {
|
|
|
- if (tav.value.kind != ExactValue_Invalid) {
|
|
|
- ExactValue v = tav.value;
|
|
|
- g->Global.value = ir_add_module_constant(m, tav.type, v);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- array_add(&global_variables, var);
|
|
|
-
|
|
|
- ir_module_add_value(m, e, g);
|
|
|
- string_map_set(&m->members, name, g);
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, info->entities) {
|
|
|
- Entity * e = info->entities[i];
|
|
|
- String name = e->token.string;
|
|
|
- DeclInfo *decl = e->decl_info;
|
|
|
- Scope * scope = e->scope;
|
|
|
-
|
|
|
- if ((scope->flags & ScopeFlag_File) == 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- Scope *package_scope = scope->parent;
|
|
|
- GB_ASSERT(package_scope->flags & ScopeFlag_Pkg);
|
|
|
-
|
|
|
- switch (e->kind) {
|
|
|
- case Entity_Variable:
|
|
|
- // NOTE(bill): Handled above as it requires a specific load order
|
|
|
- continue;
|
|
|
- case Entity_ProcGroup:
|
|
|
- continue;
|
|
|
-
|
|
|
- case Entity_Procedure:
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- bool polymorphic_struct = false;
|
|
|
- if (e->type != nullptr && e->kind == Entity_TypeName) {
|
|
|
- Type *bt = base_type(e->type);
|
|
|
- if (bt->kind == Type_Struct) {
|
|
|
- polymorphic_struct = is_type_polymorphic(bt);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!polymorphic_struct && !ir_min_dep_entity(m, e)) {
|
|
|
- // NOTE(bill): Nothing depends upon it so doesn't need to be built
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- String original_name = name;
|
|
|
-
|
|
|
- #if 0
|
|
|
- if (!package_scope->is_global || polymorphic_struct || is_type_polymorphic(e->type)) {
|
|
|
- if (e->kind == Entity_Procedure && e->Procedure.is_export) {
|
|
|
- } else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
|
|
|
- // Handle later
|
|
|
- } else {
|
|
|
- name = ir_mangle_name(s, e);
|
|
|
- }
|
|
|
- }
|
|
|
- #else
|
|
|
- if (e->kind == Entity_Procedure && e->Procedure.is_export) {
|
|
|
- // Okay
|
|
|
- } else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
|
|
|
- // Handle later
|
|
|
- } else {
|
|
|
- name = ir_mangle_name(s, e);
|
|
|
- }
|
|
|
- #endif
|
|
|
-
|
|
|
- ir_add_entity_name(m, e, name);
|
|
|
-
|
|
|
- switch (e->kind) {
|
|
|
- case Entity_TypeName:
|
|
|
- ir_gen_global_type_name(m, e, name);
|
|
|
- break;
|
|
|
-
|
|
|
- case Entity_Procedure: {
|
|
|
- ast_node(pl, ProcLit, decl->proc_lit);
|
|
|
- String original_name = name;
|
|
|
- Ast *body = pl->body;
|
|
|
-
|
|
|
- if (e->Procedure.is_foreign) {
|
|
|
- name = e->token.string; // NOTE(bill): Don't use the mangled name
|
|
|
- ir_add_foreign_library_path(m, e->Procedure.foreign_library);
|
|
|
- }
|
|
|
- if (e->Procedure.link_name.len > 0) {
|
|
|
- name = e->Procedure.link_name;
|
|
|
- }
|
|
|
-
|
|
|
- Ast *type_expr = pl->type;
|
|
|
-
|
|
|
- set_procedure_abi_types(e->type);
|
|
|
- irValue *p = ir_value_procedure(m, e, e->type, type_expr, body, name);
|
|
|
- p->Proc.tags = pl->tags;
|
|
|
- p->Proc.inlining = pl->inlining;
|
|
|
- p->Proc.is_export = e->Procedure.is_export;
|
|
|
-
|
|
|
- ir_module_add_value(m, e, p);
|
|
|
- StringHashKey hash_name = string_hash_string(name);
|
|
|
- if (string_map_get(&m->members, hash_name) == nullptr) {
|
|
|
- string_map_set(&m->members, hash_name, p);
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, m->members.entries) {
|
|
|
- auto *entry = &m->members.entries[i];
|
|
|
- irValue *v = entry->value;
|
|
|
- if (v->kind == irValue_Proc) {
|
|
|
- ir_build_proc(v, nullptr);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- irDebugInfo *compile_unit = m->debug_info.entries[0].value;
|
|
|
- GB_ASSERT(compile_unit->kind == irDebugInfo_CompileUnit);
|
|
|
-
|
|
|
- for_array(i, m->info->required_foreign_imports_through_force) {
|
|
|
- Entity *e = m->info->required_foreign_imports_through_force[i];
|
|
|
- ir_add_foreign_library_path(m, e);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-#if defined(GB_SYSTEM_WINDOWS)
|
|
|
- if (build_context.build_mode == BuildMode_DynamicLibrary && !has_dll_main && !build_context.no_entry_point) {
|
|
|
- // DllMain :: proc(inst: rawptr, reason: u32, reserved: rawptr) -> i32
|
|
|
- String name = str_lit("DllMain");
|
|
|
- Type *proc_params = alloc_type_tuple();
|
|
|
- Type *proc_results = alloc_type_tuple();
|
|
|
-
|
|
|
- Scope *proc_scope = gb_alloc_item(a, Scope);
|
|
|
-
|
|
|
- array_init(&proc_params->Tuple.variables, a, 3);
|
|
|
- array_init(&proc_results->Tuple.variables, a, 1);
|
|
|
-
|
|
|
- proc_params->Tuple.variables[0] = alloc_entity_param(proc_scope, blank_token, t_rawptr, false, false);
|
|
|
- proc_params->Tuple.variables[1] = alloc_entity_param(proc_scope, make_token_ident(str_lit("reason")), t_i32, false, false);
|
|
|
- proc_params->Tuple.variables[2] = alloc_entity_param(proc_scope, blank_token, t_rawptr, false, false);
|
|
|
-
|
|
|
-
|
|
|
- proc_results->Tuple.variables[0] = alloc_entity_param(proc_scope, empty_token, t_i32, false, false);
|
|
|
-
|
|
|
-
|
|
|
- Type *proc_type = alloc_type_proc(proc_scope,
|
|
|
- proc_params, 3,
|
|
|
- proc_results, 1, false, ProcCC_StdCall);
|
|
|
-
|
|
|
- // TODO(bill): make this more robust
|
|
|
- proc_type->Proc.abi_compat_params = array_make<Type *>(a, proc_params->Tuple.variables.count);
|
|
|
- for_array(i, proc_params->Tuple.variables) {
|
|
|
- proc_type->Proc.abi_compat_params[i] = proc_params->Tuple.variables[i]->type;
|
|
|
- }
|
|
|
- proc_type->Proc.abi_compat_result_type = proc_results->Tuple.variables[0]->type;
|
|
|
-
|
|
|
- Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
|
|
|
- Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
|
|
|
- irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
|
|
|
- p->Proc.is_startup = true;
|
|
|
-
|
|
|
- map_set(&m->values, hash_entity(e), p);
|
|
|
- string_map_set(&m->members, name, p);
|
|
|
-
|
|
|
- irProcedure *proc = &p->Proc;
|
|
|
- proc->inlining = ProcInlining_no_inline; // TODO(bill): is no_inline a good idea?
|
|
|
- proc->is_entry_point = true;
|
|
|
- e->Procedure.link_name = name;
|
|
|
-
|
|
|
- ir_begin_procedure_body(proc);
|
|
|
- defer (ir_end_procedure_body(proc));
|
|
|
-
|
|
|
- // NOTE(bill): https://msdn.microsoft.com/en-us/library/windows/desktop/ms682583(v=vs.85).aspx
|
|
|
- // DLL_PROCESS_ATTACH == 1
|
|
|
-
|
|
|
- irAddr reason_addr = ir_build_addr_from_entity(proc, proc_params->Tuple.variables[1], nullptr);
|
|
|
- irValue *cond = ir_emit_comp(proc, Token_CmpEq, ir_addr_load(proc, reason_addr), v_one32);
|
|
|
- irBlock *then = ir_new_block(proc, nullptr, "if.then");
|
|
|
- irBlock *done = ir_new_block(proc, nullptr, "if.done"); // NOTE(bill): Append later
|
|
|
- ir_emit_if(proc, cond, then, done);
|
|
|
- ir_start_block(proc, then);
|
|
|
-
|
|
|
- {
|
|
|
- irValue **found = map_get(&m->values, hash_entity(entry_point));
|
|
|
- ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime));
|
|
|
- if (found != nullptr) {
|
|
|
- Array<irValue *> args = {};
|
|
|
- ir_emit_call(proc, *found, args);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit_jump(proc, done);
|
|
|
- ir_start_block(proc, done);
|
|
|
-
|
|
|
- ir_emit_return(proc, v_one32);
|
|
|
- }
|
|
|
-#endif
|
|
|
- if (!(build_context.build_mode == BuildMode_DynamicLibrary && !has_dll_main) && !build_context.no_entry_point) {
|
|
|
- // main :: proc(argc: i32, argv: ^^u8) -> i32
|
|
|
- String name = str_lit("main");
|
|
|
-
|
|
|
-#if 0
|
|
|
- if (str_eq_ignore_case(cross_compile_target, str_lit("Essence"))) {
|
|
|
- // This is a bit hacky,
|
|
|
- // because this makes this function the first function run in the executable
|
|
|
- // so it won't actually have the argc/argv arguments.
|
|
|
- name = str_lit("ProgramEntry");
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
- Type *proc_params = alloc_type_tuple();
|
|
|
- Type *proc_results = alloc_type_tuple();
|
|
|
-
|
|
|
- Scope *proc_scope = gb_alloc_item(a, Scope);
|
|
|
-
|
|
|
- array_init(&proc_params->Tuple.variables, a, 2);
|
|
|
- array_init(&proc_results->Tuple.variables, a, 1);
|
|
|
-
|
|
|
- Type *cstring_ptr = alloc_type_pointer(t_cstring);
|
|
|
- proc_params->Tuple.variables[0] = alloc_entity_param(proc_scope, make_token_ident(str_lit("argc")), t_i32, false, false);
|
|
|
- proc_params->Tuple.variables[1] = alloc_entity_param(proc_scope, make_token_ident(str_lit("argv")), cstring_ptr, false, false);
|
|
|
-
|
|
|
-
|
|
|
- proc_results->Tuple.variables[0] = alloc_entity_param(proc_scope, empty_token, t_i32, false, false);
|
|
|
-
|
|
|
-
|
|
|
- Type *proc_type = alloc_type_proc(proc_scope,
|
|
|
- proc_params, 2,
|
|
|
- proc_results, 1, false, ProcCC_CDecl);
|
|
|
-
|
|
|
- // TODO(bill): make this more robust
|
|
|
- proc_type->Proc.abi_compat_params = array_make<Type *>(a, proc_params->Tuple.variables.count);
|
|
|
- for_array(i, proc_params->Tuple.variables) {
|
|
|
- proc_type->Proc.abi_compat_params[i] = proc_params->Tuple.variables[i]->type;
|
|
|
- }
|
|
|
- proc_type->Proc.abi_compat_result_type = proc_results->Tuple.variables[0]->type;
|
|
|
-
|
|
|
- Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
|
|
|
- Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
|
|
|
- irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
|
|
|
- p->Proc.is_startup = true;
|
|
|
-
|
|
|
- map_set(&m->values, hash_entity(e), p);
|
|
|
- string_map_set(&m->members, name, p);
|
|
|
-
|
|
|
- irProcedure *proc = &p->Proc;
|
|
|
- proc->inlining = ProcInlining_no_inline; // TODO(bill): is no_inline a good idea?
|
|
|
- proc->is_entry_point = true;
|
|
|
- e->Procedure.link_name = name;
|
|
|
-
|
|
|
- ir_begin_procedure_body(proc);
|
|
|
- defer (ir_end_procedure_body(proc));
|
|
|
-
|
|
|
- // NOTE(bill): https://msdn.microsoft.com/en-us/library/windows/desktop/ms682583(v=vs.85).aspx
|
|
|
- // DLL_PROCESS_ATTACH == 1
|
|
|
-
|
|
|
- irValue *argc = ir_emit_load(proc, *map_get(&proc->module->values, hash_entity(proc_params->Tuple.variables[0])));
|
|
|
- irValue *argv = ir_emit_load(proc, *map_get(&proc->module->values, hash_entity(proc_params->Tuple.variables[1])));
|
|
|
-
|
|
|
- irValue *global_args = ir_find_global_variable(proc, str_lit("args__"));
|
|
|
-
|
|
|
- ir_fill_slice(proc, global_args, argv, ir_emit_conv(proc, argc, t_int));
|
|
|
-
|
|
|
- ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime));
|
|
|
- Array<irValue *> empty_args = {};
|
|
|
- if (build_context.command_kind == Command_test) {
|
|
|
- Type *t_Internal_Test = find_type_in_pkg(m->info, str_lit("testing"), str_lit("Internal_Test"));
|
|
|
- Type *array_type = alloc_type_array(t_Internal_Test, m->info->testing_procedures.count);
|
|
|
- Type *slice_type = alloc_type_slice(t_Internal_Test);
|
|
|
- irValue *all_tests_array = ir_add_global_generated(proc->module, array_type, nullptr);
|
|
|
-
|
|
|
- for_array(i, m->info->testing_procedures) {
|
|
|
- Entity *testing_proc = m->info->testing_procedures[i];
|
|
|
- String name = testing_proc->token.string;
|
|
|
- irValue **found = map_get(&m->values, hash_entity(testing_proc));
|
|
|
- GB_ASSERT(found != nullptr);
|
|
|
-
|
|
|
- String pkg_name = {};
|
|
|
- if (testing_proc->pkg != nullptr) {
|
|
|
- pkg_name = testing_proc->pkg->name;
|
|
|
- }
|
|
|
- irValue *v_pkg = ir_find_or_add_entity_string(m, pkg_name);
|
|
|
- irValue *v_name = ir_find_or_add_entity_string(m, name);
|
|
|
- irValue *v_p = *found;
|
|
|
-
|
|
|
-
|
|
|
- irValue *elem_ptr = ir_emit_array_epi(proc, all_tests_array, cast(i32)i);
|
|
|
- irValue *pkg_ptr = ir_emit_struct_ep(proc, elem_ptr, 0);
|
|
|
- irValue *name_ptr = ir_emit_struct_ep(proc, elem_ptr, 1);
|
|
|
- irValue *p_ptr = ir_emit_struct_ep(proc, elem_ptr, 2);
|
|
|
- ir_emit_store(proc, pkg_ptr, v_pkg);
|
|
|
- ir_emit_store(proc, name_ptr, v_name);
|
|
|
- ir_emit_store(proc, p_ptr, v_p);
|
|
|
- }
|
|
|
-
|
|
|
- irValue *all_tests_slice = ir_add_local_generated(proc, slice_type, true);
|
|
|
- ir_fill_slice(proc, all_tests_slice,
|
|
|
- ir_array_elem(proc, all_tests_array),
|
|
|
- ir_const_int(m->info->testing_procedures.count));
|
|
|
-
|
|
|
-
|
|
|
- irValue *runner = ir_get_package_value(m, str_lit("testing"), str_lit("runner"));
|
|
|
-
|
|
|
- auto args = array_make<irValue *>(temporary_allocator(), 1);
|
|
|
- args[0] = ir_emit_load(proc, all_tests_slice);
|
|
|
- ir_emit_call(proc, runner, args);
|
|
|
- } else {
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(entry_point));
|
|
|
- if (found != nullptr) {
|
|
|
- ir_emit_call(proc, *found, empty_args);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ir_emit_return(proc, v_zero32);
|
|
|
- }
|
|
|
-
|
|
|
-#if defined(GB_SYSTEM_WINDOWS)
|
|
|
- if (build_context.build_mode != BuildMode_DynamicLibrary && build_context.no_crt && !build_context.no_entry_point) {
|
|
|
- s->print_chkstk = true;
|
|
|
-
|
|
|
- {
|
|
|
- // void mainCRTStartup(void)
|
|
|
- String name = str_lit("mainCRTStartup");
|
|
|
- Type *proc_params = alloc_type_tuple();
|
|
|
- Type *proc_results = alloc_type_tuple();
|
|
|
-
|
|
|
-
|
|
|
- Type *proc_type = alloc_type_proc(nullptr,
|
|
|
- nullptr, 0,
|
|
|
- nullptr, 0,
|
|
|
- false,
|
|
|
- ProcCC_StdCall);
|
|
|
-
|
|
|
- Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
|
|
|
- Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
|
|
|
- irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
|
|
|
- p->Proc.is_startup = true;
|
|
|
-
|
|
|
- m->entry_point_entity = e;
|
|
|
-
|
|
|
- map_set(&m->values, hash_entity(e), p);
|
|
|
- string_map_set(&m->members, name, p);
|
|
|
-
|
|
|
- irProcedure *proc = &p->Proc;
|
|
|
- // proc->tags = ProcTag_no_inline; // TODO(bill): is no_inline a good idea?
|
|
|
- e->Procedure.link_name = name;
|
|
|
-
|
|
|
- ir_begin_procedure_body(proc);
|
|
|
- ir_emit(proc, ir_alloc_instr(proc, irInstr_StartupRuntime));
|
|
|
- irValue **found = map_get(&proc->module->values, hash_entity(entry_point));
|
|
|
- if (found != nullptr) {
|
|
|
- Array<irValue *> args = {};
|
|
|
- ir_emit_call(proc, *found, args);
|
|
|
- }
|
|
|
- ir_end_procedure_body(proc);
|
|
|
- }
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
- irValue *startup_type_info = nullptr;
|
|
|
- { // Startup Type Info
|
|
|
- // Cleanup(bill): probably better way of doing code insertion
|
|
|
- String name = str_lit(IR_STARTUP_TYPE_INFO_PROC_NAME);
|
|
|
- Type *proc_type = alloc_type_proc(gb_alloc_item(a, Scope),
|
|
|
- nullptr, 0,
|
|
|
- nullptr, 0, false,
|
|
|
- ProcCC_Contextless);
|
|
|
- Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
|
|
|
- Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
|
|
|
- irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
|
|
|
- p->Proc.is_startup = true;
|
|
|
- startup_type_info = p;
|
|
|
-
|
|
|
- map_set(&m->values, hash_entity(e), p);
|
|
|
- string_map_set(&m->members, name, p);
|
|
|
-
|
|
|
- irProcedure *proc = &p->Proc;
|
|
|
- proc->inlining = ProcInlining_no_inline; // TODO(bill): is no_inline a good idea?
|
|
|
-
|
|
|
- ir_begin_procedure_body(proc);
|
|
|
- ir_setup_type_info_data(proc);
|
|
|
- ir_end_procedure_body(proc);
|
|
|
- }
|
|
|
-
|
|
|
- { // Startup Runtime
|
|
|
- // Cleanup(bill): probably better way of doing code insertion
|
|
|
- String name = str_lit(IR_STARTUP_RUNTIME_PROC_NAME);
|
|
|
- Type *proc_type = alloc_type_proc(gb_alloc_item(a, Scope),
|
|
|
- nullptr, 0,
|
|
|
- nullptr, 0, false,
|
|
|
- ProcCC_Contextless);
|
|
|
- Ast *body = alloc_ast_node(nullptr, Ast_Invalid);
|
|
|
- Entity *e = alloc_entity_procedure(nullptr, make_token_ident(name), proc_type, 0);
|
|
|
- irValue *p = ir_value_procedure(m, e, proc_type, nullptr, body, name);
|
|
|
- p->Proc.is_startup = true;
|
|
|
-
|
|
|
- map_set(&m->values, hash_entity(e), p);
|
|
|
- string_map_set(&m->members, name, p);
|
|
|
-
|
|
|
-
|
|
|
- irProcedure *proc = &p->Proc;
|
|
|
- proc->inlining = ProcInlining_no_inline; // TODO(bill): is no_inline a good idea?
|
|
|
-
|
|
|
- ir_begin_procedure_body(proc);
|
|
|
- defer (ir_end_procedure_body(proc));
|
|
|
-
|
|
|
- ir_emit(proc, ir_instr_call(proc, startup_type_info, nullptr, {}, nullptr, nullptr, ProcInlining_none));
|
|
|
-
|
|
|
- for_array(i, global_variables) {
|
|
|
- irGlobalVariable *var = &global_variables[i];
|
|
|
- if (var->decl->init_expr != nullptr) {
|
|
|
- var->init = ir_build_expr(proc, var->decl->init_expr);
|
|
|
- }
|
|
|
-
|
|
|
- Entity *e = var->var->Global.entity;
|
|
|
- GB_ASSERT(e->kind == Entity_Variable);
|
|
|
-
|
|
|
- if (e->Variable.is_foreign) {
|
|
|
- Entity *fl = e->Procedure.foreign_library;
|
|
|
- ir_add_foreign_library_path(m, fl);
|
|
|
- }
|
|
|
-
|
|
|
- if (e->flags & EntityFlag_Static) {
|
|
|
- var->var->Global.is_internal = true;
|
|
|
- }
|
|
|
-
|
|
|
- if (var->init != nullptr) {
|
|
|
- Type *t = type_deref(ir_type(var->var));
|
|
|
-
|
|
|
- if (is_type_any(t)) {
|
|
|
- // NOTE(bill): Edge case for 'any' type
|
|
|
- Type *var_type = default_type(ir_type(var->init));
|
|
|
- irValue *g = ir_add_global_generated(proc->module, var_type, var->init);
|
|
|
- ir_emit_store(proc, g, var->init);
|
|
|
-
|
|
|
- irValue *data = ir_emit_struct_ep(proc, var->var, 0);
|
|
|
- irValue *ti = ir_emit_struct_ep(proc, var->var, 1);
|
|
|
- ir_emit_store(proc, data, ir_emit_conv(proc, g, t_rawptr));
|
|
|
- ir_emit_store(proc, ti, ir_type_info(proc, var_type));
|
|
|
- } else {
|
|
|
- ir_emit_store(proc, var->var, ir_emit_conv(proc, var->init, t));
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- for_array(i, m->procs_to_generate) {
|
|
|
- irValue *p = m->procs_to_generate[i];
|
|
|
- ir_build_proc(p, p->Proc.parent);
|
|
|
- }
|
|
|
-
|
|
|
- GB_ASSERT_MSG(m->debug_location_stack.count == 0, "Debug location stack contains unpopped entries.");
|
|
|
-
|
|
|
- // Number debug info
|
|
|
- for_array(i, m->debug_info.entries) {
|
|
|
- auto *entry = &m->debug_info.entries[i];
|
|
|
- irDebugInfo *di = entry->value;
|
|
|
- di->id = cast(i32)(i+1);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // m->layout = str_lit("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64");
|
|
|
-}
|
|
|
-
|
gingerBill