6559 lines
280 KiB
C++
6559 lines
280 KiB
C++
#include <compiler.h>
|
|
#include <llvm.h>
|
|
|
|
enum class EvaluationKind
|
|
{
|
|
scalar,
|
|
aggregate,
|
|
complex,
|
|
};
|
|
|
|
enum class TypeKind
|
|
{
|
|
abi,
|
|
memory,
|
|
};
|
|
|
|
fn EvaluationKind get_evaluation_kind(Type* type)
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::void_type:
|
|
case TypeId::noreturn:
|
|
case TypeId::forward_declaration:
|
|
case TypeId::unresolved:
|
|
case TypeId::function:
|
|
case TypeId::alias:
|
|
unreachable();
|
|
case TypeId::integer:
|
|
case TypeId::pointer:
|
|
case TypeId::bits:
|
|
case TypeId::enumerator:
|
|
return EvaluationKind::scalar;
|
|
case TypeId::array:
|
|
case TypeId::structure:
|
|
case TypeId::union_type:
|
|
return EvaluationKind::aggregate;
|
|
default:
|
|
unreachable();
|
|
}
|
|
}
|
|
|
|
fn bool type_is_aggregate_type_for_abi(Type* type)
|
|
{
|
|
auto evaluation_kind = get_evaluation_kind(type);
|
|
auto is_member_function_pointer_type = false; // TODO
|
|
return evaluation_kind != EvaluationKind::scalar || is_member_function_pointer_type;
|
|
}
|
|
|
|
fn u64 get_byte_allocation_size(Type* type)
|
|
{
|
|
auto size = get_byte_size(type);
|
|
auto alignment = get_byte_alignment(type);
|
|
auto result = align_forward(size, alignment);
|
|
return result;
|
|
}
|
|
|
|
struct LLVMGlobal
|
|
{
|
|
String host_triple;
|
|
String host_cpu_model;
|
|
String host_cpu_features;
|
|
};
|
|
|
|
global_variable LLVMGlobal llvm_global;
|
|
|
|
fn bool type_is_signed(Type* type)
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::integer:
|
|
return type->integer.is_signed;
|
|
case TypeId::enumerator:
|
|
return type_is_signed(type->enumerator.backing_type);
|
|
case TypeId::bits:
|
|
return type_is_signed(type->bits.backing_type);
|
|
case TypeId::pointer: // TODO: pointers should be signed?
|
|
return false;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn bool type_is_slice(Type* type)
|
|
{
|
|
return type->id == TypeId::structure && type->structure.is_slice;
|
|
}
|
|
|
|
fn bool is_integral_or_enumeration_type(Type* type)
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::alias: return is_integral_or_enumeration_type(type->alias.type);
|
|
case TypeId::integer:
|
|
case TypeId::bits:
|
|
return true;
|
|
case TypeId::structure:
|
|
return false;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn Type* align_integer_type(Module* module, Type* type)
|
|
{
|
|
auto bit_count = (u32)get_bit_size(type);
|
|
auto abi_bit_count = align_bit_count(bit_count);
|
|
bool is_signed = type_is_signed(type);
|
|
auto result = integer_type(module, { .bit_count = abi_bit_count, .is_signed = is_signed });
|
|
return result;
|
|
}
|
|
|
|
fn bool is_promotable_integer_type_for_abi(Type* type)
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::integer: return type->integer.bit_count < 32;
|
|
case TypeId::bits: return is_promotable_integer_type_for_abi(type->bits.backing_type);
|
|
case TypeId::alias: return is_promotable_integer_type_for_abi(type->alias.type);
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn void llvm_initialize_all_raw()
|
|
{
|
|
assert(!llvm_initialized);
|
|
|
|
LLVMInitializeX86TargetInfo();
|
|
LLVMInitializeX86Target();
|
|
LLVMInitializeX86TargetMC();
|
|
LLVMInitializeX86AsmPrinter();
|
|
LLVMInitializeX86AsmParser();
|
|
LLVMInitializeX86Disassembler();
|
|
|
|
llvm_global = {
|
|
.host_triple = llvm_default_target_triple(),
|
|
.host_cpu_model = llvm_host_cpu_name(),
|
|
.host_cpu_features = llvm_host_cpu_features(),
|
|
};
|
|
}
|
|
|
|
fn void llvm_initialize_all()
|
|
{
|
|
if (!llvm_initialized)
|
|
{
|
|
llvm_initialize_all_raw();
|
|
}
|
|
}
|
|
|
|
fn bool is_arbitrary_bit_integer(Type* type)
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::integer: switch (type->integer.bit_count)
|
|
{
|
|
case 8:
|
|
case 16:
|
|
case 32:
|
|
case 64:
|
|
case 128:
|
|
return false;
|
|
default: return true;
|
|
} break;
|
|
case TypeId::unresolved: unreachable();
|
|
case TypeId::bits: return is_arbitrary_bit_integer(type->bits.backing_type);
|
|
case TypeId::enumerator: return is_arbitrary_bit_integer(type->enumerator.backing_type);
|
|
default: return false;
|
|
}
|
|
|
|
}
|
|
|
|
fn u64 integer_max_value(u32 bit_count, bool is_signed)
|
|
{
|
|
auto max_value = bit_count == 64 ? ~(u64)0 : ((u64)1 << (bit_count - is_signed)) - 1;
|
|
return max_value;
|
|
}
|
|
|
|
fn void dump_module(Module* module)
|
|
{
|
|
print(llvm_module_to_string(module->llvm.module));
|
|
}
|
|
|
|
fn void emit_value(Module* module, Value* value, TypeKind type_kind);
|
|
|
|
fn LLVMCallConv llvm_calling_convention(CallingConvention calling_convention)
|
|
{
|
|
LLVMCallConv cc;
|
|
switch (calling_convention)
|
|
{
|
|
case CallingConvention::c: cc = LLVMCCallConv; break;
|
|
case CallingConvention::count: unreachable();
|
|
}
|
|
|
|
return cc;
|
|
}
|
|
|
|
fn Type* resolve_alias(Module* module, Type* type)
|
|
{
|
|
Type* result_type = 0;
|
|
switch (type->id)
|
|
{
|
|
case TypeId::pointer:
|
|
{
|
|
auto* element_type = type->pointer.element_type;
|
|
auto* resolved_element_type = resolve_alias(module, element_type);
|
|
result_type = get_pointer_type(module, resolved_element_type);
|
|
} break;
|
|
case TypeId::array:
|
|
{
|
|
auto* element_type = type->array.element_type;
|
|
auto element_count = type->array.element_count;
|
|
assert(element_count);
|
|
auto* resolved_element_type = resolve_alias(module, element_type);
|
|
result_type = get_array_type(module, resolved_element_type, element_count);
|
|
} break;
|
|
case TypeId::void_type:
|
|
case TypeId::noreturn:
|
|
case TypeId::integer:
|
|
case TypeId::enumerator:
|
|
case TypeId::function:
|
|
case TypeId::bits:
|
|
{
|
|
result_type = type;
|
|
} break;
|
|
case TypeId::structure:
|
|
{
|
|
if (type->structure.is_slice)
|
|
{
|
|
auto element_type = resolve_alias(module, type->structure.fields[0].type->pointer.element_type);
|
|
result_type = get_slice_type(module, element_type);
|
|
}
|
|
else
|
|
{
|
|
result_type = type;
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(result_type);
|
|
return result_type;
|
|
}
|
|
|
|
fn void llvm_initialize(Module* module)
|
|
{
|
|
llvm_initialize_all();
|
|
|
|
auto context = LLVMContextCreate();
|
|
auto m = llvm_context_create_module(context, module->name);
|
|
auto builder = LLVMCreateBuilderInContext(context);
|
|
LLVMDIBuilderRef di_builder = 0;
|
|
LLVMMetadataRef di_compile_unit = 0;
|
|
LLVMMetadataRef di_file = 0;
|
|
|
|
if (module->has_debug_info)
|
|
{
|
|
di_builder = LLVMCreateDIBuilder(m);
|
|
auto last_slash = string_last_character(module->path, '/');
|
|
if (last_slash == string_no_match)
|
|
{
|
|
report_error();
|
|
}
|
|
auto directory = module->path(0, last_slash);
|
|
auto file_name = module->path(last_slash + 1);
|
|
di_file = LLVMDIBuilderCreateFile(di_builder, (char*)file_name.pointer, file_name.length, (char*)directory.pointer, directory.length);
|
|
auto producer_name = string_literal("bloat buster");
|
|
auto is_optimized = build_mode_is_optimized(module->build_mode);
|
|
auto flags = string_literal("");
|
|
u32 runtime_version = 0;
|
|
auto split_name = string_literal("");
|
|
auto sysroot = string_literal("");
|
|
auto sdk = string_literal("");
|
|
di_compile_unit = LLVMDIBuilderCreateCompileUnit(di_builder, LLVMDWARFSourceLanguageC17, di_file, (char*)producer_name.pointer, producer_name.length, is_optimized, (char*)flags.pointer, flags.length, runtime_version, (char*)split_name.pointer, split_name.length, LLVMDWARFEmissionFull, 0, 0, is_optimized, (char*)sysroot.pointer, sysroot.length, (char*)sdk.pointer, sdk.length);
|
|
module->scope.llvm = di_compile_unit;
|
|
}
|
|
|
|
module->llvm = {
|
|
.context = context,
|
|
.module = m,
|
|
.builder = builder,
|
|
.di_builder = di_builder,
|
|
.file = di_file,
|
|
.compile_unit = di_compile_unit,
|
|
.pointer_type = LLVMPointerTypeInContext(context, 0),
|
|
.void_type = LLVMVoidTypeInContext(context),
|
|
};
|
|
|
|
for (u64 i = 0; i < (u64)IntrinsicIndex::count; i += 1)
|
|
{
|
|
String name = intrinsic_names[i];
|
|
module->llvm.intrinsic_table[i].n = LLVMLookupIntrinsicID((char*)name.pointer, name.length);
|
|
}
|
|
}
|
|
|
|
enum class AbiSystemVClass
|
|
{
|
|
none,
|
|
integer,
|
|
sse,
|
|
sse_up,
|
|
x87,
|
|
x87_up,
|
|
complex_x87,
|
|
memory,
|
|
};
|
|
|
|
struct AbiSystemVClassifyResult
|
|
{
|
|
AbiSystemVClass r[2];
|
|
};
|
|
|
|
|
|
// AMD64-ABI 3.2.3p2: Rule 4. Each field of an object is
|
|
// classified recursively so that always two fields are
|
|
// considered. The resulting class is calculated according to
|
|
// the classes of the fields in the eightbyte:
|
|
//
|
|
// (a) If both classes are equal, this is the resulting class.
|
|
//
|
|
// (b) If one of the classes is NO_CLASS, the resulting class is
|
|
// the other class.
|
|
//
|
|
// (c) If one of the classes is MEMORY, the result is the MEMORY
|
|
// class.
|
|
//
|
|
// (d) If one of the classes is INTEGER, the result is the
|
|
// INTEGER.
|
|
//
|
|
// (e) If one of the classes is X87, X87UP, COMPLEX_X87 class,
|
|
// MEMORY is used as class.
|
|
//
|
|
// (f) Otherwise class SSE is used.
|
|
|
|
// Accum should never be memory (we should have returned) or
|
|
// ComplexX87 (because this cannot be passed in a structure).
|
|
fn AbiSystemVClass abi_system_v_merge_class(AbiSystemVClass accumulator, AbiSystemVClass field)
|
|
{
|
|
assert(accumulator != AbiSystemVClass::memory && accumulator != AbiSystemVClass::complex_x87);
|
|
|
|
if (accumulator == field || field == AbiSystemVClass::none)
|
|
{
|
|
return accumulator;
|
|
}
|
|
|
|
if (field == AbiSystemVClass::memory)
|
|
{
|
|
return AbiSystemVClass::memory;
|
|
}
|
|
|
|
if (accumulator == AbiSystemVClass::integer || field == AbiSystemVClass::integer)
|
|
{
|
|
return AbiSystemVClass::integer;
|
|
}
|
|
|
|
if (field == AbiSystemVClass::x87 || field == AbiSystemVClass::x87_up || field == AbiSystemVClass::complex_x87 || accumulator == AbiSystemVClass::x87 || accumulator == AbiSystemVClass::x87_up)
|
|
{
|
|
return AbiSystemVClass::memory;
|
|
}
|
|
|
|
return AbiSystemVClass::sse;
|
|
}
|
|
|
|
fn AbiSystemVClassifyResult abi_system_v_classify_post_merge(u64 aggregate_size, AbiSystemVClassifyResult classes)
|
|
{
|
|
AbiSystemVClassifyResult result = classes;
|
|
|
|
if (result.r[1] == AbiSystemVClass::memory)
|
|
{
|
|
result.r[0] = AbiSystemVClass::memory;
|
|
}
|
|
|
|
if (result.r[1] == AbiSystemVClass::x87_up)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
if (aggregate_size > 16 && (result.r[0] != AbiSystemVClass::sse || result.r[1] != AbiSystemVClass::sse_up))
|
|
{
|
|
result.r[0] = AbiSystemVClass::memory;
|
|
}
|
|
|
|
if (result.r[1] == AbiSystemVClass::sse_up && result.r[0] != AbiSystemVClass::sse)
|
|
{
|
|
result.r[0] = AbiSystemVClass::sse;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
fn bool contains_no_user_data(Type* type, u64 start, u64 end)
|
|
{
|
|
unused(end);
|
|
if (get_byte_size(type) <= start)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::structure:
|
|
{
|
|
u64 offset = 0;
|
|
|
|
for (auto& field: type->structure.fields)
|
|
{
|
|
if (offset >= end)
|
|
{
|
|
break;
|
|
}
|
|
|
|
auto field_start = offset < start ? start - offset : 0;
|
|
if (!contains_no_user_data(field.type, field_start, end - offset))
|
|
{
|
|
return false;
|
|
}
|
|
offset += get_byte_size(field.type);
|
|
}
|
|
|
|
return true;
|
|
} break;
|
|
case TypeId::array:
|
|
{
|
|
auto element_type = type->array.element_type;
|
|
auto element_count = type->array.element_count;
|
|
auto element_size = get_byte_size(element_type);
|
|
|
|
for (u64 i = 0; i < element_count; i += 1)
|
|
{
|
|
auto offset = i * element_size;
|
|
if (offset >= end)
|
|
{
|
|
break;
|
|
}
|
|
|
|
auto element_start = offset < start ? start - offset : 0;
|
|
if (!contains_no_user_data(element_type, element_start, end - offset))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
trap();
|
|
} break;
|
|
default: return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn Field* get_member_at_offset(Type* struct_type, u32 offset)
|
|
{
|
|
assert(struct_type->id == TypeId::structure);
|
|
|
|
Field* result = 0;
|
|
|
|
if (struct_type->structure.byte_size > offset)
|
|
{
|
|
u32 offset_it = 0;
|
|
auto fields = struct_type->structure.fields;
|
|
|
|
for (u64 i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto* field = &fields[i];
|
|
|
|
if (offset_it > offset)
|
|
{
|
|
break;
|
|
}
|
|
|
|
result = field;
|
|
offset_it = (u32)align_forward(offset_it + get_byte_size(field->type), get_byte_alignment(field->type));
|
|
}
|
|
|
|
assert(result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
fn Type* abi_system_v_get_integer_type_at_offset(Module* module, Type* type, u32 offset, Type* source_type, u32 source_offset)
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::integer:
|
|
{
|
|
auto bit_count = type->integer.bit_count;
|
|
switch (bit_count)
|
|
{
|
|
case 64: return type;
|
|
case 32: case 16: case 8:
|
|
{
|
|
assert(offset == 0);
|
|
auto start = source_offset + get_byte_size(type);
|
|
auto end = source_offset + 8;
|
|
|
|
if (contains_no_user_data(source_type, start, end))
|
|
{
|
|
return type;
|
|
}
|
|
} break;
|
|
default:
|
|
{
|
|
auto original_byte_count = get_byte_size(type);
|
|
assert(original_byte_count != source_offset);
|
|
auto byte_count = MIN(original_byte_count - source_offset, 8);
|
|
auto bit_count = byte_count * 8;
|
|
|
|
auto result_type = integer_type(module, { .bit_count = (u32)bit_count, .is_signed = false });
|
|
return result_type;
|
|
} break;
|
|
}
|
|
} break;
|
|
case TypeId::pointer:
|
|
{
|
|
if (offset == 0)
|
|
{
|
|
return type;
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case TypeId::structure:
|
|
{
|
|
auto* field = get_member_at_offset(type, offset);
|
|
if (field)
|
|
{
|
|
auto field_type = field->type;
|
|
switch (field_type->id)
|
|
{
|
|
case TypeId::integer:
|
|
case TypeId::enumerator:
|
|
{
|
|
field_type = align_integer_type(module, field_type);
|
|
} break;
|
|
default: break;
|
|
}
|
|
|
|
return abi_system_v_get_integer_type_at_offset(module, field_type, offset - field->offset, source_type, source_offset);
|
|
}
|
|
else
|
|
{
|
|
unreachable();
|
|
}
|
|
} break;
|
|
case TypeId::bits:
|
|
{
|
|
auto backing_type = type->bits.backing_type;
|
|
return abi_system_v_get_integer_type_at_offset(module, backing_type, offset, source_type == type ? backing_type : source_type, source_offset);
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
auto source_size = get_byte_size(source_type);
|
|
auto byte_count = source_size - source_offset;
|
|
u32 bit_count = byte_count > 8 ? 64 : byte_count * 8;
|
|
auto result = integer_type(module, { .bit_count = bit_count, .is_signed = false });
|
|
return result;
|
|
}
|
|
|
|
struct AbiSystemVClassify
|
|
{
|
|
u64 base_offset;
|
|
bool is_variable_argument;
|
|
bool is_register_call;
|
|
};
|
|
|
|
fn AbiSystemVClassifyResult abi_system_v_classify_type(Type* type, AbiSystemVClassify options)
|
|
{
|
|
AbiSystemVClassifyResult result = {};
|
|
auto is_memory = options.base_offset >= 8;
|
|
auto current_index = is_memory;
|
|
auto not_current_index = !is_memory;
|
|
assert(current_index != not_current_index);
|
|
result.r[current_index] = AbiSystemVClass::memory;
|
|
|
|
switch (type->id)
|
|
{
|
|
case TypeId::void_type:
|
|
case TypeId::noreturn:
|
|
result.r[current_index] = AbiSystemVClass::none;
|
|
break;
|
|
case TypeId::bits:
|
|
return abi_system_v_classify_type(type->bits.backing_type, options);
|
|
case TypeId::enumerator:
|
|
return abi_system_v_classify_type(type->enumerator.backing_type, options);
|
|
case TypeId::pointer:
|
|
result.r[current_index] = AbiSystemVClass::integer;
|
|
break;
|
|
case TypeId::integer:
|
|
{
|
|
if (type->integer.bit_count <= 64)
|
|
{
|
|
result.r[current_index] = AbiSystemVClass::integer;
|
|
}
|
|
else if (type->integer.bit_count == 128)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
report_error();
|
|
}
|
|
} break;
|
|
case TypeId::array:
|
|
{
|
|
auto byte_size = get_byte_size(type);
|
|
if (byte_size <= 64)
|
|
{
|
|
if (options.base_offset % get_byte_alignment(type) == 0)
|
|
{
|
|
auto element_type = type->array.element_type;
|
|
auto element_size = get_byte_size(element_type);
|
|
|
|
result.r[current_index] = AbiSystemVClass::none;
|
|
|
|
u64 vector_size = 16;
|
|
|
|
if (byte_size > 16 && (byte_size != get_byte_size(element_type) || byte_size > vector_size))
|
|
{
|
|
unreachable();
|
|
}
|
|
else
|
|
{
|
|
auto offset = options.base_offset;
|
|
auto element_count = type->array.element_count;
|
|
|
|
for (u64 i = 0; i < element_count; i += 1)
|
|
{
|
|
auto element_classes = abi_system_v_classify_type(element_type, AbiSystemVClassify{
|
|
.base_offset = offset,
|
|
.is_variable_argument = options.is_variable_argument,
|
|
});
|
|
unused(element_classes);
|
|
offset += element_size;
|
|
|
|
result.r[0] = abi_system_v_merge_class(result.r[0], element_classes.r[0]);
|
|
result.r[1] = abi_system_v_merge_class(result.r[1], element_classes.r[1]);
|
|
|
|
if (result.r[0] == AbiSystemVClass::memory || result.r[1] == AbiSystemVClass::memory)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
auto final_result = abi_system_v_classify_post_merge(byte_size, result);
|
|
assert(final_result.r[1] != AbiSystemVClass::sse || final_result.r[0] != AbiSystemVClass::sse);
|
|
result = final_result;
|
|
}
|
|
}
|
|
}
|
|
} break;
|
|
case TypeId::structure:
|
|
case TypeId::union_type:
|
|
{
|
|
auto byte_size = type->structure.byte_size;
|
|
|
|
if (byte_size <= 64)
|
|
{
|
|
auto has_variable_array = false;
|
|
if (!has_variable_array)
|
|
{
|
|
result.r[current_index] = AbiSystemVClass::none;
|
|
auto is_union = type->id == TypeId::union_type;
|
|
unused(is_union);
|
|
|
|
switch (type->id)
|
|
{
|
|
case TypeId::structure:
|
|
{
|
|
for (auto& field : type->structure.fields)
|
|
{
|
|
auto offset = options.base_offset + field.offset;
|
|
auto member_type = field.type;
|
|
auto member_size = get_byte_size(member_type);
|
|
auto member_alignment = get_byte_alignment(member_type);
|
|
|
|
u64 native_vector_size = 16;
|
|
|
|
auto gt_16 = byte_size > 16 && ((!is_union && byte_size != member_size) || byte_size > native_vector_size);
|
|
auto padding = offset % member_alignment != 0;
|
|
|
|
if (gt_16 || padding)
|
|
{
|
|
result.r[0] = AbiSystemVClass::memory;
|
|
result = abi_system_v_classify_post_merge(byte_size, result);
|
|
return result;
|
|
}
|
|
|
|
auto member_classes = abi_system_v_classify_type(member_type, {
|
|
.base_offset = offset,
|
|
.is_variable_argument = options.is_variable_argument,
|
|
.is_register_call = options.is_register_call,
|
|
});
|
|
|
|
for (u64 i = 0; i < array_length(member_classes.r); i += 1)
|
|
{
|
|
result.r[i] = abi_system_v_merge_class(result.r[i], member_classes.r[i]);
|
|
}
|
|
|
|
if (result.r[0] == AbiSystemVClass::memory || result.r[1] == AbiSystemVClass::memory)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
result = abi_system_v_classify_post_merge(byte_size, result);
|
|
} break;
|
|
case TypeId::union_type:
|
|
{
|
|
trap();
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
}
|
|
} break;
|
|
case TypeId::alias:
|
|
return abi_system_v_classify_type(type->alias.type, options);
|
|
default: unreachable();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
fn void resolve_type_in_place_memory(Module* module, Type* type);
|
|
fn void resolve_type_in_place_abi(Module* module, Type* type)
|
|
{
|
|
if (!type->llvm.abi)
|
|
{
|
|
LLVMTypeRef result = 0;
|
|
|
|
switch (type->id)
|
|
{
|
|
case TypeId::void_type:
|
|
case TypeId::noreturn:
|
|
result = module->llvm.void_type;
|
|
break;
|
|
case TypeId::integer:
|
|
result = LLVMIntTypeInContext(module->llvm.context, type->integer.bit_count);
|
|
break;
|
|
case TypeId::pointer:
|
|
result = module->llvm.pointer_type;
|
|
break;
|
|
case TypeId::array:
|
|
{
|
|
auto* element_type = type->array.element_type;
|
|
auto element_count = type->array.element_count;
|
|
assert(element_count);
|
|
resolve_type_in_place_memory(module, element_type);
|
|
auto array_type = LLVMArrayType2(element_type->llvm.memory, element_count);
|
|
result = array_type;
|
|
} break;
|
|
case TypeId::enumerator:
|
|
{
|
|
auto backing_type = type->enumerator.backing_type;
|
|
resolve_type_in_place_abi(module, backing_type);
|
|
result = backing_type->llvm.abi;
|
|
} break;
|
|
case TypeId::structure:
|
|
{
|
|
LLVMTypeRef llvm_type_buffer[64];
|
|
auto fields = type->structure.fields;
|
|
for (u64 i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto& field = fields[i];
|
|
resolve_type_in_place_memory(module, field.type);
|
|
llvm_type_buffer[i] = field.type->llvm.memory;
|
|
}
|
|
|
|
result = LLVMStructTypeInContext(module->llvm.context, llvm_type_buffer, fields.length, 0);
|
|
} break;
|
|
case TypeId::bits:
|
|
{
|
|
auto backing_type = type->bits.backing_type;
|
|
resolve_type_in_place_abi(module, backing_type);
|
|
result = backing_type->llvm.abi;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(result);
|
|
type->llvm.abi = result;
|
|
}
|
|
}
|
|
|
|
fn void resolve_type_in_place_memory(Module* module, Type* type)
|
|
{
|
|
if (!type->llvm.memory)
|
|
{
|
|
resolve_type_in_place_abi(module, type);
|
|
|
|
LLVMTypeRef result = 0;
|
|
|
|
switch (type->id)
|
|
{
|
|
case TypeId::void_type:
|
|
case TypeId::noreturn:
|
|
case TypeId::pointer:
|
|
case TypeId::array:
|
|
case TypeId::structure:
|
|
result = type->llvm.abi;
|
|
break;
|
|
case TypeId::integer:
|
|
{
|
|
auto byte_size = get_byte_size(type);
|
|
auto bit_count = byte_size * 8;
|
|
result = LLVMIntTypeInContext(module->llvm.context, bit_count);
|
|
} break;
|
|
case TypeId::enumerator:
|
|
{
|
|
auto backing_type = type->enumerator.backing_type;
|
|
resolve_type_in_place_memory(module, backing_type);
|
|
result = backing_type->llvm.memory;
|
|
} break;
|
|
case TypeId::bits:
|
|
{
|
|
auto backing_type = type->bits.backing_type;
|
|
resolve_type_in_place_memory(module, backing_type);
|
|
result = backing_type->llvm.memory;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(result);
|
|
type->llvm.memory = result;
|
|
|
|
if (type->id == TypeId::bits)
|
|
{
|
|
assert(type->llvm.memory == type->llvm.abi);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn void resolve_type_in_place_debug(Module* module, Type* type)
|
|
{
|
|
if (module->has_debug_info)
|
|
{
|
|
if (!type->llvm.debug)
|
|
{
|
|
LLVMMetadataRef result = 0;
|
|
|
|
switch (type->id)
|
|
{
|
|
case TypeId::void_type:
|
|
case TypeId::noreturn:
|
|
{
|
|
result = LLVMDIBuilderCreateBasicType(module->llvm.di_builder, (char*)type->name.pointer, type->name.length, 0, (u32)DwarfType::void_type, type->id == TypeId::noreturn ? LLVMDIFlagNoReturn : LLVMDIFlagZero);
|
|
} break;
|
|
case TypeId::integer:
|
|
{
|
|
DwarfType dwarf_type = type->integer.bit_count == 1 ? DwarfType::boolean : (type->integer.is_signed ? DwarfType::signed_type : DwarfType::unsigned_type);
|
|
LLVMDIFlags flags = {};
|
|
result = LLVMDIBuilderCreateBasicType(module->llvm.di_builder, (char*)type->name.pointer, type->name.length, type->integer.bit_count, (u32)dwarf_type, flags);
|
|
} break;
|
|
case TypeId::pointer:
|
|
{
|
|
resolve_type_in_place_debug(module, type->pointer.element_type);
|
|
if (type->llvm.debug)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
result = LLVMDIBuilderCreatePointerType(module->llvm.di_builder, type->pointer.element_type->llvm.debug, 64, 64, 0, (char*)type->name.pointer, type->name.length);
|
|
}
|
|
} break;
|
|
case TypeId::array:
|
|
{
|
|
auto array_element_type = type->array.element_type;
|
|
auto array_element_count = type->array.element_count;
|
|
assert(array_element_count);
|
|
resolve_type_in_place_debug(module, array_element_type);
|
|
auto bit_alignment = get_byte_alignment(type) * 8;
|
|
auto array_type = LLVMDIBuilderCreateArrayType(module->llvm.di_builder, array_element_count, bit_alignment, array_element_type->llvm.debug, 0, 0);
|
|
result = array_type;
|
|
} break;
|
|
case TypeId::enumerator:
|
|
{
|
|
auto backing_type = type->enumerator.backing_type;
|
|
resolve_type_in_place_debug(module, backing_type);
|
|
|
|
LLVMMetadataRef field_buffer[64];
|
|
for (u64 i = 0; i < type->enumerator.fields.length; i += 1)
|
|
{
|
|
auto& field = type->enumerator.fields[i];
|
|
auto enum_field = LLVMDIBuilderCreateEnumerator(module->llvm.di_builder, (char*)field.name.pointer, field.name.length, field.value, type_is_signed(backing_type));
|
|
field_buffer[i] = enum_field;
|
|
}
|
|
|
|
result = LLVMDIBuilderCreateEnumerationType(module->llvm.di_builder, module->scope.llvm, (char*)type->name.pointer, type->name.length, module->llvm.file, type->enumerator.line, get_bit_size(type), get_byte_alignment(type) * 8, field_buffer, type->enumerator.fields.length, backing_type->llvm.debug);
|
|
} break;
|
|
case TypeId::structure:
|
|
{
|
|
LLVMDIFlags flags = {};
|
|
auto forward_declaration = LLVMDIBuilderCreateReplaceableCompositeType(module->llvm.di_builder, module->llvm.debug_tag, (char*)type->name.pointer, type->name.length, module->scope.llvm, module->llvm.file, type->structure.line, 0, type->structure.byte_size * 8, type->structure.byte_alignment * 8, flags, (char*)type->name.pointer, type->name.length);
|
|
module->llvm.debug_tag += 1;
|
|
|
|
LLVMMetadataRef llvm_type_buffer[64];
|
|
|
|
auto fields = type->structure.fields;
|
|
for (u64 i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto& field = fields[i];
|
|
auto field_type = field.type;
|
|
resolve_type_in_place_debug(module, field_type);
|
|
auto member_type = LLVMDIBuilderCreateMemberType(module->llvm.di_builder, module->scope.llvm, (char*)field.name.pointer, field.name.length, module->llvm.file, field.line, get_byte_size(field_type) * 8, get_byte_alignment(field_type) * 8, field.offset * 8, flags, field_type->llvm.debug);
|
|
llvm_type_buffer[i] = member_type;
|
|
}
|
|
|
|
auto struct_type = LLVMDIBuilderCreateStructType(module->llvm.di_builder, module->scope.llvm, (char*)type->name.pointer, type->name.length, module->llvm.file, type->structure.line, type->structure.byte_size * 8, type->structure.byte_alignment * 8, flags, 0, llvm_type_buffer, fields.length, 0, 0, (char*)type->name.pointer, type->name.length);
|
|
LLVMMetadataReplaceAllUsesWith(forward_declaration, struct_type);
|
|
result = struct_type;
|
|
} break;
|
|
case TypeId::bits:
|
|
{
|
|
LLVMMetadataRef llvm_type_buffer[64];
|
|
|
|
auto fields = type->bits.fields;
|
|
auto backing_type = type->bits.backing_type->llvm.debug;
|
|
LLVMDIFlags flags = {};
|
|
for (u64 i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto& field = fields[i];
|
|
auto field_type = field.type;
|
|
resolve_type_in_place_debug(module, field_type);
|
|
u64 bit_offset = 0;
|
|
auto member_type = LLVMDIBuilderCreateBitFieldMemberType(module->llvm.di_builder, module->scope.llvm, (char*)field.name.pointer, field.name.length, module->llvm.file, field.line, get_bit_size(field_type), bit_offset, field.offset, flags, backing_type);
|
|
llvm_type_buffer[i] = member_type;
|
|
}
|
|
|
|
auto size = get_byte_size(type) * 8;
|
|
auto alignment = get_byte_alignment(type) * 8;
|
|
auto struct_type = LLVMDIBuilderCreateStructType(module->llvm.di_builder, module->scope.llvm, (char*)type->name.pointer, type->name.length, module->llvm.file, type->bits.line, size, alignment, flags, 0, llvm_type_buffer, fields.length, 0, 0, (char*)type->name.pointer, type->name.length);
|
|
result = struct_type;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(result);
|
|
type->llvm.debug = result;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn void resolve_type_in_place(Module* module, Type* type)
|
|
{
|
|
resolve_type_in_place_abi(module, type);
|
|
resolve_type_in_place_memory(module, type);
|
|
resolve_type_in_place_debug(module, type);
|
|
}
|
|
|
|
fn bool type_is_abi_equal(Module* module, Type* a, Type* b)
|
|
{
|
|
resolve_type_in_place(module, a);
|
|
resolve_type_in_place(module, b);
|
|
|
|
bool result = a == b;
|
|
if (!result)
|
|
{
|
|
result = a->llvm.abi == b->llvm.abi;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
fn AbiInformation abi_system_v_get_ignore(Module* module, Type* semantic_type)
|
|
{
|
|
resolve_type_in_place(module, semantic_type);
|
|
|
|
return {
|
|
.semantic_type = semantic_type,
|
|
.flags = {
|
|
.kind = AbiKind::ignore,
|
|
},
|
|
};
|
|
}
|
|
|
|
struct DirectOptions
|
|
{
|
|
Type* semantic_type;
|
|
Type* type;
|
|
Type* padding;
|
|
u32 offset;
|
|
u32 alignment;
|
|
bool can_be_flattened = true;
|
|
};
|
|
|
|
fn AbiInformation abi_system_v_get_direct(Module* module, DirectOptions direct)
|
|
{
|
|
AbiInformation result = {
|
|
.semantic_type = direct.semantic_type,
|
|
.flags = {
|
|
.kind = AbiKind::direct,
|
|
},
|
|
};
|
|
resolve_type_in_place(module, direct.semantic_type);
|
|
resolve_type_in_place(module, direct.type);
|
|
if (unlikely(direct.padding))
|
|
{
|
|
resolve_type_in_place(module, direct.padding);
|
|
}
|
|
|
|
result.set_coerce_to_type(direct.type);
|
|
result.set_padding_type(direct.padding);
|
|
result.set_direct_offset(direct.offset);
|
|
result.set_direct_alignment(direct.alignment);
|
|
result.set_can_be_flattened(direct.can_be_flattened);
|
|
|
|
return result;
|
|
}
|
|
|
|
struct ExtendOptions
|
|
{
|
|
Type* semantic_type;
|
|
Type* type;
|
|
bool sign;
|
|
};
|
|
|
|
fn AbiInformation abi_system_v_get_extend(ExtendOptions options)
|
|
{
|
|
assert(is_integral_or_enumeration_type(options.semantic_type));
|
|
AbiInformation result = {
|
|
.semantic_type = options.semantic_type,
|
|
.flags = {
|
|
.kind = AbiKind::extend,
|
|
},
|
|
};
|
|
|
|
result.set_coerce_to_type(options.type ? options.type : options.semantic_type);
|
|
result.set_padding_type(0);
|
|
result.set_direct_offset(0);
|
|
result.set_direct_alignment(0);
|
|
result.flags.sign_extension = options.sign;
|
|
|
|
return result;
|
|
}
|
|
|
|
fn Type* get_anonymous_struct_pair(Module* module, Type* low, Type* high)
|
|
{
|
|
unused(module);
|
|
unused(low);
|
|
unused(high);
|
|
|
|
Type* pair;
|
|
for (pair = module->first_pair_struct_type; pair; pair = pair->structure.next)
|
|
{
|
|
assert(pair->id == TypeId::structure);
|
|
assert(pair->structure.fields.length == 2);
|
|
|
|
if (pair->structure.fields[0].type == low &&
|
|
pair->structure.fields[1].type == high)
|
|
{
|
|
return pair;
|
|
}
|
|
|
|
if (!pair->structure.next)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
auto high_alignment = get_byte_alignment(high);
|
|
auto alignment = MAX(get_byte_alignment(low), high_alignment);
|
|
u64 high_offset = align_forward(get_byte_size(low), high_alignment);
|
|
|
|
auto fields = arena_allocate<Field>(module->arena, 2);
|
|
fields[0] = {
|
|
.name = string_literal("low"),
|
|
.type = low,
|
|
.offset = 0,
|
|
.line = 0,
|
|
};
|
|
fields[1] = {
|
|
.name = string_literal("high"),
|
|
.type = high,
|
|
.offset = high_offset,
|
|
.line = 0,
|
|
};
|
|
|
|
auto struct_type = type_allocate_init(module, {
|
|
.structure = {
|
|
.fields = fields,
|
|
.byte_size = high_offset + get_byte_size(high),
|
|
.byte_alignment = alignment,
|
|
},
|
|
.id = TypeId::structure,
|
|
.name = string_literal(""),
|
|
});
|
|
|
|
if (pair)
|
|
{
|
|
assert(module->first_pair_struct_type);
|
|
pair->structure.next = struct_type;
|
|
}
|
|
else
|
|
{
|
|
assert(!module->first_pair_struct_type);
|
|
module->first_pair_struct_type = struct_type;
|
|
}
|
|
|
|
return struct_type;
|
|
}
|
|
|
|
fn Type* get_by_value_argument_pair(Module* module, Type* low, Type* high)
|
|
{
|
|
unused(module);
|
|
unused(low);
|
|
unused(high);
|
|
auto low_size = get_byte_allocation_size(low);
|
|
auto high_alignment = get_byte_alignment(high);
|
|
auto high_start = align_forward(low_size, high_alignment);
|
|
assert(high_start != 0 && high_start <= 8);
|
|
if (high_start != 8)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto result = get_anonymous_struct_pair(module, low, high);
|
|
return result;
|
|
}
|
|
|
|
|
|
struct IndirectOptions
|
|
{
|
|
Type* semantic_type;
|
|
Type* padding_type = 0;
|
|
u32 alignment;
|
|
bool by_value = true;
|
|
bool realign = false;
|
|
};
|
|
|
|
fn AbiInformation abi_system_v_get_indirect(IndirectOptions indirect)
|
|
{
|
|
auto result = AbiInformation{
|
|
.semantic_type = indirect.semantic_type,
|
|
.attributes = {
|
|
.indirect = {
|
|
.alignment = 0,
|
|
.address_space = 0,
|
|
},
|
|
},
|
|
.flags = {
|
|
.kind = AbiKind::indirect,
|
|
},
|
|
};
|
|
|
|
result.set_indirect_align(indirect.alignment);
|
|
result.set_indirect_by_value(indirect.by_value);
|
|
result.set_indirect_realign(indirect.realign);
|
|
result.set_sret_after_this(false);
|
|
result.set_padding_type(indirect.padding_type);
|
|
|
|
return result;
|
|
}
|
|
|
|
struct NaturalAlignIndirect
|
|
{
|
|
Type* semantic_type;
|
|
Type* padding_type = 0;
|
|
bool by_value = true;
|
|
bool realign = false;
|
|
};
|
|
|
|
fn AbiInformation abi_system_v_get_natural_align_indirect(NaturalAlignIndirect natural)
|
|
{
|
|
auto alignment = get_byte_alignment(natural.semantic_type);
|
|
return abi_system_v_get_indirect({
|
|
.semantic_type = natural.semantic_type,
|
|
.padding_type = natural.padding_type,
|
|
.alignment = alignment,
|
|
.by_value = natural.by_value,
|
|
.realign = natural.realign,
|
|
});
|
|
}
|
|
|
|
fn bool is_illegal_vector_type(Type* type)
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::vector: trap();
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
fn AbiInformation abi_system_v_get_indirect_result(Module* module, Type* type, u32 free_gpr)
|
|
{
|
|
unused(module);
|
|
unused(type);
|
|
unused(free_gpr);
|
|
if (!type_is_aggregate_type_for_abi(type) && !is_illegal_vector_type(type) && !is_arbitrary_bit_integer(type))
|
|
{
|
|
if (is_promotable_integer_type_for_abi(type))
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
return abi_system_v_get_direct(module, {
|
|
.semantic_type = type,
|
|
.type = type,
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto alignment = MAX(get_byte_alignment(type), 8);
|
|
auto size = get_byte_size(type);
|
|
|
|
if (free_gpr == 0 && alignment == 8 && size <= 8)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
return abi_system_v_get_indirect({
|
|
.semantic_type = type,
|
|
.alignment = alignment,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
struct AbiSystemVClassifyArgumentTypeOptions
|
|
{
|
|
u32 available_gpr;
|
|
bool is_named_argument;
|
|
bool is_reg_call;
|
|
};
|
|
|
|
struct AbiSystemVClassifyArgumentTypeResult
|
|
{
|
|
AbiInformation abi;
|
|
AbiRegisterCountSystemV needed_registers;
|
|
};
|
|
|
|
fn AbiSystemVClassifyArgumentTypeResult abi_system_v_classify_argument_type(Module* module, Type* semantic_argument_type, AbiSystemVClassifyArgumentTypeOptions options)
|
|
{
|
|
auto classify_result = abi_system_v_classify_type(semantic_argument_type, AbiSystemVClassify{
|
|
.base_offset = 0,
|
|
.is_variable_argument = !options.is_named_argument,
|
|
.is_register_call = options.is_reg_call,
|
|
});
|
|
|
|
auto low_class = classify_result.r[0];
|
|
auto high_class = classify_result.r[1];
|
|
|
|
AbiRegisterCountSystemV needed_registers = {};
|
|
|
|
Type* low_type = 0;
|
|
|
|
switch (low_class)
|
|
{
|
|
case AbiSystemVClass::none: unreachable();
|
|
case AbiSystemVClass::integer:
|
|
{
|
|
needed_registers.gpr += 1;
|
|
low_type = abi_system_v_get_integer_type_at_offset(module, semantic_argument_type, 0, semantic_argument_type, 0);
|
|
|
|
if (high_class == AbiSystemVClass::none && low_type->id == TypeId::integer)
|
|
{
|
|
// TODO: if enumerator
|
|
|
|
if (is_integral_or_enumeration_type(semantic_argument_type) && is_promotable_integer_type_for_abi(semantic_argument_type))
|
|
{
|
|
return { abi_system_v_get_extend({
|
|
.semantic_type = semantic_argument_type,
|
|
.sign = type_is_signed(semantic_argument_type),
|
|
}), needed_registers };
|
|
}
|
|
}
|
|
} break;
|
|
case AbiSystemVClass::memory:
|
|
{
|
|
return { abi_system_v_get_indirect_result(module, semantic_argument_type, options.available_gpr), needed_registers };
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
Type* high_type = 0;
|
|
|
|
switch (high_class)
|
|
{
|
|
case AbiSystemVClass::none:
|
|
break;
|
|
case AbiSystemVClass::integer:
|
|
{
|
|
needed_registers.gpr += 1;
|
|
high_type = abi_system_v_get_integer_type_at_offset(module, semantic_argument_type, 8, semantic_argument_type, 8);
|
|
|
|
if (low_class == AbiSystemVClass::none)
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
unused(high_type);
|
|
|
|
Type* result_type = low_type;
|
|
if (high_type)
|
|
{
|
|
result_type = get_by_value_argument_pair(module, low_type, high_type);
|
|
}
|
|
|
|
return {
|
|
abi_system_v_get_direct(module, DirectOptions{
|
|
.semantic_type = semantic_argument_type,
|
|
.type = result_type,
|
|
}),
|
|
needed_registers,
|
|
};
|
|
}
|
|
|
|
struct AbiSystemVClassifyArgumentOptions
|
|
{
|
|
Type* type;
|
|
u16 abi_start;
|
|
bool is_reg_call = false;
|
|
bool is_named_argument;
|
|
};
|
|
|
|
fn AbiInformation abi_system_v_classify_argument(Module* module, AbiRegisterCountSystemV* available_registers, Slice<LLVMTypeRef> llvm_abi_argument_type_buffer, Slice<Type*> abi_argument_type_buffer, AbiSystemVClassifyArgumentOptions options)
|
|
{
|
|
auto semantic_argument_type = options.type;
|
|
if (options.is_reg_call)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto result = abi_system_v_classify_argument_type(module, semantic_argument_type, {
|
|
.available_gpr = available_registers->gpr,
|
|
.is_named_argument = options.is_named_argument,
|
|
.is_reg_call = options.is_reg_call,
|
|
});
|
|
auto abi = result.abi;
|
|
auto needed_registers = result.needed_registers;
|
|
|
|
AbiInformation argument_abi;
|
|
if (available_registers->gpr >= needed_registers.gpr && available_registers->sse >= needed_registers.sse)
|
|
{
|
|
available_registers->gpr -= needed_registers.gpr;
|
|
available_registers->sse -= needed_registers.sse;
|
|
argument_abi = abi;
|
|
}
|
|
else
|
|
{
|
|
argument_abi = abi_system_v_get_indirect_result(module, semantic_argument_type, available_registers->gpr);
|
|
}
|
|
|
|
if (argument_abi.get_padding_type())
|
|
{
|
|
trap();
|
|
}
|
|
|
|
argument_abi.abi_start = options.abi_start;
|
|
|
|
u16 count = 0;
|
|
|
|
switch (argument_abi.flags.kind)
|
|
{
|
|
case AbiKind::direct:
|
|
case AbiKind::extend:
|
|
{
|
|
auto coerce_to_type = argument_abi.get_coerce_to_type();
|
|
resolve_type_in_place(module, coerce_to_type);
|
|
|
|
auto is_flattened_struct = argument_abi.flags.kind == AbiKind::direct && argument_abi.get_can_be_flattened() && coerce_to_type->id == TypeId::structure;
|
|
|
|
count = is_flattened_struct ? coerce_to_type->structure.fields.length : 1;
|
|
|
|
if (is_flattened_struct)
|
|
{
|
|
for (u64 i = 0; i < coerce_to_type->structure.fields.length; i += 1)
|
|
{
|
|
auto& field = coerce_to_type->structure.fields[i];
|
|
auto field_type = field.type;
|
|
llvm_abi_argument_type_buffer[argument_abi.abi_start + i] = field_type->llvm.abi;
|
|
abi_argument_type_buffer[argument_abi.abi_start + i] = field_type;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
llvm_abi_argument_type_buffer[argument_abi.abi_start] = coerce_to_type->llvm.abi;
|
|
abi_argument_type_buffer[argument_abi.abi_start] = coerce_to_type;
|
|
}
|
|
} break;
|
|
case AbiKind::indirect:
|
|
{
|
|
auto indirect_type = get_pointer_type(module, argument_abi.semantic_type);
|
|
auto abi_index = argument_abi.abi_start;
|
|
abi_argument_type_buffer[abi_index] = indirect_type;
|
|
resolve_type_in_place(module, indirect_type);
|
|
llvm_abi_argument_type_buffer[abi_index] = indirect_type->llvm.abi;
|
|
count = 1;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(count);
|
|
argument_abi.abi_count = count;
|
|
|
|
return argument_abi;
|
|
}
|
|
|
|
fn AbiInformation abi_system_v_get_indirect_return_result(Type* type)
|
|
{
|
|
if (type_is_aggregate_type_for_abi(type))
|
|
{
|
|
return abi_system_v_get_natural_align_indirect({
|
|
.semantic_type = type,
|
|
});
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
}
|
|
|
|
fn AbiInformation abi_system_classify_return_type(Module* module, Type* semantic_return_type)
|
|
{
|
|
auto type_classes = abi_system_v_classify_type(semantic_return_type, {});
|
|
auto low_class = type_classes.r[0];
|
|
auto high_class = type_classes.r[1];
|
|
assert(high_class != AbiSystemVClass::memory || low_class == AbiSystemVClass::memory);
|
|
assert(high_class != AbiSystemVClass::sse_up || low_class == AbiSystemVClass::sse);
|
|
|
|
Type* low_type = 0;
|
|
|
|
switch (low_class)
|
|
{
|
|
case AbiSystemVClass::none:
|
|
{
|
|
if (high_class == AbiSystemVClass::none)
|
|
{
|
|
return abi_system_v_get_ignore(module, semantic_return_type);
|
|
}
|
|
|
|
trap();
|
|
} break;
|
|
case AbiSystemVClass::integer:
|
|
{
|
|
low_type = abi_system_v_get_integer_type_at_offset(module, semantic_return_type, 0, semantic_return_type, 0);
|
|
|
|
if (high_class == AbiSystemVClass::none && low_type->id == TypeId::integer)
|
|
{
|
|
if (semantic_return_type->id == TypeId::enumerator)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
if (is_integral_or_enumeration_type(semantic_return_type) && is_promotable_integer_type_for_abi(semantic_return_type))
|
|
{
|
|
return abi_system_v_get_extend({
|
|
.semantic_type = semantic_return_type,
|
|
.sign = type_is_signed(semantic_return_type),
|
|
});
|
|
}
|
|
}
|
|
} break;
|
|
case AbiSystemVClass::memory:
|
|
{
|
|
return abi_system_v_get_indirect_return_result(semantic_return_type);
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
Type* high_type = 0;
|
|
|
|
switch (high_class)
|
|
{
|
|
case AbiSystemVClass::none:
|
|
break;
|
|
case AbiSystemVClass::integer:
|
|
{
|
|
u64 high_offset = 8;
|
|
high_type = abi_system_v_get_integer_type_at_offset(module, semantic_return_type, high_offset, semantic_return_type, high_offset);
|
|
if (low_class == AbiSystemVClass::none)
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
|
|
default: unreachable();
|
|
}
|
|
|
|
if (high_type)
|
|
{
|
|
low_type = get_by_value_argument_pair(module, low_type, high_type);
|
|
}
|
|
|
|
auto result = abi_system_v_get_direct(module, {
|
|
.semantic_type = semantic_return_type,
|
|
.type = low_type,
|
|
});
|
|
return result;
|
|
}
|
|
|
|
struct AttributeBuildOptions
|
|
{
|
|
AbiInformation return_abi;
|
|
Slice<AbiInformation> argument_abis;
|
|
Slice<Type*> abi_argument_types;
|
|
Type* abi_return_type;
|
|
FunctionAttributes attributes;
|
|
bool call_site;
|
|
};
|
|
|
|
struct AllocaOptions
|
|
{
|
|
Type* type;
|
|
String name = string_literal("");
|
|
u32 alignment;
|
|
};
|
|
|
|
fn LLVMValueRef create_alloca(Module* module, AllocaOptions options)
|
|
{
|
|
auto abi_type = options.type;
|
|
resolve_type_in_place(module, abi_type);
|
|
|
|
u32 alignment;
|
|
if (options.alignment)
|
|
{
|
|
alignment = options.alignment;
|
|
}
|
|
else
|
|
{
|
|
alignment = get_byte_alignment(abi_type);
|
|
}
|
|
|
|
auto alloca = llvm_builder_create_alloca(module->llvm.builder, abi_type->llvm.memory, 0, alignment, options.name);
|
|
return alloca;
|
|
}
|
|
|
|
struct StoreOptions
|
|
{
|
|
LLVMValueRef source;
|
|
LLVMValueRef destination;
|
|
Type* type;
|
|
u32 alignment;
|
|
};
|
|
|
|
fn void create_store(Module* module, StoreOptions options)
|
|
{
|
|
assert(options.source);
|
|
assert(options.destination);
|
|
assert(options.type);
|
|
|
|
auto resolved_type = resolve_alias(module, options.type);
|
|
resolve_type_in_place(module, resolved_type);
|
|
|
|
LLVMValueRef source_value;
|
|
|
|
LLVMTypeRef memory_type = resolved_type->llvm.memory;
|
|
if (resolved_type->llvm.abi == memory_type)
|
|
{
|
|
source_value = options.source;
|
|
}
|
|
else
|
|
{
|
|
source_value = LLVMBuildIntCast2(module->llvm.builder, options.source, memory_type, type_is_signed(resolved_type), "");
|
|
}
|
|
|
|
u32 alignment;
|
|
if (options.alignment)
|
|
{
|
|
alignment = options.alignment;
|
|
}
|
|
else
|
|
{
|
|
alignment = get_byte_alignment(resolved_type);
|
|
}
|
|
|
|
auto store = LLVMBuildStore(module->llvm.builder, source_value, options.destination);
|
|
LLVMSetAlignment(store, alignment);
|
|
}
|
|
|
|
struct LoadOptions
|
|
{
|
|
Type* type;
|
|
LLVMValueRef pointer;
|
|
u32 alignment;
|
|
TypeKind kind;
|
|
};
|
|
|
|
fn LLVMValueRef create_load(Module* module, LoadOptions options)
|
|
{
|
|
resolve_type_in_place(module, options.type);
|
|
|
|
u32 alignment;
|
|
if (options.alignment)
|
|
{
|
|
alignment = options.alignment;
|
|
}
|
|
else
|
|
{
|
|
alignment = get_byte_alignment(options.type);
|
|
}
|
|
|
|
auto result = LLVMBuildLoad2(module->llvm.builder, options.type->llvm.memory, options.pointer, "");
|
|
LLVMSetAlignment(result, alignment);
|
|
|
|
switch (options.kind)
|
|
{
|
|
case TypeKind::abi:
|
|
{
|
|
if (options.type->llvm.memory == options.type->llvm.abi)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
result = LLVMBuildIntCast2(module->llvm.builder, result, options.type->llvm.abi, type_is_signed(options.type), "");
|
|
}
|
|
} break;
|
|
case TypeKind::memory: break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
struct GEPOptions
|
|
{
|
|
LLVMTypeRef type;
|
|
LLVMValueRef pointer;
|
|
Slice<LLVMValueRef> indices;
|
|
bool inbounds = true;
|
|
};
|
|
|
|
fn LLVMValueRef create_gep(Module* module, GEPOptions options)
|
|
{
|
|
auto* gep_function = options.inbounds ? &LLVMBuildInBoundsGEP2 : &LLVMBuildGEP2;
|
|
auto gep = gep_function(module->llvm.builder, options.type, options.pointer, options.indices.pointer, (u32)options.indices.length, "");
|
|
return gep;
|
|
}
|
|
|
|
fn BBLLVMAttributeList build_attribute_list(Module* module, AttributeBuildOptions options)
|
|
{
|
|
resolve_type_in_place(module, options.return_abi.semantic_type);
|
|
BBLLVMAttributeListOptions attributes = {};
|
|
|
|
attributes.return_ = {
|
|
.semantic_type = options.return_abi.semantic_type->llvm.memory,
|
|
.abi_type = options.abi_return_type->llvm.abi,
|
|
.dereferenceable_bytes = 0,
|
|
.alignment = 0,
|
|
.no_alias = false,
|
|
.non_null = false,
|
|
.no_undef = false,
|
|
.sign_extend = options.return_abi.flags.kind == AbiKind::extend and options.return_abi.flags.sign_extension,
|
|
.zero_extend = options.return_abi.flags.kind == AbiKind::extend and !options.return_abi.flags.sign_extension,
|
|
.in_reg = false,
|
|
.no_fp_class = 0, // TODO: this is a struct
|
|
.struct_return = false,
|
|
.writable = false,
|
|
.dead_on_unwind = false,
|
|
.in_alloca = false,
|
|
.dereferenceable = false,
|
|
.dereferenceable_or_null = false,
|
|
.nest = false,
|
|
.by_value = false,
|
|
.by_reference = false,
|
|
.no_capture = false,
|
|
};
|
|
|
|
BBLLVMArgumentAttributes argument_attribute_buffer[128];
|
|
Slice<BBLLVMArgumentAttributes> argument_attributes = { .pointer = argument_attribute_buffer, .length = options.abi_argument_types.length };
|
|
attributes.argument_pointer = argument_attributes.pointer;
|
|
attributes.argument_count = argument_attributes.length;
|
|
|
|
u64 total_abi_count = 0;
|
|
if (options.return_abi.flags.kind == AbiKind::indirect)
|
|
{
|
|
auto abi_index = options.return_abi.flags.sret_after_this;
|
|
auto argument_attribute = &argument_attributes[abi_index];
|
|
*argument_attribute = {
|
|
.semantic_type = options.return_abi.semantic_type->llvm.memory,
|
|
.abi_type = options.abi_argument_types[abi_index]->llvm.abi,
|
|
.dereferenceable_bytes = 0,
|
|
.alignment = get_byte_alignment(options.return_abi.semantic_type),
|
|
.no_alias = true,
|
|
.non_null = false,
|
|
.no_undef = false,
|
|
.sign_extend = false,
|
|
.zero_extend = false,
|
|
.in_reg = options.return_abi.flags.in_reg,
|
|
.no_fp_class = {},
|
|
.struct_return = true,
|
|
.writable = true,
|
|
.dead_on_unwind = true,
|
|
.in_alloca = false,
|
|
.dereferenceable = false,
|
|
.dereferenceable_or_null = false,
|
|
.nest = false,
|
|
.by_value = false,
|
|
.by_reference = false,
|
|
.no_capture = false,
|
|
};
|
|
total_abi_count += 1;
|
|
}
|
|
|
|
for (const auto& abi: options.argument_abis)
|
|
{
|
|
for (auto abi_index = abi.abi_start; abi_index < abi.abi_start + abi.abi_count; abi_index += 1)
|
|
{
|
|
auto& attributes = argument_attributes[abi_index];
|
|
resolve_type_in_place(module, abi.semantic_type);
|
|
|
|
auto abi_type = options.abi_argument_types[abi_index];
|
|
resolve_type_in_place(module, abi_type);
|
|
|
|
attributes = {
|
|
.semantic_type = abi.semantic_type->llvm.memory,
|
|
.abi_type = abi_type->llvm.abi,
|
|
.dereferenceable_bytes = 0,
|
|
.alignment = (u32)(abi.flags.kind == AbiKind::indirect ? 8 : 0),
|
|
.no_alias = false,
|
|
.non_null = false,
|
|
.no_undef = false,
|
|
.sign_extend = abi.flags.kind == AbiKind::extend and abi.flags.sign_extension,
|
|
.zero_extend = abi.flags.kind == AbiKind::extend and !abi.flags.sign_extension,
|
|
.in_reg = abi.flags.in_reg,
|
|
.no_fp_class = {},
|
|
.struct_return = false,
|
|
.writable = false,
|
|
.dead_on_unwind = false,
|
|
.in_alloca = false,
|
|
.dereferenceable = false,
|
|
.dereferenceable_or_null = false,
|
|
.nest = false,
|
|
.by_value = abi.flags.indirect_by_value,
|
|
.by_reference = false,
|
|
.no_capture = false,
|
|
};
|
|
total_abi_count += 1;
|
|
}
|
|
}
|
|
assert(total_abi_count == options.abi_argument_types.length);
|
|
|
|
attributes.function = {
|
|
.prefer_vector_width = {},
|
|
.stack_protector_buffer_size = {},
|
|
.definition_probe_stack = {},
|
|
.definition_stack_probe_size = {},
|
|
.flags0 = {
|
|
.noreturn = options.return_abi.semantic_type == noreturn_type(module),
|
|
.cmse_ns_call = false,
|
|
.nounwind = true,
|
|
.returns_twice = false,
|
|
.cold = false,
|
|
.hot = false,
|
|
.no_duplicate = false,
|
|
.convergent = false,
|
|
.no_merge = false,
|
|
.will_return = false,
|
|
.no_caller_saved_registers = false,
|
|
.no_cf_check = false,
|
|
.no_callback = false,
|
|
.alloc_size = false, // TODO
|
|
.uniform_work_group_size = false,
|
|
.aarch64_pstate_sm_body = false,
|
|
.aarch64_pstate_sm_enabled = false,
|
|
.aarch64_pstate_sm_compatible = false,
|
|
.aarch64_preserves_za = false,
|
|
.aarch64_in_za = false,
|
|
.aarch64_out_za = false,
|
|
.aarch64_inout_za = false,
|
|
.aarch64_preserves_zt0 = false,
|
|
.aarch64_in_zt0 = false,
|
|
.aarch64_out_zt0 = false,
|
|
.aarch64_inout_zt0 = false,
|
|
.optimize_for_size = false,
|
|
.min_size = false,
|
|
.no_red_zone = false,
|
|
.indirect_tls_seg_refs = false,
|
|
.no_implicit_floats = false,
|
|
.sample_profile_suffix_elision_policy = false,
|
|
.memory_none = false,
|
|
.memory_readonly = false,
|
|
.memory_inaccessible_or_arg_memory_only = false,
|
|
.memory_arg_memory_only = false,
|
|
.strict_fp = false,
|
|
.no_inline = options.attributes.inline_behavior == InlineBehavior::no_inline,
|
|
.always_inline = options.attributes.inline_behavior == InlineBehavior::always_inline,
|
|
.guard_no_cf = false,
|
|
// TODO: branch protection function attributes
|
|
// TODO: cpu features
|
|
|
|
// CALL-SITE ATTRIBUTES
|
|
.call_no_builtins = false,
|
|
|
|
// DEFINITION-SITE ATTRIBUTES
|
|
.definition_frame_pointer_kind = module->has_debug_info ? BBLLVMFramePointerKind::all : BBLLVMFramePointerKind::none,
|
|
.definition_less_precise_fpmad = false,
|
|
.definition_null_pointer_is_valid = false,
|
|
.definition_no_trapping_fp_math = false,
|
|
.definition_no_infs_fp_math = false,
|
|
.definition_no_nans_fp_math = false,
|
|
.definition_approx_func_fp_math = false,
|
|
.definition_unsafe_fp_math = false,
|
|
.definition_use_soft_float = false,
|
|
.definition_no_signed_zeroes_fp_math = false,
|
|
.definition_stack_realignment = false,
|
|
.definition_backchain = false,
|
|
.definition_split_stack = false,
|
|
.definition_speculative_load_hardening = false,
|
|
.definition_zero_call_used_registers = ZeroCallUsedRegsKind::all,
|
|
// TODO: denormal builtins
|
|
.definition_non_lazy_bind = false,
|
|
.definition_cmse_nonsecure_entry = false,
|
|
.definition_unwind_table_kind = BBLLVMUWTableKind::None,
|
|
},
|
|
.flags1 = {
|
|
.definition_disable_tail_calls = false,
|
|
.definition_stack_protect_strong = false,
|
|
.definition_stack_protect = false,
|
|
.definition_stack_protect_req = false,
|
|
.definition_aarch64_new_za = false,
|
|
.definition_aarch64_new_zt0 = false,
|
|
.definition_optimize_none = false,
|
|
.definition_naked = !options.call_site and options.attributes.naked,
|
|
.definition_inline_hint = !options.call_site and options.attributes.inline_behavior == InlineBehavior::inline_hint,
|
|
},
|
|
};
|
|
|
|
auto attribute_list = llvm_attribute_list_build(module->llvm.context, &attributes, options.call_site);
|
|
return attribute_list;
|
|
}
|
|
|
|
fn void check_types(Module* module, Type* expected, Type* source)
|
|
{
|
|
assert(expected);
|
|
assert(source);
|
|
|
|
if (expected != source)
|
|
{
|
|
auto resolved_expected = resolve_alias(module, expected);
|
|
auto resolved_source = resolve_alias(module, source);
|
|
|
|
if (resolved_expected != resolved_source)
|
|
{
|
|
auto is_dst_p_and_source_int = resolved_expected->id == TypeId::pointer && resolved_source->id == TypeId::integer;
|
|
if (!is_dst_p_and_source_int)
|
|
{
|
|
report_error();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn void typecheck(Module* module, Type* expected, Type* source)
|
|
{
|
|
if (expected)
|
|
{
|
|
check_types(module, expected, source);
|
|
}
|
|
}
|
|
|
|
fn bool unary_is_boolean(UnaryId id)
|
|
{
|
|
switch (id)
|
|
{
|
|
case UnaryId::exclamation:
|
|
return true;
|
|
case UnaryId::minus:
|
|
case UnaryId::plus:
|
|
case UnaryId::ampersand:
|
|
case UnaryId::tilde:
|
|
case UnaryId::enum_name:
|
|
case UnaryId::extend:
|
|
case UnaryId::truncate:
|
|
case UnaryId::pointer_cast:
|
|
case UnaryId::int_from_enum:
|
|
case UnaryId::int_from_pointer:
|
|
case UnaryId::va_end:
|
|
case UnaryId::bitwise_not:
|
|
case UnaryId::dereference:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
fn bool binary_is_boolean(BinaryId id)
|
|
{
|
|
switch (id)
|
|
{
|
|
case BinaryId::add:
|
|
case BinaryId::sub:
|
|
case BinaryId::mul:
|
|
case BinaryId::div:
|
|
case BinaryId::rem:
|
|
case BinaryId::bitwise_and:
|
|
case BinaryId::bitwise_or:
|
|
case BinaryId::bitwise_xor:
|
|
case BinaryId::shift_left:
|
|
case BinaryId::shift_right:
|
|
return false;
|
|
case BinaryId::compare_equal:
|
|
case BinaryId::compare_not_equal:
|
|
case BinaryId::compare_greater:
|
|
case BinaryId::compare_less:
|
|
case BinaryId::compare_greater_equal:
|
|
case BinaryId::compare_less_equal:
|
|
case BinaryId::logical_and:
|
|
case BinaryId::logical_or:
|
|
case BinaryId::logical_and_shortcircuit:
|
|
case BinaryId::logical_or_shortcircuit:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
fn bool binary_is_shortcircuiting(BinaryId id)
|
|
{
|
|
switch (id)
|
|
{
|
|
case BinaryId::logical_and_shortcircuit:
|
|
case BinaryId::logical_or_shortcircuit:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
fn void analyze_type(Module* module, Value* value, Type* expected_type);
|
|
|
|
fn void analyze_binary_type(Module* module, Value* left, Value* right, bool is_boolean, Type* expected_type)
|
|
{
|
|
auto left_constant = left->is_constant();
|
|
auto right_constant = right->is_constant();
|
|
|
|
if (!expected_type)
|
|
{
|
|
if (left_constant && right_constant)
|
|
{
|
|
if (!left->type && !right->type)
|
|
{
|
|
auto are_string_literal = left->id == ValueId::string_literal && right->id == ValueId::string_literal;
|
|
|
|
if (are_string_literal)
|
|
{
|
|
expected_type = get_slice_type(module, uint8(module));
|
|
}
|
|
else
|
|
{
|
|
report_error();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (is_boolean || !expected_type)
|
|
{
|
|
if (left_constant)
|
|
{
|
|
analyze_type(module, right, 0);
|
|
analyze_type(module, left, right->type);
|
|
}
|
|
else
|
|
{
|
|
analyze_type(module, left, 0);
|
|
analyze_type(module, right, left->type);
|
|
}
|
|
}
|
|
else if (!is_boolean && expected_type)
|
|
{
|
|
analyze_type(module, left, expected_type);
|
|
analyze_type(module, right, expected_type);
|
|
}
|
|
else
|
|
{
|
|
report_error(); // TODO: this might not be an error necessarily?
|
|
}
|
|
|
|
assert(left->type);
|
|
assert(right->type);
|
|
}
|
|
|
|
fn Type* get_va_list_type(Module* module)
|
|
{
|
|
if (!module->va_list_type)
|
|
{
|
|
auto u32_type = uint32(module);
|
|
auto void_pointer = get_pointer_type(module, uint8(module));
|
|
auto fields = arena_allocate<Field>(module->arena, 4);
|
|
fields[0] = { .name = string_literal("gp_offset"), .type = u32_type, .offset = 0 };
|
|
fields[1] = { .name = string_literal("fp_offset"), .type = u32_type, .offset = 4 };
|
|
fields[2] = { .name = string_literal("overflow_arg_area"), .type = void_pointer, .offset = 8 };
|
|
fields[3] = { .name = string_literal("reg_save_area"), .type = void_pointer, .offset = 16 };
|
|
|
|
auto va_list_struct = type_allocate_init(module, {
|
|
.structure = {
|
|
.fields = fields,
|
|
.byte_size = 24,
|
|
.byte_alignment = 16,
|
|
},
|
|
.id = TypeId::structure,
|
|
.name = string_literal("va_list"),
|
|
});
|
|
|
|
module->va_list_type = get_array_type(module, va_list_struct, 1);
|
|
}
|
|
|
|
assert(module->va_list_type);
|
|
|
|
return module->va_list_type;
|
|
}
|
|
|
|
fn Global* get_enum_name_array_global(Module* module, Type* enum_type)
|
|
{
|
|
assert(enum_type->id == TypeId::enumerator);
|
|
|
|
if (!enum_type->enumerator.name_array)
|
|
{
|
|
auto fields = enum_type->enumerator.fields;
|
|
auto u8_type = uint8(module);
|
|
auto u64_type = uint64(module);
|
|
resolve_type_in_place(module, u8_type);
|
|
resolve_type_in_place(module, u64_type);
|
|
LLVMValueRef name_before = 0;
|
|
LLVMValueRef name_constant_buffer[64];
|
|
|
|
for (u32 i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto null_terminate = true;
|
|
auto& field = fields[i];
|
|
auto is_constant = true;
|
|
String name_parts[] = {
|
|
string_literal("string."),
|
|
enum_type->name,
|
|
string_literal("."),
|
|
field.name,
|
|
};
|
|
unsigned address_space = 0;
|
|
auto name_global = llvm_module_create_global_variable(module->llvm.module, LLVMArrayType2(u8_type->llvm.abi, field.name.length + null_terminate), is_constant, LLVMInternalLinkage, LLVMConstStringInContext2(module->llvm.context, (char*)field.name.pointer, field.name.length, false), arena_join_string(module->arena, array_to_slice(name_parts)), name_before, LLVMNotThreadLocal, address_space, false);
|
|
name_before = name_global;
|
|
LLVMValueRef constants[] = {
|
|
name_global,
|
|
LLVMConstInt(u64_type->llvm.abi, field.name.length, false),
|
|
};
|
|
auto slice_constant = LLVMConstStructInContext(module->llvm.context, constants, array_length(constants), false);
|
|
name_constant_buffer[i] = slice_constant;
|
|
}
|
|
|
|
unused(module);
|
|
|
|
auto slice_type = get_slice_type(module, u8_type);
|
|
auto array_element_count = fields.length;
|
|
auto name_array = LLVMConstArray2(slice_type->llvm.abi, name_constant_buffer, array_element_count);
|
|
auto name_array_type = LLVMArrayType2(slice_type->llvm.abi, array_element_count);
|
|
auto is_constant = true;
|
|
unsigned address_space = 0;
|
|
auto name_array_variable = llvm_module_create_global_variable(module->llvm.module, name_array_type, is_constant, LLVMInternalLinkage, name_array, string_literal("name.array.enum"), name_before, LLVMNotThreadLocal, address_space, false);
|
|
LLVMSetAlignment(name_array_variable, get_byte_alignment(slice_type));
|
|
LLVMSetUnnamedAddress(name_array_variable, LLVMGlobalUnnamedAddr);
|
|
|
|
auto global_type = get_array_type(module, slice_type, array_element_count);
|
|
resolve_type_in_place(module, global_type);
|
|
|
|
auto storage_type = get_pointer_type(module, global_type);
|
|
resolve_type_in_place(module, storage_type);
|
|
|
|
auto global_storage = new_value(module);
|
|
*global_storage = {
|
|
.type = storage_type,
|
|
.id = ValueId::global,
|
|
.kind = ValueKind::left,
|
|
.llvm = name_array_variable,
|
|
};
|
|
|
|
String name_parts[] = {
|
|
string_literal("name.array.enum."),
|
|
enum_type->name,
|
|
};
|
|
|
|
auto global = new_global(module);
|
|
*global = {
|
|
.variable = {
|
|
.storage = global_storage,
|
|
.initial_value = 0,
|
|
.type = global_type,
|
|
.scope = &module->scope,
|
|
.name = arena_join_string(module->arena, array_to_slice(name_parts)),
|
|
.line = 0,
|
|
.column = 0,
|
|
},
|
|
.linkage = Linkage::internal,
|
|
};
|
|
|
|
enum_type->enumerator.name_array = global;
|
|
}
|
|
|
|
return enum_type->enumerator.name_array;
|
|
}
|
|
|
|
fn void analyze_type(Module* module, Value* value, Type* expected_type)
|
|
{
|
|
assert(!value->type);
|
|
assert(!value->llvm);
|
|
|
|
if (expected_type && expected_type->id == TypeId::unresolved)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
Type* value_type = 0;
|
|
|
|
switch (value->id)
|
|
{
|
|
case ValueId::constant_integer:
|
|
{
|
|
if (!expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
resolve_type_in_place(module, expected_type);
|
|
auto* resolved_type = resolve_alias(module, expected_type);
|
|
switch (resolved_type->id)
|
|
{
|
|
case TypeId::integer:
|
|
{
|
|
if (value->constant_integer.is_signed)
|
|
{
|
|
if (resolved_type->integer.is_signed)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
auto max_value = integer_max_value(resolved_type->integer.bit_count, resolved_type->integer.is_signed);
|
|
|
|
if (value->constant_integer.value > max_value)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = expected_type;
|
|
}
|
|
} break;
|
|
case TypeId::pointer: value_type = uint64(module); break;
|
|
default: trap();
|
|
}
|
|
|
|
typecheck(module, expected_type, value_type);
|
|
} break;
|
|
case ValueId::unary:
|
|
{
|
|
auto unary_id = value->unary.id;
|
|
auto unary_value = value->unary.value;
|
|
switch (unary_id)
|
|
{
|
|
case UnaryId::extend:
|
|
{
|
|
if (!expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto extended_value = unary_value;
|
|
analyze_type(module, extended_value, 0);
|
|
auto source = extended_value->type;
|
|
assert(source);
|
|
|
|
auto source_bit_size = get_bit_size(source);
|
|
auto expected_bit_size = get_bit_size(expected_type);
|
|
if (source_bit_size > expected_bit_size)
|
|
{
|
|
report_error();
|
|
}
|
|
else if (source_bit_size == expected_bit_size && type_is_signed(source) == type_is_signed(expected_type))
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = expected_type;
|
|
} break;
|
|
case UnaryId::truncate:
|
|
{
|
|
if (!expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
analyze_type(module, unary_value, 0);
|
|
auto expected_bit_size = get_bit_size(expected_type);
|
|
auto source_bit_size = get_bit_size(unary_value->type);
|
|
|
|
if (expected_bit_size >= source_bit_size)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = expected_type;
|
|
} break;
|
|
case UnaryId::dereference:
|
|
{
|
|
analyze_type(module, unary_value, 0);
|
|
if (value->kind == ValueKind::left)
|
|
{
|
|
report_error();
|
|
}
|
|
auto pointer_type = unary_value->type;
|
|
assert(pointer_type->id == TypeId::pointer);
|
|
auto dereference_type = pointer_type->pointer.element_type;
|
|
|
|
typecheck(module, expected_type, dereference_type);
|
|
value_type = dereference_type;
|
|
} break;
|
|
case UnaryId::int_from_enum:
|
|
{
|
|
analyze_type(module, unary_value, 0);
|
|
|
|
auto value_enum_type = unary_value->type;
|
|
if (value_enum_type->id != TypeId::enumerator)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto backing_type = value_enum_type->enumerator.backing_type;
|
|
typecheck(module, expected_type, backing_type);
|
|
|
|
value_type = backing_type;
|
|
} break;
|
|
case UnaryId::int_from_pointer:
|
|
{
|
|
analyze_type(module, unary_value, 0);
|
|
|
|
auto value_enum_type = unary_value->type;
|
|
if (value_enum_type->id != TypeId::pointer)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = uint64(module);
|
|
typecheck(module, expected_type, value_type);
|
|
} break;
|
|
case UnaryId::pointer_cast:
|
|
{
|
|
if (!expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (expected_type->id != TypeId::pointer)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
analyze_type(module, unary_value, 0);
|
|
auto value_pointer_type = unary_value->type;
|
|
if (value_pointer_type == expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (value_pointer_type->id != TypeId::pointer)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = expected_type;
|
|
} break;
|
|
default:
|
|
{
|
|
auto is_boolean = unary_is_boolean(unary_id);
|
|
if (is_boolean)
|
|
{
|
|
analyze_type(module, unary_value, 0);
|
|
value_type = uint1(module);
|
|
}
|
|
else
|
|
{
|
|
analyze_type(module, unary_value, expected_type);
|
|
value_type = unary_value->type;
|
|
}
|
|
|
|
typecheck(module, expected_type, value_type);
|
|
} break;
|
|
}
|
|
} break;
|
|
case ValueId::unary_type:
|
|
{
|
|
auto unary_type = value->unary_type.type;
|
|
auto unary_type_id = value->unary_type.id;
|
|
switch (unary_type_id)
|
|
{
|
|
case UnaryTypeId::byte_size:
|
|
{
|
|
if (!expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (expected_type->id != TypeId::integer)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto size = get_byte_size(unary_type);
|
|
auto max_value = integer_max_value(unary_type->integer.bit_count, unary_type->integer.is_signed);
|
|
if (size > max_value)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = expected_type;
|
|
} break;
|
|
case UnaryTypeId::integer_max:
|
|
{
|
|
if (unary_type->id != TypeId::integer)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (expected_type)
|
|
{
|
|
if (expected_type->id != TypeId::integer)
|
|
{
|
|
report_error();
|
|
}
|
|
}
|
|
|
|
value_type = expected_type ? expected_type : unary_type;
|
|
typecheck(module, expected_type, value_type);
|
|
} break;
|
|
}
|
|
} break;
|
|
case ValueId::binary:
|
|
{
|
|
auto is_boolean = binary_is_boolean(value->binary.id);
|
|
analyze_binary_type(module, value->binary.left, value->binary.right, is_boolean, expected_type);
|
|
check_types(module, value->binary.left->type, value->binary.right->type);
|
|
|
|
value_type = is_boolean ? uint1(module) : value->binary.left->type;
|
|
} break;
|
|
case ValueId::variable_reference:
|
|
{
|
|
switch (value->kind)
|
|
{
|
|
case ValueKind::left: value_type = value->variable_reference->storage->type; break;
|
|
case ValueKind::right: value_type = value->variable_reference->type; break;
|
|
}
|
|
assert(value_type);
|
|
typecheck(module, expected_type, value_type);
|
|
} break;
|
|
case ValueId::call:
|
|
{
|
|
auto call = &value->call;
|
|
auto callable = call->callable;
|
|
analyze_type(module, callable, 0);
|
|
Type* function_type = 0;
|
|
switch (callable->id)
|
|
{
|
|
case ValueId::variable_reference:
|
|
{
|
|
auto variable_type = callable->variable_reference->type;
|
|
switch (variable_type->id)
|
|
{
|
|
case TypeId::function:
|
|
function_type = variable_type; break;
|
|
case TypeId::pointer:
|
|
{
|
|
auto* element_type = variable_type->pointer.element_type;
|
|
switch (element_type->id)
|
|
{
|
|
case TypeId::function: function_type = element_type; break;
|
|
default: report_error();
|
|
}
|
|
} break;
|
|
default: report_error();
|
|
}
|
|
} break;
|
|
default:
|
|
report_error();
|
|
}
|
|
|
|
assert(function_type);
|
|
call->function_type = function_type;
|
|
|
|
auto semantic_argument_types = function_type->function.semantic_argument_types;
|
|
auto call_arguments = call->arguments;
|
|
if (function_type->function.is_variable_arguments)
|
|
{
|
|
if (call_arguments.length < semantic_argument_types.length)
|
|
{
|
|
report_error();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (call_arguments.length != semantic_argument_types.length)
|
|
{
|
|
report_error();
|
|
}
|
|
}
|
|
|
|
for (u64 i = 0; i < semantic_argument_types.length; i += 1)
|
|
{
|
|
auto* argument_type = semantic_argument_types[i];
|
|
auto* call_argument = call_arguments[i];
|
|
analyze_type(module, call_argument, argument_type);
|
|
check_types(module, argument_type, call_argument->type);
|
|
}
|
|
|
|
for (u64 i = semantic_argument_types.length; i < call_arguments.length; i += 1)
|
|
{
|
|
auto* call_argument = call_arguments[i];
|
|
analyze_type(module, call_argument, 0);
|
|
}
|
|
|
|
auto semantic_return_type = function_type->function.semantic_return_type;
|
|
typecheck(module, expected_type, semantic_return_type);
|
|
value_type = semantic_return_type;
|
|
} break;
|
|
case ValueId::array_initialization:
|
|
{
|
|
auto values = value->array_initialization.values;
|
|
if (expected_type)
|
|
{
|
|
if (expected_type->array.element_count == 0)
|
|
{
|
|
expected_type->array.element_count = values.length;
|
|
assert(expected_type->name.equal(string_literal("")));
|
|
expected_type->name = array_name(module, expected_type->array.element_type, expected_type->array.element_count);
|
|
}
|
|
else
|
|
{
|
|
if (expected_type->array.element_count != values.length)
|
|
{
|
|
report_error();
|
|
}
|
|
}
|
|
|
|
bool is_constant = true;
|
|
|
|
auto* element_type = expected_type->array.element_type;
|
|
for (auto value : values)
|
|
{
|
|
analyze_type(module, value, element_type);
|
|
is_constant = is_constant && value->is_constant();
|
|
}
|
|
|
|
value->array_initialization.is_constant = is_constant;
|
|
|
|
if (value->kind == ValueKind::left) // TODO: possible?
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = expected_type;
|
|
}
|
|
else
|
|
{
|
|
if (values.length == 0)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
trap();
|
|
}
|
|
} break;
|
|
case ValueId::array_expression:
|
|
{
|
|
analyze_type(module, value->array_expression.index, uint64(module));
|
|
auto array_like = value->array_expression.array_like;
|
|
array_like->kind = ValueKind::left;
|
|
analyze_type(module, array_like, 0);
|
|
assert(array_like->kind == ValueKind::left);
|
|
auto array_like_type = array_like->type;
|
|
if (array_like_type->id != TypeId::pointer)
|
|
{
|
|
report_error();
|
|
}
|
|
auto pointer_element_type = array_like_type->pointer.element_type;
|
|
|
|
Type* element_type = 0;
|
|
switch (pointer_element_type->id)
|
|
{
|
|
case TypeId::array:
|
|
{
|
|
element_type = pointer_element_type->array.element_type;
|
|
} break;
|
|
case TypeId::structure:
|
|
{
|
|
auto slice_type = pointer_element_type;
|
|
if (!slice_type->structure.is_slice)
|
|
{
|
|
report_error();
|
|
}
|
|
auto slice_pointer_type = slice_type->structure.fields[0].type;
|
|
assert(slice_pointer_type->id == TypeId::pointer);
|
|
element_type = slice_pointer_type->pointer.element_type;
|
|
} break;
|
|
case TypeId::pointer:
|
|
{
|
|
element_type = pointer_element_type->pointer.element_type;
|
|
} break;
|
|
default: report_error();
|
|
}
|
|
|
|
assert(element_type);
|
|
|
|
value_type = element_type;
|
|
if (value->kind == ValueKind::left)
|
|
{
|
|
value_type = get_pointer_type(module, element_type);
|
|
}
|
|
|
|
typecheck(module, expected_type, value_type);
|
|
} break;
|
|
case ValueId::enum_literal:
|
|
{
|
|
if (!expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (expected_type->id != TypeId::enumerator)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = expected_type;
|
|
} break;
|
|
case ValueId::trap:
|
|
{
|
|
value_type = noreturn_type(module);
|
|
} break;
|
|
case ValueId::field_access:
|
|
{
|
|
auto aggregate = value->field_access.aggregate;
|
|
auto field_name = value->field_access.field_name;
|
|
unused(field_name);
|
|
analyze_type(module, aggregate, 0);
|
|
|
|
if (aggregate->kind == ValueKind::right)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto aggregate_type = aggregate->type;
|
|
if (aggregate_type->id != TypeId::pointer)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto aggregate_element_type = aggregate_type->pointer.element_type;
|
|
Type* real_aggregate_type = aggregate_element_type->id == TypeId::pointer ? aggregate_element_type->pointer.element_type : aggregate_element_type;
|
|
auto resolved_aggregate_type = resolve_alias(module, real_aggregate_type);
|
|
|
|
switch (resolved_aggregate_type->id)
|
|
{
|
|
case TypeId::structure:
|
|
{
|
|
Field* result_field = 0;
|
|
auto fields = resolved_aggregate_type->structure.fields;
|
|
for (u64 i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto* field = &fields[i];
|
|
if (field_name.equal(field->name))
|
|
{
|
|
result_field = field;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!result_field)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto field_type = result_field->type;
|
|
value_type = value->kind == ValueKind::left ? get_pointer_type(module, field_type) : field_type;
|
|
} break;
|
|
case TypeId::union_type:
|
|
{
|
|
trap();
|
|
} break;
|
|
case TypeId::bits:
|
|
{
|
|
if (value->kind == ValueKind::left)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto fields = resolved_aggregate_type->bits.fields;
|
|
u64 i;
|
|
for (i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto field = fields[i];
|
|
if (field_name.equal(field.name))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == fields.length)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
assert(value->kind == ValueKind::right);
|
|
|
|
auto field = fields[i];
|
|
value_type = field.type;
|
|
} break;
|
|
case TypeId::array:
|
|
{
|
|
trap();
|
|
} break;
|
|
case TypeId::pointer: report_error(); // Double indirection is not allowed
|
|
default: report_error();
|
|
}
|
|
|
|
assert(value_type);
|
|
|
|
typecheck(module, expected_type, value_type);
|
|
} break;
|
|
case ValueId::slice_expression:
|
|
{
|
|
auto array_like = value->slice_expression.array_like;
|
|
auto start = value->slice_expression.start;
|
|
auto end = value->slice_expression.end;
|
|
|
|
if (array_like->kind != ValueKind::left)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
analyze_type(module, array_like, 0);
|
|
|
|
auto pointer_type = array_like->type;
|
|
if (pointer_type->id != TypeId::pointer)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
Type* sliceable_type = pointer_type->pointer.element_type;
|
|
|
|
Type* element_type = 0;
|
|
|
|
switch (sliceable_type->id)
|
|
{
|
|
case TypeId::pointer:
|
|
{
|
|
element_type = sliceable_type->pointer.element_type;
|
|
} break;
|
|
case TypeId::structure:
|
|
{
|
|
if (!sliceable_type->structure.is_slice)
|
|
{
|
|
report_error();
|
|
}
|
|
auto slice_pointer_type = sliceable_type->structure.fields[0].type;
|
|
assert(slice_pointer_type->id == TypeId::pointer);
|
|
auto slice_element_type = slice_pointer_type->pointer.element_type;
|
|
element_type = slice_element_type;
|
|
} break;
|
|
case TypeId::array:
|
|
{
|
|
element_type = sliceable_type->array.element_type;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(element_type);
|
|
|
|
auto slice_type = get_slice_type(module, element_type);
|
|
typecheck(module, expected_type, slice_type);
|
|
|
|
auto index_type = uint64(module);
|
|
|
|
Value* indices[] = { start, end };
|
|
|
|
for (auto index : indices)
|
|
{
|
|
if (index)
|
|
{
|
|
analyze_type(module, index, index_type);
|
|
|
|
if (index->type->id != TypeId::integer)
|
|
{
|
|
report_error();
|
|
}
|
|
}
|
|
}
|
|
|
|
value_type = slice_type;
|
|
} break;
|
|
case ValueId::string_literal:
|
|
{
|
|
auto slice_type = get_slice_type(module, uint8(module));
|
|
typecheck(module, expected_type, slice_type);
|
|
value_type = slice_type;
|
|
} break;
|
|
case ValueId::va_start:
|
|
{
|
|
auto va_list_type = get_va_list_type(module);
|
|
typecheck(module, expected_type, va_list_type);
|
|
value_type = va_list_type;
|
|
} break;
|
|
case ValueId::va_arg:
|
|
{
|
|
analyze_type(module, value->va_arg.va_list, get_pointer_type(module, get_va_list_type(module)));
|
|
value_type = value->va_arg.type;
|
|
typecheck(module, expected_type, value_type);
|
|
} break;
|
|
case ValueId::aggregate_initialization:
|
|
{
|
|
if (!expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto resolved_type = resolve_alias(module, expected_type);
|
|
value_type = resolved_type;
|
|
|
|
assert(!value->aggregate_initialization.is_constant);
|
|
bool is_constant = true;
|
|
auto values = value->aggregate_initialization.values;
|
|
auto names = value->aggregate_initialization.names;
|
|
|
|
switch (resolved_type->id)
|
|
{
|
|
case TypeId::structure:
|
|
{
|
|
bool is_ordered = true;
|
|
auto fields = resolved_type->structure.fields;
|
|
|
|
for (u32 initialization_index = 0; initialization_index < values.length; initialization_index += 1)
|
|
{
|
|
auto value = values[initialization_index];
|
|
auto name = names[initialization_index];
|
|
|
|
u32 declaration_index;
|
|
for (declaration_index = 0; declaration_index < fields.length; declaration_index += 1)
|
|
{
|
|
auto& field = fields[declaration_index];
|
|
|
|
if (name.equal(field.name))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (declaration_index == fields.length)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
is_ordered = is_ordered && declaration_index == initialization_index;
|
|
|
|
auto field = fields[declaration_index];
|
|
auto declaration_type = field.type;
|
|
analyze_type(module, value, declaration_type);
|
|
is_constant = is_constant && value->is_constant();
|
|
}
|
|
|
|
value->aggregate_initialization.is_constant = is_constant && is_ordered;
|
|
} break;
|
|
case TypeId::bits:
|
|
{
|
|
auto fields = resolved_type->bits.fields;
|
|
|
|
|
|
assert(values.length == names.length);
|
|
|
|
for (u32 initialization_index = 0; initialization_index < values.length; initialization_index += 1)
|
|
{
|
|
auto value = values[initialization_index];
|
|
auto name = names[initialization_index];
|
|
|
|
u32 declaration_index;
|
|
for (declaration_index = 0; declaration_index < fields.length; declaration_index += 1)
|
|
{
|
|
auto& field = fields[declaration_index];
|
|
|
|
if (name.equal(field.name))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (declaration_index == fields.length)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto field = fields[declaration_index];
|
|
auto declaration_type = field.type;
|
|
analyze_type(module, value, declaration_type);
|
|
is_constant = is_constant && value->is_constant();
|
|
}
|
|
|
|
value->aggregate_initialization.is_constant = is_constant;
|
|
} break;
|
|
case TypeId::union_type:
|
|
{
|
|
trap();
|
|
} break;
|
|
default: report_error();
|
|
}
|
|
} break;
|
|
case ValueId::zero:
|
|
{
|
|
if (!expected_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (expected_type->id == TypeId::void_type || expected_type->id == TypeId::noreturn)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
value_type = expected_type;
|
|
} break;
|
|
case ValueId::select:
|
|
{
|
|
auto condition = value->select.condition;
|
|
auto true_value = value->select.true_value;
|
|
auto false_value = value->select.false_value;
|
|
analyze_type(module, condition, 0);
|
|
auto is_boolean = false;
|
|
analyze_binary_type(module, true_value, false_value, is_boolean, expected_type);
|
|
|
|
auto left_type = true_value->type;
|
|
auto right_type = false_value->type;
|
|
check_types(module, left_type, right_type);
|
|
|
|
assert(left_type == right_type);
|
|
auto result_type = left_type;
|
|
typecheck(module, expected_type, result_type);
|
|
|
|
value_type = result_type;
|
|
} break;
|
|
case ValueId::unreachable:
|
|
{
|
|
value_type = noreturn_type(module);
|
|
} break;
|
|
case ValueId::string_to_enum:
|
|
{
|
|
auto enum_type = value->string_to_enum.type;
|
|
auto enum_string_value = value->string_to_enum.string;
|
|
if (enum_type->id != TypeId::enumerator)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (!enum_type->enumerator.string_to_enum_function)
|
|
{
|
|
resolve_type_in_place(module, enum_type);
|
|
|
|
auto fields = enum_type->enumerator.fields;
|
|
auto array_element_count = fields.length;
|
|
|
|
auto insert_block = LLVMGetInsertBlock(module->llvm.builder);
|
|
|
|
auto u1_type = uint1(module);
|
|
auto u8_type = uint8(module);
|
|
auto u64_type = uint64(module);
|
|
resolve_type_in_place(module, u1_type);
|
|
resolve_type_in_place(module, u8_type);
|
|
resolve_type_in_place(module, u64_type);
|
|
|
|
auto u64_zero = LLVMConstNull(u64_type->llvm.abi);
|
|
|
|
auto enum_alignment = get_byte_alignment(enum_type);
|
|
auto enum_size = get_byte_size(enum_type);
|
|
auto byte_size = align_forward(enum_size + 1, enum_alignment);
|
|
|
|
auto struct_fields = arena_allocate<Field>(module->arena, 2);
|
|
|
|
struct_fields[0] = {
|
|
.name = string_literal("enum_value"),
|
|
.type = enum_type,
|
|
};
|
|
|
|
struct_fields[1] = {
|
|
.name = string_literal("is_valid"),
|
|
.type = enum_type,
|
|
.offset = enum_size,
|
|
};
|
|
|
|
auto struct_type = type_allocate_init(module, {
|
|
.structure = {
|
|
.fields = struct_fields,
|
|
.byte_size = byte_size,
|
|
.byte_alignment = enum_alignment,
|
|
},
|
|
.id = TypeId::structure,
|
|
.name = string_literal("string_to_enum"),
|
|
});
|
|
resolve_type_in_place(module, struct_type);
|
|
|
|
LLVMTypeRef argument_types[] = { module->llvm.pointer_type, u64_type->llvm.abi };
|
|
auto llvm_function_type = LLVMFunctionType(struct_type->llvm.abi, argument_types, array_length(argument_types), false);
|
|
auto slice_struct_type = get_slice_type(module, u8_type);
|
|
|
|
String name_parts[] = {
|
|
string_literal("string_to_enum."),
|
|
enum_type->name,
|
|
};
|
|
auto function_name = arena_join_string(module->arena, array_to_slice(name_parts));
|
|
auto llvm_function = llvm_module_create_function(module->llvm.module, llvm_function_type, LLVMInternalLinkage, 0, function_name);
|
|
LLVMSetFunctionCallConv(llvm_function, LLVMFastCallConv);
|
|
|
|
auto name_array_global = get_enum_name_array_global(module, enum_type);
|
|
unused(name_array_global);
|
|
|
|
auto enum_value_type = enum_type->llvm.memory;
|
|
|
|
LLVMValueRef value_constant_buffer[64];
|
|
for (u32 i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto& field = fields[i];
|
|
auto global_value = LLVMConstInt(enum_value_type, field.value, false);
|
|
value_constant_buffer[i] = global_value;
|
|
}
|
|
|
|
auto value_array = LLVMConstArray2(enum_value_type, value_constant_buffer, array_element_count);
|
|
auto value_array_variable_type = LLVMArrayType2(enum_value_type, array_element_count);
|
|
auto is_constant = true;
|
|
LLVMValueRef before = 0;
|
|
LLVMThreadLocalMode thread_local_mode = LLVMNotThreadLocal;
|
|
unsigned address_space = 0;
|
|
auto externally_initialized = false;
|
|
auto value_array_variable = llvm_module_create_global_variable(module->llvm.module, value_array_variable_type, is_constant, LLVMInternalLinkage, value_array, string_literal("value.array.enum"), before, thread_local_mode, address_space, externally_initialized);
|
|
LLVMSetAlignment(value_array_variable, enum_alignment);
|
|
LLVMSetUnnamedAddress(value_array_variable, LLVMGlobalUnnamedAddr);
|
|
|
|
auto* entry_block = llvm_context_create_basic_block(module->llvm.context, string_literal("entry"), llvm_function);
|
|
auto* return_block = llvm_context_create_basic_block(module->llvm.context, string_literal("return_block"), llvm_function);
|
|
auto* loop_entry_block = llvm_context_create_basic_block(module->llvm.context, string_literal("loop.entry"), llvm_function);
|
|
auto* loop_body_block = llvm_context_create_basic_block(module->llvm.context, string_literal("loop.body"), llvm_function);
|
|
auto* loop_exit_block = llvm_context_create_basic_block(module->llvm.context, string_literal("loop.exit"), llvm_function);
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, entry_block);
|
|
|
|
LLVMValueRef arguments[2];
|
|
LLVMGetParams(llvm_function, arguments);
|
|
|
|
auto return_value_alloca = create_alloca(module, {
|
|
.type = enum_type,
|
|
.name = string_literal("retval"),
|
|
});
|
|
|
|
auto return_boolean_alloca = create_alloca(module, {
|
|
.type = u8_type,
|
|
.name = string_literal("retbool"),
|
|
});
|
|
|
|
auto index_alloca = create_alloca(module, {
|
|
.type = u64_type,
|
|
.name = string_literal("index"),
|
|
});
|
|
|
|
create_store(module, {
|
|
.source = u64_zero,
|
|
.destination = index_alloca,
|
|
.type = u64_type,
|
|
});
|
|
|
|
auto slice_pointer = arguments[0];
|
|
auto slice_length = arguments[1];
|
|
LLVMBuildBr(module->llvm.builder, loop_entry_block);
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, loop_entry_block);
|
|
auto index_load = create_load(module, {
|
|
.type = u64_type,
|
|
.pointer = index_alloca,
|
|
});
|
|
auto loop_compare = LLVMBuildICmp(module->llvm.builder, LLVMIntULT, index_load, LLVMConstInt(u64_type->llvm.abi, array_element_count, false), "");
|
|
LLVMBuildCondBr(module->llvm.builder, loop_compare, loop_body_block, loop_exit_block);
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, loop_body_block);
|
|
auto body_index_load = create_load(module, {
|
|
.type = u64_type,
|
|
.pointer = index_alloca,
|
|
});
|
|
|
|
LLVMValueRef indices[] = {
|
|
u64_zero,
|
|
body_index_load,
|
|
};
|
|
auto array_element_pointer = create_gep(module, {
|
|
.type = name_array_global->variable.type->llvm.memory,
|
|
.pointer = name_array_global->variable.storage->llvm,
|
|
.indices = array_to_slice(indices),
|
|
});
|
|
|
|
auto element_length_pointer = LLVMBuildStructGEP2(module->llvm.builder, slice_struct_type->llvm.abi, array_element_pointer, 1, "");
|
|
auto element_length = create_load(module, {
|
|
.type = u64_type,
|
|
.pointer = element_length_pointer,
|
|
});
|
|
|
|
auto length_comparison = LLVMBuildICmp(module->llvm.builder, LLVMIntEQ, slice_length, element_length, "");
|
|
|
|
auto* length_match_block = llvm_context_create_basic_block(module->llvm.context, string_literal("length.match"), llvm_function);
|
|
auto* length_mismatch_block = llvm_context_create_basic_block(module->llvm.context, string_literal("length.mismatch"), llvm_function);
|
|
LLVMBuildCondBr(module->llvm.builder, length_comparison, length_match_block, length_mismatch_block);
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, length_match_block);
|
|
|
|
auto s32_type = sint32(module);
|
|
resolve_type_in_place(module, s32_type);
|
|
|
|
LLVMValueRef memcmp = module->llvm.memcmp;
|
|
if (!memcmp)
|
|
{
|
|
memcmp = LLVMGetNamedFunction(module->llvm.module, "memcmp");
|
|
if (!memcmp)
|
|
{
|
|
LLVMTypeRef arguments[] = {
|
|
module->llvm.pointer_type,
|
|
module->llvm.pointer_type,
|
|
u64_type->llvm.abi,
|
|
};
|
|
auto llvm_function_type = LLVMFunctionType(s32_type->llvm.abi, arguments, array_length(arguments), false);
|
|
auto llvm_function = llvm_module_create_function(module->llvm.module, llvm_function_type, LLVMExternalLinkage, address_space, string_literal("memcmp"));
|
|
memcmp = llvm_function;
|
|
}
|
|
|
|
module->llvm.memcmp = memcmp;
|
|
}
|
|
|
|
assert(memcmp);
|
|
assert(module->llvm.memcmp);
|
|
|
|
auto length_index_load = create_load(module, {
|
|
.type = u64_type,
|
|
.pointer = index_alloca,
|
|
});
|
|
|
|
LLVMValueRef length_indices[] = { u64_zero, length_index_load };
|
|
auto length_array_element_pointer = create_gep(module, {
|
|
.type = name_array_global->variable.type->llvm.memory,
|
|
.pointer = name_array_global->variable.storage->llvm,
|
|
.indices = array_to_slice(length_indices),
|
|
});
|
|
|
|
auto element_pointer_pointer = LLVMBuildStructGEP2(module->llvm.builder, slice_struct_type->llvm.abi, length_array_element_pointer, 0, "");
|
|
auto element_pointer = create_load(module, {
|
|
.type = get_pointer_type(module, u8_type),
|
|
.pointer = element_pointer_pointer,
|
|
});
|
|
|
|
LLVMValueRef memcmp_arguments[] = {
|
|
slice_pointer,
|
|
element_pointer,
|
|
slice_length,
|
|
};
|
|
auto memcmp_return_result = LLVMBuildCall2(module->llvm.builder, LLVMGlobalGetValueType(memcmp), memcmp, memcmp_arguments, array_length(memcmp_arguments), "");
|
|
auto content_comparison = LLVMBuildICmp(module->llvm.builder, LLVMIntEQ, memcmp_return_result, LLVMConstNull(s32_type->llvm.abi), "");
|
|
auto* content_match_block = llvm_context_create_basic_block(module->llvm.context, string_literal("content.match"), llvm_function);
|
|
LLVMBuildCondBr(module->llvm.builder, content_comparison, content_match_block, length_mismatch_block);
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, content_match_block);
|
|
|
|
auto content_index_load = create_load(module, {
|
|
.type = u64_type,
|
|
.pointer = index_alloca,
|
|
});
|
|
|
|
LLVMValueRef value_array_indices[] = {
|
|
u64_zero,
|
|
content_index_load,
|
|
};
|
|
auto value_array_element_pointer = create_gep(module, {
|
|
.type = value_array_variable_type,
|
|
.pointer = value_array_variable,
|
|
.indices = array_to_slice(value_array_indices),
|
|
});
|
|
|
|
auto enum_value_load = create_load(module, {
|
|
.type = enum_type,
|
|
.pointer = value_array_element_pointer,
|
|
});
|
|
|
|
create_store(module, {
|
|
.source = enum_value_load,
|
|
.destination = return_value_alloca,
|
|
.type = enum_type,
|
|
});
|
|
|
|
create_store(module, {
|
|
.source = LLVMConstInt(u8_type->llvm.abi, 1, false),
|
|
.destination = return_boolean_alloca,
|
|
.type = u8_type,
|
|
});
|
|
|
|
LLVMBuildBr(module->llvm.builder, return_block);
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, length_mismatch_block);
|
|
|
|
auto inc_index_load = create_load(module, {
|
|
.type = u64_type,
|
|
.pointer = index_alloca,
|
|
});
|
|
|
|
auto inc = LLVMBuildAdd(module->llvm.builder, inc_index_load, LLVMConstInt(u64_type->llvm.abi, 1, false), "");
|
|
|
|
create_store(module, {
|
|
.source = inc,
|
|
.destination = index_alloca,
|
|
.type = u64_type,
|
|
});
|
|
|
|
LLVMBuildBr(module->llvm.builder, loop_entry_block);
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, loop_exit_block);
|
|
|
|
create_store(module, {
|
|
.source = LLVMConstNull(enum_type->llvm.memory),
|
|
.destination = return_value_alloca,
|
|
.type = enum_type,
|
|
});
|
|
create_store(module, {
|
|
.source = LLVMConstNull(u8_type->llvm.abi),
|
|
.destination = return_boolean_alloca,
|
|
.type = u8_type,
|
|
});
|
|
LLVMBuildBr(module->llvm.builder, return_block);
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, return_block);
|
|
auto value_load = create_load(module, {
|
|
.type = enum_type,
|
|
.pointer = return_value_alloca,
|
|
.kind = TypeKind::memory,
|
|
});
|
|
|
|
auto return_value = LLVMBuildInsertValue(module->llvm.builder, LLVMGetPoison(struct_type->llvm.memory), value_load, 0, "");
|
|
auto bool_load = create_load(module, {
|
|
.type = u8_type,
|
|
.pointer = return_boolean_alloca,
|
|
});
|
|
|
|
return_value = LLVMBuildInsertValue(module->llvm.builder, return_value, bool_load, 1, "");
|
|
|
|
LLVMBuildRet(module->llvm.builder, return_value);
|
|
|
|
// End of scope
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, insert_block);
|
|
|
|
enum_type->enumerator.string_to_enum_function = llvm_function;
|
|
enum_type->enumerator.string_to_enum_struct_type = struct_type;
|
|
}
|
|
|
|
auto struct_type = enum_type->enumerator.string_to_enum_struct_type;
|
|
assert(struct_type);
|
|
|
|
typecheck(module, expected_type, struct_type);
|
|
|
|
auto string_type = get_slice_type(module, uint8(module));
|
|
|
|
analyze_type(module, enum_string_value, string_type);
|
|
value_type = struct_type;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(value_type);
|
|
value->type = value_type;
|
|
}
|
|
|
|
fn LLVMTypeRef get_llvm_type(Type* type, TypeKind type_kind)
|
|
{
|
|
switch (type_kind)
|
|
{
|
|
case TypeKind::abi:
|
|
return type->llvm.abi;
|
|
case TypeKind::memory:
|
|
return type->llvm.memory;
|
|
}
|
|
}
|
|
|
|
fn void analyze_value(Module* module, Value* value, Type* expected_type, TypeKind type_kind);
|
|
|
|
fn bool type_is_integer_backing(Type* type)
|
|
{
|
|
switch (type->id)
|
|
{
|
|
case TypeId::enumerator:
|
|
case TypeId::integer:
|
|
case TypeId::bits:
|
|
case TypeId::pointer:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
struct ValueTypePair
|
|
{
|
|
LLVMValueRef value;
|
|
Type* type;
|
|
};
|
|
|
|
fn ValueTypePair enter_struct_pointer_for_coerced_access(Module* module, LLVMValueRef source_value, Type* source_type, u64 destination_size)
|
|
{
|
|
unused(module);
|
|
unused(source_value);
|
|
unused(source_type);
|
|
unused(destination_size);
|
|
assert(source_type->id == TypeId::structure && source_type->structure.fields.length > 0);
|
|
auto first_field_type = source_type->structure.fields[0].type;
|
|
auto first_field_size = get_byte_size(first_field_type);
|
|
auto source_size = get_byte_size(source_type);
|
|
|
|
if (!(first_field_size < destination_size && first_field_size < source_size))
|
|
{
|
|
trap();
|
|
}
|
|
|
|
return { source_value, source_type };
|
|
}
|
|
|
|
fn LLVMValueRef create_coerced_load(Module* module, LLVMValueRef source, Type* source_type, Type* destination_type)
|
|
{
|
|
unused(module);
|
|
unused(source);
|
|
unused(source_type);
|
|
unused(destination_type);
|
|
|
|
LLVMValueRef result = 0;
|
|
|
|
if (type_is_abi_equal(module, source_type, destination_type))
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
auto destination_size = get_byte_size(destination_type);
|
|
unused(destination_size);
|
|
if (source_type->id == TypeId::structure)
|
|
{
|
|
auto src = enter_struct_pointer_for_coerced_access(module, source, source_type, destination_size);
|
|
source = src.value;
|
|
source_type = src.type;
|
|
}
|
|
|
|
if (type_is_integer_backing(source_type) && type_is_integer_backing(destination_type))
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
auto source_size = get_byte_size(source_type);
|
|
|
|
auto is_source_type_scalable = false;
|
|
auto is_destination_type_scalable = false;
|
|
|
|
if (!is_source_type_scalable && !is_destination_type_scalable && source_size >= destination_size)
|
|
{
|
|
result = create_load(module, LoadOptions{ .type = destination_type, .pointer = source });
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
}
|
|
}
|
|
|
|
assert(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
fn void create_coerced_store(Module* module, LLVMValueRef source_value, Type* source_type, LLVMValueRef destination_value, Type* destination_type, u64 destination_size, bool destination_volatile)
|
|
{
|
|
unused(destination_volatile);
|
|
unused(source_value);
|
|
unused(destination_value);
|
|
|
|
auto source_size = get_byte_size(source_type);
|
|
|
|
if (!type_is_abi_equal(module, source_type, destination_type))
|
|
{
|
|
auto r = enter_struct_pointer_for_coerced_access(module, destination_value, destination_type, source_size);
|
|
destination_value = r.value;
|
|
destination_type = r.type;
|
|
}
|
|
|
|
auto is_scalable = false;
|
|
|
|
if (is_scalable || source_size <= destination_size)
|
|
{
|
|
auto destination_alignment = get_byte_alignment(destination_type);
|
|
|
|
if (source_type->id == TypeId::integer && destination_type->id == TypeId::pointer && source_size == align_forward(destination_size, destination_alignment))
|
|
{
|
|
trap();
|
|
}
|
|
else if (source_type->id == TypeId::structure)
|
|
{
|
|
auto fields = source_type->structure.fields;
|
|
for (u32 i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto& field = fields[i];
|
|
auto gep = LLVMBuildStructGEP2(module->llvm.builder, source_type->llvm.abi, destination_value, i, "");
|
|
auto field_value = LLVMBuildExtractValue(module->llvm.builder, source_value, i, "");
|
|
create_store(module, {
|
|
.source = field_value,
|
|
.destination = gep,
|
|
.type = field.type,
|
|
.alignment = destination_alignment,
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
create_store(module, StoreOptions{
|
|
.source = source_value,
|
|
.destination = destination_value,
|
|
.type = destination_type,
|
|
.alignment = destination_alignment,
|
|
});
|
|
}
|
|
}
|
|
else if (type_is_integer_backing(source_type))
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
}
|
|
|
|
fn LLVMValueRef emit_call(Module* module, Value* value, LLVMValueRef left_llvm, Type* left_type)
|
|
{
|
|
unused(left_llvm);
|
|
unused(left_type);
|
|
switch (value->id)
|
|
{
|
|
case ValueId::call:
|
|
{
|
|
auto call = &value->call;
|
|
|
|
auto raw_function_type = call->function_type;
|
|
auto callable = call->callable;
|
|
auto call_arguments = call->arguments;
|
|
|
|
LLVMValueRef llvm_callable = 0;
|
|
|
|
switch (callable->id)
|
|
{
|
|
case ValueId::variable_reference:
|
|
{
|
|
auto variable = callable->variable_reference;
|
|
auto variable_type = variable->type;
|
|
switch (variable_type->id)
|
|
{
|
|
case TypeId::pointer:
|
|
{
|
|
auto element_type = variable_type->pointer.element_type;
|
|
switch (element_type->id)
|
|
{
|
|
case TypeId::function:
|
|
{
|
|
llvm_callable = create_load(module, LoadOptions{
|
|
.type = get_pointer_type(module, raw_function_type),
|
|
.pointer = variable->storage->llvm,
|
|
});
|
|
} break;
|
|
default: report_error();
|
|
}
|
|
} break;
|
|
case TypeId::function: llvm_callable = variable->storage->llvm; break;
|
|
default: report_error();
|
|
}
|
|
} break;
|
|
default: report_error();
|
|
}
|
|
|
|
assert(llvm_callable);
|
|
|
|
LLVMValueRef llvm_abi_argument_value_buffer[64];
|
|
LLVMTypeRef llvm_abi_argument_type_buffer[64];
|
|
Type* abi_argument_type_buffer[64];
|
|
AbiInformation argument_abi_buffer[64];
|
|
|
|
u16 abi_argument_count = 0;
|
|
|
|
bool uses_in_alloca = false;
|
|
if (uses_in_alloca)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
LLVMValueRef llvm_indirect_return_value = 0;
|
|
unused(llvm_indirect_return_value);
|
|
|
|
auto& return_abi = raw_function_type->function.return_abi;
|
|
auto return_abi_kind = return_abi.flags.kind;
|
|
switch (return_abi_kind)
|
|
{
|
|
case AbiKind::indirect:
|
|
case AbiKind::in_alloca:
|
|
case AbiKind::coerce_and_expand:
|
|
{
|
|
// TODO: handle edge cases:
|
|
// - virtual function pointer thunk
|
|
// - return alloca already exists
|
|
LLVMValueRef pointer = 0;
|
|
auto semantic_return_type = return_abi.semantic_type;
|
|
if (left_llvm)
|
|
{
|
|
assert(left_type->pointer.element_type == semantic_return_type);
|
|
pointer = left_llvm;
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
assert(pointer);
|
|
|
|
auto has_sret = return_abi.flags.kind == AbiKind::indirect;
|
|
if (has_sret)
|
|
{
|
|
auto void_ty = void_type(module);
|
|
llvm_abi_argument_value_buffer[abi_argument_count] = pointer;
|
|
abi_argument_type_buffer[abi_argument_count] = void_ty;
|
|
llvm_abi_argument_type_buffer[abi_argument_count] = void_ty->llvm.abi;
|
|
abi_argument_count += 1;
|
|
llvm_indirect_return_value = pointer;
|
|
}
|
|
else if (return_abi.flags.kind == AbiKind::in_alloca)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
default: break;
|
|
}
|
|
|
|
auto available_registers = raw_function_type->function.available_registers;
|
|
|
|
auto declaration_semantic_argument_count = raw_function_type->function.semantic_argument_types.length;
|
|
for (u64 call_argument_index = 0; call_argument_index < call_arguments.length; call_argument_index += 1)
|
|
{
|
|
auto is_named_argument = call_argument_index < declaration_semantic_argument_count;
|
|
auto semantic_call_argument_value = call_arguments[call_argument_index];
|
|
|
|
Type* semantic_argument_type;
|
|
AbiInformation argument_abi;
|
|
Slice<LLVMTypeRef> llvm_abi_argument_type_buffer_slice = array_to_slice(llvm_abi_argument_type_buffer);
|
|
Slice<Type*> abi_argument_type_buffer_slice = array_to_slice(abi_argument_type_buffer);
|
|
|
|
if (is_named_argument)
|
|
{
|
|
argument_abi = raw_function_type->function.argument_abis[call_argument_index];
|
|
semantic_argument_type = argument_abi.semantic_type;
|
|
}
|
|
else
|
|
{
|
|
semantic_argument_type = semantic_call_argument_value->type;
|
|
argument_abi = abi_system_v_classify_argument(module, &available_registers.system_v, llvm_abi_argument_type_buffer_slice, abi_argument_type_buffer_slice, {
|
|
.type = semantic_argument_type,
|
|
.abi_start = abi_argument_count,
|
|
.is_named_argument = false,
|
|
});
|
|
}
|
|
|
|
if (get_byte_size(semantic_argument_type) > 60 && argument_abi.flags.kind != AbiKind::indirect)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
resolve_type_in_place(module, semantic_argument_type);
|
|
|
|
if (is_named_argument)
|
|
{
|
|
auto llvm_abi_argument_types = llvm_abi_argument_type_buffer_slice(argument_abi.abi_start)(0, argument_abi.abi_count);
|
|
auto destination_abi_argument_types = abi_argument_type_buffer_slice(argument_abi.abi_start)(0, argument_abi.abi_count);
|
|
auto source_abi_argument_types = raw_function_type->function.abi_argument_types(argument_abi.abi_start)(0, argument_abi.abi_count);
|
|
for (u16 i = 0; i < argument_abi.abi_count; i += 1)
|
|
{
|
|
llvm_abi_argument_types[i] = source_abi_argument_types[i]->llvm.abi;
|
|
destination_abi_argument_types[i] = source_abi_argument_types[i];
|
|
}
|
|
}
|
|
|
|
argument_abi_buffer[call_argument_index] = argument_abi;
|
|
|
|
if (argument_abi.padding.type)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
assert(abi_argument_count == argument_abi.abi_start);
|
|
auto argument_abi_kind = argument_abi.flags.kind;
|
|
switch (argument_abi_kind)
|
|
{
|
|
case AbiKind::direct:
|
|
case AbiKind::extend:
|
|
{
|
|
auto coerce_to_type = argument_abi.get_coerce_to_type();
|
|
resolve_type_in_place(module, coerce_to_type);
|
|
|
|
if (coerce_to_type->id != TypeId::structure && type_is_abi_equal(module, semantic_argument_type, coerce_to_type) && argument_abi.attributes.direct.offset == 0)
|
|
{
|
|
emit_value(module, semantic_call_argument_value, TypeKind::memory);
|
|
|
|
auto evaluation_kind = get_evaluation_kind(argument_abi.semantic_type);
|
|
Value* v;
|
|
switch (evaluation_kind)
|
|
{
|
|
case EvaluationKind::scalar: v = semantic_call_argument_value; break;
|
|
case EvaluationKind::aggregate: trap();
|
|
case EvaluationKind::complex: trap();
|
|
}
|
|
|
|
if (!type_is_abi_equal(module, coerce_to_type, v->type))
|
|
{
|
|
trap();
|
|
}
|
|
|
|
llvm_abi_argument_value_buffer[abi_argument_count] = v->llvm;
|
|
abi_argument_count += 1;
|
|
}
|
|
else
|
|
{
|
|
if (coerce_to_type->id == TypeId::structure && argument_abi.flags.kind == AbiKind::direct && !argument_abi.flags.can_be_flattened)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto evaluation_kind = get_evaluation_kind(semantic_argument_type);
|
|
Value* src = 0;
|
|
switch (evaluation_kind)
|
|
{
|
|
case EvaluationKind::scalar: trap();
|
|
case EvaluationKind::aggregate: src = semantic_call_argument_value; break;
|
|
case EvaluationKind::complex: trap();
|
|
}
|
|
assert(src);
|
|
|
|
if (argument_abi.attributes.direct.offset != 0)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
if (coerce_to_type->id == TypeId::structure && argument_abi.flags.kind == AbiKind::direct && argument_abi.flags.can_be_flattened)
|
|
{
|
|
auto source_type_is_scalable = false;
|
|
if (source_type_is_scalable)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
if (src->kind == ValueKind::right)
|
|
{
|
|
if (src->id == ValueId::variable_reference)
|
|
{
|
|
src->type = 0;
|
|
src->kind = ValueKind::left;
|
|
analyze_type(module, src, 0);
|
|
}
|
|
}
|
|
|
|
emit_value(module, semantic_call_argument_value, TypeKind::memory);
|
|
auto destination_size = get_byte_size(coerce_to_type);
|
|
auto source_size = get_byte_size(argument_abi.semantic_type);
|
|
auto alignment = get_byte_alignment(argument_abi.semantic_type);
|
|
unused(alignment);
|
|
|
|
LLVMValueRef source = src->llvm;
|
|
if (source_size < destination_size)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto coerce_fields = coerce_to_type->structure.fields;
|
|
|
|
// TODO:
|
|
assert(argument_abi.attributes.direct.offset == 0);
|
|
|
|
switch (semantic_call_argument_value->kind)
|
|
{
|
|
case ValueKind::left:
|
|
{
|
|
for (u32 i = 0; i < (u32)coerce_fields.length; i += 1)
|
|
{
|
|
auto& field = coerce_fields[i];
|
|
auto gep = LLVMBuildStructGEP2(module->llvm.builder, coerce_to_type->llvm.memory, source, i, "");
|
|
auto maybe_undef = false;
|
|
if (maybe_undef)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto load = create_load(module, {
|
|
.type = field.type,
|
|
.pointer = gep,
|
|
.alignment = alignment,
|
|
});
|
|
llvm_abi_argument_value_buffer[abi_argument_count] = load;
|
|
abi_argument_count += 1;
|
|
}
|
|
} break;
|
|
case ValueKind::right:
|
|
{
|
|
if (type_is_abi_equal(module, coerce_to_type, semantic_argument_type))
|
|
{
|
|
for (u32 i = 0; i < (u32)coerce_fields.length; i += 1)
|
|
{
|
|
llvm_abi_argument_value_buffer[abi_argument_count] = LLVMBuildExtractValue(module->llvm.builder, source, i, "");
|
|
abi_argument_count += 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (semantic_call_argument_value->id)
|
|
{
|
|
case ValueId::aggregate_initialization:
|
|
{
|
|
auto is_constant = semantic_call_argument_value->aggregate_initialization.is_constant;
|
|
|
|
if (is_constant)
|
|
{
|
|
bool is_constant = true;
|
|
LLVMLinkage linkage_type = LLVMInternalLinkage;
|
|
LLVMValueRef before = 0;
|
|
LLVMThreadLocalMode thread_local_mode = {};
|
|
u32 address_space = 0;
|
|
bool externally_initialized = false;
|
|
|
|
auto global = llvm_module_create_global_variable(module->llvm.module, semantic_argument_type->llvm.memory, is_constant, linkage_type, semantic_call_argument_value->llvm, string_literal("conststruct"), before, thread_local_mode, address_space, externally_initialized);
|
|
LLVMSetUnnamedAddress(global, LLVMGlobalUnnamedAddr);
|
|
|
|
auto alignment = get_byte_alignment(semantic_argument_type);
|
|
LLVMSetAlignment(global, alignment);
|
|
|
|
for (u32 i = 0; i < coerce_fields.length; i += 1)
|
|
{
|
|
auto gep = LLVMBuildStructGEP2(module->llvm.builder, coerce_to_type->llvm.abi, global, i, "");
|
|
auto& field = coerce_fields[i];
|
|
auto maybe_undef = false;
|
|
if (maybe_undef)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto load = create_load(module, { .type = field.type, .pointer = gep, .alignment = alignment });
|
|
|
|
llvm_abi_argument_value_buffer[abi_argument_count] = load;
|
|
abi_argument_count += 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
default: trap();
|
|
}
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
assert(argument_abi.abi_count == 1);
|
|
auto destination_type = coerce_to_type;
|
|
|
|
LLVMValueRef v = 0;
|
|
switch (src->id)
|
|
{
|
|
case ValueId::zero:
|
|
{
|
|
trap();
|
|
} break;
|
|
default:
|
|
{
|
|
if (src->type->id != TypeId::pointer)
|
|
{
|
|
assert(src->kind == ValueKind::right);
|
|
assert(src->type->id == TypeId::structure);
|
|
auto type = src->type;
|
|
assert(src->kind == ValueKind::right);
|
|
src->type = 0;
|
|
src->kind = ValueKind::left;
|
|
analyze_type(module, src, get_pointer_type(module, type));
|
|
}
|
|
|
|
assert(src->type->id == TypeId::pointer);
|
|
assert(src->type->llvm.abi == module->llvm.pointer_type);
|
|
emit_value(module, src, TypeKind::memory);
|
|
|
|
assert(src->type->id == TypeId::pointer);
|
|
auto source_type = src->type->pointer.element_type;
|
|
assert(source_type == argument_abi.semantic_type);
|
|
auto load = create_coerced_load(module, src->llvm, source_type, destination_type);
|
|
|
|
auto is_cmse_ns_call = false;
|
|
if (is_cmse_ns_call)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto maybe_undef = false;
|
|
if (maybe_undef)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
v = load;
|
|
} break;
|
|
}
|
|
assert(v);
|
|
unused(destination_type);
|
|
|
|
llvm_abi_argument_value_buffer[abi_argument_count] = v;
|
|
abi_argument_count += 1;
|
|
}
|
|
}
|
|
} break;
|
|
case AbiKind::indirect:
|
|
case AbiKind::indirect_aliased:
|
|
{
|
|
auto evaluation_kind = get_evaluation_kind(semantic_argument_type);
|
|
auto do_continue = false;
|
|
if (evaluation_kind == EvaluationKind::aggregate)
|
|
{
|
|
auto same_address_space = true;
|
|
assert(argument_abi.abi_start >= raw_function_type->function.abi_argument_types.length || same_address_space);
|
|
|
|
// TODO: handmade code, may contain bugs
|
|
assert(argument_abi.abi_count == 1);
|
|
auto abi_argument_type = abi_argument_type_buffer[argument_abi.abi_start];
|
|
|
|
if (abi_argument_type == semantic_call_argument_value->type)
|
|
{
|
|
trap();
|
|
}
|
|
else if (abi_argument_type->id == TypeId::pointer && abi_argument_type->pointer.element_type == semantic_call_argument_value->type)
|
|
{
|
|
auto is_constant = semantic_call_argument_value->is_constant();
|
|
|
|
if (is_constant)
|
|
{
|
|
emit_value(module, semantic_call_argument_value, TypeKind::memory);
|
|
|
|
bool is_constant = true;
|
|
LLVMLinkage linkage_type = LLVMInternalLinkage;
|
|
LLVMValueRef before = 0;
|
|
LLVMThreadLocalMode thread_local_mode = {};
|
|
u32 address_space = 0;
|
|
bool externally_initialized = false;
|
|
|
|
auto global = llvm_module_create_global_variable(module->llvm.module, semantic_argument_type->llvm.memory, is_constant, linkage_type, semantic_call_argument_value->llvm, string_literal("conststruct"), before, thread_local_mode, address_space, externally_initialized);
|
|
LLVMSetUnnamedAddress(global, LLVMGlobalUnnamedAddr);
|
|
|
|
auto alignment = get_byte_alignment(semantic_argument_type);
|
|
LLVMSetAlignment(global, alignment);
|
|
|
|
llvm_abi_argument_value_buffer[abi_argument_count] = global;
|
|
abi_argument_count += 1;
|
|
do_continue = true;
|
|
}
|
|
else
|
|
{
|
|
switch (semantic_call_argument_value->id)
|
|
{
|
|
case ValueId::variable_reference:
|
|
{
|
|
auto pointer_type = get_pointer_type(module, semantic_call_argument_value->type);
|
|
semantic_call_argument_value->type = 0;
|
|
semantic_call_argument_value->kind = ValueKind::left;
|
|
analyze_value(module, semantic_call_argument_value, pointer_type, TypeKind::memory);
|
|
llvm_abi_argument_value_buffer[abi_argument_count] = semantic_call_argument_value->llvm;
|
|
abi_argument_count += 1;
|
|
do_continue = true;
|
|
} break;
|
|
default:
|
|
{
|
|
trap();
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
}
|
|
|
|
if (!do_continue)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
} break;
|
|
case AbiKind::ignore: unreachable();
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(abi_argument_count == argument_abi.abi_start + argument_abi.abi_count);
|
|
}
|
|
|
|
auto declaration_abi_argument_count = raw_function_type->function.abi_argument_types.length;
|
|
|
|
if (raw_function_type->function.is_variable_arguments)
|
|
{
|
|
assert(abi_argument_count >= declaration_abi_argument_count);
|
|
}
|
|
else
|
|
{
|
|
assert(abi_argument_count == declaration_abi_argument_count);
|
|
}
|
|
|
|
assert(raw_function_type->llvm.abi);
|
|
Slice<AbiInformation> argument_abis = { .pointer = argument_abi_buffer, .length = call_arguments.length };
|
|
auto llvm_call = LLVMBuildCall2(module->llvm.builder, raw_function_type->llvm.abi, llvm_callable, llvm_abi_argument_value_buffer, abi_argument_count, "");
|
|
auto attribute_list = build_attribute_list(module, {
|
|
.return_abi = return_abi,
|
|
.argument_abis = argument_abis,
|
|
.abi_argument_types = { .pointer = abi_argument_type_buffer, .length = abi_argument_count },
|
|
.abi_return_type = raw_function_type->function.abi_return_type,
|
|
.attributes = {},
|
|
.call_site = true,
|
|
});
|
|
LLVMSetInstructionCallConv(llvm_call, llvm_calling_convention(raw_function_type->function.calling_convention));
|
|
llvm_call_base_set_attributes(llvm_call, attribute_list);
|
|
switch (return_abi_kind)
|
|
{
|
|
case AbiKind::ignore:
|
|
{
|
|
assert(return_abi.semantic_type == noreturn_type(module) || return_abi.semantic_type == void_type(module));
|
|
return llvm_call;
|
|
} break;
|
|
case AbiKind::direct:
|
|
case AbiKind::extend:
|
|
{
|
|
auto coerce_to_type = return_abi.get_coerce_to_type();
|
|
|
|
if (type_is_abi_equal(module, return_abi.semantic_type, coerce_to_type) && return_abi.attributes.direct.offset == 0)
|
|
{
|
|
auto evaluation_kind = get_evaluation_kind(coerce_to_type);
|
|
|
|
switch (evaluation_kind)
|
|
{
|
|
case EvaluationKind::scalar: return llvm_call;
|
|
case EvaluationKind::aggregate: break;
|
|
case EvaluationKind::complex: unreachable();
|
|
}
|
|
}
|
|
|
|
// TODO: if
|
|
auto fixed_vector_type = false;
|
|
if (fixed_vector_type)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
LLVMValueRef coerce_alloca = 0;
|
|
|
|
if (left_llvm)
|
|
{
|
|
assert(left_type->pointer.element_type == return_abi.semantic_type);
|
|
coerce_alloca = left_llvm;
|
|
}
|
|
else
|
|
{
|
|
coerce_alloca = create_alloca(module, {
|
|
.type = return_abi.semantic_type,
|
|
.name = string_literal("coerce"),
|
|
});
|
|
}
|
|
|
|
LLVMValueRef destination_pointer = coerce_alloca;
|
|
if (return_abi.attributes.direct.offset != 0)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto destination_type = return_abi.semantic_type;
|
|
|
|
assert(return_abi.semantic_type->id == TypeId::structure);
|
|
if (return_abi.semantic_type->structure.fields.length > 0)
|
|
{
|
|
auto source_value = llvm_call;
|
|
auto source_type = raw_function_type->function.abi_return_type;
|
|
auto destination_size = get_byte_size(destination_type);
|
|
auto left_destination_size = destination_size - return_abi.attributes.direct.offset;
|
|
auto is_destination_volatile = false;
|
|
create_coerced_store(module, source_value, source_type, destination_pointer, destination_type, left_destination_size, is_destination_volatile);
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
|
|
assert(coerce_alloca);
|
|
if (left_llvm)
|
|
{
|
|
assert(destination_pointer == left_llvm);
|
|
return destination_pointer;
|
|
}
|
|
else
|
|
{
|
|
switch (value->kind)
|
|
{
|
|
case ValueKind::right: return create_load(module, { .type = destination_type, .pointer = destination_pointer });
|
|
case ValueKind::left: trap();
|
|
}
|
|
}
|
|
} break;
|
|
case AbiKind::indirect:
|
|
{
|
|
assert(llvm_indirect_return_value);
|
|
return llvm_indirect_return_value;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn LLVMValueRef emit_intrinsic_call(Module* module, IntrinsicIndex index, Slice<LLVMTypeRef> argument_types, Slice<LLVMValueRef> argument_values)
|
|
{
|
|
auto intrinsic_id = module->llvm.intrinsic_table[(backing_type(IntrinsicIndex))index];
|
|
auto intrinsic_function = LLVMGetIntrinsicDeclaration(module->llvm.module, intrinsic_id.n, argument_types.pointer, argument_types.length);
|
|
auto intrinsic_function_type = LLVMIntrinsicGetType(module->llvm.context, intrinsic_id.n, argument_types.pointer, argument_types.length);
|
|
auto call = LLVMBuildCall2(module->llvm.builder, intrinsic_function_type, intrinsic_function, argument_values.pointer, argument_values.length, "");
|
|
return call;
|
|
}
|
|
|
|
fn LLVMValueRef emit_field_access(Module* module, Value* value, LLVMValueRef left_llvm, Type* left_type, TypeKind type_kind)
|
|
{
|
|
unused(module);
|
|
unused(value);
|
|
unused(left_llvm);
|
|
unused(left_type);
|
|
unused(type_kind);
|
|
|
|
switch (value->id)
|
|
{
|
|
case ValueId::field_access:
|
|
{
|
|
auto aggregate = value->field_access.aggregate;
|
|
auto field_name = value->field_access.field_name;
|
|
unused(field_name);
|
|
|
|
emit_value(module, aggregate, TypeKind::memory);
|
|
|
|
assert(aggregate->kind == ValueKind::left);
|
|
auto base_type = aggregate->type;
|
|
assert(base_type->id == TypeId::pointer);
|
|
|
|
auto base_child_type = base_type->pointer.element_type;
|
|
auto pointer_type = base_child_type->id == TypeId::pointer ? base_child_type->pointer.element_type : base_type;
|
|
assert(pointer_type->id == TypeId::pointer);
|
|
auto element_type = pointer_type->pointer.element_type;
|
|
resolve_type_in_place(module, element_type);
|
|
|
|
auto resolved_element_type = resolve_alias(module, element_type);
|
|
unused(resolved_element_type);
|
|
|
|
LLVMValueRef v;
|
|
if (pointer_type == base_type)
|
|
{
|
|
v = create_load(module, {
|
|
.type = pointer_type,
|
|
.pointer = aggregate->llvm,
|
|
});
|
|
}
|
|
else
|
|
{
|
|
v = aggregate->llvm;
|
|
}
|
|
|
|
switch (resolved_element_type->id)
|
|
{
|
|
case TypeId::structure:
|
|
case TypeId::union_type:
|
|
{
|
|
struct StructLikeFieldAccess
|
|
{
|
|
Type* type;
|
|
u32 field_index;
|
|
LLVMTypeRef struct_type;
|
|
};
|
|
|
|
StructLikeFieldAccess field_access;
|
|
switch (resolved_element_type->id)
|
|
{
|
|
case TypeId::structure:
|
|
{
|
|
u32 field_index;
|
|
auto fields = resolved_element_type->structure.fields;
|
|
auto field_count = (u32)fields.length;
|
|
for (field_index = 0; field_index < field_count; field_index += 1)
|
|
{
|
|
auto& field = fields[field_index];
|
|
if (field_name.equal(field.name))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (field_index == field_count)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
field_access = {
|
|
.type = resolved_element_type->structure.fields[field_index].type,
|
|
.field_index = field_index,
|
|
.struct_type = resolved_element_type->llvm.memory,
|
|
};
|
|
} break;
|
|
case TypeId::union_type:
|
|
{
|
|
trap();
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
auto gep = LLVMBuildStructGEP2(module->llvm.builder, field_access.struct_type, v, field_access.field_index, "");
|
|
auto uint64_type = uint64(module);
|
|
unused(gep);
|
|
unused(uint64_type);
|
|
|
|
if (left_llvm)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
switch (value->kind)
|
|
{
|
|
case ValueKind::left:
|
|
{
|
|
return gep;
|
|
} break;
|
|
case ValueKind::right:
|
|
{
|
|
auto load = create_load(module, {
|
|
.type = field_access.type,
|
|
.pointer = gep,
|
|
});
|
|
return load;
|
|
} break;
|
|
}
|
|
}
|
|
} break;
|
|
case TypeId::bits:
|
|
{
|
|
auto fields = resolved_element_type->bits.fields;
|
|
u64 i;
|
|
for (i = 0; i < fields.length; i += 1)
|
|
{
|
|
auto& field = fields[i];
|
|
if (field_name.equal(field.name))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(i < fields.length);
|
|
|
|
auto& field = fields[i];
|
|
auto field_type = field.type;
|
|
resolve_type_in_place(module, field_type);
|
|
|
|
auto load = create_load(module, {
|
|
.type = resolved_element_type,
|
|
.pointer = v,
|
|
});
|
|
auto shift = LLVMBuildLShr(module->llvm.builder, load, LLVMConstInt(resolved_element_type->llvm.abi, field.offset, false), "");
|
|
auto trunc = LLVMBuildTrunc(module->llvm.builder, shift, field_type->llvm.abi, "");
|
|
if (left_llvm)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
return trunc;
|
|
} break;
|
|
case TypeId::array:
|
|
{
|
|
trap();
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
struct SliceEmitResult
|
|
{
|
|
LLVMValueRef values[2];
|
|
};
|
|
|
|
fn SliceEmitResult emit_slice_expression(Module* module, Value* value)
|
|
{
|
|
unused(module);
|
|
|
|
switch (value->id)
|
|
{
|
|
case ValueId::slice_expression:
|
|
{
|
|
auto value_type = value->type;
|
|
assert(value_type);
|
|
assert(type_is_slice(value_type));
|
|
auto slice_pointer_type = value_type->structure.fields[0].type;
|
|
assert(slice_pointer_type->id == TypeId::pointer);
|
|
auto slice_element_type = slice_pointer_type->pointer.element_type;
|
|
unused(slice_element_type);
|
|
|
|
auto index_type = uint64(module);
|
|
resolve_type_in_place(module, index_type);
|
|
auto llvm_index_type = index_type->llvm.abi;
|
|
auto index_zero = LLVMConstInt(llvm_index_type, 0, 0);
|
|
|
|
auto array_like = value->slice_expression.array_like;
|
|
auto start = value->slice_expression.start;
|
|
auto end = value->slice_expression.end;
|
|
|
|
assert(array_like->kind == ValueKind::left);
|
|
emit_value(module, array_like, TypeKind::memory);
|
|
|
|
auto pointer_type = array_like->type;
|
|
assert(pointer_type->id == TypeId::pointer);
|
|
auto sliceable_type = pointer_type->pointer.element_type;
|
|
bool has_start = start && start->id == ValueId::constant_integer && start->constant_integer.value != 0;
|
|
|
|
if (start)
|
|
{
|
|
emit_value(module, start, TypeKind::memory);
|
|
}
|
|
|
|
if (end)
|
|
{
|
|
emit_value(module, end, TypeKind::memory);
|
|
}
|
|
|
|
switch (sliceable_type->id)
|
|
{
|
|
case TypeId::pointer:
|
|
{
|
|
auto element_type = sliceable_type->pointer.element_type;
|
|
auto pointer_load = create_load(module, {
|
|
.type = sliceable_type,
|
|
.pointer = array_like->llvm,
|
|
});
|
|
|
|
auto slice_pointer = pointer_load;
|
|
if (has_start)
|
|
{
|
|
LLVMValueRef indices[] = { start->llvm };
|
|
slice_pointer = create_gep(module, {
|
|
.type = element_type->llvm.memory,
|
|
.pointer = pointer_load,
|
|
.indices = array_to_slice(indices),
|
|
});
|
|
}
|
|
|
|
auto slice_length = end->llvm;
|
|
|
|
if (has_start)
|
|
{
|
|
slice_length = LLVMBuildSub(module->llvm.builder, slice_length, start->llvm, "");
|
|
}
|
|
return { slice_pointer, slice_length };
|
|
} break;
|
|
case TypeId::structure:
|
|
{
|
|
assert(sliceable_type->structure.is_slice);
|
|
auto slice_load = create_load(module, {
|
|
.type = sliceable_type,
|
|
.pointer = array_like->llvm,
|
|
});
|
|
auto old_slice_pointer = LLVMBuildExtractValue(module->llvm.builder, slice_load, 0, "");
|
|
auto slice_pointer = old_slice_pointer;
|
|
|
|
if (has_start)
|
|
{
|
|
LLVMValueRef indices[] = { start->llvm };
|
|
slice_pointer = create_gep(module, {
|
|
.type = slice_element_type->llvm.memory,
|
|
.pointer = old_slice_pointer,
|
|
.indices = array_to_slice(indices),
|
|
});
|
|
}
|
|
|
|
auto slice_end = end ? end->llvm : LLVMBuildExtractValue(module->llvm.builder, slice_load, 1, "");
|
|
auto slice_length = slice_end;
|
|
if (has_start)
|
|
{
|
|
slice_length = LLVMBuildSub(module->llvm.builder, slice_end, start->llvm, "");
|
|
}
|
|
|
|
return { slice_pointer, slice_length };
|
|
} break;
|
|
case TypeId::array:
|
|
{
|
|
assert(sliceable_type->array.element_type == slice_element_type);
|
|
LLVMValueRef slice_pointer = array_like->llvm;
|
|
if (has_start)
|
|
{
|
|
LLVMValueRef indices[] = { index_zero, start->llvm };
|
|
slice_pointer = create_gep(module, {
|
|
.type = sliceable_type->llvm.memory,
|
|
.pointer = slice_pointer,
|
|
.indices = array_to_slice(indices),
|
|
});
|
|
}
|
|
|
|
LLVMValueRef slice_length = 0;
|
|
if (has_start)
|
|
{
|
|
trap();
|
|
}
|
|
else if (end)
|
|
{
|
|
slice_length = end->llvm;
|
|
}
|
|
else
|
|
{
|
|
auto element_count = sliceable_type->array.element_count;
|
|
slice_length = LLVMConstInt(llvm_index_type, element_count, 0);
|
|
}
|
|
|
|
assert(slice_length);
|
|
return { slice_pointer, slice_length };
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn void emit_block(Module* module, LLVMBasicBlockRef basic_block)
|
|
{
|
|
auto current_basic_block = LLVMGetInsertBlock(module->llvm.builder);
|
|
if (current_basic_block)
|
|
{
|
|
if (!LLVMGetBasicBlockTerminator(current_basic_block))
|
|
{
|
|
LLVMBuildBr(module->llvm.builder, basic_block);
|
|
}
|
|
}
|
|
|
|
if (current_basic_block && LLVMGetBasicBlockParent(current_basic_block))
|
|
{
|
|
LLVMInsertExistingBasicBlockAfterInsertBlock(module->llvm.builder, basic_block);
|
|
}
|
|
else
|
|
{
|
|
LLVMAppendExistingBasicBlock(module->current_function->variable.storage->llvm, basic_block);
|
|
|
|
}
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, basic_block);
|
|
}
|
|
|
|
fn LLVMValueRef emit_va_arg_from_memory(Module* module, LLVMValueRef va_list_pointer, Type* va_list_struct, Type* argument_type)
|
|
{
|
|
assert(va_list_struct->id == TypeId::structure);
|
|
auto overflow_arg_area_pointer = LLVMBuildStructGEP2(module->llvm.builder, va_list_struct->llvm.abi, va_list_pointer, 2, "");
|
|
auto overflow_arg_area_type = va_list_struct->structure.fields[2].type;
|
|
auto overflow_arg_area = create_load(module, { .type = overflow_arg_area_type, .pointer = overflow_arg_area_pointer });
|
|
if (get_byte_alignment(argument_type) > 8)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto argument_type_size = get_byte_size(argument_type);
|
|
|
|
auto raw_offset = align_forward(argument_type_size, 8);
|
|
auto uint32_type = uint32(module)->llvm.abi;
|
|
auto offset = LLVMConstInt(uint32_type, raw_offset, false);
|
|
LLVMValueRef indices[] = {
|
|
offset,
|
|
};
|
|
auto new_overflow_arg_area = create_gep(module, {
|
|
.type = uint32_type,
|
|
.pointer = overflow_arg_area,
|
|
.indices = array_to_slice(indices),
|
|
.inbounds = false,
|
|
});
|
|
create_store(module, {
|
|
.source = new_overflow_arg_area,
|
|
.destination = overflow_arg_area_pointer,
|
|
.type = overflow_arg_area_type,
|
|
});
|
|
return overflow_arg_area;
|
|
}
|
|
|
|
fn LLVMValueRef emit_va_arg(Module* module, Value* value, LLVMValueRef left_llvm, Type* left_type)
|
|
{
|
|
switch (value->id)
|
|
{
|
|
case ValueId::va_arg:
|
|
{
|
|
auto raw_va_list_type = get_va_list_type(module);
|
|
|
|
auto va_list_value = value->va_arg.va_list;
|
|
emit_value(module, va_list_value, TypeKind::memory);
|
|
auto u64_type = uint64(module);
|
|
resolve_type_in_place(module, u64_type);
|
|
auto zero = LLVMConstNull(u64_type->llvm.memory);
|
|
LLVMValueRef gep_indices[] = {zero, zero};
|
|
auto va_list_value_llvm = create_gep(module, {
|
|
.type = raw_va_list_type->llvm.memory,
|
|
.pointer = va_list_value->llvm,
|
|
.indices = array_to_slice(gep_indices),
|
|
});
|
|
unused(va_list_value_llvm);
|
|
|
|
auto va_arg_type = value->va_arg.type;
|
|
auto r = abi_system_v_classify_argument_type(module, va_arg_type, {});
|
|
auto abi = r.abi;
|
|
auto needed_registers = r.needed_registers;
|
|
assert(abi.flags.kind != AbiKind::ignore);
|
|
|
|
assert(raw_va_list_type->id == TypeId::array);
|
|
auto va_list_struct = raw_va_list_type->array.element_type;
|
|
unused(va_list_struct);
|
|
LLVMValueRef address = 0;
|
|
|
|
if (needed_registers.gpr == 0 && needed_registers.sse == 0)
|
|
{
|
|
address = emit_va_arg_from_memory(module, va_list_value_llvm, va_list_struct, va_arg_type);
|
|
}
|
|
else
|
|
{
|
|
auto va_list_struct_llvm = va_list_struct->llvm.memory;
|
|
|
|
LLVMValueRef gpr_offset_pointer = 0;
|
|
LLVMValueRef gpr_offset = 0;
|
|
if (needed_registers.gpr != 0)
|
|
{
|
|
gpr_offset_pointer = LLVMBuildStructGEP2(module->llvm.builder, va_list_struct_llvm, va_list_value_llvm, 0, "");
|
|
gpr_offset = create_load(module, {
|
|
.type = va_list_struct->structure.fields[0].type,
|
|
.pointer = gpr_offset_pointer,
|
|
.alignment = 16,
|
|
});
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto raw_in_regs = 48 - needed_registers.gpr * 8;
|
|
auto u32_type = uint32(module);
|
|
resolve_type_in_place(module, u32_type);
|
|
auto u32_llvm = u32_type->llvm.memory;
|
|
LLVMValueRef in_regs = 0;
|
|
if (needed_registers.gpr != 0)
|
|
{
|
|
in_regs = LLVMConstInt(u32_llvm, raw_in_regs, false);
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
|
|
if (needed_registers.gpr != 0)
|
|
{
|
|
in_regs = LLVMBuildICmp(module->llvm.builder, LLVMIntULE, gpr_offset, in_regs, "");
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
|
|
assert(in_regs);
|
|
|
|
LLVMValueRef fp_offset_pointer = 0;
|
|
if (needed_registers.sse)
|
|
{
|
|
trap();
|
|
}
|
|
LLVMValueRef fp_offset = 0;
|
|
if (needed_registers.sse)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto raw_fits_in_fp = 176 - needed_registers.sse * 16;
|
|
LLVMValueRef fits_in_fp = 0;
|
|
if (needed_registers.sse)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
if (needed_registers.sse && needed_registers.gpr)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto* in_reg_block = llvm_context_create_basic_block(module->llvm.context, string_literal("va_arg.in_reg"), 0);
|
|
auto* in_mem_block = llvm_context_create_basic_block(module->llvm.context, string_literal("va_arg.in_mem"), 0);
|
|
auto* end_block = llvm_context_create_basic_block(module->llvm.context, string_literal("va_arg.end"), 0);
|
|
LLVMBuildCondBr(module->llvm.builder, in_regs, in_reg_block, in_mem_block);
|
|
|
|
emit_block(module, in_reg_block);
|
|
|
|
auto reg_save_area_type = va_list_struct->structure.fields[3].type;
|
|
auto reg_save_area = create_load(module, {
|
|
.type = reg_save_area_type,
|
|
.pointer = LLVMBuildStructGEP2(module->llvm.builder, va_list_struct_llvm, va_list_value_llvm, 3, ""),
|
|
.alignment = 16,
|
|
});
|
|
|
|
LLVMValueRef register_address = 0;
|
|
|
|
if (needed_registers.gpr && needed_registers.sse)
|
|
{
|
|
trap();
|
|
}
|
|
else if (needed_registers.gpr)
|
|
{
|
|
auto t = reg_save_area_type->pointer.element_type;
|
|
resolve_type_in_place(module, t);
|
|
|
|
LLVMValueRef indices[] = { gpr_offset };
|
|
register_address = create_gep(module, {
|
|
.type = t->llvm.abi,
|
|
.pointer = reg_save_area,
|
|
.indices = array_to_slice(indices),
|
|
.inbounds = false,
|
|
});
|
|
if (get_byte_alignment(va_arg_type) > 8)
|
|
{
|
|
trap();
|
|
}
|
|
}
|
|
else if (needed_registers.sse == 1)
|
|
{
|
|
trap();
|
|
}
|
|
else if (needed_registers.sse == 2)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
unreachable();
|
|
}
|
|
|
|
if (needed_registers.gpr)
|
|
{
|
|
auto raw_offset = needed_registers.gpr * 8;
|
|
auto new_offset = LLVMBuildAdd(module->llvm.builder, gpr_offset, LLVMConstInt(u32_llvm, raw_offset, false), "");
|
|
create_store(module, StoreOptions{
|
|
.source = new_offset,
|
|
.destination = gpr_offset_pointer,
|
|
.type = u32_type,
|
|
});
|
|
}
|
|
|
|
if (needed_registers.sse)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
LLVMBuildBr(module->llvm.builder, end_block);
|
|
|
|
emit_block(module, in_mem_block);
|
|
auto memory_address = emit_va_arg_from_memory(module, va_list_value_llvm, va_list_struct, va_arg_type);
|
|
|
|
emit_block(module, end_block);
|
|
|
|
LLVMValueRef values[] = {
|
|
register_address,
|
|
memory_address,
|
|
};
|
|
LLVMBasicBlockRef blocks[] = {
|
|
in_reg_block,
|
|
in_mem_block,
|
|
};
|
|
|
|
auto phi = LLVMBuildPhi(module->llvm.builder, module->llvm.pointer_type, "");
|
|
LLVMAddIncoming(phi, values, blocks, array_length(values));
|
|
|
|
address = phi;
|
|
|
|
unused(fp_offset_pointer);
|
|
unused(fp_offset);
|
|
unused(raw_fits_in_fp);
|
|
unused(fits_in_fp);
|
|
}
|
|
|
|
assert(address);
|
|
|
|
auto evaluation_kind = get_evaluation_kind(va_arg_type);
|
|
|
|
LLVMValueRef result = 0;
|
|
|
|
switch (evaluation_kind)
|
|
{
|
|
case EvaluationKind::scalar:
|
|
{
|
|
assert(!left_llvm);
|
|
assert(!left_type);
|
|
result = create_load(module, {
|
|
.type = va_arg_type,
|
|
.pointer = address,
|
|
});
|
|
} break;
|
|
case EvaluationKind::aggregate:
|
|
{
|
|
if (left_llvm)
|
|
{
|
|
auto u64_type = uint64(module);
|
|
resolve_type_in_place(module, u64_type);
|
|
u64 memcpy_size = get_byte_size(va_arg_type);
|
|
auto alignment = get_byte_alignment(va_arg_type);
|
|
LLVMBuildMemCpy(module->llvm.builder, left_llvm, alignment, address, alignment, LLVMConstInt(u64_type->llvm.abi, memcpy_size, false));
|
|
return left_llvm;
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case EvaluationKind::complex:
|
|
{
|
|
trap();
|
|
} break;
|
|
}
|
|
|
|
assert(result);
|
|
return result;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn LLVMValueRef emit_binary(Module* module, LLVMValueRef left, Type* left_type, LLVMValueRef right, Type* right_type, BinaryId id, Type* resolved_value_type)
|
|
{
|
|
switch (resolved_value_type->id)
|
|
{
|
|
case TypeId::integer:
|
|
{
|
|
switch (id)
|
|
{
|
|
case BinaryId::shift_right:
|
|
if (resolved_value_type->integer.is_signed)
|
|
{
|
|
return LLVMBuildAShr(module->llvm.builder, left, right, "");
|
|
}
|
|
else
|
|
{
|
|
return LLVMBuildLShr(module->llvm.builder, left, right, "");
|
|
}
|
|
break;
|
|
case BinaryId::div:
|
|
if (resolved_value_type->integer.is_signed)
|
|
{
|
|
return LLVMBuildSDiv(module->llvm.builder, left, right, "");
|
|
}
|
|
else
|
|
{
|
|
return LLVMBuildUDiv(module->llvm.builder, left, right, "");
|
|
}
|
|
break;
|
|
case BinaryId::rem:
|
|
if (resolved_value_type->integer.is_signed)
|
|
{
|
|
return LLVMBuildSRem(module->llvm.builder, left, right, "");
|
|
}
|
|
else
|
|
{
|
|
return LLVMBuildURem(module->llvm.builder, left, right, "");
|
|
}
|
|
break;
|
|
case BinaryId::compare_equal:
|
|
case BinaryId::compare_not_equal:
|
|
case BinaryId::compare_greater:
|
|
case BinaryId::compare_less:
|
|
case BinaryId::compare_greater_equal:
|
|
case BinaryId::compare_less_equal:
|
|
{
|
|
LLVMIntPredicate predicate;
|
|
assert(left_type == right_type);
|
|
auto left_signed = type_is_signed(left_type);
|
|
auto right_signed = type_is_signed(right_type);
|
|
assert(left_signed == right_signed);
|
|
auto is_signed = left_signed;
|
|
|
|
switch (id)
|
|
{
|
|
case BinaryId::compare_equal: predicate = LLVMIntEQ; break;
|
|
case BinaryId::compare_not_equal: predicate = LLVMIntNE; break;
|
|
case BinaryId::compare_greater: predicate = is_signed ? LLVMIntSGT : LLVMIntUGT;
|
|
case BinaryId::compare_less: predicate = is_signed ? LLVMIntSLT : LLVMIntULT;
|
|
case BinaryId::compare_greater_equal: predicate = is_signed ? LLVMIntSGE : LLVMIntUGE;
|
|
case BinaryId::compare_less_equal: predicate = is_signed ? LLVMIntSLE : LLVMIntULE;
|
|
default: unreachable();
|
|
}
|
|
return LLVMBuildICmp(module->llvm.builder, predicate, left, right, "");
|
|
} break;
|
|
case BinaryId::add: return LLVMBuildAdd(module->llvm.builder, left, right, ""); break;
|
|
case BinaryId::sub: return LLVMBuildSub(module->llvm.builder, left, right, ""); break;
|
|
case BinaryId::mul: return LLVMBuildMul(module->llvm.builder, left, right, ""); break;
|
|
case BinaryId::bitwise_and: return LLVMBuildAnd(module->llvm.builder, left, right, ""); break;
|
|
case BinaryId::bitwise_or: return LLVMBuildOr(module->llvm.builder, left, right, ""); break;
|
|
case BinaryId::bitwise_xor: return LLVMBuildXor(module->llvm.builder, left, right, ""); break;
|
|
case BinaryId::shift_left: return LLVMBuildShl(module->llvm.builder, left, right, ""); break;
|
|
default: unreachable();
|
|
}
|
|
} break;
|
|
case TypeId::pointer:
|
|
{
|
|
auto element_type = resolved_value_type->pointer.element_type;
|
|
resolve_type_in_place(module, element_type);
|
|
|
|
if (id != BinaryId::add && id != BinaryId::sub)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
LLVMValueRef index = right;
|
|
if (id == BinaryId::sub)
|
|
{
|
|
index = LLVMBuildNeg(module->llvm.builder, index, "");
|
|
}
|
|
|
|
LLVMValueRef indices[] = { index };
|
|
|
|
return create_gep(module, {
|
|
.type = element_type->llvm.abi,
|
|
.pointer = left,
|
|
.indices = array_to_slice(indices),
|
|
});
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn void emit_value(Module* module, Value* value, TypeKind type_kind)
|
|
{
|
|
assert(value->type);
|
|
assert(!value->llvm);
|
|
auto resolved_value_type = resolve_alias(module, value->type);
|
|
resolve_type_in_place(module, resolved_value_type);
|
|
|
|
auto must_be_constant = !module->current_function && !module->current_macro_instantiation;
|
|
|
|
LLVMValueRef llvm_value = 0;
|
|
switch (value->id)
|
|
{
|
|
case ValueId::constant_integer:
|
|
{
|
|
auto llvm_integer_type = get_llvm_type(resolved_value_type, type_kind);
|
|
llvm_value = LLVMConstInt(llvm_integer_type, value->constant_integer.value, value->constant_integer.is_signed);
|
|
} break;
|
|
case ValueId::unary:
|
|
{
|
|
auto unary_value = value->unary.value;
|
|
assert(!unary_value->llvm);
|
|
auto unary_id = value->unary.id;
|
|
auto resolved_unary_type = resolve_alias(module, unary_value->type);
|
|
emit_value(module, unary_value, type_kind);
|
|
if (unary_id == UnaryId::truncate)
|
|
{
|
|
type_kind = TypeKind::abi;
|
|
}
|
|
auto destination_type = get_llvm_type(resolved_value_type, type_kind);
|
|
assert(destination_type);
|
|
auto llvm_unary_value = unary_value->llvm;
|
|
assert(llvm_unary_value);
|
|
|
|
switch (unary_id)
|
|
{
|
|
case UnaryId::minus:
|
|
{
|
|
if (value->unary.value->is_constant())
|
|
{
|
|
llvm_value = LLVMConstNeg(llvm_unary_value);
|
|
}
|
|
else
|
|
{
|
|
llvm_value = LLVMBuildNeg(module->llvm.builder, llvm_unary_value, "");
|
|
}
|
|
} break;
|
|
case UnaryId::plus:
|
|
{
|
|
trap();
|
|
} break;
|
|
case UnaryId::ampersand:
|
|
{
|
|
assert(resolved_value_type == resolved_unary_type);
|
|
llvm_value = llvm_unary_value;
|
|
} break;
|
|
case UnaryId::exclamation:
|
|
{
|
|
if (resolved_value_type == resolved_unary_type)
|
|
{
|
|
llvm_value = LLVMBuildNot(module->llvm.builder, llvm_unary_value, "");
|
|
}
|
|
else
|
|
{
|
|
switch (resolved_unary_type->id)
|
|
{
|
|
case TypeId::pointer:
|
|
{
|
|
llvm_value = LLVMBuildICmp(module->llvm.builder, LLVMIntEQ, llvm_unary_value, LLVMConstNull(resolved_unary_type->llvm.abi), "");
|
|
} break;
|
|
default: report_error();
|
|
}
|
|
}
|
|
} break;
|
|
case UnaryId::tilde:
|
|
{
|
|
trap();
|
|
} break;
|
|
case UnaryId::enum_name:
|
|
{
|
|
trap();
|
|
} break;
|
|
case UnaryId::extend:
|
|
{
|
|
assert(resolved_unary_type->id == TypeId::integer);
|
|
if (resolved_unary_type->integer.is_signed)
|
|
{
|
|
llvm_value = LLVMBuildSExt(module->llvm.builder, llvm_unary_value, destination_type, "");
|
|
}
|
|
else
|
|
{
|
|
llvm_value = LLVMBuildZExt(module->llvm.builder, llvm_unary_value, destination_type, "");
|
|
}
|
|
} break;
|
|
case UnaryId::truncate:
|
|
{
|
|
if (type_kind != TypeKind::abi)
|
|
{
|
|
assert(resolved_value_type->llvm.abi == resolved_value_type->llvm.memory);
|
|
}
|
|
|
|
llvm_value = LLVMBuildTrunc(module->llvm.builder, llvm_unary_value, destination_type, "");
|
|
} break;
|
|
case UnaryId::pointer_cast:
|
|
case UnaryId::int_from_enum:
|
|
{
|
|
llvm_value = llvm_unary_value;
|
|
} break;
|
|
case UnaryId::int_from_pointer:
|
|
{
|
|
llvm_value = LLVMBuildPtrToInt(module->llvm.builder, llvm_unary_value, resolved_value_type->llvm.abi, "");
|
|
} break;
|
|
case UnaryId::va_end:
|
|
{
|
|
LLVMTypeRef argument_types[] = { module->llvm.pointer_type };
|
|
LLVMValueRef argument_values[] = { llvm_unary_value };
|
|
llvm_value = emit_intrinsic_call(module, IntrinsicIndex::va_end, array_to_slice(argument_types), array_to_slice(argument_values));
|
|
} break;
|
|
case UnaryId::bitwise_not:
|
|
{
|
|
trap();
|
|
} break;
|
|
case UnaryId::dereference:
|
|
{
|
|
switch (value->kind)
|
|
{
|
|
case ValueKind::right:
|
|
{
|
|
auto pointer_type = unary_value->type;
|
|
assert(pointer_type->id == TypeId::pointer);
|
|
auto child_type = pointer_type->pointer.element_type;
|
|
assert(child_type == resolved_value_type);
|
|
auto load = create_load(module, LoadOptions{
|
|
.type = child_type,
|
|
.pointer = unary_value->llvm,
|
|
.kind = type_kind,
|
|
});
|
|
llvm_value = load;
|
|
} break;
|
|
case ValueKind::left:
|
|
trap();
|
|
}
|
|
} break;
|
|
}
|
|
} break;
|
|
case ValueId::unary_type:
|
|
{
|
|
auto unary_type = value->unary_type.type;
|
|
auto unary_type_id = value->unary_type.id;
|
|
|
|
resolve_type_in_place(module, unary_type);
|
|
|
|
switch (unary_type_id)
|
|
{
|
|
case UnaryTypeId::byte_size:
|
|
{
|
|
assert(resolved_value_type->id == TypeId::integer);
|
|
auto constant_integer = LLVMConstInt(resolved_value_type->llvm.abi, get_byte_size(unary_type), false);
|
|
llvm_value = constant_integer;
|
|
} break;
|
|
case UnaryTypeId::integer_max:
|
|
{
|
|
assert(unary_type->id == TypeId::integer);
|
|
auto is_signed = unary_type->integer.is_signed;
|
|
auto max_value = integer_max_value(resolved_value_type->integer.bit_count, is_signed);
|
|
auto constant_integer = LLVMConstInt(resolved_value_type->llvm.abi, max_value, is_signed);
|
|
llvm_value = constant_integer;
|
|
} break;
|
|
}
|
|
} break;
|
|
case ValueId::binary:
|
|
{
|
|
bool is_shorcircuiting = binary_is_shortcircuiting(value->binary.id);
|
|
|
|
if (is_shorcircuiting)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
LLVMValueRef llvm_values[2];
|
|
Value* values[2] = { value->binary.left, value->binary.right };
|
|
for (u64 i = 0; i < array_length(values); i += 1)
|
|
{
|
|
auto* binary_value = values[i];
|
|
if (binary_value->llvm)
|
|
{
|
|
assert(false); // TODO: check if this if is really necessary
|
|
}
|
|
else
|
|
{
|
|
emit_value(module, binary_value, TypeKind::abi);
|
|
}
|
|
|
|
llvm_values[i] = binary_value->llvm;
|
|
}
|
|
|
|
llvm_value = emit_binary(module, llvm_values[0], values[0]->type, llvm_values[1], values[1]->type, value->binary.id, resolved_value_type);
|
|
}
|
|
} break;
|
|
case ValueId::variable_reference:
|
|
{
|
|
auto* variable = value->variable_reference;
|
|
|
|
auto resolved_variable_value_type = resolve_alias(module, variable->type);
|
|
auto resolved_variable_pointer_type = resolve_alias(module, variable->storage->type);
|
|
|
|
switch (value->kind)
|
|
{
|
|
case ValueKind::left:
|
|
{
|
|
if (resolved_variable_pointer_type == resolved_value_type)
|
|
{
|
|
llvm_value = variable->storage->llvm;
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case ValueKind::right:
|
|
{
|
|
if (resolved_variable_value_type != resolved_value_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (must_be_constant)
|
|
{
|
|
if (variable->scope->kind != ScopeKind::global)
|
|
{
|
|
report_error();
|
|
}
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
assert(get_byte_size(resolved_value_type) <= 16);
|
|
|
|
auto evaluation_kind = get_evaluation_kind(resolved_value_type);
|
|
switch (evaluation_kind)
|
|
{
|
|
case EvaluationKind::scalar:
|
|
case EvaluationKind::aggregate:
|
|
{
|
|
llvm_value = create_load(module, {
|
|
.type = resolved_value_type,
|
|
.pointer = variable->storage->llvm,
|
|
});
|
|
} break;
|
|
case EvaluationKind::complex:
|
|
trap();
|
|
}
|
|
}
|
|
} break;
|
|
}
|
|
} break;
|
|
case ValueId::call:
|
|
{
|
|
auto call = emit_call(module, value, 0, 0);
|
|
llvm_value = call;
|
|
} break;
|
|
case ValueId::array_initialization:
|
|
{
|
|
if (value->array_initialization.is_constant)
|
|
{
|
|
assert(value->kind == ValueKind::right);
|
|
auto element_type = resolved_value_type->array.element_type;
|
|
auto element_count = value->array_initialization.values.length;
|
|
LLVMValueRef value_buffer[64];
|
|
|
|
resolve_type_in_place(module, element_type);
|
|
|
|
for (u64 i = 0; i < element_count; i += 1)
|
|
{
|
|
auto* v = value->array_initialization.values[i];
|
|
emit_value(module, v, TypeKind::memory);
|
|
value_buffer[i] = v->llvm;
|
|
}
|
|
|
|
auto constant_array = LLVMConstArray2(element_type->llvm.memory, value_buffer, element_count);
|
|
llvm_value = constant_array;
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case ValueId::array_expression:
|
|
{
|
|
auto* array_like = value->array_expression.array_like;
|
|
auto* index = value->array_expression.index;
|
|
|
|
switch (array_like->kind)
|
|
{
|
|
case ValueKind::left:
|
|
{
|
|
emit_value(module, array_like, TypeKind::memory);
|
|
emit_value(module, index, TypeKind::memory);
|
|
|
|
auto array_like_type = array_like->type;
|
|
assert(array_like_type->id == TypeId::pointer);
|
|
auto pointer_element_type = array_like_type->pointer.element_type;
|
|
|
|
switch (pointer_element_type->id)
|
|
{
|
|
case TypeId::array:
|
|
{
|
|
auto array_type = pointer_element_type;
|
|
|
|
auto uint64_type = uint64(module);
|
|
resolve_type_in_place(module, uint64_type);
|
|
auto zero_index = LLVMConstNull(uint64_type->llvm.abi);
|
|
LLVMValueRef indices[] = { zero_index, index->llvm };
|
|
auto gep = create_gep(module, {
|
|
.type = array_type->llvm.memory,
|
|
.pointer = array_like->llvm,
|
|
.indices = array_to_slice(indices),
|
|
});
|
|
auto element_type = array_type->array.element_type;
|
|
|
|
switch (value->kind)
|
|
{
|
|
case ValueKind::left:
|
|
llvm_value = gep;
|
|
break;
|
|
case ValueKind::right:
|
|
llvm_value = create_load(module, LoadOptions{
|
|
.type = element_type,
|
|
.pointer = gep,
|
|
});
|
|
break;
|
|
}
|
|
} break;
|
|
case TypeId::structure:
|
|
{
|
|
auto slice_type = pointer_element_type;
|
|
assert(slice_type->structure.is_slice);
|
|
auto slice_pointer_type = slice_type->structure.fields[0].type;
|
|
auto slice_element_type = slice_pointer_type->pointer.element_type;
|
|
resolve_type_in_place(module, slice_element_type);
|
|
|
|
auto pointer_load = create_load(module, {
|
|
.type = slice_pointer_type,
|
|
.pointer = array_like->llvm,
|
|
});
|
|
LLVMValueRef indices[1] = {
|
|
index->llvm,
|
|
};
|
|
auto gep = create_gep(module, {
|
|
.type = slice_element_type->llvm.memory,
|
|
.pointer = pointer_load,
|
|
.indices = array_to_slice(indices),
|
|
});
|
|
|
|
switch (value->kind)
|
|
{
|
|
case ValueKind::left:
|
|
llvm_value = gep;
|
|
break;
|
|
case ValueKind::right:
|
|
llvm_value = create_load(module, LoadOptions{
|
|
.type = slice_element_type,
|
|
.pointer = gep,
|
|
});
|
|
break;
|
|
}
|
|
} break;
|
|
case TypeId::pointer:
|
|
{
|
|
auto element_type = pointer_element_type->pointer.element_type;
|
|
// TODO: consider not emitting the and doing straight GEP?
|
|
auto pointer_load = create_load(module, {
|
|
.type = pointer_element_type,
|
|
.pointer = array_like->llvm,
|
|
});
|
|
LLVMValueRef indices[] = { index->llvm };
|
|
auto gep = create_gep(module, {
|
|
.type = element_type->llvm.memory,
|
|
.pointer = pointer_load,
|
|
.indices = array_to_slice(indices),
|
|
});
|
|
|
|
llvm_value = gep;
|
|
|
|
if (value->kind == ValueKind::right)
|
|
{
|
|
llvm_value = create_load(module, {
|
|
.type = element_type,
|
|
.pointer = gep,
|
|
});
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
} break;
|
|
case ValueKind::right:
|
|
{
|
|
trap();
|
|
} break;
|
|
}
|
|
} break;
|
|
case ValueId::enum_literal:
|
|
{
|
|
assert(resolved_value_type->id == TypeId::enumerator);
|
|
auto enum_name = value->enum_literal;
|
|
bool found = false;
|
|
u64 i;
|
|
for (i = 0; i < resolved_value_type->enumerator.fields.length; i += 1)
|
|
{
|
|
auto& field = resolved_value_type->enumerator.fields[i];
|
|
if (enum_name.equal(field.name))
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto& field = resolved_value_type->enumerator.fields[i];
|
|
auto llvm_type = get_llvm_type(resolved_value_type, type_kind);
|
|
llvm_value = LLVMConstInt(llvm_type, field.value, type_is_signed(resolved_value_type));
|
|
} break;
|
|
case ValueId::trap:
|
|
{
|
|
auto call = emit_intrinsic_call(module, IntrinsicIndex::trap, {}, {});
|
|
LLVMBuildUnreachable(module->llvm.builder);
|
|
LLVMClearInsertionPosition(module->llvm.builder);
|
|
llvm_value = call;
|
|
} break;
|
|
case ValueId::field_access:
|
|
{
|
|
llvm_value = emit_field_access(module, value, 0, 0, type_kind);
|
|
} break;
|
|
case ValueId::slice_expression:
|
|
{
|
|
auto slice = emit_slice_expression(module, value);
|
|
auto result = LLVMGetPoison(resolved_value_type->llvm.abi);
|
|
result = LLVMBuildInsertValue(module->llvm.builder, result, slice.values[0], 0, "");
|
|
result = LLVMBuildInsertValue(module->llvm.builder, result, slice.values[1], 1, "");
|
|
llvm_value = result;
|
|
} break;
|
|
case ValueId::va_arg:
|
|
{
|
|
llvm_value = emit_va_arg(module, value, 0, 0);
|
|
} break;
|
|
case ValueId::aggregate_initialization:
|
|
{
|
|
auto names = value->aggregate_initialization.names;
|
|
auto values = value->aggregate_initialization.values;
|
|
assert(names.length == values.length);
|
|
auto is_constant = value->aggregate_initialization.is_constant;
|
|
auto zero = value->aggregate_initialization.zero;
|
|
|
|
switch (resolved_value_type->id)
|
|
{
|
|
case TypeId::structure:
|
|
{
|
|
auto fields = resolved_value_type->structure.fields;
|
|
|
|
if (is_constant)
|
|
{
|
|
LLVMValueRef constant_buffer[64];
|
|
u32 constant_count = (u32)values.length;
|
|
|
|
for (u64 i = 0; i < values.length; i += 1)
|
|
{
|
|
auto* value = values[i];
|
|
emit_value(module, value, TypeKind::memory);
|
|
auto llvm_value = value->llvm;
|
|
assert(llvm_value);
|
|
assert(LLVMIsAConstant(llvm_value));
|
|
constant_buffer[i] = llvm_value;
|
|
}
|
|
|
|
|
|
if (zero)
|
|
{
|
|
if (values.length == fields.length)
|
|
{
|
|
unreachable();
|
|
}
|
|
|
|
for (u64 i = values.length; i < fields.length; i += 1)
|
|
{
|
|
auto& field = fields[i];
|
|
auto field_type = field.type;
|
|
resolve_type_in_place(module, field_type);
|
|
constant_buffer[i] = LLVMConstNull(field_type->llvm.memory);
|
|
constant_count += 1;
|
|
}
|
|
}
|
|
|
|
assert(constant_count == fields.length);
|
|
|
|
llvm_value = LLVMConstNamedStruct(get_llvm_type(resolved_value_type, type_kind), constant_buffer, constant_count);
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case TypeId::union_type:
|
|
{
|
|
trap();
|
|
} break;
|
|
case TypeId::bits:
|
|
{
|
|
auto fields = resolved_value_type->bits.fields;
|
|
Type* backing_type = resolved_value_type->bits.backing_type;
|
|
if (is_constant)
|
|
{
|
|
u64 bits_value = 0;
|
|
|
|
for (u32 initialization_index = 0; initialization_index < values.length; initialization_index += 1)
|
|
{
|
|
auto value = values[initialization_index];
|
|
auto name = names[initialization_index];
|
|
|
|
u32 declaration_index;
|
|
for (declaration_index = 0; declaration_index < fields.length; declaration_index += 1)
|
|
{
|
|
auto& field = fields[declaration_index];
|
|
|
|
if (name.equal(field.name))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (declaration_index == fields.length)
|
|
{
|
|
unreachable();
|
|
}
|
|
|
|
auto field = fields[declaration_index];
|
|
u64 field_value;
|
|
switch (value->id)
|
|
{
|
|
case ValueId::constant_integer:
|
|
{
|
|
field_value = value->constant_integer.value;
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
bits_value |= field_value << field.offset;
|
|
}
|
|
|
|
resolve_type_in_place(module, backing_type);
|
|
|
|
llvm_value = LLVMConstInt(get_llvm_type(backing_type, type_kind), bits_value, false);
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
} break;
|
|
case ValueId::zero:
|
|
{
|
|
llvm_value = LLVMConstNull(get_llvm_type(resolved_value_type, type_kind));
|
|
} break;
|
|
case ValueId::select:
|
|
{
|
|
auto condition = value->select.condition;
|
|
auto true_value = value->select.true_value;
|
|
auto false_value = value->select.false_value;
|
|
emit_value(module, condition, TypeKind::abi);
|
|
LLVMValueRef llvm_condition = condition->llvm;
|
|
auto condition_type = condition->type;
|
|
|
|
switch (condition_type->id)
|
|
{
|
|
case TypeId::integer:
|
|
{
|
|
if (condition_type->integer.bit_count != 1)
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
default: trap();
|
|
}
|
|
|
|
emit_value(module, true_value, type_kind);
|
|
emit_value(module, false_value, type_kind);
|
|
|
|
llvm_value = LLVMBuildSelect(module->llvm.builder, llvm_condition, true_value->llvm, false_value->llvm, "");
|
|
} break;
|
|
case ValueId::unreachable:
|
|
{
|
|
llvm_value = LLVMBuildUnreachable(module->llvm.builder);
|
|
LLVMClearInsertionPosition(module->llvm.builder);
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(llvm_value);
|
|
value->llvm = llvm_value;
|
|
}
|
|
|
|
fn void emit_assignment(Module* module, LLVMValueRef left_llvm, Type* left_type, Value* right)
|
|
{
|
|
assert(!right->llvm);
|
|
auto pointer_type = left_type;
|
|
auto value_type = right->type;
|
|
assert(pointer_type);
|
|
assert(value_type);
|
|
resolve_type_in_place(module, pointer_type);
|
|
resolve_type_in_place(module, value_type);
|
|
|
|
auto resolved_pointer_type = resolve_alias(module, pointer_type);
|
|
auto resolved_value_type = resolve_alias(module, value_type);
|
|
assert(resolved_pointer_type->id == TypeId::pointer);
|
|
assert(resolved_pointer_type->pointer.element_type == resolved_value_type);
|
|
|
|
auto type_kind = TypeKind::memory;
|
|
|
|
auto evaluation_kind = get_evaluation_kind(resolved_value_type);
|
|
switch (evaluation_kind)
|
|
{
|
|
case EvaluationKind::scalar:
|
|
{
|
|
emit_value(module, right, type_kind);
|
|
create_store(module, {
|
|
.source = right->llvm,
|
|
.destination = left_llvm,
|
|
.type = resolved_value_type,
|
|
});
|
|
} break;
|
|
case EvaluationKind::aggregate:
|
|
{
|
|
switch (right->id)
|
|
{
|
|
case ValueId::array_initialization:
|
|
{
|
|
if (right->array_initialization.is_constant)
|
|
{
|
|
emit_value(module, right, TypeKind::memory);
|
|
|
|
bool is_constant = true;
|
|
LLVMLinkage linkage_type = LLVMInternalLinkage;
|
|
LLVMValueRef before = 0;
|
|
LLVMThreadLocalMode thread_local_mode = {};
|
|
u32 address_space = 0;
|
|
bool externally_initialized = false;
|
|
|
|
auto global = llvm_module_create_global_variable(module->llvm.module, value_type->llvm.memory, is_constant, linkage_type, right->llvm, string_literal("constarray"), before, thread_local_mode, address_space, externally_initialized);
|
|
|
|
LLVMSetUnnamedAddress(global, LLVMGlobalUnnamedAddr);
|
|
|
|
auto alignment = get_byte_alignment(resolved_value_type);
|
|
LLVMSetAlignment(global, alignment);
|
|
|
|
auto uint64_type = uint64(module);
|
|
resolve_type_in_place(module, uint64_type);
|
|
|
|
auto element_type = resolved_value_type->array.element_type;
|
|
auto element_count = resolved_value_type->array.element_count;
|
|
assert(right->array_initialization.values.length == element_count);
|
|
|
|
u64 memcpy_size = get_byte_size(element_type) * element_count;
|
|
LLVMBuildMemCpy(module->llvm.builder, left_llvm, alignment, global, alignment, LLVMConstInt(uint64_type->llvm.abi, memcpy_size, false));
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case ValueId::string_literal:
|
|
{
|
|
bool null_terminate = true;
|
|
auto length = right->string_literal.length;
|
|
auto constant_string = LLVMConstStringInContext2(module->llvm.context, (char*)right->string_literal.pointer, length, !null_terminate);
|
|
auto u8_type = uint8(module);
|
|
resolve_type_in_place(module, u8_type);
|
|
auto string_type = LLVMArrayType2(u8_type->llvm.abi, length + null_terminate);
|
|
auto is_constant = true;
|
|
LLVMValueRef before = 0;
|
|
LLVMThreadLocalMode tlm = LLVMNotThreadLocal;
|
|
bool externally_initialized = false;
|
|
unsigned address_space = 0;
|
|
auto global = llvm_module_create_global_variable(module->llvm.module, string_type, is_constant, LLVMInternalLinkage, constant_string, string_literal("conststring"), before, tlm, address_space, externally_initialized);
|
|
LLVMSetUnnamedAddress(global, LLVMGlobalUnnamedAddr);
|
|
auto slice_type = get_slice_type(module, u8_type);
|
|
|
|
if (resolved_value_type->id != TypeId::structure)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (!resolved_value_type->structure.is_slice)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (slice_type != resolved_value_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
LLVMValueRef values[] = {global, LLVMConstNull(slice_type->structure.fields[1].type->llvm.abi) };
|
|
|
|
for (u32 i = 0; i < array_length(values); i += 1)
|
|
{
|
|
auto member_pointer = LLVMBuildStructGEP2(module->llvm.builder, slice_type->llvm.abi, left_llvm, i, "");
|
|
auto slice_member_type = slice_type->structure.fields[i].type;
|
|
create_store(module, {
|
|
.source = values[i],
|
|
.destination = member_pointer,
|
|
.type = slice_member_type,
|
|
});
|
|
}
|
|
} break;
|
|
case ValueId::va_start:
|
|
{
|
|
assert(resolved_value_type == get_va_list_type(module));
|
|
assert(pointer_type->pointer.element_type == get_va_list_type(module));
|
|
LLVMTypeRef argument_types[] = {
|
|
module->llvm.pointer_type,
|
|
};
|
|
LLVMValueRef argument_values[] = {
|
|
left_llvm,
|
|
};
|
|
auto call = emit_intrinsic_call(module, IntrinsicIndex::va_start, array_to_slice(argument_types), array_to_slice(argument_values));
|
|
unused(call);
|
|
} break;
|
|
case ValueId::aggregate_initialization:
|
|
{
|
|
auto names = right->aggregate_initialization.names;
|
|
auto values = right->aggregate_initialization.values;
|
|
auto is_constant = right->aggregate_initialization.is_constant;
|
|
auto zero = right->aggregate_initialization.zero;
|
|
assert(names.length == values.length);
|
|
|
|
if (is_constant)
|
|
{
|
|
emit_value(module, right, TypeKind::memory);
|
|
|
|
LLVMLinkage linkage_type = LLVMInternalLinkage;
|
|
LLVMValueRef before = 0;
|
|
unsigned address_space = 0;
|
|
LLVMThreadLocalMode thread_local_mode = LLVMNotThreadLocal;
|
|
bool externally_initialized = false;
|
|
auto global = llvm_module_create_global_variable(module->llvm.module, value_type->llvm.memory, is_constant, linkage_type, right->llvm, string_literal("constarray"), before, thread_local_mode, address_space, externally_initialized);
|
|
LLVMSetUnnamedAddress(global, LLVMGlobalUnnamedAddr);
|
|
auto alignment = get_byte_alignment(value_type);
|
|
LLVMSetAlignment(global, alignment);
|
|
auto u64_type = uint64(module);
|
|
resolve_type_in_place(module, u64_type);
|
|
u64 memcpy_size = get_byte_size(value_type);
|
|
LLVMBuildMemCpy(module->llvm.builder, left_llvm, alignment, global, alignment, LLVMConstInt(u64_type->llvm.abi, memcpy_size, false));
|
|
}
|
|
else
|
|
{
|
|
switch (resolved_value_type->id)
|
|
{
|
|
case TypeId::structure:
|
|
{
|
|
u64 max_field_index = 0;
|
|
u64 field_mask = 0;
|
|
auto fields = resolved_value_type->structure.fields;
|
|
assert(fields.length <= 64);
|
|
unused(field_mask);
|
|
|
|
for (u32 initialization_index = 0; initialization_index < (u32)values.length; initialization_index += 1)
|
|
{
|
|
auto name = names[initialization_index];
|
|
auto value = values[initialization_index];
|
|
unused(name);
|
|
unused(value);
|
|
|
|
u32 declaration_index;
|
|
for (declaration_index = 0; declaration_index < (u32)fields.length; declaration_index += 1)
|
|
{
|
|
auto field = fields[declaration_index];
|
|
|
|
if (name.equal(field.name))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(declaration_index < fields.length);
|
|
|
|
field_mask |= 1 << declaration_index;
|
|
max_field_index = MAX(max_field_index, declaration_index);
|
|
auto& field = fields[declaration_index];
|
|
auto destination_pointer = LLVMBuildStructGEP2(module->llvm.builder, resolved_value_type->llvm.memory, left_llvm, declaration_index, "");
|
|
emit_assignment(module, destination_pointer, get_pointer_type(module, field.type), value);
|
|
}
|
|
|
|
if (zero)
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case TypeId::union_type:
|
|
{
|
|
trap();
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
} break;
|
|
case ValueId::call:
|
|
{
|
|
auto result = emit_call(module, right, left_llvm, left_type);
|
|
assert(result == left_llvm);
|
|
} break;
|
|
case ValueId::va_arg:
|
|
{
|
|
auto result = emit_va_arg(module, right, left_llvm, left_type);
|
|
if (result != left_llvm)
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case ValueId::slice_expression:
|
|
{
|
|
auto slice = emit_slice_expression(module, right);
|
|
auto slice_pointer_type = resolved_value_type->structure.fields[0].type;
|
|
create_store(module, {
|
|
.source = slice.values[0],
|
|
.destination = left_llvm,
|
|
.type = slice_pointer_type,
|
|
});
|
|
|
|
auto slice_length_destination = LLVMBuildStructGEP2(module->llvm.builder, resolved_value_type->llvm.abi, left_llvm, 1, "");
|
|
create_store(module, {
|
|
.source = slice.values[1],
|
|
.destination = slice_length_destination,
|
|
.type = uint64(module),
|
|
});
|
|
} break;
|
|
case ValueId::zero:
|
|
{
|
|
auto u8_type = uint8(module);
|
|
auto u64_type = uint64(module);
|
|
resolve_type_in_place(module, u8_type);
|
|
resolve_type_in_place(module, u64_type);
|
|
|
|
auto size = get_byte_size(resolved_value_type);
|
|
auto alignment = get_byte_alignment(resolved_value_type);
|
|
LLVMBuildMemSet(module->llvm.builder, left_llvm, LLVMConstNull(u8_type->llvm.memory), LLVMConstInt(u64_type->llvm.memory, size, false), alignment);
|
|
} break;
|
|
case ValueId::variable_reference:
|
|
{
|
|
auto* variable = right->variable_reference;
|
|
unused(variable);
|
|
switch (right->kind)
|
|
{
|
|
case ValueKind::left:
|
|
{
|
|
trap();
|
|
} break;
|
|
case ValueKind::right:
|
|
{
|
|
auto u64_type = uint64(module);
|
|
resolve_type_in_place(module, u64_type);
|
|
auto memcpy_size = get_byte_size(resolved_value_type);
|
|
auto alignment = get_byte_alignment(resolved_value_type);
|
|
LLVMBuildMemCpy(module->llvm.builder, left_llvm, alignment, variable->storage->llvm, alignment, LLVMConstInt(u64_type->llvm.abi, memcpy_size, false));
|
|
} break;
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn void emit_local_storage(Module* module, Variable* variable)
|
|
{
|
|
assert(!variable->storage);
|
|
auto value_type = variable->type;
|
|
resolve_type_in_place(module, value_type);
|
|
auto pointer_type = get_pointer_type(module, value_type);
|
|
auto storage = new_value(module);
|
|
auto alloca = create_alloca(module, {
|
|
.type = value_type,
|
|
.name = variable->name,
|
|
});
|
|
*storage = Value{
|
|
.type = pointer_type,
|
|
.id = ValueId::local,
|
|
.llvm = alloca,
|
|
};
|
|
variable->storage = storage;
|
|
}
|
|
|
|
fn LLVMMetadataRef null_expression(Module* module)
|
|
{
|
|
return LLVMDIBuilderCreateExpression(module->llvm.di_builder, 0, 0);
|
|
}
|
|
|
|
fn void emit_local_variable(Module* module, Local* local)
|
|
{
|
|
emit_local_storage(module, &local->variable);
|
|
assert(local->variable.storage);
|
|
|
|
if (module->has_debug_info)
|
|
{
|
|
auto debug_type = local->variable.type->llvm.debug;
|
|
assert(debug_type);
|
|
bool always_preserve = true;
|
|
LLVMDIFlags flags = {};
|
|
|
|
auto scope = local->variable.scope->llvm;
|
|
auto bit_alignment = get_byte_alignment(local->variable.storage->type->pointer.element_type) * 8;
|
|
auto local_variable = LLVMDIBuilderCreateAutoVariable(module->llvm.di_builder, scope, (char*)local->variable.name.pointer, local->variable.name.length, module->llvm.file, local->variable.line, debug_type, always_preserve, flags, bit_alignment);
|
|
auto debug_location = LLVMDIBuilderCreateDebugLocation(module->llvm.context, local->variable.line, local->variable.column, scope, module->llvm.inlined_at);
|
|
LLVMSetCurrentDebugLocation2(module->llvm.builder, debug_location);
|
|
auto basic_block = LLVMGetInsertBlock(module->llvm.builder);
|
|
assert(basic_block);
|
|
LLVMDIBuilderInsertDeclareRecordAtEnd(module->llvm.di_builder, local->variable.storage->llvm, local_variable, null_expression(module), debug_location, basic_block);
|
|
}
|
|
}
|
|
|
|
fn void analyze_value(Module* module, Value* value, Type* expected_type, TypeKind type_kind)
|
|
{
|
|
analyze_type(module, value, expected_type);
|
|
emit_value(module, value, type_kind);
|
|
}
|
|
|
|
fn void analyze_statement(Module* module, Scope* scope, Statement* statement, u32* last_line, u32* last_column, LLVMMetadataRef* last_debug_location);
|
|
|
|
fn void analyze_block(Module* module, Block* block)
|
|
{
|
|
if (module->has_debug_info)
|
|
{
|
|
auto lexical_block = LLVMDIBuilderCreateLexicalBlock(module->llvm.di_builder, block->scope.parent->llvm, module->llvm.file, block->scope.line, block->scope.column);
|
|
block->scope.llvm = lexical_block;
|
|
}
|
|
|
|
u32 last_line = 0;
|
|
u32 last_column = 0;
|
|
LLVMMetadataRef last_debug_location = 0;
|
|
|
|
for (auto* statement = block->first_statement; statement; statement = statement->next)
|
|
{
|
|
analyze_statement(module, &block->scope, statement, &last_line, &last_column, &last_debug_location);
|
|
}
|
|
}
|
|
|
|
fn void analyze_statement(Module* module, Scope* scope, Statement* statement, u32* last_line, u32* last_column, LLVMMetadataRef* last_debug_location)
|
|
{
|
|
Global* parent_function_global;
|
|
if (module->current_function)
|
|
{
|
|
parent_function_global = module->current_function;
|
|
}
|
|
else if (module->current_macro_instantiation)
|
|
{
|
|
parent_function_global = module->current_macro_instantiation->instantiation_function;
|
|
}
|
|
else
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
auto* llvm_function = parent_function_global->variable.storage->llvm;
|
|
assert(llvm_function);
|
|
|
|
if (module->has_debug_info)
|
|
{
|
|
if (statement->line != *last_line || statement->column != *last_column)
|
|
{
|
|
auto new_location = LLVMDIBuilderCreateDebugLocation(module->llvm.context, statement->line, statement->column, scope->llvm, module->llvm.inlined_at);
|
|
*last_debug_location = new_location;
|
|
LLVMSetCurrentDebugLocation2(module->llvm.builder, new_location);
|
|
*last_line = statement->line;
|
|
*last_column = statement->column;
|
|
}
|
|
}
|
|
|
|
switch (statement->id)
|
|
{
|
|
case StatementId::return_st:
|
|
{
|
|
if (module->current_function)
|
|
{
|
|
auto& function_type = parent_function_global->variable.storage->type->pointer.element_type->function;
|
|
auto& return_abi = function_type.return_abi;
|
|
auto return_value = statement->return_st;
|
|
|
|
switch (return_abi.semantic_type->id)
|
|
{
|
|
case TypeId::void_type:
|
|
{
|
|
if (return_value)
|
|
{
|
|
report_error();
|
|
}
|
|
} break;
|
|
case TypeId::noreturn:
|
|
{
|
|
report_error();
|
|
} break;
|
|
default:
|
|
{
|
|
if (module->has_debug_info)
|
|
{
|
|
LLVMSetCurrentDebugLocation2(module->llvm.builder, *last_debug_location);
|
|
}
|
|
|
|
auto return_alloca = module->current_function->variable.storage->function.llvm.return_alloca;
|
|
if (!return_alloca)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
if (!return_value)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
analyze_type(module, return_value, return_abi.semantic_type);
|
|
auto pointer_type = get_pointer_type(module, return_abi.semantic_type);
|
|
emit_assignment(module, return_alloca, pointer_type, return_value);
|
|
} break;
|
|
}
|
|
|
|
auto return_block = module->current_function->variable.storage->function.llvm.return_block;
|
|
LLVMBuildBr(module->llvm.builder, return_block);
|
|
LLVMClearInsertionPosition(module->llvm.builder);
|
|
}
|
|
else if (module->current_macro_instantiation)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
report_error();
|
|
}
|
|
} break;
|
|
case StatementId::local:
|
|
{
|
|
auto local = statement->local;
|
|
auto expected_type = local->variable.type;
|
|
assert(!local->variable.storage);
|
|
analyze_type(module, local->variable.initial_value, expected_type);
|
|
local->variable.type = expected_type ? expected_type : local->variable.initial_value->type;
|
|
assert(local->variable.type);
|
|
if (expected_type)
|
|
{
|
|
assert(expected_type == local->variable.type);
|
|
}
|
|
emit_local_variable(module, local);
|
|
emit_assignment(module, local->variable.storage->llvm, local->variable.storage->type, local->variable.initial_value);
|
|
} break;
|
|
case StatementId::if_st:
|
|
{
|
|
auto* taken_block = llvm_context_create_basic_block(module->llvm.context, string_literal("if.taken"), llvm_function);
|
|
auto* not_taken_block = llvm_context_create_basic_block(module->llvm.context, string_literal("if.not_taken"), llvm_function);
|
|
auto* exit_block = llvm_context_create_basic_block(module->llvm.context, string_literal("if.exit"), llvm_function);
|
|
|
|
auto condition = statement->if_st.condition;
|
|
analyze_value(module, condition, 0, TypeKind::abi);
|
|
auto condition_type = condition->type;
|
|
|
|
LLVMValueRef llvm_condition = 0;
|
|
switch (condition_type->id)
|
|
{
|
|
case TypeId::integer:
|
|
{
|
|
llvm_condition = condition->llvm;
|
|
if (condition_type->integer.bit_count != 1)
|
|
{
|
|
llvm_condition = LLVMBuildICmp(module->llvm.builder, LLVMIntNE, llvm_condition, LLVMConstNull(condition_type->llvm.abi), "");
|
|
}
|
|
} break;
|
|
default: report_error();
|
|
}
|
|
assert(llvm_condition);
|
|
LLVMBuildCondBr(module->llvm.builder, llvm_condition, taken_block, not_taken_block);
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, taken_block);
|
|
|
|
analyze_statement(module, scope, statement->if_st.if_statement, last_line, last_column, last_debug_location);
|
|
|
|
if (LLVMGetInsertBlock(module->llvm.builder))
|
|
{
|
|
LLVMBuildBr(module->llvm.builder, exit_block);
|
|
}
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, not_taken_block);
|
|
auto else_statement = statement->if_st.else_statement;
|
|
if (else_statement)
|
|
{
|
|
analyze_statement(module, scope, else_statement, last_line, last_column, last_debug_location);
|
|
}
|
|
|
|
if (LLVMGetInsertBlock(module->llvm.builder))
|
|
{
|
|
LLVMBuildBr(module->llvm.builder, exit_block);
|
|
}
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, exit_block);
|
|
} break;
|
|
case StatementId::block:
|
|
{
|
|
analyze_block(module, statement->block);
|
|
} break;
|
|
case StatementId::expression:
|
|
{
|
|
analyze_value(module, statement->expression, 0, TypeKind::memory);
|
|
} break;
|
|
case StatementId::while_st:
|
|
{
|
|
auto* entry_block = llvm_context_create_basic_block(module->llvm.context, string_literal("while.entry"), llvm_function);
|
|
LLVMBuildBr(module->llvm.builder, entry_block);
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, entry_block);
|
|
|
|
auto body_block = llvm_context_create_basic_block(module->llvm.context, string_literal("while.body"), llvm_function);
|
|
auto continue_block = llvm_context_create_basic_block(module->llvm.context, string_literal("while.continue"), llvm_function);
|
|
auto exit_block = llvm_context_create_basic_block(module->llvm.context, string_literal("while.exit"), llvm_function);
|
|
|
|
auto previous_continue_block = module->llvm.continue_block;
|
|
auto previous_exit_block = module->llvm.exit_block;
|
|
module->llvm.continue_block = continue_block;
|
|
module->llvm.exit_block = continue_block;
|
|
|
|
auto condition = statement->while_st.condition;
|
|
auto block = statement->while_st.block;
|
|
|
|
if (condition->is_constant())
|
|
{
|
|
switch (condition->id)
|
|
{
|
|
case ValueId::constant_integer:
|
|
{
|
|
if (condition->constant_integer.value == 0)
|
|
{
|
|
report_error();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
LLVMBuildBr(module->llvm.builder, body_block);
|
|
}
|
|
else
|
|
{
|
|
analyze_value(module, condition, 0, TypeKind::abi);
|
|
|
|
auto boolean = uint1(module);
|
|
|
|
LLVMValueRef llvm_condition = condition->llvm;
|
|
auto condition_type = condition->type;
|
|
if (condition_type != boolean)
|
|
{
|
|
switch (condition_type->id)
|
|
{
|
|
case TypeId::integer:
|
|
{
|
|
llvm_condition = LLVMBuildICmp(module->llvm.builder, LLVMIntNE, llvm_condition, LLVMConstNull(condition_type->llvm.abi), "");
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
LLVMBuildCondBr(module->llvm.builder, llvm_condition, body_block, exit_block);
|
|
}
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, body_block);
|
|
|
|
analyze_block(module, block);
|
|
|
|
if (LLVMGetInsertBlock(module->llvm.builder))
|
|
{
|
|
LLVMBuildBr(module->llvm.builder, continue_block);
|
|
}
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, continue_block);
|
|
|
|
LLVMBuildBr(module->llvm.builder, entry_block);
|
|
|
|
if (llvm_value_use_empty((LLVMValueRef)body_block))
|
|
{
|
|
trap();
|
|
}
|
|
|
|
if (llvm_value_use_empty((LLVMValueRef)exit_block))
|
|
{
|
|
trap();
|
|
}
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, exit_block);
|
|
|
|
module->llvm.continue_block = previous_continue_block;
|
|
module->llvm.exit_block = previous_exit_block;
|
|
} break;
|
|
case StatementId::assignment:
|
|
{
|
|
auto left = statement->assignment.left;
|
|
auto right = statement->assignment.right;
|
|
unused(right);
|
|
auto id = statement->assignment.id;
|
|
analyze_value(module, left, 0, TypeKind::memory);
|
|
|
|
auto left_type = left->type;
|
|
if (left_type->id != TypeId::pointer)
|
|
{
|
|
report_error();
|
|
}
|
|
auto element_type = left_type->pointer.element_type;
|
|
auto left_llvm = left->llvm;
|
|
|
|
switch (id)
|
|
{
|
|
case StatementAssignmentId::assign:
|
|
{
|
|
analyze_type(module, right, element_type);
|
|
emit_assignment(module, left_llvm, left_type, right);
|
|
} break;
|
|
case StatementAssignmentId::assign_add:
|
|
case StatementAssignmentId::assign_sub:
|
|
case StatementAssignmentId::assign_mul:
|
|
case StatementAssignmentId::assign_div:
|
|
case StatementAssignmentId::assign_rem:
|
|
case StatementAssignmentId::assign_shift_left:
|
|
case StatementAssignmentId::assign_shift_right:
|
|
case StatementAssignmentId::assign_and:
|
|
case StatementAssignmentId::assign_or:
|
|
case StatementAssignmentId::assign_xor:
|
|
{
|
|
auto evaluation_kind = get_evaluation_kind(element_type);
|
|
assert(evaluation_kind == EvaluationKind::scalar);
|
|
auto load = create_load(module, {
|
|
.type = element_type,
|
|
.pointer = left_llvm,
|
|
.kind = TypeKind::abi,
|
|
});
|
|
analyze_value(module, right, element_type, TypeKind::abi);
|
|
auto a = load;
|
|
auto b = right->llvm;
|
|
|
|
BinaryId binary_id;
|
|
switch (id)
|
|
{
|
|
case StatementAssignmentId::assign: unreachable();
|
|
case StatementAssignmentId::assign_add: binary_id = BinaryId::add; break;
|
|
case StatementAssignmentId::assign_sub: binary_id = BinaryId::sub; break;
|
|
case StatementAssignmentId::assign_mul: binary_id = BinaryId::mul; break;
|
|
case StatementAssignmentId::assign_div: binary_id = BinaryId::div; break;
|
|
case StatementAssignmentId::assign_rem: binary_id = BinaryId::rem; break;
|
|
case StatementAssignmentId::assign_shift_left: binary_id = BinaryId::shift_left; break;
|
|
case StatementAssignmentId::assign_shift_right: binary_id = BinaryId::shift_right; break;
|
|
case StatementAssignmentId::assign_and: binary_id = BinaryId::bitwise_and; break;
|
|
case StatementAssignmentId::assign_or: binary_id = BinaryId::bitwise_or; break;
|
|
case StatementAssignmentId::assign_xor: binary_id = BinaryId::bitwise_xor; break;
|
|
}
|
|
|
|
auto op = emit_binary(module, a, element_type, b, right->type, binary_id, element_type);
|
|
|
|
create_store(module, {
|
|
.source = op,
|
|
.destination = left_llvm,
|
|
.type = element_type,
|
|
});
|
|
} break;
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
}
|
|
|
|
fn void emit_debug_argument(Module* module, Argument* argument, LLVMBasicBlockRef basic_block)
|
|
{
|
|
assert(module->has_debug_info);
|
|
resolve_type_in_place(module, argument->variable.type);
|
|
bool always_preserve = true;
|
|
LLVMDIFlags flags = {};
|
|
LLVMMetadataRef scope = argument->variable.scope->llvm;
|
|
auto parameter_variable = LLVMDIBuilderCreateParameterVariable(module->llvm.di_builder, scope, (char*)argument->variable.name.pointer, argument->variable.name.length, argument->index, module->llvm.file, argument->variable.line, argument->variable.type->llvm.debug, always_preserve, flags);
|
|
auto inlined_at = module->llvm.inlined_at;
|
|
auto debug_location = LLVMDIBuilderCreateDebugLocation(module->llvm.context, argument->variable.line, argument->variable.column, scope, inlined_at);
|
|
LLVMDIBuilderInsertDeclareRecordAtEnd(module->llvm.di_builder, argument->variable.storage->llvm, parameter_variable, LLVMDIBuilderCreateExpression(module->llvm.di_builder, 0, 0), debug_location, basic_block);
|
|
}
|
|
|
|
void emit(Module* module)
|
|
{
|
|
llvm_initialize(module);
|
|
|
|
for (auto* global = module->first_global; global; global = global->next)
|
|
{
|
|
switch (global->variable.storage->id)
|
|
{
|
|
case ValueId::function:
|
|
case ValueId::external_function:
|
|
{
|
|
auto function_type = &global->variable.storage->type->pointer.element_type->function;
|
|
auto semantic_argument_count = function_type->semantic_argument_types.length;
|
|
function_type->argument_abis = arena_allocate<AbiInformation>(module->arena, semantic_argument_count);
|
|
auto resolved_calling_convention = resolve_calling_convention(function_type->calling_convention);
|
|
auto is_reg_call = resolved_calling_convention == ResolvedCallingConvention::system_v && false; // TODO: regcall calling convention
|
|
|
|
LLVMTypeRef llvm_abi_argument_type_buffer[64];
|
|
|
|
switch (resolved_calling_convention)
|
|
{
|
|
case ResolvedCallingConvention::system_v:
|
|
{
|
|
function_type->available_registers = {
|
|
.system_v = {
|
|
.gpr = (u32)(is_reg_call ? 11 : 6),
|
|
.sse = (u32)(is_reg_call ? 16 : 8),
|
|
},
|
|
};
|
|
function_type->return_abi = abi_system_classify_return_type(module, function_type->semantic_return_type);
|
|
auto return_abi_kind = function_type->return_abi.flags.kind;
|
|
|
|
Type* abi_argument_type_buffer[64];
|
|
u16 abi_argument_type_count = 0;
|
|
|
|
Type* abi_return_type;
|
|
switch (return_abi_kind)
|
|
{
|
|
case AbiKind::direct:
|
|
case AbiKind::extend:
|
|
{
|
|
abi_return_type = function_type->return_abi.coerce_to_type;
|
|
} break;
|
|
case AbiKind::ignore:
|
|
case AbiKind::indirect:
|
|
{
|
|
abi_return_type = void_type(module);
|
|
} break;
|
|
default: unreachable(); // TODO
|
|
}
|
|
assert(abi_return_type);
|
|
function_type->abi_return_type = abi_return_type;
|
|
resolve_type_in_place(module, abi_return_type);
|
|
|
|
if (function_type->return_abi.flags.kind == AbiKind::indirect)
|
|
{
|
|
assert(!function_type->return_abi.flags.sret_after_this);
|
|
function_type->available_registers.system_v.gpr -= 1;
|
|
auto indirect_type = get_pointer_type(module, function_type->return_abi.semantic_type);
|
|
resolve_type_in_place(module, indirect_type);
|
|
|
|
auto abi_index = abi_argument_type_count;
|
|
abi_argument_type_buffer[abi_index] = indirect_type;
|
|
llvm_abi_argument_type_buffer[abi_index] = indirect_type->llvm.abi;
|
|
abi_argument_type_count += 1;
|
|
}
|
|
|
|
for (u64 i = 0; i < semantic_argument_count; i += 1)
|
|
{
|
|
auto& abi = function_type->argument_abis[i];
|
|
auto semantic_argument_type = function_type->semantic_argument_types[i];
|
|
auto is_named_argument = i < semantic_argument_count;
|
|
assert(is_named_argument);
|
|
|
|
abi = abi_system_v_classify_argument(module, &function_type->available_registers.system_v, array_to_slice(llvm_abi_argument_type_buffer), array_to_slice(abi_argument_type_buffer), {
|
|
.type = semantic_argument_type,
|
|
.abi_start = abi_argument_type_count,
|
|
.is_named_argument = is_named_argument,
|
|
});
|
|
|
|
abi_argument_type_count += abi.abi_count;
|
|
}
|
|
|
|
auto abi_argument_types = new_type_array(module, abi_argument_type_count);
|
|
memcpy(abi_argument_types.pointer, abi_argument_type_buffer, sizeof(abi_argument_type_buffer[0]) * abi_argument_type_count);
|
|
function_type->abi_argument_types = abi_argument_types;
|
|
} break;
|
|
case ResolvedCallingConvention::win64:
|
|
{
|
|
report_error();
|
|
} break;
|
|
case ResolvedCallingConvention::count: unreachable();
|
|
}
|
|
|
|
auto llvm_function_type = LLVMFunctionType(function_type->abi_return_type->llvm.abi, llvm_abi_argument_type_buffer, (u32)function_type->abi_argument_types.length, function_type->is_variable_arguments);
|
|
|
|
LLVMMetadataRef subroutine_type = 0;
|
|
if (module->has_debug_info)
|
|
{
|
|
LLVMMetadataRef debug_argument_type_buffer[64];
|
|
Slice<LLVMMetadataRef> debug_argument_types = { .pointer = debug_argument_type_buffer, .length = function_type->argument_abis.length + 1 + function_type->is_variable_arguments };
|
|
debug_argument_types[0] = function_type->return_abi.semantic_type->llvm.debug;
|
|
assert(debug_argument_types[0]);
|
|
|
|
auto debug_argument_type_slice = debug_argument_types(1)(0, function_type->argument_abis.length);
|
|
|
|
for (u64 i = 0; i < function_type->argument_abis.length; i += 1)
|
|
{
|
|
auto& argument_abi = function_type->argument_abis[i];
|
|
auto* debug_argument_type = &debug_argument_type_slice[i];
|
|
*debug_argument_type = argument_abi.semantic_type->llvm.debug;
|
|
assert(*debug_argument_type);
|
|
}
|
|
|
|
if (function_type->is_variable_arguments)
|
|
{
|
|
auto void_ty = void_type(module);
|
|
assert(void_ty->llvm.debug);
|
|
debug_argument_types[function_type->argument_abis.length + 1] = void_ty->llvm.debug;
|
|
}
|
|
|
|
LLVMDIFlags flags = {};
|
|
subroutine_type = LLVMDIBuilderCreateSubroutineType(module->llvm.di_builder, module->llvm.file, debug_argument_types.pointer, (u32)debug_argument_types.length, flags);
|
|
}
|
|
|
|
global->variable.storage->type->pointer.element_type->llvm.abi = llvm_function_type;
|
|
global->variable.storage->type->pointer.element_type->llvm.debug = subroutine_type;
|
|
|
|
LLVMLinkage llvm_linkage_type;
|
|
switch (global->linkage)
|
|
{
|
|
case Linkage::internal: llvm_linkage_type = LLVMInternalLinkage; break;
|
|
case Linkage::external: llvm_linkage_type = LLVMExternalLinkage; break;
|
|
}
|
|
unsigned address_space = 0;
|
|
auto llvm_function = llvm_module_create_function(module->llvm.module, llvm_function_type, llvm_linkage_type, address_space, global->variable.name);
|
|
global->variable.storage->llvm = llvm_function;
|
|
|
|
LLVMCallConv cc;
|
|
switch (function_type->calling_convention)
|
|
{
|
|
case CallingConvention::c: cc = LLVMCCallConv; break;
|
|
case CallingConvention::count: unreachable();
|
|
}
|
|
LLVMSetFunctionCallConv(llvm_function, cc);
|
|
|
|
auto attribute_list = build_attribute_list(module, {
|
|
.return_abi = function_type->return_abi,
|
|
.argument_abis = function_type->argument_abis,
|
|
.abi_argument_types = function_type->abi_argument_types,
|
|
.abi_return_type = function_type->abi_return_type,
|
|
.attributes = global->variable.storage->function.attributes,
|
|
.call_site = false,
|
|
});
|
|
llvm_function_set_attributes(llvm_function, attribute_list);
|
|
|
|
LLVMMetadataRef subprogram = 0;
|
|
auto is_definition = global->variable.storage->id == ValueId::function;
|
|
|
|
if (module->has_debug_info)
|
|
{
|
|
auto is_local_to_unit = global->linkage == Linkage::internal;
|
|
auto line = global->variable.line;
|
|
auto scope_line = line + 1;
|
|
LLVMDIFlags flags = {};
|
|
auto is_optimized = build_mode_is_optimized(module->build_mode);
|
|
subprogram = LLVMDIBuilderCreateFunction(module->llvm.di_builder, module->scope.llvm, (char*)global->variable.name.pointer, global->variable.name.length, (char*)global->variable.name.pointer, global->variable.name.length, module->llvm.file, line, subroutine_type, is_local_to_unit, is_definition, scope_line, flags, is_optimized);
|
|
LLVMSetSubprogram(llvm_function, subprogram);
|
|
}
|
|
|
|
if (is_definition)
|
|
{
|
|
global->variable.storage->function.scope.llvm = subprogram;
|
|
|
|
module->current_function = global;
|
|
|
|
LLVMValueRef llvm_abi_argument_buffer[64];
|
|
Slice<LLVMValueRef> llvm_abi_arguments = { .pointer = llvm_abi_argument_buffer, .length = function_type->abi_argument_types.length };
|
|
LLVMGetParams(llvm_function, llvm_abi_argument_buffer);
|
|
|
|
auto* entry_block = llvm_context_create_basic_block(module->llvm.context, string_literal("entry"), llvm_function);
|
|
auto return_block = llvm_context_create_basic_block(module->llvm.context, string_literal("return_block"), 0);
|
|
global->variable.storage->function.llvm.return_block = return_block;
|
|
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, entry_block);
|
|
LLVMSetCurrentDebugLocation2(module->llvm.builder, 0);
|
|
|
|
auto return_abi_kind = function_type->return_abi.flags.kind;
|
|
switch (return_abi_kind)
|
|
{
|
|
case AbiKind::indirect:
|
|
{
|
|
auto indirect_argument_index = function_type->return_abi.flags.sret_after_this;
|
|
if (function_type->return_abi.flags.sret_after_this)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
global->variable.storage->function.llvm.return_alloca = llvm_abi_arguments[indirect_argument_index];
|
|
|
|
if (!function_type->return_abi.flags.indirect_by_value)
|
|
{
|
|
trap();
|
|
}
|
|
} break;
|
|
case AbiKind::in_alloca:
|
|
{
|
|
trap();
|
|
} break;
|
|
default:
|
|
{
|
|
auto alloca = create_alloca(module, {
|
|
.type = function_type->return_abi.semantic_type,
|
|
.name = string_literal("retval"),
|
|
});
|
|
global->variable.storage->function.llvm.return_alloca = alloca;
|
|
} break;
|
|
case AbiKind::ignore: break;
|
|
}
|
|
|
|
auto arguments = global->variable.storage->function.arguments;
|
|
auto argument_abis = function_type->argument_abis;
|
|
assert(arguments.length == argument_abis.length);
|
|
for (u64 i = 0; i < semantic_argument_count; i += 1)
|
|
{
|
|
auto* argument = &arguments[i];
|
|
auto& argument_abi = argument_abis[i];
|
|
auto argument_abi_arguments = llvm_abi_arguments(argument_abi.abi_start)(0, argument_abi.abi_count);
|
|
|
|
LLVMValueRef semantic_argument_storage = 0;
|
|
switch (argument_abi.flags.kind)
|
|
{
|
|
case AbiKind::direct:
|
|
case AbiKind::extend:
|
|
{
|
|
auto first_argument = argument_abi_arguments[0];
|
|
auto coerce_to_type = argument_abi.get_coerce_to_type();
|
|
if (coerce_to_type->id != TypeId::structure && type_is_abi_equal(module, coerce_to_type, argument_abi.semantic_type) && argument_abi.attributes.direct.offset == 0)
|
|
{
|
|
assert(argument_abi.abi_count == 1);
|
|
|
|
auto is_promoted = false;
|
|
auto v = first_argument;
|
|
if (coerce_to_type->llvm.abi != LLVMTypeOf(v))
|
|
{
|
|
trap();
|
|
}
|
|
|
|
if (is_promoted)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
// TODO: this we can get rid of because we handle all of this inside `create_alloca`, load, stores, etc
|
|
if (is_arbitrary_bit_integer(argument_abi.semantic_type))
|
|
{
|
|
auto bit_count = (u32)get_bit_size(argument_abi.semantic_type);
|
|
auto abi_bit_count = align_bit_count(bit_count);
|
|
bool is_signed = type_is_signed(argument_abi.semantic_type);
|
|
auto destination_type = integer_type(module, { .bit_count = abi_bit_count, .is_signed = is_signed });
|
|
auto alloca = create_alloca(module, {
|
|
.type = destination_type,
|
|
.name = argument->variable.name,
|
|
});
|
|
|
|
LLVMValueRef result;
|
|
if (bit_count < abi_bit_count)
|
|
{
|
|
if (is_signed)
|
|
{
|
|
result = LLVMBuildSExt(module->llvm.builder, first_argument, destination_type->llvm.memory, "");
|
|
}
|
|
else
|
|
{
|
|
result = LLVMBuildZExt(module->llvm.builder, first_argument, destination_type->llvm.memory, "");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
|
|
create_store(module, {
|
|
.source = result,
|
|
.destination = alloca,
|
|
.type = destination_type,
|
|
});
|
|
|
|
semantic_argument_storage = alloca;
|
|
}
|
|
else
|
|
{
|
|
auto alloca = create_alloca(module, {
|
|
.type = argument_abi.semantic_type,
|
|
.name = argument->variable.name,
|
|
});
|
|
create_store(module, {
|
|
.source = first_argument,
|
|
.destination = alloca,
|
|
.type = argument_abi.semantic_type,
|
|
});
|
|
|
|
semantic_argument_storage = alloca;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto is_fixed_vector_type = false;
|
|
if (is_fixed_vector_type)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
if (coerce_to_type->id == TypeId::structure && coerce_to_type->structure.fields.length > 1 && argument_abi.flags.kind == AbiKind::direct && !argument_abi.flags.can_be_flattened)
|
|
{
|
|
auto contains_homogeneous_scalable_vector_types = false;
|
|
if (contains_homogeneous_scalable_vector_types)
|
|
{
|
|
trap();
|
|
}
|
|
}
|
|
|
|
auto alloca = create_alloca(module, { .type = argument_abi.semantic_type });
|
|
LLVMValueRef pointer;
|
|
Type* pointer_type;
|
|
if (argument_abi.attributes.direct.offset > 0)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
pointer = alloca;
|
|
pointer_type = argument_abi.semantic_type;
|
|
}
|
|
|
|
if (coerce_to_type->id == TypeId::structure && coerce_to_type->structure.fields.length > 1 && argument_abi.flags.kind == AbiKind::direct && argument_abi.flags.can_be_flattened)
|
|
{
|
|
auto struct_size = get_byte_size(coerce_to_type);
|
|
auto pointer_element_size = get_byte_size(pointer_type);
|
|
auto is_scalable = false;
|
|
|
|
if (is_scalable)
|
|
{
|
|
trap();
|
|
}
|
|
else
|
|
{
|
|
auto source_size = struct_size;
|
|
auto destination_size = pointer_element_size;
|
|
auto address_alignment = get_byte_alignment(argument_abi.semantic_type);
|
|
|
|
LLVMValueRef address;
|
|
if (source_size <= destination_size)
|
|
{
|
|
address = alloca;
|
|
}
|
|
else
|
|
{
|
|
address = create_alloca(module, { .type = coerce_to_type, .name = string_literal("coerce"), .alignment = address_alignment });
|
|
}
|
|
|
|
assert(coerce_to_type->structure.fields.length == argument_abi.abi_count);
|
|
|
|
resolve_type_in_place(module, coerce_to_type);
|
|
|
|
for (u64 i = 0; i < coerce_to_type->structure.fields.length; i += 1)
|
|
{
|
|
auto gep = LLVMBuildStructGEP2(module->llvm.builder, coerce_to_type->llvm.abi, address, i, "");
|
|
create_store(module, {
|
|
.source = argument_abi_arguments[i],
|
|
.destination = gep,
|
|
.type = coerce_to_type->structure.fields[i].type,
|
|
});
|
|
}
|
|
|
|
if (source_size > destination_size)
|
|
{
|
|
unused(pointer);
|
|
trap();
|
|
}
|
|
}
|
|
}
|
|
|
|
semantic_argument_storage = alloca;
|
|
}
|
|
} break;
|
|
case AbiKind::indirect:
|
|
{
|
|
assert(argument_abi.abi_count == 1);
|
|
auto evaluation_kind = get_evaluation_kind(argument_abi.semantic_type);
|
|
switch (evaluation_kind)
|
|
{
|
|
default:
|
|
{
|
|
if (argument_abi.flags.indirect_realign || argument_abi.flags.kind == AbiKind::indirect_aliased)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto use_indirect_debug_address = !argument_abi.flags.indirect_by_value;
|
|
if (use_indirect_debug_address)
|
|
{
|
|
trap();
|
|
}
|
|
|
|
auto llvm_argument = argument_abi_arguments[0];
|
|
semantic_argument_storage = llvm_argument;
|
|
} break;
|
|
case EvaluationKind::scalar: trap();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
assert(semantic_argument_storage);
|
|
|
|
auto storage = new_value(module);
|
|
auto value_type = argument->variable.type;
|
|
*storage = {
|
|
.type = get_pointer_type(module, value_type),
|
|
.id = ValueId::argument,
|
|
.llvm = semantic_argument_storage,
|
|
};
|
|
argument->variable.storage = storage;
|
|
|
|
if (module->has_debug_info)
|
|
{
|
|
emit_debug_argument(module, argument, entry_block);
|
|
}
|
|
}
|
|
|
|
analyze_block(module, global->variable.storage->function.block);
|
|
|
|
auto* current_basic_block = LLVMGetInsertBlock(module->llvm.builder);
|
|
if (current_basic_block)
|
|
{
|
|
assert(!LLVMGetBasicBlockTerminator(current_basic_block));
|
|
|
|
if (llvm_basic_block_is_empty(current_basic_block) || llvm_value_use_empty((LLVMValueRef)current_basic_block))
|
|
{
|
|
LLVMReplaceAllUsesWith((LLVMValueRef)return_block, (LLVMValueRef)current_basic_block);
|
|
llvm_basic_block_delete(return_block);
|
|
}
|
|
else
|
|
{
|
|
emit_block(module, return_block);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool is_reachable = false;
|
|
|
|
if (llvm_value_has_one_use((LLVMValueRef)return_block))
|
|
{
|
|
auto user = llvm_basic_block_user_begin(return_block);
|
|
is_reachable = LLVMIsABranchInst(user) && !LLVMIsConditional(user) && LLVMGetSuccessor(user, 0) == return_block;
|
|
if (is_reachable)
|
|
{
|
|
LLVMPositionBuilderAtEnd(module->llvm.builder, LLVMGetInstructionParent(user));
|
|
LLVMInstructionEraseFromParent(user);
|
|
llvm_basic_block_delete(return_block);
|
|
}
|
|
}
|
|
|
|
if (!is_reachable)
|
|
{
|
|
emit_block(module, return_block);
|
|
}
|
|
}
|
|
|
|
if (module->has_debug_info)
|
|
{
|
|
LLVMSetCurrentDebugLocation2(module->llvm.builder, 0);
|
|
auto subprogram = LLVMGetSubprogram(llvm_function);
|
|
LLVMDIBuilderFinalizeSubprogram(module->llvm.di_builder, subprogram);
|
|
}
|
|
|
|
if (function_type->return_abi.semantic_type == noreturn_type(module) || global->variable.storage->function.attributes.naked)
|
|
{
|
|
LLVMBuildUnreachable(module->llvm.builder);
|
|
}
|
|
else if (function_type->return_abi.semantic_type == void_type(module))
|
|
{
|
|
LLVMBuildRetVoid(module->llvm.builder);
|
|
}
|
|
else
|
|
{
|
|
LLVMValueRef return_value = 0;
|
|
|
|
switch (return_abi_kind)
|
|
{
|
|
case AbiKind::direct:
|
|
case AbiKind::extend:
|
|
{
|
|
auto return_alloca = global->variable.storage->function.llvm.return_alloca;
|
|
auto coerce_to_type = function_type->return_abi.get_coerce_to_type();
|
|
auto return_semantic_type = function_type->return_abi.semantic_type;
|
|
if (type_is_abi_equal(module, coerce_to_type, return_semantic_type) && function_type->return_abi.attributes.direct.offset == 0)
|
|
{
|
|
auto store = llvm_find_return_value_dominating_store(module->llvm.builder, return_alloca, return_semantic_type->llvm.abi);
|
|
if (store)
|
|
{
|
|
return_value = LLVMGetOperand(store, 0);
|
|
auto alloca = LLVMGetOperand(store, 1);
|
|
assert(alloca == return_alloca);
|
|
LLVMInstructionEraseFromParent(store);
|
|
assert(llvm_value_use_empty(alloca));
|
|
LLVMInstructionEraseFromParent(alloca);
|
|
}
|
|
else
|
|
{
|
|
return_value = create_load(module, LoadOptions{
|
|
.type = return_semantic_type,
|
|
.pointer = return_alloca,
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LLVMValueRef source = 0;
|
|
if (function_type->return_abi.attributes.direct.offset == 0)
|
|
{
|
|
source = return_alloca;
|
|
}
|
|
else
|
|
{
|
|
trap();
|
|
}
|
|
assert(source);
|
|
|
|
auto source_type = function_type->return_abi.semantic_type;
|
|
auto destination_type = coerce_to_type;
|
|
auto result = create_coerced_load(module, source, source_type, destination_type);
|
|
return_value = result;
|
|
}
|
|
} break;
|
|
case AbiKind::indirect:
|
|
{
|
|
auto evaluation_kind = get_evaluation_kind(function_type->return_abi.semantic_type);
|
|
switch (evaluation_kind)
|
|
{
|
|
case EvaluationKind::scalar: trap();
|
|
case EvaluationKind::aggregate: break;
|
|
case EvaluationKind::complex: trap();
|
|
}
|
|
} break;
|
|
default: unreachable();
|
|
}
|
|
|
|
LLVMBuildRet(module->llvm.builder, return_value);
|
|
}
|
|
|
|
// END OF SCOPE
|
|
module->current_function = 0;
|
|
}
|
|
} break;
|
|
case ValueId::global:
|
|
{
|
|
analyze_value(module, global->variable.initial_value, global->variable.type, TypeKind::memory);
|
|
|
|
auto initial_value_type = global->variable.initial_value->type;
|
|
|
|
if (!global->variable.type)
|
|
{
|
|
global->variable.type = initial_value_type;
|
|
}
|
|
|
|
auto global_type = global->variable.type;
|
|
|
|
if (global_type != initial_value_type)
|
|
{
|
|
report_error();
|
|
}
|
|
|
|
resolve_type_in_place(module, global_type);
|
|
|
|
bool is_constant = false;
|
|
LLVMLinkage linkage;
|
|
switch (global->linkage)
|
|
{
|
|
case Linkage::internal: linkage = LLVMInternalLinkage; break;
|
|
case Linkage::external: linkage = LLVMExternalLinkage; break;
|
|
}
|
|
|
|
LLVMValueRef before = 0;
|
|
LLVMThreadLocalMode thread_local_mode = LLVMNotThreadLocal;
|
|
unsigned address_space = 0;
|
|
bool externally_initialized = false;
|
|
|
|
auto global_llvm = llvm_module_create_global_variable(module->llvm.module, global_type->llvm.memory, is_constant, linkage, global->variable.initial_value->llvm, global->variable.name, before, thread_local_mode, address_space, externally_initialized);
|
|
auto alignment = get_byte_alignment(global_type);
|
|
LLVMSetAlignment(global_llvm, alignment);
|
|
global->variable.storage->llvm = global_llvm;
|
|
global->variable.storage->type = get_pointer_type(module, global_type);
|
|
|
|
if (module->has_debug_info)
|
|
{
|
|
auto name = global->variable.name;
|
|
auto linkage_name = name;
|
|
auto local_to_unit = global->linkage == Linkage::internal;
|
|
auto global_debug = LLVMDIBuilderCreateGlobalVariableExpression(module->llvm.di_builder, module->scope.llvm, (char*)name.pointer, name.length, (char*)linkage_name.pointer, linkage_name.length, module->llvm.file, global->variable.line, global_type->llvm.debug, local_to_unit, null_expression(module), 0, alignment * 8);
|
|
LLVMGlobalSetMetadata(global_llvm, 0, global_debug);
|
|
}
|
|
} break;
|
|
default: report_error();
|
|
}
|
|
}
|
|
|
|
if (module->has_debug_info)
|
|
{
|
|
LLVMDIBuilderFinalize(module->llvm.di_builder);
|
|
}
|
|
|
|
String verification_error_message = {};
|
|
if (!llvm_module_verify(module->llvm.module, &verification_error_message))
|
|
{
|
|
dump_module(module);
|
|
print(string_literal("\n==========================\nLLVM VERIFICATION ERROR\n==========================\n"));
|
|
print(verification_error_message);
|
|
fail();
|
|
}
|
|
|
|
if (!module->silent)
|
|
{
|
|
dump_module(module);
|
|
}
|
|
}
|