From 2aaef48c5c362bb3e04d0c9cd1e722e21b3755e5 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Fri, 5 Aug 2016 00:54:05 +0100 Subject: String support --- src/codegen/codegen.cpp | 8 +- src/codegen/print.cpp | 540 ------------------------------------------- src/codegen/print_llvm.cpp | 564 +++++++++++++++++++++++++++++++++++++++++++++ src/codegen/ssa.cpp | 323 ++++++++++++++++++-------- 4 files changed, 797 insertions(+), 638 deletions(-) delete mode 100644 src/codegen/print.cpp create mode 100644 src/codegen/print_llvm.cpp (limited to 'src/codegen') diff --git a/src/codegen/codegen.cpp b/src/codegen/codegen.cpp index f799497ca..412daae3d 100644 --- a/src/codegen/codegen.cpp +++ b/src/codegen/codegen.cpp @@ -1,5 +1,5 @@ #include "ssa.cpp" -#include "print.cpp" +#include "print_llvm.cpp" struct ssaGen { ssaModule module; @@ -7,14 +7,14 @@ struct ssaGen { }; b32 ssa_gen_init(ssaGen *s, Checker *c) { - if (c->error_collector.count != 0) + if (c->error_collector.count > 0) return false; gb_for_array(i, c->parser->files) { AstFile *f = &c->parser->files[i]; - if (f->error_collector.count != 0) + if (f->error_collector.count > 0) return false; - if (f->tokenizer.error_count != 0) + if (f->tokenizer.error_count > 0) return false; } diff --git a/src/codegen/print.cpp b/src/codegen/print.cpp deleted file mode 100644 index f6f1afe42..000000000 --- a/src/codegen/print.cpp +++ /dev/null @@ -1,540 +0,0 @@ -void ssa_fprintf(gbFile *f, char *fmt, ...) { - va_list va; - va_start(va, fmt); - gb_fprintf_va(f, fmt, va); -#if 1 - gb_printf_va(fmt, va); -#endif - va_end(va); -} - - -b32 ssa_valid_char(u8 c) { - if (gb_char_is_alphanumeric(c)) - return true; - - switch (c) { - case '$': - case '-': - case '.': - case '_': - return true; - } - - return false; -} - -void ssa_print_escape_string(gbFile *f, String name) { - isize extra = 0; - for (isize i = 0; i < name.len; i++) { - u8 c = name.text[i]; - if (!ssa_valid_char(c)) - extra += 2; - } - - if (extra == 0) { - ssa_fprintf(f, "%.*s", LIT(name)); - return; - } - - char hex_table[] = "0123456789ABCDEF"; - isize buf_len = name.len + extra; - u8 *buf = gb_alloc_array(gb_heap_allocator(), u8, buf_len); - defer (gb_free(gb_heap_allocator(), buf)); - - isize j = 0; - for (isize i = 0; i < name.len; i++) { - u8 c = name.text[i]; - if (ssa_valid_char(c)) { - buf[j++] = c; - } else { - buf[j] = '\\'; - buf[j+1] = hex_table[c >> 4]; - buf[j+2] = hex_table[c & 0x0f]; - j += 3; - } - } - - gb_file_write(f, buf, buf_len); -} - - - -void ssa_print_encoded_local(gbFile *f, String name) { - ssa_fprintf(f, "%%"); - ssa_print_escape_string(f, name); -} - -void ssa_print_encoded_global(gbFile *f, String name) { - ssa_fprintf(f, "@"); - ssa_print_escape_string(f, name); -} - - -void ssa_print_type(gbFile *f, BaseTypeSizes s, Type *t) { - i64 word_bits = 8*s.word_size; - GB_ASSERT_NOT_NULL(t); - t = default_type(t); - - switch (t->kind) { - case Type_Basic: - switch (t->basic.kind) { - case Basic_bool: ssa_fprintf(f, "i1"); break; - case Basic_i8: ssa_fprintf(f, "i8"); break; - case Basic_i16: ssa_fprintf(f, "i16"); break; - case Basic_i32: ssa_fprintf(f, "i32"); break; - case Basic_i64: ssa_fprintf(f, "i64"); break; - case Basic_u8: ssa_fprintf(f, "i8"); break; - case Basic_u16: ssa_fprintf(f, "i16"); break; - case Basic_u32: ssa_fprintf(f, "i32"); break; - case Basic_u64: ssa_fprintf(f, "i64"); break; - case Basic_f32: ssa_fprintf(f, "float"); break; - case Basic_f64: ssa_fprintf(f, "double"); break; - case Basic_rawptr: ssa_fprintf(f, "void*"); break; - case Basic_string: ssa_fprintf(f, "{i8*, i%lld}", word_bits); break; - case Basic_int: ssa_fprintf(f, "i%lld", word_bits); break; - case Basic_uint: ssa_fprintf(f, "i%lld", word_bits); break; - } - break; - case Type_Array: - ssa_fprintf(f, "[%lld x ", t->array.count); - ssa_print_type(f, s, t->array.element); - ssa_fprintf(f, "]"); - break; - case Type_Slice: - ssa_fprintf(f, "{"); - ssa_print_type(f, s, t->slice.element); - ssa_fprintf(f, "*, i%lld, i%lld}", word_bits, word_bits); - break; - case Type_Structure: - ssa_fprintf(f, "{"); - for (isize i = 0; i < t->structure.field_count; i++) { - if (i > 0) ssa_fprintf(f, ", "); - ssa_print_type(f, s, t->structure.fields[i]->type); - } - ssa_fprintf(f, "}"); - break; - case Type_Pointer: - ssa_print_type(f, s, t->pointer.element); - ssa_fprintf(f, "*"); - break; - case Type_Named: - ssa_print_encoded_local(f, t->named.name); - break; - case Type_Alias: - ssa_print_type(f, s, t->alias.base); - break; - case Type_Tuple: - if (t->tuple.variable_count == 1) { - ssa_print_type(f, s, t->tuple.variables[0]->type); - } else { - ssa_fprintf(f, "{"); - for (isize i = 0; i < t->tuple.variable_count; i++) { - if (i > 0) ssa_fprintf(f, ", "); - ssa_print_type(f, s, t->tuple.variables[i]->type); - } - ssa_fprintf(f, "}"); - } - break; - case Type_Procedure: - if (t->procedure.result_count == 0) - ssa_fprintf(f, "void"); - else - ssa_print_type(f, s, t->procedure.results); - ssa_fprintf(f, " ("); - for (isize i = 0; i < t->procedure.param_count; i++) { - if (i > 0) ssa_fprintf(f, ", "); - ssa_print_type(f, s, &t->procedure.params[i]); - } - ssa_fprintf(f, ")*"); - break; - } -} - -void ssa_print_exact_value(gbFile *f, ssaModule *m, ExactValue value, Type *type) { - switch (value.kind) { - case ExactValue_Bool: - ssa_fprintf(f, (value.value_bool ? "true" : "false")); - break; - case ExactValue_String: { - ssa_fprintf(f, "c\""); - // TODO(bill): Make unquote string function - String unquoted = value.value_string; - unquoted.text++; - unquoted.len -= 2; - ssa_print_escape_string(f, unquoted); - ssa_fprintf(f, "\""); - } break; - case ExactValue_Integer: - ssa_fprintf(f, "%lld", value.value_integer); - break; - case ExactValue_Float: { - u64 u = 0; - if (is_type_float(type) && type->basic.kind == Basic_f32) { - // IMPORTANT NOTE(bill): LLVM requires all floating point constants to be - // a 64 bit number if bits_of(float type) <= 64. - // To overcome this problem, fill the "bottom" 32 bits with zeros - // https://groups.google.com/forum/#!topic/llvm-dev/IlqV3TbSk6M - f32 fp = cast(f32)value.value_float; - u = *cast(u32 *)&fp; - u <<= 32; - - } else { - u = *cast(u64 *)&value.value_float; - } - ssa_fprintf(f, "0x%llx", u); - } break; - case ExactValue_Pointer: - if (value.value_float == NULL) { - ssa_fprintf(f, "null"); - } else { - GB_PANIC("TODO(bill): ExactValue_Pointer"); - } - break; - default: - GB_PANIC("Invalid ExactValue"); - break; - } -} - -void ssa_print_block_name(gbFile *f, ssaBlock *b) { - ssa_fprintf(f, "\""); - ssa_print_escape_string(f, b->label); - ssa_fprintf(f, " - %d", b->id); - ssa_fprintf(f, "\""); -} - -void ssa_print_value(gbFile *f, ssaModule *m, ssaValue *value, Type *type_hint) { - if (value == NULL) { - ssa_fprintf(f, "!!!NULL_VALUE"); - return; - } - switch (value->kind) { - case ssaValue_Constant: - ssa_print_exact_value(f, m, value->constant.value, type_hint); - break; - case ssaValue_TypeName: - ssa_print_encoded_local(f, value->type_name.entity->token.string); - break; - case ssaValue_Global: - ssa_print_encoded_global(f, value->global.entity->token.string); - break; - case ssaValue_Param: - ssa_print_encoded_local(f, value->param.entity->token.string); - break; - case ssaValue_Proc: - ssa_print_encoded_global(f, value->proc.entity->token.string); - break; - case ssaValue_Instr: - ssa_fprintf(f, "%%%d", value->id); - break; - } -} - -void ssa_print_instr(gbFile *f, ssaModule *m, ssaValue *value) { - GB_ASSERT(value->kind == ssaValue_Instr); - ssaInstr *instr = &value->instr; - - ssa_fprintf(f, "\t"); - switch (instr->kind) { - case ssaInstr_Local: { - Type *type = instr->local.entity->type; - ssa_fprintf(f, "%%%d = alloca ", value->id); - ssa_print_type(f, m->sizes, type); - ssa_fprintf(f, ", align %lld ", type_align_of(m->sizes, gb_heap_allocator(), type)); - { - String str = instr->local.entity->token.string; - if (str.len > 0) - ssa_fprintf(f, "; %.*s", LIT(instr->local.entity->token.string)); - } - ssa_fprintf(f, "\n"); - ssa_fprintf(f, "\tstore "); - ssa_print_type(f, m->sizes, type); - ssa_fprintf(f, " zeroinitializer, "); - ssa_print_type(f, m->sizes, type); - ssa_fprintf(f, "* %%%d\n", value->id); - } break; - - case ssaInstr_Store: { - Type *type = ssa_value_type(instr->store.address); - ssa_fprintf(f, "store "); - ssa_print_type(f, m->sizes, type); - ssa_fprintf(f, " "); - ssa_print_value(f, m, instr->store.value, type); - ssa_fprintf(f, ", "); - ssa_print_type(f, m->sizes, type); - ssa_fprintf(f, "* "); - ssa_print_value(f, m, instr->store.address, type); - ssa_fprintf(f, "\n"); - } break; - - case ssaInstr_Load: { - Type *type = instr->load.type; - ssa_fprintf(f, "%%%d = load ", value->id); - ssa_print_type(f, m->sizes, type); - ssa_fprintf(f, ", "); - ssa_print_type(f, m->sizes, type); - ssa_fprintf(f, "* "); - ssa_print_value(f, m, instr->load.address, type); - ssa_fprintf(f, "\n"); - } break; - - case ssaInstr_GetElementPtr: { - Type *et = instr->get_element_ptr.element_type; - ssa_fprintf(f, "%%%d = getelementptr ", value->id); - if (instr->get_element_ptr.inbounds) - ssa_fprintf(f, "inbounds "); - - ssa_print_type(f, m->sizes, et); - ssa_fprintf(f, ", "); - ssa_print_type(f, m->sizes, et); - ssa_fprintf(f, "* "); - ssa_print_value(f, m, instr->get_element_ptr.address, et); - for (isize i = 0; i < instr->get_element_ptr.index_count; i++) { - ssaValue *index = instr->get_element_ptr.indices[i]; - Type *t = ssa_value_type(index); - ssa_fprintf(f, ", "); - ssa_print_type(f, m->sizes, t); - ssa_fprintf(f, " "); - ssa_print_value(f, m, index, t); - } - ssa_fprintf(f, "\n"); - } break; - - case ssaInstr_Br: { - ssa_fprintf(f, "br "); - if (instr->br.cond != NULL) { - ssa_print_type(f, m->sizes, t_bool); - ssa_fprintf(f, " "); - ssa_print_value(f, m, instr->br.cond, t_bool); - ssa_fprintf(f, ", ", instr->br.cond->id); - } - ssa_fprintf(f, "label "); - ssa_fprintf(f, "%%"); ssa_print_block_name(f, instr->br.true_block); - if (instr->br.false_block != NULL) { - ssa_fprintf(f, ", label "); - ssa_fprintf(f, "%%"); ssa_print_block_name(f, instr->br.false_block); - } - ssa_fprintf(f, "\n"); - } break; - - case ssaInstr_Ret: { - auto *ret = &instr->ret; - ssa_fprintf(f, "ret "); - if (ret->value == NULL) { - ssa_fprintf(f, "void"); - } else { - Type *t = ssa_value_type(ret->value); - ssa_print_type(f, m->sizes, t); - ssa_fprintf(f, " "); - ssa_print_value(f, m, ret->value, t); - } - - ssa_fprintf(f, "\n"); - - } break; - - case ssaInstr_Unreachable: { - ssa_fprintf(f, "unreachable\n"); - } break; - - case ssaInstr_BinaryOp: { - auto *bo = &value->instr.binary_op; - Type *type = ssa_value_type(bo->left); - - ssa_fprintf(f, "%%%d = ", value->id); - - if (gb_is_between(bo->op.kind, Token__ComparisonBegin+1, Token__ComparisonEnd-1)) { - if (is_type_float(type)) { - ssa_fprintf(f, "fcmp "); - switch (bo->op.kind) { - case Token_CmpEq: ssa_fprintf(f, "oeq"); break; - case Token_NotEq: ssa_fprintf(f, "one"); break; - case Token_Lt: ssa_fprintf(f, "olt"); break; - case Token_Gt: ssa_fprintf(f, "ogt"); break; - case Token_LtEq: ssa_fprintf(f, "ole"); break; - case Token_GtEq: ssa_fprintf(f, "oge"); break; - } - } else { - ssa_fprintf(f, "icmp "); - if (bo->op.kind != Token_CmpEq && - bo->op.kind != Token_NotEq) { - if (is_type_unsigned(type)) { - ssa_fprintf(f, "u"); - } else { - ssa_fprintf(f, "s"); - } - } - switch (bo->op.kind) { - case Token_CmpEq: ssa_fprintf(f, "eq"); break; - case Token_NotEq: ssa_fprintf(f, "ne"); break; - case Token_Lt: ssa_fprintf(f, "lt"); break; - case Token_Gt: ssa_fprintf(f, "gt"); break; - case Token_LtEq: ssa_fprintf(f, "le"); break; - case Token_GtEq: ssa_fprintf(f, "ge"); break; - } - } - } else { - if (is_type_float(type)) - ssa_fprintf(f, "f"); - - switch (bo->op.kind) { - case Token_Add: ssa_fprintf(f, "add"); break; - case Token_Sub: ssa_fprintf(f, "sub"); break; - case Token_And: ssa_fprintf(f, "and"); break; - case Token_Or: ssa_fprintf(f, "or"); break; - case Token_Xor: ssa_fprintf(f, "xor"); break; - - case Token_AndNot: GB_PANIC("Token_AndNot Should never be called"); - - case Token_Mul: ssa_fprintf(f, "mul"); break; - - default: { - if (!is_type_float(type)) { - if (is_type_unsigned(type)) ssa_fprintf(f, "u"); - else ssa_fprintf(f, "s"); - } - - switch (bo->op.kind) { - case Token_Quo: ssa_fprintf(f, "div"); break; - case Token_Mod: ssa_fprintf(f, "rem"); break; - } - } break; - } - } - - ssa_fprintf(f, " "); - ssa_print_type(f, m->sizes, type); - ssa_fprintf(f, " "); - ssa_print_value(f, m, bo->left, type); - ssa_fprintf(f, ", "); - ssa_print_value(f, m, bo->right, type); - ssa_fprintf(f, "\n"); - - } break; - - case ssaInstr_Call: { - auto *call = &instr->call; - if (call->type) { - ssa_fprintf(f, "%%%d = ", value->id); - } - ssa_fprintf(f, "call "); - if (call->type) { - ssa_print_type(f, m->sizes, call->type); - } else { - ssa_fprintf(f, "void"); - } - ssa_fprintf(f, " "); - ssa_print_value(f, m, call->value, call->type); - - - ssa_fprintf(f, "("); - for (isize i = 0; i < call->arg_count; i++) { - ssaValue *arg = call->args[i]; - Type *t = ssa_value_type(arg); - if (i > 0) { - ssa_fprintf(f, ", "); - } - ssa_print_type(f, m->sizes, t); - ssa_fprintf(f, " "); - ssa_print_value(f, m, arg, t); - } - ssa_fprintf(f, ")\n"); - - } break; - - default: - ssa_fprintf(f, "; %d\n", instr->kind); - break; - } -} - -void ssa_print_llvm_ir(gbFile *f, ssaModule *m) { - if (m->layout.len > 0) { - ssa_fprintf(f, "target datalayout = %.*s\n", LIT(m->layout)); - } - - gb_for_array(member_index, m->members.entries) { - auto *entry = &m->members.entries[member_index]; - ssaValue *v = entry->value; - switch (v->kind) { - case ssaValue_TypeName: { - ssa_print_encoded_local(f, v->type_name.entity->token.string); - ssa_fprintf(f, " = type "); - ssa_print_type(f, m->sizes, get_base_type(v->type_name.type)); - ssa_fprintf(f, "\n"); - } break; - - case ssaValue_Global: { - auto *g = &v->global; - ssa_print_encoded_global(f, g->entity->token.string); - ssa_fprintf(f, " = "); - if (g->is_constant) { - ssa_fprintf(f, "private constant "); - } else { - ssa_fprintf(f, "global "); - } - - ssa_print_type(f, m->sizes, get_base_type(g->entity->type)); - ssa_fprintf(f, " "); - ssa_print_value(f, m, g->value, g->entity->type); - ssa_fprintf(f, "\n"); - } break; - - case ssaValue_Proc: { - ssaProcedure *proc = &v->proc; - if (proc->body == NULL) { - ssa_fprintf(f, "declare "); - } else { - ssa_fprintf(f, "define "); - } - - auto *proc_type = &proc->entity->type->procedure; - - if (proc_type->result_count == 0) { - ssa_fprintf(f, "void"); - } else { - ssa_print_type(f, m->sizes, proc_type->results); - } - - ssa_fprintf(f, " "); - - ssa_print_encoded_global(f, proc->name); - ssa_fprintf(f, "("); - - if (proc_type->param_count > 0) { - auto *params = &proc_type->params->tuple; - for (isize i = 0; i < params->variable_count; i++) { - Entity *e = params->variables[i]; - if (i > 0) - ssa_fprintf(f, ", "); - ssa_print_type(f, m->sizes, e->type); - ssa_fprintf(f, " %%%.*s", LIT(e->token.string)); - } - } - - ssa_fprintf(f, ") "); - - if (proc->body == NULL) { - ssa_fprintf(f, "\n"); - } else { - ssa_fprintf(f, "{\n"); - gb_for_array(i, proc->blocks) { - ssaBlock *block = proc->blocks[i]; - - if (i > 0) ssa_fprintf(f, "\n"); - ssa_print_block_name(f, block); - ssa_fprintf(f, ":\n"); - - gb_for_array(j, block->instrs) { - ssaValue *value = block->instrs[j]; - ssa_print_instr(f, m, value); - } - } - ssa_fprintf(f, "}\n\n"); - } - - } break; - } - } -} diff --git a/src/codegen/print_llvm.cpp b/src/codegen/print_llvm.cpp new file mode 100644 index 000000000..8f0d0a413 --- /dev/null +++ b/src/codegen/print_llvm.cpp @@ -0,0 +1,564 @@ +#define SSA_PRINT_TO_STDOUT 0 + +void ssa_fprintf(gbFile *f, char *fmt, ...) { + va_list va; + va_start(va, fmt); + gb_fprintf_va(f, fmt, va); +#if SSA_PRINT_TO_STDOUT + gb_printf_va(fmt, va); +#endif + va_end(va); +} + +void ssa_file_write(gbFile *f, void *data, isize len) { + gb_file_write(f, data, len); +#if SSA_PRINT_TO_STDOUT + gb_file_write(gb_file_get_standard(gbFileStandard_Output), data, len); +#endif +} + +b32 ssa_valid_char(u8 c) { + if (c >= 0x80) + return false; + + if (gb_char_is_alphanumeric(c)) + return true; + + switch (c) { + case '$': + case '-': + case '.': + case '_': + return true; + } + + return false; +} + +void ssa_print_escape_string(gbFile *f, String name) { + isize extra = 0; + for (isize i = 0; i < name.len; i++) { + u8 c = name.text[i]; + if (!ssa_valid_char(c)) + extra += 2; + } + + if (extra == 0) { + ssa_fprintf(f, "%.*s", LIT(name)); + return; + } + + char hex_table[] = "0123456789ABCDEF"; + isize buf_len = name.len + extra; + u8 *buf = gb_alloc_array(gb_heap_allocator(), u8, buf_len); + defer (gb_free(gb_heap_allocator(), buf)); + + isize j = 0; + for (isize i = 0; i < name.len; i++) { + u8 c = name.text[i]; + if (ssa_valid_char(c)) { + buf[j++] = c; + } else { + buf[j] = '\\'; + buf[j+1] = hex_table[c >> 4]; + buf[j+2] = hex_table[c & 0x0f]; + j += 3; + } + } + + ssa_file_write(f, buf, buf_len); +} + + + +void ssa_print_encoded_local(gbFile *f, String name) { + ssa_fprintf(f, "%%"); + ssa_print_escape_string(f, name); +} + +void ssa_print_encoded_global(gbFile *f, String name) { + ssa_fprintf(f, "@"); + ssa_print_escape_string(f, name); +} + + +void ssa_print_type(gbFile *f, BaseTypeSizes s, Type *t) { + i64 word_bits = 8*s.word_size; + GB_ASSERT_NOT_NULL(t); + t = default_type(t); + + switch (t->kind) { + case Type_Basic: + switch (t->basic.kind) { + case Basic_bool: ssa_fprintf(f, "i1"); break; + case Basic_i8: ssa_fprintf(f, "i8"); break; + case Basic_i16: ssa_fprintf(f, "i16"); break; + case Basic_i32: ssa_fprintf(f, "i32"); break; + case Basic_i64: ssa_fprintf(f, "i64"); break; + case Basic_u8: ssa_fprintf(f, "i8"); break; + case Basic_u16: ssa_fprintf(f, "i16"); break; + case Basic_u32: ssa_fprintf(f, "i32"); break; + case Basic_u64: ssa_fprintf(f, "i64"); break; + case Basic_f32: ssa_fprintf(f, "float"); break; + case Basic_f64: ssa_fprintf(f, "double"); break; + case Basic_rawptr: ssa_fprintf(f, "void*"); break; + case Basic_string: ssa_fprintf(f, "{i8*, i%lld}", word_bits); break; + case Basic_uint: ssa_fprintf(f, "i%lld", word_bits); break; + case Basic_int: ssa_fprintf(f, "i%lld", word_bits); break; + } + break; + case Type_Array: + ssa_fprintf(f, "[%lld x ", t->array.count); + ssa_print_type(f, s, t->array.element); + ssa_fprintf(f, "]"); + break; + case Type_Slice: + ssa_fprintf(f, "{"); + ssa_print_type(f, s, t->slice.element); + ssa_fprintf(f, "*, i%lld, i%lld}", word_bits, word_bits); + break; + case Type_Structure: + ssa_fprintf(f, "{"); + for (isize i = 0; i < t->structure.field_count; i++) { + if (i > 0) { + ssa_fprintf(f, ", "); + } + ssa_print_type(f, s, t->structure.fields[i]->type); + } + ssa_fprintf(f, "}"); + break; + case Type_Pointer: + ssa_print_type(f, s, t->pointer.element); + ssa_fprintf(f, "*"); + break; + case Type_Named: + ssa_print_encoded_local(f, t->named.name); + break; + case Type_Alias: + ssa_print_type(f, s, t->alias.base); + break; + case Type_Tuple: + if (t->tuple.variable_count == 1) { + ssa_print_type(f, s, t->tuple.variables[0]->type); + } else { + ssa_fprintf(f, "{"); + for (isize i = 0; i < t->tuple.variable_count; i++) { + if (i > 0) ssa_fprintf(f, ", "); + ssa_print_type(f, s, t->tuple.variables[i]->type); + } + ssa_fprintf(f, "}"); + } + break; + case Type_Procedure: + if (t->procedure.result_count == 0) { + ssa_fprintf(f, "void"); + } else { + ssa_print_type(f, s, t->procedure.results); + } + ssa_fprintf(f, " ("); + for (isize i = 0; i < t->procedure.param_count; i++) { + if (i > 0) { + ssa_fprintf(f, ", "); + } + ssa_print_type(f, s, &t->procedure.params[i]); + } + ssa_fprintf(f, ")*"); + break; + } +} + +void ssa_print_exact_value(gbFile *f, ssaModule *m, ExactValue value, Type *type) { + switch (value.kind) { + case ExactValue_Bool: + ssa_fprintf(f, (value.value_bool ? "true" : "false")); + break; + case ExactValue_String: { + ssa_fprintf(f, "c\""); + ssa_print_escape_string(f, value.value_string); + ssa_fprintf(f, "\""); + } break; + case ExactValue_Integer: + ssa_fprintf(f, "%lld", value.value_integer); + break; + case ExactValue_Float: { + u64 u = 0; + if (is_type_float(type) && type->basic.kind == Basic_f32) { + // IMPORTANT NOTE(bill): LLVM requires all floating point constants to be + // a 64 bit number if bits_of(float type) <= 64. + // To overcome this problem, fill the "bottom" 32 bits with zeros + // https://groups.google.com/forum/#!topic/llvm-dev/IlqV3TbSk6M + f32 fp = cast(f32)value.value_float; + u = *cast(u32 *)&fp; + u <<= 32; + + } else { + u = *cast(u64 *)&value.value_float; + } + ssa_fprintf(f, "0x%llx", u); + } break; + case ExactValue_Pointer: + if (value.value_float == NULL) { + ssa_fprintf(f, "null"); + } else { + GB_PANIC("TODO(bill): ExactValue_Pointer"); + } + break; + default: + GB_PANIC("Invalid ExactValue"); + break; + } +} + +void ssa_print_block_name(gbFile *f, ssaBlock *b) { + ssa_fprintf(f, "\""); + ssa_print_escape_string(f, b->label); + ssa_fprintf(f, " - %d", b->id); + ssa_fprintf(f, "\""); +} + +void ssa_print_value(gbFile *f, ssaModule *m, ssaValue *value, Type *type_hint) { + if (value == NULL) { + ssa_fprintf(f, "!!!NULL_VALUE"); + return; + } + switch (value->kind) { + case ssaValue_Constant: + ssa_print_exact_value(f, m, value->constant.value, type_hint); + break; + case ssaValue_TypeName: + ssa_print_encoded_local(f, value->type_name.entity->token.string); + break; + case ssaValue_Global: + ssa_print_encoded_global(f, value->global.entity->token.string); + break; + case ssaValue_Param: + ssa_print_encoded_local(f, value->param.entity->token.string); + break; + case ssaValue_Proc: + ssa_print_encoded_global(f, value->proc.entity->token.string); + break; + case ssaValue_Instr: + ssa_fprintf(f, "%%%d", value->id); + break; + } +} + +void ssa_print_instr(gbFile *f, ssaModule *m, ssaValue *value) { + GB_ASSERT(value->kind == ssaValue_Instr); + ssaInstr *instr = &value->instr; + + ssa_fprintf(f, "\t"); + switch (instr->kind) { + case ssaInstr_Local: { + Type *type = instr->local.entity->type; + ssa_fprintf(f, "%%%d = alloca ", value->id); + ssa_print_type(f, m->sizes, type); + ssa_fprintf(f, ", align %lld ", type_align_of(m->sizes, gb_heap_allocator(), type)); + { + String str = instr->local.entity->token.string; + if (str.len > 0) + ssa_fprintf(f, "; %.*s", LIT(instr->local.entity->token.string)); + } + ssa_fprintf(f, "\n"); + ssa_fprintf(f, "\tstore "); + ssa_print_type(f, m->sizes, type); + ssa_fprintf(f, " zeroinitializer, "); + ssa_print_type(f, m->sizes, type); + ssa_fprintf(f, "* %%%d\n", value->id); + } break; + + case ssaInstr_Store: { + Type *type = ssa_value_type(instr->store.address); + ssa_fprintf(f, "store "); + ssa_print_type(f, m->sizes, type); + ssa_fprintf(f, " "); + ssa_print_value(f, m, instr->store.value, type); + ssa_fprintf(f, ", "); + ssa_print_type(f, m->sizes, type); + ssa_fprintf(f, "* "); + ssa_print_value(f, m, instr->store.address, type); + ssa_fprintf(f, "\n"); + } break; + + case ssaInstr_Load: { + Type *type = instr->load.type; + ssa_fprintf(f, "%%%d = load ", value->id); + ssa_print_type(f, m->sizes, type); + ssa_fprintf(f, ", "); + ssa_print_type(f, m->sizes, type); + ssa_fprintf(f, "* "); + ssa_print_value(f, m, instr->load.address, type); + ssa_fprintf(f, "\n"); + } break; + + case ssaInstr_GetElementPtr: { + Type *et = instr->get_element_ptr.element_type; + ssa_fprintf(f, "%%%d = getelementptr ", value->id); + if (instr->get_element_ptr.inbounds) + ssa_fprintf(f, "inbounds "); + + ssa_print_type(f, m->sizes, et); + ssa_fprintf(f, ", "); + ssa_print_type(f, m->sizes, et); + ssa_fprintf(f, "* "); + ssa_print_value(f, m, instr->get_element_ptr.address, et); + for (isize i = 0; i < instr->get_element_ptr.index_count; i++) { + ssaValue *index = instr->get_element_ptr.indices[i]; + Type *t = ssa_value_type(index); + ssa_fprintf(f, ", "); + ssa_print_type(f, m->sizes, t); + ssa_fprintf(f, " "); + ssa_print_value(f, m, index, t); + } + ssa_fprintf(f, "\n"); + } break; + + case ssaInstr_Br: { + ssa_fprintf(f, "br "); + if (instr->br.cond != NULL) { + ssa_print_type(f, m->sizes, t_bool); + ssa_fprintf(f, " "); + ssa_print_value(f, m, instr->br.cond, t_bool); + ssa_fprintf(f, ", ", instr->br.cond->id); + } + ssa_fprintf(f, "label "); + ssa_fprintf(f, "%%"); ssa_print_block_name(f, instr->br.true_block); + if (instr->br.false_block != NULL) { + ssa_fprintf(f, ", label "); + ssa_fprintf(f, "%%"); ssa_print_block_name(f, instr->br.false_block); + } + ssa_fprintf(f, "\n"); + } break; + + case ssaInstr_Ret: { + auto *ret = &instr->ret; + ssa_fprintf(f, "ret "); + if (ret->value == NULL) { + ssa_fprintf(f, "void"); + } else { + Type *t = ssa_value_type(ret->value); + ssa_print_type(f, m->sizes, t); + ssa_fprintf(f, " "); + ssa_print_value(f, m, ret->value, t); + } + + ssa_fprintf(f, "\n"); + + } break; + + case ssaInstr_Conv: { + auto *c = &instr->conv; + ssa_fprintf(f, "%%%d = %.*s ", value->id, LIT(ssa_conv_strings[c->kind])); + ssa_print_type(f, m->sizes, c->from); + ssa_fprintf(f, " "); + ssa_print_value(f, m, c->value, c->from); + ssa_fprintf(f, " to "); + ssa_print_type(f, m->sizes, c->to); + ssa_fprintf(f, "\n"); + + } break; + + case ssaInstr_Unreachable: { + ssa_fprintf(f, "unreachable\n"); + } break; + + case ssaInstr_BinaryOp: { + auto *bo = &value->instr.binary_op; + Type *type = ssa_value_type(bo->left); + + ssa_fprintf(f, "%%%d = ", value->id); + + if (gb_is_between(bo->op.kind, Token__ComparisonBegin+1, Token__ComparisonEnd-1)) { + if (is_type_float(type)) { + ssa_fprintf(f, "fcmp "); + switch (bo->op.kind) { + case Token_CmpEq: ssa_fprintf(f, "oeq"); break; + case Token_NotEq: ssa_fprintf(f, "one"); break; + case Token_Lt: ssa_fprintf(f, "olt"); break; + case Token_Gt: ssa_fprintf(f, "ogt"); break; + case Token_LtEq: ssa_fprintf(f, "ole"); break; + case Token_GtEq: ssa_fprintf(f, "oge"); break; + } + } else { + ssa_fprintf(f, "icmp "); + if (bo->op.kind != Token_CmpEq && + bo->op.kind != Token_NotEq) { + if (is_type_unsigned(type)) { + ssa_fprintf(f, "u"); + } else { + ssa_fprintf(f, "s"); + } + } + switch (bo->op.kind) { + case Token_CmpEq: ssa_fprintf(f, "eq"); break; + case Token_NotEq: ssa_fprintf(f, "ne"); break; + case Token_Lt: ssa_fprintf(f, "lt"); break; + case Token_Gt: ssa_fprintf(f, "gt"); break; + case Token_LtEq: ssa_fprintf(f, "le"); break; + case Token_GtEq: ssa_fprintf(f, "ge"); break; + } + } + } else { + if (is_type_float(type)) + ssa_fprintf(f, "f"); + + switch (bo->op.kind) { + case Token_Add: ssa_fprintf(f, "add"); break; + case Token_Sub: ssa_fprintf(f, "sub"); break; + case Token_And: ssa_fprintf(f, "and"); break; + case Token_Or: ssa_fprintf(f, "or"); break; + case Token_Xor: ssa_fprintf(f, "xor"); break; + + case Token_AndNot: GB_PANIC("Token_AndNot Should never be called"); + + case Token_Mul: ssa_fprintf(f, "mul"); break; + + default: { + if (!is_type_float(type)) { + if (is_type_unsigned(type)) ssa_fprintf(f, "u"); + else ssa_fprintf(f, "s"); + } + + switch (bo->op.kind) { + case Token_Quo: ssa_fprintf(f, "div"); break; + case Token_Mod: ssa_fprintf(f, "rem"); break; + } + } break; + } + } + + ssa_fprintf(f, " "); + ssa_print_type(f, m->sizes, type); + ssa_fprintf(f, " "); + ssa_print_value(f, m, bo->left, type); + ssa_fprintf(f, ", "); + ssa_print_value(f, m, bo->right, type); + ssa_fprintf(f, "\n"); + + } break; + + case ssaInstr_Call: { + auto *call = &instr->call; + if (call->type) { + ssa_fprintf(f, "%%%d = ", value->id); + } + ssa_fprintf(f, "call "); + if (call->type) { + ssa_print_type(f, m->sizes, call->type); + } else { + ssa_fprintf(f, "void"); + } + ssa_fprintf(f, " "); + ssa_print_value(f, m, call->value, call->type); + + + ssa_fprintf(f, "("); + for (isize i = 0; i < call->arg_count; i++) { + ssaValue *arg = call->args[i]; + Type *t = ssa_value_type(arg); + if (i > 0) { + ssa_fprintf(f, ", "); + } + ssa_print_type(f, m->sizes, t); + ssa_fprintf(f, " "); + ssa_print_value(f, m, arg, t); + } + ssa_fprintf(f, ")\n"); + + } break; + + default: + ssa_fprintf(f, "; %d\n", instr->kind); + break; + } +} + +void ssa_print_llvm_ir(gbFile *f, ssaModule *m) { + if (m->layout.len > 0) { + ssa_fprintf(f, "target datalayout = %.*s\n", LIT(m->layout)); + } + + gb_for_array(member_index, m->members.entries) { + auto *entry = &m->members.entries[member_index]; + ssaValue *v = entry->value; + switch (v->kind) { + case ssaValue_TypeName: { + ssa_print_encoded_local(f, v->type_name.entity->token.string); + ssa_fprintf(f, " = type "); + ssa_print_type(f, m->sizes, get_base_type(v->type_name.type)); + ssa_fprintf(f, "\n"); + } break; + + case ssaValue_Global: { + auto *g = &v->global; + ssa_print_encoded_global(f, g->entity->token.string); + ssa_fprintf(f, " = "); + if (g->is_constant) { + ssa_fprintf(f, "private constant "); + } else { + ssa_fprintf(f, "global "); + } + + ssa_print_type(f, m->sizes, get_base_type(g->entity->type)); + ssa_fprintf(f, " "); + ssa_print_value(f, m, g->value, g->entity->type); + ssa_fprintf(f, "\n"); + } break; + + case ssaValue_Proc: { + ssaProcedure *proc = &v->proc; + if (proc->body == NULL) { + ssa_fprintf(f, "declare "); + } else { + ssa_fprintf(f, "define "); + } + + auto *proc_type = &proc->entity->type->procedure; + + if (proc_type->result_count == 0) { + ssa_fprintf(f, "void"); + } else { + ssa_print_type(f, m->sizes, proc_type->results); + } + + ssa_fprintf(f, " "); + + ssa_print_encoded_global(f, proc->name); + ssa_fprintf(f, "("); + + if (proc_type->param_count > 0) { + auto *params = &proc_type->params->tuple; + for (isize i = 0; i < params->variable_count; i++) { + Entity *e = params->variables[i]; + if (i > 0) + ssa_fprintf(f, ", "); + ssa_print_type(f, m->sizes, e->type); + ssa_fprintf(f, " %%%.*s", LIT(e->token.string)); + } + } + + ssa_fprintf(f, ") "); + + if (proc->body == NULL) { + ssa_fprintf(f, "\n"); + } else { + ssa_fprintf(f, "{\n"); + gb_for_array(i, proc->blocks) { + ssaBlock *block = proc->blocks[i]; + + if (i > 0) ssa_fprintf(f, "\n"); + ssa_print_block_name(f, block); + ssa_fprintf(f, ":\n"); + + gb_for_array(j, block->instrs) { + ssaValue *value = block->instrs[j]; + ssa_print_instr(f, m, value); + } + } + ssa_fprintf(f, "}\n\n"); + } + + } break; + } + } +} diff --git a/src/codegen/ssa.cpp b/src/codegen/ssa.cpp index b387df1fc..db91a4093 100644 --- a/src/codegen/ssa.cpp +++ b/src/codegen/ssa.cpp @@ -59,7 +59,7 @@ struct ssaProcedure { SSA_INSTR_KIND(Store), \ SSA_INSTR_KIND(Load), \ SSA_INSTR_KIND(GetElementPtr), \ - SSA_INSTR_KIND(Convert), \ + SSA_INSTR_KIND(Conv), \ SSA_INSTR_KIND(Br), \ SSA_INSTR_KIND(Ret), \ SSA_INSTR_KIND(Unreachable), \ @@ -79,20 +79,31 @@ String const ssa_instr_strings[] = { #undef SSA_INSTR_KIND }; -enum ssaConversionKind { - ssaConversion_Invalid, - - ssaConversion_ZExt, - ssaConversion_FPExt, - ssaConversion_FPToUI, - ssaConversion_FPToSI, - ssaConversion_UIToFP, - ssaConversion_SIToFP, - ssaConversion_PtrToInt, - ssaConversion_IntToPtr, - ssaConversion_BitCast, +#define SSA_CONV_KINDS \ + SSA_CONV_KIND(Invalid), \ + SSA_CONV_KIND(trunc), \ + SSA_CONV_KIND(zext), \ + SSA_CONV_KIND(fptrunc), \ + SSA_CONV_KIND(fpext), \ + SSA_CONV_KIND(fptoui), \ + SSA_CONV_KIND(fptosi), \ + SSA_CONV_KIND(uitofp), \ + SSA_CONV_KIND(sitofp), \ + SSA_CONV_KIND(ptrtoint), \ + SSA_CONV_KIND(inttoptr), \ + SSA_CONV_KIND(bitcast), \ + SSA_CONV_KIND(Count) + +enum ssaConvKind { +#define SSA_CONV_KIND(x) GB_JOIN2(ssaConv_, x) + SSA_CONV_KINDS +#undef SSA_CONV_KIND +}; - ssaConversion_Count, +String const ssa_conv_strings[] = { +#define SSA_CONV_KIND(x) {cast(u8 *)#x, gb_size_of(#x)-1} + SSA_CONV_KINDS +#undef SSA_CONV_KIND }; struct ssaInstr { @@ -124,10 +135,10 @@ struct ssaInstr { b32 inbounds; } get_element_ptr; struct { - ssaConversionKind kind; + ssaConvKind kind; ssaValue *value; Type *from, *to; - } conversion; + } conv; struct { ssaValue *cond; ssaBlock *true_block; @@ -266,6 +277,8 @@ Type *ssa_instr_type(ssaInstr *instr) { return instr->get_element_ptr.result_type; case ssaInstr_BinaryOp: return instr->binary_op.type; + case ssaInstr_Conv: + return instr->conv.to; } return NULL; } @@ -287,6 +300,9 @@ void ssa_instr_set_type(ssaInstr *instr, Type *type) { case ssaInstr_BinaryOp: instr->binary_op.type = type; break; + case ssaInstr_Conv: + instr->conv.to = type; + break; } } @@ -481,6 +497,18 @@ ssaValue *ssa_make_instr_call(ssaProcedure *p, ssaValue *value, ssaValue **args, return v; } +ssaValue *ssa_make_instr_conv(ssaProcedure *p, ssaConvKind kind, ssaValue *value, Type *from, Type *to) { + ssaValue *v = ssa_alloc_instr(p->module->allocator, ssaInstr_Conv); + v->instr.conv.kind = kind; + v->instr.conv.value = value; + v->instr.conv.from = from; + v->instr.conv.to = to; + if (p->curr_block) { + gb_array_append(p->curr_block->values, v); + } + return v; +} + @@ -736,16 +764,73 @@ ssaValue *ssa_emit_conv(ssaProcedure *proc, ssaValue *value, Type *t) { if (are_types_identical(t, src_type)) return value; - Type *dst = get_base_type(t); Type *src = get_base_type(src_type); + Type *dst = get_base_type(t); if (value->kind == ssaValue_Constant) { if (dst->kind == Type_Basic) return ssa_make_value_constant(proc->module->allocator, t, value->constant.value); } + // integer -> integer + if (is_type_integer(src) && is_type_integer(dst)) { + i64 sz = basic_type_sizes[src->basic.kind]; + i64 dz = basic_type_sizes[dst->basic.kind]; + ssaConvKind kind = ssaConv_trunc; + if (dz >= sz) { + kind = ssaConv_zext; + } + return ssa_emit(proc, ssa_make_instr_conv(proc, kind, value, src, dst)); + } + + // float -> float + if (is_type_float(src) && is_type_float(dst)) { + i64 sz = basic_type_sizes[src->basic.kind]; + i64 dz = basic_type_sizes[dst->basic.kind]; + ssaConvKind kind = ssaConv_fptrunc; + if (dz >= sz) { + kind = ssaConv_fpext; + } + return ssa_emit(proc, ssa_make_instr_conv(proc, kind, value, src, dst)); + } + + // float -> integer + if (is_type_float(src) && is_type_integer(dst)) { + ssaConvKind kind = ssaConv_fptosi; + if (is_type_unsigned(dst)) { + kind = ssaConv_fptoui; + } + return ssa_emit(proc, ssa_make_instr_conv(proc, kind, value, src, dst)); + } + + // integer -> float + if (is_type_integer(src) && is_type_float(dst)) { + ssaConvKind kind = ssaConv_sitofp; + if (is_type_unsigned(dst)) { + kind = ssaConv_uitofp; + } + return ssa_emit(proc, ssa_make_instr_conv(proc, kind, value, src, dst)); + } + + // Pointer to int + if (is_type_pointer(src) && is_type_integer(dst)) { + return ssa_emit(proc, ssa_make_instr_conv(proc, ssaConv_ptrtoint, value, src, dst)); + } + + // int to Pointer + if (is_type_integer(src) && is_type_pointer(dst)) { + return ssa_emit(proc, ssa_make_instr_conv(proc, ssaConv_inttoptr, value, src, dst)); + } + + // Pointer to Pointer + if (is_type_pointer(src) && is_type_pointer(dst)) { + return ssa_emit(proc, ssa_make_instr_conv(proc, ssaConv_bitcast, value, src, dst)); + } + GB_PANIC("TODO(bill): ssa_emit_conv"); + GB_PANIC("TODO(bill): string -> []byte"); + GB_PANIC("TODO(bill): []byte -> string"); return NULL; } @@ -930,6 +1015,32 @@ ssaValue *ssa_emit_slice(ssaProcedure *proc, Type *slice_type, ssaValue *base, s return ssa_emit_load(proc, slice); } +ssaValue *ssa_emit_substring(ssaProcedure *proc, ssaValue *base, ssaValue *low, ssaValue *high) { + Type *bt = get_base_type(ssa_value_type(base)); + GB_ASSERT(bt == t_string); + if (low == NULL) { + low = v_zero; + } + if (high == NULL) { + high = ssa_string_len(proc, base); + } + + Token op_sub = {Token_Sub}; + ssaValue *len = ssa_emit_arith(proc, op_sub, high, low, t_int); + + ssaValue *elem = ssa_string_elem(proc, base); + elem = ssa_emit_ptr_offset(proc, elem, low); + + ssaValue *str = ssa_add_local_generated(proc, t_string); + ssaValue *gep = NULL; + gep = ssa_emit_struct_gep(proc, str, v_zero32, ssa_value_type(elem)); + ssa_emit_store(proc, gep, elem); + + gep = ssa_emit_struct_gep(proc, str, v_one32, t_int); + ssa_emit_store(proc, gep, len); + + return ssa_emit_load(proc, str); +} ssaValue *ssa_add_global_string_array(ssaProcedure *proc, ExactValue value) { @@ -944,13 +1055,11 @@ ssaValue *ssa_add_global_string_array(ssaProcedure *proc, ExactValue value) { String name = make_string(str, len-1); Token token = {Token_String}; token.string = name; - // TODO(bill): unquote function - Type *type = make_type_array(a, t_u8, value.value_string.len-2); + Type *type = make_type_array(a, t_u8, value.value_string.len); Entity *entity = make_entity_constant(a, NULL, token, type, value); ssaValue *v = ssa_make_value_constant(a, type, value); ssaValue *g = ssa_make_value_global(a, entity, v); - g->global.is_constant = true; map_set(&proc->module->values, hash_pointer(entity), g); map_set(&proc->module->members, hash_string(name), g); @@ -971,39 +1080,6 @@ ssaValue *ssa_emit_string(ssaProcedure *proc, ssaValue *elem, ssaValue *len) { return ssa_emit_load(proc, str); } -ssaValue *ssa_emit_call(ssaProcedure *proc, AstNode *expr, Type *result_type) { - ast_node(ce, CallExpr, expr); - - ssaValue *value = ssa_build_expr(proc, ce->proc); - Type *proc_type_ = ssa_value_type(value); - GB_ASSERT(proc_type_->kind == Type_Procedure); - auto *type = &proc_type_->procedure; - - isize arg_index = 0; - isize arg_count = type->param_count; - ssaValue **args = gb_alloc_array(proc->module->allocator, ssaValue *, arg_count); - - for (AstNode *arg = ce->arg_list; arg != NULL; arg = arg->next) { - ssaValue *a = ssa_build_expr(proc, arg); - Type *at = ssa_value_type(a); - if (at->kind == Type_Tuple) { - GB_PANIC("TODO(bill): tuple call arguments"); - } else { - args[arg_index++] = a; - } - } - - for (isize i = 0; i < arg_count; i++) { - Entity *e = type->params->tuple.variables[i]; - args[i] = ssa_emit_conv(proc, args[i], e->type); - } - - ssaValue *call = ssa_make_instr_call(proc, value, args, arg_count, result_type); - return ssa_emit(proc, call); -} - - - ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue *tv) { switch (expr->kind) { @@ -1105,7 +1181,8 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue case_end; case_ast_node(ce, CastExpr, expr); - GB_PANIC("TODO(bill): ssa_build_single_expr CastExpr"); + ssaValue *v = ssa_build_expr(proc, ce->expr); + return ssa_emit_conv(proc, v, tv->type); case_end; case_ast_node(ce, CallExpr, expr); @@ -1113,33 +1190,90 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue if (p->kind == AstNode_Ident) { Entity **found = map_get(&proc->module->info->uses, hash_pointer(p)); if (found && (*found)->kind == Entity_Builtin) { - GB_PANIC("TODO(bill): CallExpr Builtin"); + Entity *e = *found; + switch (e->builtin.id) { + case BuiltinProcedure_len: { + ssaValue *v = ssa_lvalue_address(ssa_build_addr(proc, ce->arg_list), proc); + Type *t = get_base_type(ssa_value_type(v)); + if (t == t_string) + return ssa_string_len(proc, v); + else if (t->kind == Type_Slice) + return ssa_slice_len(proc, v); + } break; + case BuiltinProcedure_cap: { + ssaValue *v = ssa_lvalue_address(ssa_build_addr(proc, ce->arg_list), proc); + Type *t = get_base_type(ssa_value_type(v)); + if (t == t_string) + return ssa_string_cap(proc, v); + else if (t->kind == Type_Slice) + return ssa_slice_cap(proc, v); + } break; + case BuiltinProcedure_copy: { + GB_PANIC("TODO(bill): BuiltinProcedure_copy"); + } break; + case BuiltinProcedure_print: { + GB_PANIC("TODO(bill): BuiltinProcedure_print"); + } break; + case BuiltinProcedure_println: { + GB_PANIC("TODO(bill): BuiltinProcedure_println"); + } break; + } } } - return ssa_emit_call(proc, expr, tv->type); + + // NOTE(bill): Regular call + ssaValue *value = ssa_build_expr(proc, ce->proc); + Type *proc_type_ = ssa_value_type(value); + GB_ASSERT(proc_type_->kind == Type_Procedure); + auto *type = &proc_type_->procedure; + + isize arg_index = 0; + isize arg_count = type->param_count; + ssaValue **args = gb_alloc_array(proc->module->allocator, ssaValue *, arg_count); + + for (AstNode *arg = ce->arg_list; arg != NULL; arg = arg->next) { + ssaValue *a = ssa_build_expr(proc, arg); + Type *at = ssa_value_type(a); + if (at->kind == Type_Tuple) { + GB_PANIC("TODO(bill): tuple call arguments"); + } else { + args[arg_index++] = a; + } + } + + for (isize i = 0; i < arg_count; i++) { + Entity *e = type->params->tuple.variables[i]; + args[i] = ssa_emit_conv(proc, args[i], e->type); + } + + ssaValue *call = ssa_make_instr_call(proc, value, args, arg_count, tv->type); + return ssa_emit(proc, call); case_end; case_ast_node(se, SliceExpr, expr); - ssaValue *base = NULL; ssaValue *low = NULL; ssaValue *high = NULL; ssaValue *max = NULL; - switch (tv->type->kind) { - case Type_Slice: - case Type_Array: - base = ssa_lvalue_address(ssa_build_addr(proc, se->expr), proc); - break; - case Type_Basic: - GB_PANIC("SliceExpr Type_Basic"); - break; - } if (se->low != NULL) low = ssa_build_expr(proc, se->low); if (se->high != NULL) high = ssa_build_expr(proc, se->high); if (se->triple_indexed) max = ssa_build_expr(proc, se->max); - return ssa_emit_slice(proc, tv->type, base, low, high, max); + switch (tv->type->kind) { + case Type_Slice: + case Type_Array: { + ssaValue *base = ssa_lvalue_address(ssa_build_addr(proc, se->expr), proc); + return ssa_emit_slice(proc, tv->type, base, low, high, max); + } break; + case Type_Basic: { + // NOTE(bill): max is not needed + ssaValue *base = ssa_lvalue_address(ssa_build_addr(proc, se->expr), proc); + return ssa_emit_substring(proc, base, low, high); + } break; + } + + GB_PANIC("Unknown slicable type"); case_end; case_ast_node(ie, IndexExpr, expr); @@ -1234,17 +1368,17 @@ ssaLvalue ssa_build_addr(ssaProcedure *proc, AstNode *expr) { ssaValue *elem = ssa_slice_elem(proc, slice); v = ssa_emit_ptr_offset(proc, elem, index); } break; - case Type_Pointer: { - ssaValue *ptr = ssa_emit_load(proc, ssa_lvalue_address(ssa_build_addr(proc, ie->expr), proc)); - ssaValue *index = ssa_emit_conv(proc, ssa_build_expr(proc, ie->index), t_int); - v = ssa_emit_ptr_offset(proc, ptr, index); - } break; - case Type_Basic: { // string + case Type_Basic: { // Basic_string ssaValue *str = ssa_lvalue_address(ssa_build_addr(proc, ie->expr), proc); ssaValue *index = ssa_emit_conv(proc, ssa_build_expr(proc, ie->index), t_int); ssaValue *elem = ssa_string_elem(proc, str); v = ssa_emit_ptr_offset(proc, elem, index); } break; + case Type_Pointer: { + ssaValue *ptr = ssa_emit_load(proc, ssa_lvalue_address(ssa_build_addr(proc, ie->expr), proc)); + ssaValue *index = ssa_emit_conv(proc, ssa_build_expr(proc, ie->index), t_int); + v = ssa_emit_ptr_offset(proc, ptr, index); + } break; } // NOTE(bill): lvalue address encodes the pointer, thus the deref @@ -1318,12 +1452,12 @@ void ssa_build_stmt_list(ssaProcedure *proc, AstNode *list) { ssa_build_stmt(proc, stmt); } -void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { - switch (s->kind) { - case_ast_node(bs, EmptyStmt, s); +void ssa_build_stmt(ssaProcedure *proc, AstNode *node) { + switch (node->kind) { + case_ast_node(bs, EmptyStmt, node); case_end; - case_ast_node(vd, VarDecl, s); + case_ast_node(vd, VarDecl, node); if (vd->kind == Declaration_Mutable) { if (vd->name_count == vd->value_count) { // 1:1 assigment gbArray(ssaLvalue) lvals; @@ -1365,7 +1499,7 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { } case_end; - case_ast_node(ids, IncDecStmt, s); + case_ast_node(ids, IncDecStmt, node); Token op = ids->op; if (op.kind == Token_Increment) { op.kind = Token_Add; @@ -1378,7 +1512,7 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { case_end; - case_ast_node(as, AssignStmt, s); + case_ast_node(as, AssignStmt, node); switch (as->op.kind) { case Token_Eq: { gbArray(ssaLvalue) lvals; @@ -1397,7 +1531,6 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { if (as->lhs_count == as->rhs_count) { if (as->lhs_count == 1) { - AstNode *lhs = as->lhs_list; AstNode *rhs = as->rhs_list; ssaValue *init = ssa_build_expr(proc, rhs); ssa_lvalue_store(lvals[0], proc, init); @@ -1435,19 +1568,20 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { } case_end; - case_ast_node(es, ExprStmt, s); - ssaValue *value = ssa_build_expr(proc, es->expr); + case_ast_node(es, ExprStmt, node); + // NOTE(bill): No need to use return value + ssa_build_expr(proc, es->expr); case_end; - case_ast_node(bs, BlockStmt, s) + case_ast_node(bs, BlockStmt, node); ssa_build_stmt_list(proc, bs->list); case_end; - case_ast_node(bs, DeferStmt, s); + case_ast_node(bs, DeferStmt, node); GB_PANIC("DeferStmt"); case_end; - case_ast_node(rs, ReturnStmt, s); + case_ast_node(rs, ReturnStmt, node); ssaValue *v = NULL; auto *return_type_tuple = &proc->type->procedure.results->tuple; isize return_count = proc->type->procedure.result_count; @@ -1482,12 +1616,12 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { case_end; - case_ast_node(is, IfStmt, s); + case_ast_node(is, IfStmt, node); if (is->init != NULL) { ssa_build_stmt(proc, is->init); } - ssaBlock *then = ssa_add_block(proc, s, make_string("if.then")); - ssaBlock *done = ssa__make_block(proc, s, make_string("if.done")); // NOTE(bill): Append later + ssaBlock *then = ssa_add_block(proc, node, make_string("if.then")); + ssaBlock *done = ssa__make_block(proc, node, make_string("if.done")); // NOTE(bill): Append later ssaBlock *else_ = done; if (is->else_stmt != NULL) { else_ = ssa_add_block(proc, is->else_stmt, make_string("if.else")); @@ -1507,21 +1641,21 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { proc->curr_block = done; case_end; - case_ast_node(fs, ForStmt, s); + case_ast_node(fs, ForStmt, node); if (fs->init != NULL) { ssa_build_stmt(proc, fs->init); } - ssaBlock *body = ssa_add_block(proc, s, make_string("for.body")); - ssaBlock *done = ssa__make_block(proc, s, make_string("for.done")); // NOTE(bill): Append later + ssaBlock *body = ssa_add_block(proc, node, make_string("for.body")); + ssaBlock *done = ssa__make_block(proc, node, make_string("for.done")); // NOTE(bill): Append later ssaBlock *loop = body; if (fs->cond != NULL) { - loop = ssa_add_block(proc, fs->cond, make_string("for.loop")); + loop = ssa_add_block(proc, node, make_string("for.loop")); } ssaBlock *cont = loop; if (fs->post != NULL) { - cont = ssa_add_block(proc, fs->cond, make_string("for.post")); + cont = ssa_add_block(proc, node, make_string("for.post")); } ssa_emit_jump(proc, loop); proc->curr_block = loop; @@ -1545,7 +1679,7 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { case_end; - case_ast_node(bs, BranchStmt, s); + case_ast_node(bs, BranchStmt, node); ssaBlock *block = NULL; switch (bs->token.kind) { #define BRANCH_GET_BLOCK(kind_) \ @@ -1557,6 +1691,7 @@ void ssa_build_stmt(ssaProcedure *proc, AstNode *s) { BRANCH_GET_BLOCK(break); BRANCH_GET_BLOCK(continue); BRANCH_GET_BLOCK(fallthrough); + #undef BRANCH_GET_BLOCK } ssa_emit_jump(proc, block); ssa_emit_unreachable(proc); -- cgit v1.2.3