2015-11-25 04:00:38 +08:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2015 Andrew Kelley
|
|
|
|
*
|
|
|
|
* This file is part of zig, which is MIT licensed.
|
|
|
|
* See http://opensource.org/licenses/MIT
|
|
|
|
*/
|
|
|
|
|
2015-11-24 13:47:25 +08:00
|
|
|
#include "codegen.hpp"
|
|
|
|
#include "hash_map.hpp"
|
2015-11-25 04:00:38 +08:00
|
|
|
#include "zig_llvm.hpp"
|
2015-11-25 04:51:36 +08:00
|
|
|
#include "os.hpp"
|
2015-11-25 10:07:33 +08:00
|
|
|
#include "config.h"
|
2015-11-24 13:47:25 +08:00
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
2015-11-25 10:54:10 +08:00
|
|
|
#include <llvm/IR/IRBuilder.h>
|
2015-11-25 10:07:33 +08:00
|
|
|
#include <llvm/IR/DIBuilder.h>
|
|
|
|
#include <llvm/IR/DiagnosticInfo.h>
|
|
|
|
#include <llvm/IR/DiagnosticPrinter.h>
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
struct FnTableEntry {
|
|
|
|
LLVMValueRef fn_value;
|
|
|
|
AstNode *proto_node;
|
|
|
|
};
|
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
enum TypeId {
|
|
|
|
TypeIdUserDefined,
|
|
|
|
TypeIdPointer,
|
|
|
|
TypeIdU8,
|
|
|
|
TypeIdI32,
|
|
|
|
TypeIdVoid,
|
|
|
|
TypeIdUnreachable,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct TypeTableEntry {
|
|
|
|
TypeId id;
|
|
|
|
LLVMTypeRef type_ref;
|
|
|
|
llvm::DIType *di_type;
|
|
|
|
|
|
|
|
TypeTableEntry *pointer_child;
|
|
|
|
bool pointer_is_const;
|
|
|
|
int user_defined_id;
|
|
|
|
Buf name;
|
|
|
|
TypeTableEntry *pointer_const_parent;
|
|
|
|
TypeTableEntry *pointer_mut_parent;
|
|
|
|
};
|
|
|
|
|
2015-11-24 13:47:25 +08:00
|
|
|
struct CodeGen {
|
2015-11-24 17:43:45 +08:00
|
|
|
LLVMModuleRef mod;
|
2015-11-24 13:47:25 +08:00
|
|
|
AstNode *root;
|
2015-11-24 17:43:45 +08:00
|
|
|
HashMap<Buf *, AstNode *, buf_hash, buf_eql_buf> fn_defs;
|
2015-11-24 13:47:25 +08:00
|
|
|
ZigList<ErrorMsg> errors;
|
2015-11-24 15:35:23 +08:00
|
|
|
LLVMBuilderRef builder;
|
2015-11-25 10:07:33 +08:00
|
|
|
llvm::DIBuilder *dbuilder;
|
|
|
|
llvm::DICompileUnit *compile_unit;
|
2015-11-24 17:43:45 +08:00
|
|
|
HashMap<Buf *, FnTableEntry *, buf_hash, buf_eql_buf> fn_table;
|
|
|
|
HashMap<Buf *, LLVMValueRef, buf_hash, buf_eql_buf> str_table;
|
2015-11-25 10:07:33 +08:00
|
|
|
HashMap<Buf *, TypeTableEntry *, buf_hash, buf_eql_buf> type_table;
|
2015-11-25 14:44:41 +08:00
|
|
|
HashMap<Buf *, bool, buf_hash, buf_eql_buf> link_table;
|
2015-11-25 10:07:33 +08:00
|
|
|
TypeTableEntry *invalid_type_entry;
|
|
|
|
LLVMTargetDataRef target_data_ref;
|
|
|
|
unsigned pointer_size_bytes;
|
|
|
|
bool is_static;
|
2015-11-25 13:32:26 +08:00
|
|
|
bool strip_debug_symbols;
|
|
|
|
CodeGenBuildType build_type;
|
2015-11-25 10:07:33 +08:00
|
|
|
LLVMTargetMachineRef target_machine;
|
|
|
|
Buf in_file;
|
|
|
|
Buf in_dir;
|
2015-11-25 10:54:10 +08:00
|
|
|
ZigList<llvm::DIScope *> block_scopes;
|
|
|
|
llvm::DIFile *di_file;
|
2015-11-24 15:35:23 +08:00
|
|
|
};
|
|
|
|
|
2015-11-25 04:37:14 +08:00
|
|
|
struct TypeNode {
|
2015-11-25 10:07:33 +08:00
|
|
|
TypeTableEntry *entry;
|
2015-11-25 04:37:14 +08:00
|
|
|
};
|
|
|
|
|
2015-11-24 15:35:23 +08:00
|
|
|
struct CodeGenNode {
|
|
|
|
union {
|
2015-11-25 04:37:14 +08:00
|
|
|
TypeNode type_node; // for NodeTypeType
|
2015-11-24 15:35:23 +08:00
|
|
|
} data;
|
2015-11-24 13:47:25 +08:00
|
|
|
};
|
|
|
|
|
2015-11-25 13:32:26 +08:00
|
|
|
CodeGen *create_codegen(AstNode *root, Buf *in_full_path) {
|
2015-11-24 13:47:25 +08:00
|
|
|
CodeGen *g = allocate<CodeGen>(1);
|
|
|
|
g->root = root;
|
2015-11-24 17:43:45 +08:00
|
|
|
g->fn_defs.init(32);
|
|
|
|
g->fn_table.init(32);
|
|
|
|
g->str_table.init(32);
|
2015-11-25 10:07:33 +08:00
|
|
|
g->type_table.init(32);
|
2015-11-25 14:44:41 +08:00
|
|
|
g->link_table.init(32);
|
2015-11-25 13:32:26 +08:00
|
|
|
g->is_static = false;
|
|
|
|
g->build_type = CodeGenBuildTypeDebug;
|
|
|
|
g->strip_debug_symbols = false;
|
2015-11-25 10:07:33 +08:00
|
|
|
|
|
|
|
os_path_split(in_full_path, &g->in_dir, &g->in_file);
|
2015-11-24 13:47:25 +08:00
|
|
|
return g;
|
|
|
|
}
|
|
|
|
|
2015-11-25 13:32:26 +08:00
|
|
|
void codegen_set_build_type(CodeGen *g, CodeGenBuildType build_type) {
|
|
|
|
g->build_type = build_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
void codegen_set_is_static(CodeGen *g, bool is_static) {
|
|
|
|
g->is_static = is_static;
|
|
|
|
}
|
|
|
|
|
|
|
|
void codegen_set_strip(CodeGen *g, bool strip) {
|
|
|
|
g->strip_debug_symbols = strip;
|
|
|
|
}
|
|
|
|
|
2015-11-24 13:47:25 +08:00
|
|
|
static void add_node_error(CodeGen *g, AstNode *node, Buf *msg) {
|
|
|
|
g->errors.add_one();
|
|
|
|
ErrorMsg *last_msg = &g->errors.last();
|
|
|
|
last_msg->line_start = node->line;
|
|
|
|
last_msg->column_start = node->column;
|
|
|
|
last_msg->line_end = -1;
|
|
|
|
last_msg->column_end = -1;
|
|
|
|
last_msg->msg = msg;
|
|
|
|
}
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
static LLVMTypeRef to_llvm_type(AstNode *type_node) {
|
|
|
|
assert(type_node->type == NodeTypeType);
|
|
|
|
assert(type_node->codegen_node);
|
2015-11-25 10:07:33 +08:00
|
|
|
assert(type_node->codegen_node->data.type_node.entry);
|
|
|
|
|
|
|
|
return type_node->codegen_node->data.type_node.entry->type_ref;
|
|
|
|
}
|
|
|
|
|
|
|
|
static llvm::DIType *to_llvm_debug_type(AstNode *type_node) {
|
|
|
|
assert(type_node->type == NodeTypeType);
|
|
|
|
assert(type_node->codegen_node);
|
|
|
|
assert(type_node->codegen_node->data.type_node.entry);
|
2015-11-24 17:43:45 +08:00
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
return type_node->codegen_node->data.type_node.entry->di_type;
|
2015-11-25 04:37:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool type_is_unreachable(AstNode *type_node) {
|
|
|
|
assert(type_node->type == NodeTypeType);
|
|
|
|
return type_node->data.type.type == AstNodeTypeTypePrimitive &&
|
|
|
|
buf_eql_str(&type_node->data.type.primitive_name, "unreachable");
|
2015-11-24 17:43:45 +08:00
|
|
|
}
|
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
static void analyze_node(CodeGen *g, AstNode *node);
|
|
|
|
|
|
|
|
static void resolve_type_and_recurse(CodeGen *g, AstNode *node) {
|
|
|
|
assert(!node->codegen_node);
|
|
|
|
node->codegen_node = allocate<CodeGenNode>(1);
|
|
|
|
TypeNode *type_node = &node->codegen_node->data.type_node;
|
|
|
|
switch (node->data.type.type) {
|
|
|
|
case AstNodeTypeTypePrimitive:
|
|
|
|
{
|
|
|
|
Buf *name = &node->data.type.primitive_name;
|
|
|
|
auto table_entry = g->type_table.maybe_get(name);
|
|
|
|
if (table_entry) {
|
|
|
|
type_node->entry = table_entry->value;
|
|
|
|
} else {
|
|
|
|
add_node_error(g, node,
|
|
|
|
buf_sprintf("invalid type name: '%s'", buf_ptr(name)));
|
|
|
|
type_node->entry = g->invalid_type_entry;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case AstNodeTypeTypePointer:
|
|
|
|
{
|
|
|
|
analyze_node(g, node->data.type.child_type);
|
|
|
|
TypeNode *child_type_node = &node->data.type.child_type->codegen_node->data.type_node;
|
|
|
|
if (child_type_node->entry->id == TypeIdUnreachable) {
|
|
|
|
add_node_error(g, node,
|
|
|
|
buf_create_from_str("pointer to unreachable not allowed"));
|
|
|
|
}
|
|
|
|
TypeTableEntry **parent_pointer = node->data.type.is_const ?
|
|
|
|
&child_type_node->entry->pointer_const_parent :
|
|
|
|
&child_type_node->entry->pointer_mut_parent;
|
|
|
|
const char *const_or_mut_str = node->data.type.is_const ? "const" : "mut";
|
|
|
|
if (*parent_pointer) {
|
|
|
|
type_node->entry = *parent_pointer;
|
|
|
|
} else {
|
|
|
|
TypeTableEntry *entry = allocate<TypeTableEntry>(1);
|
|
|
|
entry->id = TypeIdPointer;
|
|
|
|
entry->type_ref = LLVMPointerType(child_type_node->entry->type_ref, 0);
|
2015-11-26 06:17:19 +08:00
|
|
|
buf_resize(&entry->name, 0);
|
2015-11-25 10:07:33 +08:00
|
|
|
buf_appendf(&entry->name, "*%s %s", const_or_mut_str, buf_ptr(&child_type_node->entry->name));
|
|
|
|
entry->di_type = g->dbuilder->createPointerType(child_type_node->entry->di_type,
|
|
|
|
g->pointer_size_bytes * 8, g->pointer_size_bytes * 8, buf_ptr(&entry->name));
|
|
|
|
g->type_table.put(&entry->name, entry);
|
|
|
|
type_node->entry = entry;
|
|
|
|
*parent_pointer = entry;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-24 13:47:25 +08:00
|
|
|
static void analyze_node(CodeGen *g, AstNode *node) {
|
|
|
|
switch (node->type) {
|
|
|
|
case NodeTypeRoot:
|
2015-11-24 17:43:45 +08:00
|
|
|
for (int i = 0; i < node->data.root.top_level_decls.length; i += 1) {
|
|
|
|
AstNode *child = node->data.root.top_level_decls.at(i);
|
2015-11-24 13:47:25 +08:00
|
|
|
analyze_node(g, child);
|
|
|
|
}
|
|
|
|
break;
|
2015-11-24 17:43:45 +08:00
|
|
|
case NodeTypeExternBlock:
|
2015-11-25 14:44:41 +08:00
|
|
|
for (int i = 0; i < node->data.extern_block.directives->length; i += 1) {
|
|
|
|
AstNode *directive_node = node->data.extern_block.directives->at(i);
|
|
|
|
Buf *name = &directive_node->data.directive.name;
|
|
|
|
Buf *param = &directive_node->data.directive.param;
|
|
|
|
if (buf_eql_str(name, "link")) {
|
|
|
|
g->link_table.put(param, true);
|
|
|
|
} else {
|
|
|
|
add_node_error(g, node,
|
|
|
|
buf_sprintf("invalid directive: '%s'", buf_ptr(name)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
for (int fn_decl_i = 0; fn_decl_i < node->data.extern_block.fn_decls.length; fn_decl_i += 1) {
|
|
|
|
AstNode *fn_decl = node->data.extern_block.fn_decls.at(fn_decl_i);
|
|
|
|
analyze_node(g, fn_decl);
|
|
|
|
|
|
|
|
AstNode *fn_proto = fn_decl->data.fn_decl.fn_proto;
|
|
|
|
Buf *name = &fn_proto->data.fn_proto.name;
|
|
|
|
ZigList<AstNode *> *params = &fn_proto->data.fn_proto.params;
|
|
|
|
|
|
|
|
LLVMTypeRef *fn_param_values = allocate<LLVMTypeRef>(params->length);
|
|
|
|
for (int param_i = 0; param_i < params->length; param_i += 1) {
|
|
|
|
AstNode *param_node = params->at(param_i);
|
|
|
|
assert(param_node->type == NodeTypeParamDecl);
|
|
|
|
AstNode *param_type = param_node->data.param_decl.type;
|
|
|
|
fn_param_values[param_i] = to_llvm_type(param_type);
|
|
|
|
}
|
2015-11-25 04:37:14 +08:00
|
|
|
AstNode *return_type_node = fn_proto->data.fn_proto.return_type;
|
|
|
|
LLVMTypeRef return_type = to_llvm_type(return_type_node);
|
2015-11-24 17:43:45 +08:00
|
|
|
|
|
|
|
LLVMTypeRef fn_type = LLVMFunctionType(return_type, fn_param_values, params->length, 0);
|
|
|
|
LLVMValueRef fn_val = LLVMAddFunction(g->mod, buf_ptr(name), fn_type);
|
|
|
|
LLVMSetLinkage(fn_val, LLVMExternalLinkage);
|
|
|
|
LLVMSetFunctionCallConv(fn_val, LLVMCCallConv);
|
|
|
|
|
2015-11-25 04:37:14 +08:00
|
|
|
if (type_is_unreachable(return_type_node)) {
|
|
|
|
LLVMAddFunctionAttr(fn_val, LLVMNoReturnAttribute);
|
|
|
|
}
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
FnTableEntry *fn_table_entry = allocate<FnTableEntry>(1);
|
|
|
|
fn_table_entry->fn_value = fn_val;
|
|
|
|
fn_table_entry->proto_node = fn_proto;
|
|
|
|
g->fn_table.put(name, fn_table_entry);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case NodeTypeFnDef:
|
2015-11-24 13:47:25 +08:00
|
|
|
{
|
2015-11-24 17:43:45 +08:00
|
|
|
AstNode *proto_node = node->data.fn_def.fn_proto;
|
2015-11-26 03:19:10 +08:00
|
|
|
assert(proto_node->type == NodeTypeFnProto);
|
2015-11-24 17:43:45 +08:00
|
|
|
Buf *proto_name = &proto_node->data.fn_proto.name;
|
|
|
|
auto entry = g->fn_defs.maybe_get(proto_name);
|
2015-11-24 13:47:25 +08:00
|
|
|
if (entry) {
|
|
|
|
add_node_error(g, node,
|
2015-11-24 17:43:45 +08:00
|
|
|
buf_sprintf("redefinition of '%s'", buf_ptr(proto_name)));
|
2015-11-24 13:47:25 +08:00
|
|
|
} else {
|
2015-11-24 17:43:45 +08:00
|
|
|
g->fn_defs.put(proto_name, node);
|
|
|
|
analyze_node(g, proto_node);
|
2015-11-24 13:47:25 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2015-11-24 17:43:45 +08:00
|
|
|
case NodeTypeFnDecl:
|
|
|
|
{
|
|
|
|
AstNode *proto_node = node->data.fn_decl.fn_proto;
|
|
|
|
assert(proto_node->type == NodeTypeFnProto);
|
|
|
|
analyze_node(g, proto_node);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case NodeTypeFnProto:
|
|
|
|
{
|
|
|
|
for (int i = 0; i < node->data.fn_proto.params.length; i += 1) {
|
|
|
|
AstNode *child = node->data.fn_proto.params.at(i);
|
|
|
|
analyze_node(g, child);
|
|
|
|
}
|
|
|
|
analyze_node(g, node->data.fn_proto.return_type);
|
|
|
|
break;
|
|
|
|
}
|
2015-11-24 13:47:25 +08:00
|
|
|
case NodeTypeParamDecl:
|
|
|
|
analyze_node(g, node->data.param_decl.type);
|
|
|
|
break;
|
2015-11-25 10:07:33 +08:00
|
|
|
|
2015-11-24 13:47:25 +08:00
|
|
|
case NodeTypeType:
|
2015-11-25 04:37:14 +08:00
|
|
|
{
|
2015-11-25 10:07:33 +08:00
|
|
|
resolve_type_and_recurse(g, node);
|
2015-11-25 04:37:14 +08:00
|
|
|
break;
|
2015-11-24 15:35:23 +08:00
|
|
|
}
|
2015-11-24 13:47:25 +08:00
|
|
|
case NodeTypeBlock:
|
2015-11-24 15:35:23 +08:00
|
|
|
for (int i = 0; i < node->data.block.statements.length; i += 1) {
|
|
|
|
AstNode *child = node->data.block.statements.at(i);
|
|
|
|
analyze_node(g, child);
|
|
|
|
}
|
2015-11-24 13:47:25 +08:00
|
|
|
break;
|
2015-11-26 06:44:05 +08:00
|
|
|
case NodeTypeStatementExpression:
|
|
|
|
analyze_node(g, node->data.statement_expression.expression);
|
|
|
|
break;
|
|
|
|
case NodeTypeStatementReturn:
|
|
|
|
analyze_node(g, node->data.statement_return.expression);
|
2015-11-24 13:47:25 +08:00
|
|
|
break;
|
|
|
|
case NodeTypeExpression:
|
2015-11-24 15:35:23 +08:00
|
|
|
switch (node->data.expression.type) {
|
|
|
|
case AstNodeExpressionTypeNumber:
|
|
|
|
break;
|
|
|
|
case AstNodeExpressionTypeString:
|
|
|
|
break;
|
|
|
|
case AstNodeExpressionTypeFnCall:
|
|
|
|
analyze_node(g, node->data.expression.data.fn_call);
|
|
|
|
break;
|
2015-11-25 04:37:14 +08:00
|
|
|
case AstNodeExpressionTypeUnreachable:
|
|
|
|
break;
|
2015-11-24 15:35:23 +08:00
|
|
|
}
|
2015-11-24 13:47:25 +08:00
|
|
|
break;
|
|
|
|
case NodeTypeFnCall:
|
2015-11-24 15:35:23 +08:00
|
|
|
for (int i = 0; i < node->data.fn_call.params.length; i += 1) {
|
|
|
|
AstNode *child = node->data.fn_call.params.at(i);
|
|
|
|
analyze_node(g, child);
|
|
|
|
}
|
2015-11-24 13:47:25 +08:00
|
|
|
break;
|
2015-11-25 14:44:41 +08:00
|
|
|
case NodeTypeDirective:
|
|
|
|
break;
|
2015-11-24 13:47:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
static void add_types(CodeGen *g) {
|
|
|
|
{
|
|
|
|
TypeTableEntry *entry = allocate<TypeTableEntry>(1);
|
|
|
|
entry->id = TypeIdU8;
|
|
|
|
entry->type_ref = LLVMInt8Type();
|
|
|
|
buf_init_from_str(&entry->name, "u8");
|
|
|
|
entry->di_type = g->dbuilder->createBasicType(buf_ptr(&entry->name), 8, 8, llvm::dwarf::DW_ATE_unsigned);
|
|
|
|
g->type_table.put(&entry->name, entry);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
TypeTableEntry *entry = allocate<TypeTableEntry>(1);
|
|
|
|
entry->id = TypeIdI32;
|
|
|
|
entry->type_ref = LLVMInt32Type();
|
|
|
|
buf_init_from_str(&entry->name, "i32");
|
|
|
|
entry->di_type = g->dbuilder->createBasicType(buf_ptr(&entry->name), 32, 32,
|
|
|
|
llvm::dwarf::DW_ATE_signed);
|
|
|
|
g->type_table.put(&entry->name, entry);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
TypeTableEntry *entry = allocate<TypeTableEntry>(1);
|
|
|
|
entry->id = TypeIdVoid;
|
|
|
|
entry->type_ref = LLVMVoidType();
|
|
|
|
buf_init_from_str(&entry->name, "void");
|
|
|
|
entry->di_type = g->dbuilder->createBasicType(buf_ptr(&entry->name), 0, 0,
|
|
|
|
llvm::dwarf::DW_ATE_unsigned);
|
|
|
|
g->type_table.put(&entry->name, entry);
|
|
|
|
|
|
|
|
// invalid types are void
|
|
|
|
g->invalid_type_entry = entry;
|
|
|
|
}
|
|
|
|
{
|
|
|
|
TypeTableEntry *entry = allocate<TypeTableEntry>(1);
|
|
|
|
entry->id = TypeIdUnreachable;
|
|
|
|
entry->type_ref = LLVMVoidType();
|
|
|
|
buf_init_from_str(&entry->name, "unreachable");
|
|
|
|
entry->di_type = g->invalid_type_entry->di_type;
|
|
|
|
g->type_table.put(&entry->name, entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-24 13:47:25 +08:00
|
|
|
void semantic_analyze(CodeGen *g) {
|
2015-11-25 10:07:33 +08:00
|
|
|
LLVMInitializeAllTargets();
|
|
|
|
LLVMInitializeAllTargetMCs();
|
|
|
|
LLVMInitializeAllAsmPrinters();
|
|
|
|
LLVMInitializeAllAsmParsers();
|
|
|
|
LLVMInitializeNativeTarget();
|
|
|
|
|
|
|
|
char *native_triple = LLVMGetDefaultTargetTriple();
|
|
|
|
|
|
|
|
LLVMTargetRef target_ref;
|
|
|
|
char *err_msg = nullptr;
|
|
|
|
if (LLVMGetTargetFromTriple(native_triple, &target_ref, &err_msg)) {
|
|
|
|
zig_panic("unable to get target from triple: %s", err_msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
char *native_cpu = LLVMZigGetHostCPUName();
|
|
|
|
char *native_features = LLVMZigGetNativeFeatures();
|
|
|
|
|
2015-11-25 13:32:26 +08:00
|
|
|
LLVMCodeGenOptLevel opt_level = (g->build_type == CodeGenBuildTypeDebug) ?
|
|
|
|
LLVMCodeGenLevelNone : LLVMCodeGenLevelAggressive;
|
2015-11-25 10:07:33 +08:00
|
|
|
|
|
|
|
LLVMRelocMode reloc_mode = g->is_static ? LLVMRelocStatic : LLVMRelocPIC;
|
|
|
|
|
|
|
|
g->target_machine = LLVMCreateTargetMachine(target_ref, native_triple,
|
|
|
|
native_cpu, native_features, opt_level, reloc_mode, LLVMCodeModelDefault);
|
|
|
|
|
|
|
|
g->target_data_ref = LLVMGetTargetMachineData(g->target_machine);
|
|
|
|
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
g->mod = LLVMModuleCreateWithName("ZigModule");
|
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
g->pointer_size_bytes = LLVMPointerSize(g->target_data_ref);
|
|
|
|
|
|
|
|
g->builder = LLVMCreateBuilder();
|
|
|
|
g->dbuilder = new llvm::DIBuilder(*llvm::unwrap(g->mod), true);
|
|
|
|
|
|
|
|
|
|
|
|
add_types(g);
|
|
|
|
|
2015-11-24 13:47:25 +08:00
|
|
|
// Pass 1.
|
|
|
|
analyze_node(g, g->root);
|
|
|
|
}
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
static LLVMValueRef gen_expr(CodeGen *g, AstNode *expr_node);
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-25 10:54:10 +08:00
|
|
|
static void add_debug_source_node(CodeGen *g, AstNode *node) {
|
|
|
|
llvm::unwrap(g->builder)->SetCurrentDebugLocation(llvm::DebugLoc::get(
|
|
|
|
node->line + 1, node->column + 1,
|
|
|
|
g->block_scopes.last()));
|
|
|
|
}
|
|
|
|
|
2015-11-24 15:35:23 +08:00
|
|
|
static LLVMValueRef gen_fn_call(CodeGen *g, AstNode *fn_call_node) {
|
|
|
|
assert(fn_call_node->type == NodeTypeFnCall);
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
Buf *name = &fn_call_node->data.fn_call.name;
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
auto entry = g->fn_table.maybe_get(name);
|
|
|
|
if (!entry) {
|
|
|
|
add_node_error(g, fn_call_node,
|
|
|
|
buf_sprintf("undefined function: '%s'", buf_ptr(name)));
|
|
|
|
return LLVMConstNull(LLVMInt32Type());
|
|
|
|
}
|
|
|
|
FnTableEntry *fn_table_entry = entry->value;
|
|
|
|
assert(fn_table_entry->proto_node->type == NodeTypeFnProto);
|
|
|
|
int expected_param_count = fn_table_entry->proto_node->data.fn_proto.params.length;
|
|
|
|
int actual_param_count = fn_call_node->data.fn_call.params.length;
|
|
|
|
if (expected_param_count != actual_param_count) {
|
|
|
|
add_node_error(g, fn_call_node,
|
|
|
|
buf_sprintf("wrong number of arguments. Expected %d, got %d.",
|
|
|
|
expected_param_count, actual_param_count));
|
|
|
|
return LLVMConstNull(LLVMInt32Type());
|
|
|
|
}
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
LLVMValueRef *param_values = allocate<LLVMValueRef>(actual_param_count);
|
|
|
|
for (int i = 0; i < actual_param_count; i += 1) {
|
|
|
|
AstNode *expr_node = fn_call_node->data.fn_call.params.at(i);
|
|
|
|
param_values[i] = gen_expr(g, expr_node);
|
|
|
|
}
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-25 10:54:10 +08:00
|
|
|
add_debug_source_node(g, fn_call_node);
|
2015-11-24 17:43:45 +08:00
|
|
|
LLVMValueRef result = LLVMBuildCall(g->builder, fn_table_entry->fn_value,
|
|
|
|
param_values, actual_param_count, "");
|
|
|
|
|
2015-11-25 04:37:14 +08:00
|
|
|
if (type_is_unreachable(fn_table_entry->proto_node->data.fn_proto.return_type)) {
|
|
|
|
return LLVMBuildUnreachable(g->builder);
|
|
|
|
} else {
|
|
|
|
return result;
|
|
|
|
}
|
2015-11-24 17:43:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static LLVMValueRef find_or_create_string(CodeGen *g, Buf *str) {
|
|
|
|
auto entry = g->str_table.maybe_get(str);
|
|
|
|
if (entry) {
|
|
|
|
return entry->value;
|
|
|
|
}
|
|
|
|
LLVMValueRef text = LLVMConstString(buf_ptr(str), buf_len(str), false);
|
|
|
|
LLVMValueRef global_value = LLVMAddGlobal(g->mod, LLVMTypeOf(text), "");
|
2015-11-24 18:06:10 +08:00
|
|
|
LLVMSetLinkage(global_value, LLVMPrivateLinkage);
|
2015-11-24 17:43:45 +08:00
|
|
|
LLVMSetInitializer(global_value, text);
|
|
|
|
LLVMSetGlobalConstant(global_value, true);
|
2015-11-24 18:06:10 +08:00
|
|
|
LLVMSetUnnamedAddr(global_value, true);
|
2015-11-24 17:43:45 +08:00
|
|
|
g->str_table.put(str, global_value);
|
|
|
|
|
|
|
|
return global_value;
|
2015-11-24 15:35:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static LLVMValueRef gen_expr(CodeGen *g, AstNode *expr_node) {
|
|
|
|
assert(expr_node->type == NodeTypeExpression);
|
|
|
|
switch (expr_node->data.expression.type) {
|
|
|
|
case AstNodeExpressionTypeNumber:
|
2015-11-24 17:43:45 +08:00
|
|
|
{
|
|
|
|
Buf *number_str = &expr_node->data.expression.data.number;
|
|
|
|
LLVMTypeRef number_type = LLVMInt32Type();
|
|
|
|
LLVMValueRef number_val = LLVMConstIntOfStringAndSize(number_type,
|
|
|
|
buf_ptr(number_str), buf_len(number_str), 10);
|
|
|
|
return number_val;
|
|
|
|
}
|
2015-11-24 15:35:23 +08:00
|
|
|
case AstNodeExpressionTypeString:
|
2015-11-24 17:43:45 +08:00
|
|
|
{
|
|
|
|
Buf *str = &expr_node->data.expression.data.string;
|
2015-11-24 18:06:10 +08:00
|
|
|
LLVMValueRef str_val = find_or_create_string(g, str);
|
|
|
|
LLVMValueRef indices[] = {
|
|
|
|
LLVMConstInt(LLVMInt32Type(), 0, false),
|
|
|
|
LLVMConstInt(LLVMInt32Type(), 0, false)
|
|
|
|
};
|
|
|
|
LLVMValueRef ptr_val = LLVMBuildInBoundsGEP(g->builder, str_val,
|
|
|
|
indices, 2, "");
|
|
|
|
|
|
|
|
return ptr_val;
|
2015-11-24 17:43:45 +08:00
|
|
|
}
|
2015-11-24 15:35:23 +08:00
|
|
|
case AstNodeExpressionTypeFnCall:
|
|
|
|
return gen_fn_call(g, expr_node->data.expression.data.fn_call);
|
2015-11-25 04:37:14 +08:00
|
|
|
case AstNodeExpressionTypeUnreachable:
|
|
|
|
return LLVMBuildUnreachable(g->builder);
|
2015-11-24 15:35:23 +08:00
|
|
|
}
|
|
|
|
zig_unreachable();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gen_block(CodeGen *g, AstNode *block_node) {
|
|
|
|
assert(block_node->type == NodeTypeBlock);
|
|
|
|
|
2015-11-25 10:54:10 +08:00
|
|
|
llvm::DILexicalBlock *di_block = g->dbuilder->createLexicalBlock(g->block_scopes.last(),
|
|
|
|
g->di_file, block_node->line + 1, block_node->column + 1);
|
|
|
|
g->block_scopes.append(di_block);
|
|
|
|
|
2015-11-24 15:35:23 +08:00
|
|
|
for (int i = 0; i < block_node->data.block.statements.length; i += 1) {
|
|
|
|
AstNode *statement_node = block_node->data.block.statements.at(i);
|
2015-11-26 06:44:05 +08:00
|
|
|
switch (statement_node->type) {
|
|
|
|
case NodeTypeStatementReturn:
|
2015-11-24 15:35:23 +08:00
|
|
|
{
|
2015-11-26 06:44:05 +08:00
|
|
|
AstNode *expr_node = statement_node->data.statement_return.expression;
|
2015-11-24 15:35:23 +08:00
|
|
|
LLVMValueRef value = gen_expr(g, expr_node);
|
2015-11-25 10:54:10 +08:00
|
|
|
|
|
|
|
add_debug_source_node(g, statement_node);
|
2015-11-24 15:35:23 +08:00
|
|
|
LLVMBuildRet(g->builder, value);
|
|
|
|
break;
|
|
|
|
}
|
2015-11-26 06:44:05 +08:00
|
|
|
case NodeTypeStatementExpression:
|
2015-11-24 15:35:23 +08:00
|
|
|
{
|
2015-11-26 06:44:05 +08:00
|
|
|
AstNode *expr_node = statement_node->data.statement_expression.expression;
|
2015-11-24 15:35:23 +08:00
|
|
|
gen_expr(g, expr_node);
|
|
|
|
break;
|
|
|
|
}
|
2015-11-26 06:44:05 +08:00
|
|
|
case NodeTypeRoot:
|
|
|
|
case NodeTypeFnProto:
|
|
|
|
case NodeTypeFnDef:
|
|
|
|
case NodeTypeFnDecl:
|
|
|
|
case NodeTypeParamDecl:
|
|
|
|
case NodeTypeType:
|
|
|
|
case NodeTypeBlock:
|
|
|
|
case NodeTypeExpression:
|
|
|
|
case NodeTypeFnCall:
|
|
|
|
case NodeTypeExternBlock:
|
|
|
|
case NodeTypeDirective:
|
2015-11-26 06:48:57 +08:00
|
|
|
zig_unreachable();
|
2015-11-24 15:35:23 +08:00
|
|
|
}
|
|
|
|
}
|
2015-11-25 10:54:10 +08:00
|
|
|
|
|
|
|
g->block_scopes.pop();
|
2015-11-24 15:35:23 +08:00
|
|
|
}
|
|
|
|
|
2015-11-25 10:54:10 +08:00
|
|
|
static llvm::DISubroutineType *create_di_function_type(CodeGen *g, AstNodeFnProto *fn_proto,
|
|
|
|
llvm::DIFile *di_file)
|
|
|
|
{
|
2015-11-25 10:07:33 +08:00
|
|
|
llvm::SmallVector<llvm::Metadata *, 8> types;
|
|
|
|
|
|
|
|
llvm::DIType *return_type = to_llvm_debug_type(fn_proto->return_type);
|
|
|
|
types.push_back(return_type);
|
|
|
|
|
|
|
|
for (int i = 0; i < fn_proto->params.length; i += 1) {
|
|
|
|
AstNode *param_node = fn_proto->params.at(i);
|
|
|
|
llvm::DIType *param_type = to_llvm_debug_type(param_node);
|
|
|
|
types.push_back(param_type);
|
|
|
|
}
|
|
|
|
|
2015-11-25 10:54:10 +08:00
|
|
|
return g->dbuilder->createSubroutineType(di_file, g->dbuilder->getOrCreateTypeArray(types));
|
2015-11-25 10:07:33 +08:00
|
|
|
}
|
|
|
|
|
2015-11-24 13:47:25 +08:00
|
|
|
void code_gen(CodeGen *g) {
|
2015-11-25 10:07:33 +08:00
|
|
|
Buf *producer = buf_sprintf("zig %s", ZIG_VERSION_STRING);
|
2015-11-25 13:32:26 +08:00
|
|
|
bool is_optimized = g->build_type == CodeGenBuildTypeRelease;
|
2015-11-25 10:07:33 +08:00
|
|
|
const char *flags = "";
|
|
|
|
unsigned runtime_version = 0;
|
|
|
|
g->compile_unit = g->dbuilder->createCompileUnit(llvm::dwarf::DW_LANG_C99,
|
|
|
|
buf_ptr(&g->in_file), buf_ptr(&g->in_dir),
|
2015-11-25 13:32:26 +08:00
|
|
|
buf_ptr(producer), is_optimized, flags, runtime_version,
|
|
|
|
"", llvm::DIBuilder::FullDebug, 0, !g->strip_debug_symbols);
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-25 10:54:10 +08:00
|
|
|
g->block_scopes.append(g->compile_unit);
|
|
|
|
|
|
|
|
g->di_file = g->dbuilder->createFile(g->compile_unit->getFilename(), g->compile_unit->getDirectory());
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
auto it = g->fn_defs.entry_iterator();
|
|
|
|
for (;;) {
|
|
|
|
auto *entry = it.next();
|
|
|
|
if (!entry)
|
|
|
|
break;
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
AstNode *fn_def_node = entry->value;
|
|
|
|
AstNodeFnDef *fn_def = &fn_def_node->data.fn_def;
|
|
|
|
assert(fn_def->fn_proto->type == NodeTypeFnProto);
|
|
|
|
AstNodeFnProto *fn_proto = &fn_def->fn_proto->data.fn_proto;
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
LLVMTypeRef ret_type = to_llvm_type(fn_proto->return_type);
|
|
|
|
LLVMTypeRef *param_types = allocate<LLVMTypeRef>(fn_proto->params.length);
|
|
|
|
for (int param_decl_i = 0; param_decl_i < fn_proto->params.length; param_decl_i += 1) {
|
|
|
|
AstNode *param_node = fn_proto->params.at(param_decl_i);
|
2015-11-24 15:35:23 +08:00
|
|
|
assert(param_node->type == NodeTypeParamDecl);
|
|
|
|
AstNode *type_node = param_node->data.param_decl.type;
|
|
|
|
param_types[param_decl_i] = to_llvm_type(type_node);
|
|
|
|
}
|
2015-11-24 17:43:45 +08:00
|
|
|
LLVMTypeRef function_type = LLVMFunctionType(ret_type, param_types, fn_proto->params.length, 0);
|
|
|
|
LLVMValueRef fn = LLVMAddFunction(g->mod, buf_ptr(&fn_proto->name), function_type);
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
bool internal_linkage = false;
|
|
|
|
LLVMSetLinkage(fn, internal_linkage ? LLVMPrivateLinkage : LLVMExternalLinkage);
|
|
|
|
|
2015-11-25 04:37:14 +08:00
|
|
|
if (type_is_unreachable(fn_proto->return_type)) {
|
|
|
|
LLVMAddFunctionAttr(fn, LLVMNoReturnAttribute);
|
|
|
|
}
|
2015-11-25 10:07:33 +08:00
|
|
|
LLVMAddFunctionAttr(fn, LLVMNoUnwindAttribute);
|
|
|
|
|
|
|
|
// Add debug info.
|
2015-11-25 10:54:10 +08:00
|
|
|
llvm::DIScope *fn_scope = g->di_file;
|
2015-11-25 10:07:33 +08:00
|
|
|
unsigned line_number = fn_def_node->line + 1;
|
|
|
|
unsigned scope_line = line_number;
|
|
|
|
bool is_definition = true;
|
|
|
|
unsigned flags = 0;
|
|
|
|
llvm::Function *unwrapped_function = reinterpret_cast<llvm::Function*>(llvm::unwrap(fn));
|
2015-11-25 10:54:10 +08:00
|
|
|
llvm::DISubprogram *subprogram = g->dbuilder->createFunction(
|
|
|
|
fn_scope, buf_ptr(&fn_proto->name), "", g->di_file, line_number,
|
|
|
|
create_di_function_type(g, fn_proto, g->di_file), internal_linkage,
|
2015-11-25 10:07:33 +08:00
|
|
|
is_definition, scope_line, flags, is_optimized, unwrapped_function);
|
|
|
|
|
2015-11-25 10:54:10 +08:00
|
|
|
g->block_scopes.append(subprogram);
|
2015-11-25 10:07:33 +08:00
|
|
|
|
2015-11-25 04:37:14 +08:00
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
LLVMBasicBlockRef entry_block = LLVMAppendBasicBlock(fn, "entry");
|
|
|
|
LLVMPositionBuilderAtEnd(g->builder, entry_block);
|
2015-11-24 15:35:23 +08:00
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
gen_block(g, fn_def->body);
|
2015-11-24 15:35:23 +08:00
|
|
|
}
|
2015-11-24 13:47:25 +08:00
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
g->dbuilder->finalize();
|
|
|
|
|
2015-11-24 17:43:45 +08:00
|
|
|
LLVMDumpModule(g->mod);
|
2015-11-24 18:06:10 +08:00
|
|
|
|
|
|
|
char *error = nullptr;
|
|
|
|
LLVMVerifyModule(g->mod, LLVMAbortProcessAction, &error);
|
2015-11-24 13:47:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ZigList<ErrorMsg> *codegen_error_messages(CodeGen *g) {
|
|
|
|
return &g->errors;
|
|
|
|
}
|
2015-11-25 04:00:38 +08:00
|
|
|
|
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
void code_gen_link(CodeGen *g, const char *out_file) {
|
2015-11-25 04:00:38 +08:00
|
|
|
LLVMPassRegistryRef registry = LLVMGetGlobalPassRegistry();
|
|
|
|
LLVMInitializeCore(registry);
|
|
|
|
LLVMInitializeCodeGen(registry);
|
|
|
|
LLVMZigInitializeLoopStrengthReducePass(registry);
|
|
|
|
LLVMZigInitializeLowerIntrinsicsPass(registry);
|
|
|
|
LLVMZigInitializeUnreachableBlockElimPass(registry);
|
|
|
|
|
2015-11-25 06:01:37 +08:00
|
|
|
Buf out_file_o = BUF_INIT;
|
2015-11-25 04:51:36 +08:00
|
|
|
buf_init_from_str(&out_file_o, out_file);
|
|
|
|
buf_append_str(&out_file_o, ".o");
|
|
|
|
|
2015-11-25 10:07:33 +08:00
|
|
|
char *err_msg = nullptr;
|
|
|
|
if (LLVMTargetMachineEmitToFile(g->target_machine, g->mod, buf_ptr(&out_file_o), LLVMObjectFile, &err_msg)) {
|
2015-11-25 04:00:38 +08:00
|
|
|
zig_panic("unable to write object file: %s", err_msg);
|
|
|
|
}
|
2015-11-25 04:51:36 +08:00
|
|
|
|
|
|
|
ZigList<const char *> args = {0};
|
2015-11-25 13:32:26 +08:00
|
|
|
if (g->is_static) {
|
|
|
|
args.append("-static");
|
|
|
|
}
|
2015-11-25 04:51:36 +08:00
|
|
|
args.append("-o");
|
|
|
|
args.append(out_file);
|
|
|
|
args.append((const char *)buf_ptr(&out_file_o));
|
2015-11-25 14:44:41 +08:00
|
|
|
|
|
|
|
auto it = g->link_table.entry_iterator();
|
|
|
|
for (;;) {
|
|
|
|
auto *entry = it.next();
|
|
|
|
if (!entry)
|
|
|
|
break;
|
|
|
|
|
|
|
|
Buf *arg = buf_sprintf("-l%s", buf_ptr(entry->key));
|
|
|
|
args.append(buf_ptr(arg));
|
|
|
|
}
|
|
|
|
|
2015-11-25 04:51:36 +08:00
|
|
|
os_spawn_process("ld", args, false);
|
2015-11-25 04:00:38 +08:00
|
|
|
}
|